Merge branch 'master' into trip-summary

.github/workflows/build-single-tinygrad-model.yaml

@@ -34,11 +34,6 @@ on:
         required: false
         type: string
         default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
       hf_repo:
         description: 'Hugging Face dataset repository (e.g. sunnypilot/sunnypilot_models_v1)'
         required: false
@@ -112,11 +107,6 @@ on:
         options:
           - qcom
           - chestnut
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
       hf_repo:
         description: 'Hugging Face dataset repository'
         required: false
@@ -140,45 +130,11 @@ jobs:
       is_20hz: ${{ inputs.is_20hz }}
       artifact_suffix: ${{ inputs.artifact_suffix }}
       target_hardware: ${{ inputs.target_hardware }}
-      on_device: ${{ inputs.on_device || false }}
     secrets: inherit
 
-  mock_parity:
+  publish_model:
     if: ${{ !cancelled() && needs.build_model.result == 'success' }}
     needs: build_model
-    runs-on: ubuntu-24.04
-    permissions:
-      actions: read
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: ./.github/workflows/setup-amd-mock
-        if: inputs.target_hardware == 'chestnut'
-      - run: python3 -m pip install -q numpy ${{ inputs.target_hardware != 'chestnut' && 'tinymesa==25.2.7.2' || '' }}
-      - name: Download artifact name file
-        uses: actions/download-artifact@v4
-        with:
-          name: artifact-name-${{ inputs.custom_name || inputs.upstream_branch }}
-          path: artifact_name
-      - name: Download the built model
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
-          id=$(gh api -X GET "repos/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID/artifacts" -f name="$ARTIFACT_NAME" --jq '.artifacts[0].id')
-          url=$(curl -sf -o /dev/null -w '%{redirect_url}' -H "Authorization: Bearer $GH_TOKEN" "https://api.github.com/repos/$GITHUB_REPOSITORY/actions/artifacts/$id/zip")
-          sudo apt-get install -y -qq aria2 > /dev/null
-          aria2c -q -x16 -s16 -k8M --max-tries=5 --file-allocation=none -o model.zip "$url" && unzip -q model.zip -d output && rm model.zip
-      - name: Replay its check frame on the mock and require the hardware's result bit for bit
-        env:
-          PYTHONPATH: ${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}
-          DEV: ${{ inputs.target_hardware == 'chestnut' && 'MOCKUSB+AMD' || 'MOCK+QCOM' }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check output/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl
-
-  publish_model:
-    if: ${{ !cancelled() && needs.build_model.result == 'success' && contains(fromJSON('["success", "skipped"]'), needs.mock_parity.result) }}
-    needs: [build_model, mock_parity]
     runs-on: ubuntu-latest
     permissions:
       actions: read

.github/workflows/chestnut-build-parity/action.yml

@@ -1,33 +0,0 @@
-name: Chestnut mock build parity
-description: >-
-  Convert one commaai precompiled chestnut model (LS2) on this runner under tinygrad's amd mock, as a hosted chestnut build does, and require the
-  exact bytes the chestnut runner built (the published artifact). Needs setup-amd-mock, numpy and zstandard; tinygrad_repo checked out.
-runs:
-  using: composite
-  steps:
-    - name: Rebuild LS2 on the mock and require the chestnut runner's artifact byte for byte
-      shell: bash
-      env:
-        REF: b92fc4828664f8767bce5e92f1630ed319cbe509  # commaai/openpilot: precompiled big_driving_tinygrad.pkl, pins tinygrad ec91b74b5b
-        PKL_OID: b4dead3ee091d66ab002a6b8e716c26f4f79e3c931e4be5f48e017ba92f6e960
-        PKL_SIZE: "767228907"
-        TG_SHA: ec91b74b5b6b0fc924b72d3f27689679ca2438b9
-        WANT: 680a8d629785f2b1d1a2b0e40d0dfbcd0f7291c21e20c51259f1d768a22ec217  # driving_light_speed_2_november_04_2026_tinygrad.pkl, recompiled46
-      run: |
-        set -euo pipefail
-        work="$RUNNER_TEMP/chestnut_parity" && rm -rf "$work" && mkdir -p "$work"
-        href=$(curl -fsSL --retry 3 -X POST -H "Accept: application/vnd.git-lfs+json" -H "Content-Type: application/vnd.git-lfs+json" \
-          https://huggingface.co/commaai/openpilot-lfs.git/info/lfs/objects/batch \
-          -d "{\"operation\":\"download\",\"transfer\":[\"basic\"],\"objects\":[{\"oid\":\"$PKL_OID\",\"size\":$PKL_SIZE}]}" | jq -r '.objects[0].actions.download.href')
-        curl -fsSL --retry 3 -o "$work/big_driving_tinygrad.pkl" "$href"
-        echo "$PKL_OID  $work/big_driving_tinygrad.pkl" | sha256sum -c -
-        tg="$work/tinygrad" && git init -q "$tg" && git -C "$tg" fetch -q --depth 1 https://github.com/tinygrad/tinygrad "$TG_SHA" && git -C "$tg" checkout -q FETCH_HEAD
-        rm -rf "$tg/test/mockgpu" && cp -r "$GITHUB_WORKSPACE/tinygrad_repo/test/mockgpu" "$tg/test/mockgpu"
-        LLVM_PATH="${LLVM_PATH:-$(ls /usr/lib/llvm-20/lib/libLLVM.so* | head -1)}" DEV=MOCKUSB+AMD CHECK_OOB=0 GMMU=0 PYTHONPATH="$tg:$GITHUB_WORKSPACE" \
-          python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py "$work/big_driving_tinygrad.pkl" "$work/LS2.pkl"
-        got=$(sha256sum "$work/LS2.pkl" | cut -d' ' -f1)
-        if [ "$got" != "$WANT" ]; then
-          echo "::error::the mock's LS2 build ($got) is not the chestnut runner's ($WANT): this runner's LLVM or the mock no longer builds what the chestnut does"
-          exit 1
-        fi
-        echo "LS2 rebuilt on the mock: byte-identical to the chestnut runner's build"

.github/workflows/setup-amd-mock/action.yml

@@ -1,18 +0,0 @@
-name: Set up tinygrad's amd mock
-description: LLVM 20 and ROCm comgr, as tinygrad_repo/.github/actions/setup-tinygrad installs them for the mock gpu
-runs:
-  using: composite
-  steps:
-    - name: Install LLVM 20 and ROCm comgr
-      shell: bash
-      run: |
-        . /etc/os-release
-        curl -fsSL https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
-        echo "deb http://apt.llvm.org/$VERSION_CODENAME/ llvm-toolchain-$VERSION_CODENAME-20 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-        sudo mkdir -p /etc/apt/keyrings
-        curl -fsSL https://repo.radeon.com/rocm/rocm.gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/rocm.gpg > /dev/null
-        echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/7.1 $VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/rocm.list
-        printf 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600\n' | sudo tee /etc/apt/preferences.d/rocm-pin-600
-        sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends libllvm20 clang-20 lld-20 comgr
-        printf '/opt/rocm/lib\n/opt/rocm/lib64\n' | sudo tee /etc/ld.so.conf.d/rocm.conf && sudo ldconfig
-        echo "/usr/lib/llvm-20/bin" >> "$GITHUB_PATH"

.github/workflows/sunnypilot-build-model.yaml

@@ -35,11 +35,6 @@ on:
         required: false
         type: string
         default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
   workflow_dispatch:
     inputs:
       upstream_branch:
@@ -64,11 +59,6 @@ on:
           - qcom
           - chestnut
         default: 'qcom'
-      on_device:
-        description: 'Compile on the tici / chestnut runner instead of on a hosted runner with tinygrad''s qcom / amd mock'
-        required: false
-        type: boolean
-        default: false
 
 
 run-name: Build model [${{ inputs.custom_name || inputs.upstream_branch }}] from ref [${{ inputs.upstream_branch }}]
@@ -163,48 +153,18 @@ jobs:
           if-no-files-found: error
 
   build_model:
-    runs-on: ${{ inputs.on_device && fromJSON(inputs.target_hardware == 'chestnut' && '["self-hosted","chestnut"]' || '["self-hosted","tici"]') || 'ubuntu-24.04' }}
+    runs-on: [self-hosted, "${{ inputs.target_hardware == 'chestnut' && 'chestnut' || 'tici' }}"]
     needs: get_model
     env:
       MODEL_NAME: ${{ inputs.custom_name || inputs.upstream_branch }} (${{ needs.get_model.outputs.model_date }})
       REF: ${{ inputs.upstream_branch }}
-      MOCK_BUILD: ${{ !inputs.on_device }}
     steps:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 1
           submodules: recursive
 
-      - name: Set up the hosted mock build
-        if: env.MOCK_BUILD == 'true'
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Install LLVM 20 and ROCm comgr for the amd mock
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware == 'chestnut'
-        uses: ./.github/workflows/setup-amd-mock
-
-      - name: Install the amd mock build dependencies
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware == 'chestnut'
-        run: |
-          python3 -m pip install -q numpy zstandard
-          echo "LLVM_PATH=$(ls /usr/lib/llvm-20/lib/libLLVM.so* | head -1)" >> "$GITHUB_ENV"  # the chestnut runner's LLVM, never a newer one
-
-      - name: Check this runner builds what the chestnut runner does
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware == 'chestnut'
-        uses: ./.github/workflows/chestnut-build-parity
-
-      - name: Install the qcom mock build dependencies and check the compiler
-        if: env.MOCK_BUILD == 'true' && inputs.target_hardware != 'chestnut'
-        run: |
-          sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends qemu-user-static aria2
-          python3 -m pip install -q numpy zstandard tinymesa==25.2.7.2
-          # every kernel an a630 has compiled must compile to the same bytes here before a model is built here
-          PYTHONPATH="$TINYGRAD_PATH" python3 "$TINYGRAD_PATH/test/device/qcom/compiler_parity.py" check "$TINYGRAD_PATH/test/mockgpu/qcom/a630_compiled.pkl.xz"
-
       - name: Set environment variables
-        if: env.MOCK_BUILD != 'true'
         id: set-env
         run: |
           # Set up common environment
@@ -217,7 +177,6 @@ jobs:
           printenv >> $GITHUB_ENV
 
       - name: Setup build environment
-        if: env.MOCK_BUILD != 'true'
         run: |
           mkdir -p "${BUILD_DIR}/"
           sudo find $BUILD_DIR/ -mindepth 1 -delete
@@ -239,28 +198,21 @@ jobs:
 
       - name: Build Model
         run: |
-          if [ "$MOCK_BUILD" = "true" ]; then
-            TASKSET=""
-            export CHECK_OOB=0 GMMU=0  # as test/mockgpu runs the amd mock
-          else
-            source /etc/profile
-            export UV_PROJECT_ENVIRONMENT=${HOME}/venv
-            export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
-            source ${UV_PROJECT_ENVIRONMENT}/bin/activate
-            TASKSET="taskset -c 7"
-          fi
+          source /etc/profile
+          export UV_PROJECT_ENVIRONMENT=${HOME}/venv
+          export VIRTUAL_ENV=$UV_PROJECT_ENVIRONMENT
+          source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           export PYTHONPATH="${PYTHONPATH}:${{ env.TINYGRAD_PATH }}:${{ github.workspace }}"
 
           COMPILE_MODELD="${{ github.workspace }}/openpilot/sunnypilot/modeld_v2/compile_modeld.py"
           MODEL_SIZE=$(python3 -c "from openpilot.common.transformations.model import MEDMODEL_INPUT_SIZE as s; print(f'{s[0]}x{s[1]}')")
           CAMERA_RES=$(python3 -c "from openpilot.common.transformations.camera import _ar_ox_fisheye as a, _os_fisheye as o; print(f'{a.width}x{a.height} {o.width}x{o.height}')")
 
-          MOCK=$([ "$MOCK_BUILD" = "true" ] && echo MOCK || true)
-          TG_FLAGS_QCOM="DEV=${MOCK}QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
+          TG_FLAGS_QCOM="DEV=QCOM IMAGE=1 FLOAT16=1 NOLOCALS=1 OPENPILOT_HACKS=1"
           if [ "${{ inputs.target_hardware }}" == "chestnut" ]; then
             echo "CHESTNUT build"
             export CHESTNUT=1
-            TG_FLAGS="DEBUG=1 DEV=${MOCK}USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
+            TG_FLAGS="DEBUG=1 DEV=USB+AMD:LLVM FRAME_DEV=CPU FLOAT16=1 GMMU=0 TC_OPT=2 TC_MIN_GLOBALS=32"
             OUTPUT_PKL="${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl"
           else
             echo "QCOM build"
@@ -275,17 +227,14 @@ jobs:
             echo "Converting commaai's precompiled model with tinygrad $TG_SHA"
             UPSTREAM_TG="${{ runner.temp }}/upstream_tinygrad"
             rm -rf "$UPSTREAM_TG" && git init -q "$UPSTREAM_TG" && git -C "$UPSTREAM_TG" fetch -q --depth 1 "$TG_URL" "$TG_SHA" && git -C "$UPSTREAM_TG" checkout -q FETCH_HEAD
-            if [ "$MOCK_BUILD" = "true" ]; then  # convert under commaai's tinygrad, on our mock: it is the one measured against a chestnut
-              rm -rf "$UPSTREAM_TG/test/mockgpu" && cp -r "$TINYGRAD_PATH/test/mockgpu" "$UPSTREAM_TG/test/mockgpu"
-            fi
             CONVERTED="${{ runner.temp }}/big_driving_tinygrad_plain.pkl"
-            env DEV=${MOCK}USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" $TASKSET python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
+            env DEV=USB+AMD PYTHONPATH="$UPSTREAM_TG:${{ github.workspace }}" taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py \
               "${{ env.MODELS_DIR }}/big_driving_tinygrad.pkl" "$CONVERTED"
             mv "$CONVERTED" "$OUTPUT_PKL"
           elif NEW_ARCH_ONNX=$(find "${{ env.MODELS_DIR }}" -maxdepth 1 -name "${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}*driving*.onnx" -print -quit) &&
                [ -n "$NEW_ARCH_ONNX" ] && grep -qa new_img "$NEW_ARCH_ONNX"; then # the new architecture: one ONNX taking the warped frames as new_img
             echo "Compiling new architecture ONNX: $NEW_ARCH_ONNX"
-            env ${TG_FLAGS} $TASKSET python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
+            env ${TG_FLAGS} taskset -c 7 python3 openpilot/sunnypilot/modeld_v2/compile_modeld_v2.py \
               "$NEW_ARCH_ONNX" "$OUTPUT_PKL" --device-input "*" --benchmark-runs 1
           else
             echo "Detected onnx architecture. Routing to native compile_modeld.py."
@@ -335,7 +284,7 @@ jobs:
 
             if [ -n "$MODEL_TYPE" ]; then
               echo "Detected: $MODEL_TYPE -> $OUTPUT_PKL"
-              env ${TG_FLAGS} $TASKSET python3 "$COMPILE_MODELD" \
+              env ${TG_FLAGS} taskset -c 7 python3 "$COMPILE_MODELD" \
                 --model-type $MODEL_TYPE \
                 --model-size $MODEL_SIZE \
                 --camera-resolutions $CAMERA_RES \
@@ -355,7 +304,7 @@ jobs:
             --include='/${{ inputs.target_hardware == 'chestnut' && 'big_' || '' }}driving_tinygrad.pkl' \
             --exclude='*' \
             --delete-excluded \
-            $([ "$MOCK_BUILD" = "true" ] || echo --chown=comma:comma) \
+            --chown=comma:comma \
             ${{ env.MODELS_DIR }}/ ${{ env.OUTPUT_DIR }}/
 
           python3 "${{ github.workspace }}/release/ci/model_generator.py" \
@@ -384,7 +333,7 @@ jobs:
           path: ${{ env.OUTPUT_DIR }}/artifact_name.txt
 
       - name: Re-enable powersave
-        if: always() && env.MOCK_BUILD != 'true'
+        if: always()
         run: |
           source ${UV_PROJECT_ENVIRONMENT}/bin/activate
           PYTHONPATH=$PYTHONPATH:${{ github.workspace }}/ ${{ github.workspace }}/scripts/manage-powersave.py --enable

.github/workflows/test_models.yml

@@ -28,7 +28,18 @@ jobs:
         env:
           DEV: CPU
         run: tools/op.sh test -v openpilot/sunnypilot/modeld_v2/tests/test_plain_artifact.py
-      - uses: ./.github/workflows/setup-amd-mock
+      - name: Install LLVM 20 and ROCm comgr for the amd mock, as tinygrad_repo/.github/actions/setup-tinygrad does
+        run: |
+          . /etc/os-release
+          curl -fsSL https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null
+          echo "deb http://apt.llvm.org/$VERSION_CODENAME/ llvm-toolchain-$VERSION_CODENAME-20 main" | sudo tee /etc/apt/sources.list.d/llvm.list
+          sudo mkdir -p /etc/apt/keyrings
+          curl -fsSL https://repo.radeon.com/rocm/rocm.gpg.key | gpg --dearmor | sudo tee /etc/apt/keyrings/rocm.gpg > /dev/null
+          echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/7.1 $VERSION_CODENAME main" | sudo tee /etc/apt/sources.list.d/rocm.list
+          printf 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600\n' | sudo tee /etc/apt/preferences.d/rocm-pin-600
+          sudo apt-get -qq update && sudo apt-get -qq install -y --no-install-recommends libllvm20 clang-20 lld-20 comgr
+          printf '/opt/rocm/lib\n/opt/rocm/lib64\n' | sudo tee /etc/ld.so.conf.d/rocm.conf && sudo ldconfig
+          echo "/usr/lib/llvm-20/bin" >> "$GITHUB_PATH"
       - name: Convert a pickled USB+AMD jit and replay it under tinygrad's amd mock
         env:
           DEV: MOCKUSB+AMD
@@ -69,8 +80,6 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       models: ${{ steps.set-matrix.outputs.models }}
-      chestnut: ${{ steps.set-matrix.outputs.chestnut }}
-      qcom: ${{ steps.set-matrix.outputs.qcom }}
     steps:
       - uses: actions/checkout@v4
       - name: Fetch and Parse json
@@ -82,22 +91,16 @@ jobs:
           with open("openpilot/sunnypilot/models/fetcher.py", "r") as f:
             urls = re.findall(r"MODEL_URL(?:_CHESTNUT)?\s*=\s*[\"'"'"']([^\"'"'"']+)[\"'"'"']", f.read())
 
-          artifacts, chestnut, qcom = [], [], []
+          artifacts = []
           for url in urls:
             data = json.loads(urllib.request.urlopen(url).read())
             for bundle in data.get("bundles", []):
               for model in bundle.get("models", []):
                 if "artifact" in model:
                   artifacts.append(model["artifact"])
-                  if "chestnut" in url:
-                    chestnut.append(model["artifact"])
-                  elif "tinygrad" in model["artifact"]["file_name"]:
-                    qcom.append(model["artifact"])
 
           with open(os.environ["GITHUB_OUTPUT"], "a") as f:
             f.write(f"models={json.dumps(artifacts)}\n")
-            f.write(f"chestnut={json.dumps(chestnut)}\n")
-            f.write(f"qcom={json.dumps(qcom)}\n")
           '
 
   test-model:
@@ -134,74 +137,3 @@ jobs:
           export PYTHONPATH="$GITHUB_WORKSPACE/tinygrad_repo:$GITHUB_WORKSPACE:$PYTHONPATH"
           python3 -m pip uninstall -y tinygrad || uv pip uninstall -y tinygrad --system || true
           python3 -m pytest openpilot/sunnypilot/modeld_v2/tests/test_models.py
-
-  chestnut-mock-parity:
-    name: Mock parity ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.chestnut) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: ./.github/workflows/setup-amd-mock
-      - run: python3 -m pip install -q numpy
-      - name: Download model
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_SHA: ${{ matrix.artifact.download_uri.sha256 }}
-        shell: bash
-        run: |
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "$RUNNER_TEMP/model.pkl" "$MODEL_URL"
-          if [ -n "$MODEL_SHA" ]; then echo "$MODEL_SHA  $RUNNER_TEMP/model.pkl" | sha256sum -c -; fi
-      - name: Replay its check frame on the amd mock and require the chestnut's result bit for bit
-        env:
-          PYTHONPATH: ${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check "$RUNNER_TEMP/model.pkl"
-
-  qcom-mock-parity:
-    name: QCOM mock parity ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.qcom) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - run: python3 -m pip install -q numpy tinymesa==25.2.7.2
-      - name: Download model
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-          MODEL_URL: ${{ matrix.artifact.download_uri.url }}
-          MODEL_SHA: ${{ matrix.artifact.download_uri.sha256 }}
-        shell: bash
-        run: |
-          AUTH=()
-          if [ -n "$HF_TOKEN" ]; then AUTH=(-H "Authorization: Bearer $HF_TOKEN"); fi
-          curl --retry 3 --retry-all-errors -s -S -f -L "${AUTH[@]}" -o "$RUNNER_TEMP/model.pkl" "$MODEL_URL"
-          if [ -n "$MODEL_SHA" ]; then echo "$MODEL_SHA  $RUNNER_TEMP/model.pkl" | sha256sum -c -; fi
-      - name: Replay its check frame on the qcom mock and require the comma device's result bit for bit
-        env:
-          DEV: MOCK+QCOM
-          PYTHONPATH: ${{ github.workspace }}/tinygrad_repo:${{ github.workspace }}
-        run: python3 -m openpilot.sunnypilot.modeld_v2.mock_parity check "$RUNNER_TEMP/model.pkl"
-
-  chestnut-mock-build-parity:
-    name: Chestnut build on the amd mock = chestnut runner build
-    runs-on: ubuntu-24.04
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-      - uses: ./.github/workflows/setup-amd-mock
-      - run: python3 -m pip install -q numpy zstandard
-      - uses: ./.github/workflows/chestnut-build-parity

openpilot/common/params_keys.h

@@ -200,6 +200,7 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"TripSummary", {PERSISTENT | BACKUP, BOOL, "1"}},
     {"TrueVEgoUI", {PERSISTENT | BACKUP, BOOL, "0"}},
 
     // MADS params

openpilot/selfdrive/ui/layouts/main.py

@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
 from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary
 
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
@@ -31,6 +32,7 @@ class MainLayout(Widget):
     self._sidebar = Sidebar()
     self._current_mode = MainState.HOME
     self._prev_onroad = False
+    self._trip_summary = TripSummary()
 
     # Initialize layouts
     self._home_layout = HomeLayout()

openpilot/selfdrive/ui/mici/layouts/main.py

@@ -10,6 +10,7 @@ from openpilot.selfdrive.ui.body.layouts.onroad import BodyLayout
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.scroller import Scroller
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.selfdrive.ui.sunnypilot.layouts.trip_summary import TripSummary
 
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
@@ -57,6 +58,7 @@ class MiciMainLayout(Scroller):
     self._setup_callbacks()
 
     gui_app.add_nav_stack_tick(self._handle_transitions)
+    self._trip_summary = TripSummary()
     gui_app.push_widget(self)
 
     # Start onboarding if terms or training not completed, make sure to push after self

openpilot/selfdrive/ui/sunnypilot/layouts/settings/visuals.py

@@ -72,6 +72,11 @@ class VisualsLayout(Widget):
            "It is the driver's responsibility to observe their environment and make decisions accordingly."),
         None,
       ),
+      "TripSummary": (
+        lambda: tr("Trip Summary"),
+        tr("Show a summary of distance and engagement when you shift into park after a drive."),
+        None,
+      ),
       "TrueVEgoUI": (
         lambda: tr("Speedometer: Always Display True Speed"),
         tr("For applicable vehicles, always display the true vehicle current speed from wheel speed sensors."),

openpilot/selfdrive/ui/sunnypilot/layouts/trip_summary.py

@@ -0,0 +1,199 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+import time
+import pyray as rl
+
+from opendbc.car.structs import car
+
+from openpilot.common.constants import CV
+from openpilot.selfdrive.ui.onroad.augmented_road_view import BORDER_COLORS
+from openpilot.selfdrive.ui.ui_state import ui_state, UIStatus
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+AUTO_DISMISS = 20.
+FADE_IN, FADE_OUT = 0.35, 0.3
+LAT = (UIStatus.ENGAGED, UIStatus.LAT_ONLY)
+LONG = (UIStatus.ENGAGED, UIStatus.LONG_ONLY)
+GEAR = car.CarState.GearShifter
+FORWARD = (GEAR.drive, GEAR.sport, GEAR.low, GEAR.brake, GEAR.eco, GEAR.manumatic)
+
+
+class TripTracker:
+  def __init__(self):
+    self.reset()
+
+  def reset(self):
+    self.segments: list[list] = []
+    self.seconds = 0.
+    self.takeovers = 0
+    self._t = None
+    self._status = None
+
+  def update(self, driving: bool):
+    now = time.monotonic()
+    if not driving:
+      self._t = None
+      self._status = None
+      return
+    dt = 0. if self._t is None else min(now - self._t, 0.5)
+    self._t = now
+    self.seconds += dt
+    if self._status not in (None, UIStatus.DISENGAGED) and ui_state.status == UIStatus.DISENGAGED:
+      self.takeovers += 1
+    self._status = ui_state.status
+    d = max(ui_state.sm["carState"].vEgo, 0.) * dt
+    if d <= 0.:
+      return
+    if self.segments and self.segments[-1][0] == ui_state.status:
+      self.segments[-1][1] += d
+    else:
+      self.segments.append([ui_state.status, d])
+
+  def total(self, statuses=None) -> float:
+    return sum(m for s, m in self.segments if statuses is None or s in statuses)
+
+
+class TripSummary:
+  def __init__(self):
+    self._trip = TripTracker()
+    self._dialog: TripSummaryDialog | None = None
+    self._gear = None
+    self._drove = False
+    gui_app.add_nav_stack_tick(self._tick)
+
+  def _tick(self):
+    gear = ui_state.sm["carState"].gearShifter if ui_state.started else None
+    self._trip.update(gear not in (None, GEAR.park))
+    self._drove |= gear in FORWARD
+    if gear == self._gear:
+      return
+    self._gear = gear
+
+    if gear not in (None, GEAR.park):
+      self._pop()
+    elif gear == GEAR.park and self._drove and ui_state.trip_summary and not ui_state.is_body and self._trip.total() > 0.:
+      self._dialog = TripSummaryDialog(self._trip, gui_app.get_active_widget(), self._pop)
+      gui_app.push_widget(self._dialog)
+    if gear is None:
+      self._trip.reset()
+    if gear in (None, GEAR.park):
+      self._drove = False
+
+  def _pop(self):
+    if self._dialog is not None and gui_app.get_active_widget() is self._dialog:
+      gui_app.pop_widget()
+    self._dialog = None
+
+
+def _ease(t: float) -> float:
+  t = min(max(t, 0.), 1.)
+  return 1 - (1 - t) ** 3
+
+
+def _fade(c, a: float) -> rl.Color:
+  r, g, b, al = c if isinstance(c, tuple) else (c.r, c.g, c.b, c.a)
+  return rl.Color(r, g, b, int(al * a))
+
+
+class TripSummaryDialog(Widget):
+  def __init__(self, trip: TripTracker, below: Widget | None, on_closed):
+    super().__init__()
+    self._below = below
+    self._on_closed = on_closed
+    self._segments = segments = trip.segments
+    total = sum(m for _, m in segments)
+
+    def pct(statuses):
+      return 100 * sum(m for s, m in segments if s in statuses) / total
+
+    dist = total * (CV.MS_TO_KPH if ui_state.is_metric else CV.MS_TO_MPH) / 3600
+    dist_fmt = "{:.1f}" if dist < 9.95 else "{:.0f}"
+    self._stats = [
+      (dist, dist_fmt, "km" if ui_state.is_metric else "mi", "driven"),
+      (pct(LAT + LONG), "{:.0f}", "%", "engaged"),
+      (pct(LAT), "{:.0f}", "%", "lateral"),
+      (pct(LONG), "{:.0f}", "%", "longitudinal"),
+    ]
+    mins = round(trip.seconds / 60)
+    self._details = [
+      (f"{mins // 60}h {mins % 60}" if mins >= 60 else f"{mins}", "min"),
+      (f"{trip.takeovers}", "takeover" if trip.takeovers == 1 else "takeovers"),
+    ]
+    self._bold = gui_app.font(FontWeight.BOLD)
+    self._semi = gui_app.font(FontWeight.SEMI_BOLD)
+    self._normal = gui_app.font(FontWeight.NORMAL)
+    self._big = gui_app.big_ui()
+    self._shown_t = rl.get_time()
+    self._closing_t: float | None = None
+    self.set_click_callback(self.close)
+
+  def close(self):
+    if self._closing_t is None:
+      self._closing_t = rl.get_time()
+
+  def _render(self, rect: rl.Rectangle):
+    t = rl.get_time() - self._shown_t
+    if self._closing_t is None and t > AUTO_DISMISS:
+      self.close()
+    out = 0. if self._closing_t is None else (rl.get_time() - self._closing_t) / FADE_OUT
+    if out >= 1.:
+      self._on_closed()
+      return
+    bg = 1 - _ease(out)
+    a = _ease(t / FADE_IN) * bg
+
+    if self._big and self._below is not None and bg < 1.:
+      self._below.render(rect)
+    rl.draw_rectangle_rec(rect, _fade(rl.BLACK, bg))
+
+    k = rect.height / 1080 * (1.0 if self._big else 1.22)
+    pad = 120 * k
+    x, w = rect.x + pad, rect.width - 2 * pad
+    y = rect.y + (rect.height - 850 * k) / 2
+
+    rl.draw_text_ex(self._bold, "trip summary", rl.Vector2(x, y), int(150 * k), 0, _fade(rl.WHITE, a))
+    y += 260 * k
+
+    col_w = w / len(self._stats)
+    for i, (target, fmt, unit, label) in enumerate(self._stats):
+      cx = x + col_w * (i + 0.5)
+      v = measure_text_cached(self._bold, fmt.format(target), int(170 * k))
+      u = measure_text_cached(self._semi, unit, int(80 * k))
+      vx = cx - (v.x + 10 * k + u.x) / 2
+      rl.draw_text_ex(self._bold, fmt.format(target), rl.Vector2(vx, y), int(170 * k), 0, _fade(rl.WHITE, a))
+      rl.draw_text_ex(self._semi, unit, rl.Vector2(vx + v.x + 10 * k, y + 75 * k), int(80 * k), 0, _fade(rl.WHITE, a))
+      lb = measure_text_cached(self._normal, label, int(70 * k))
+      rl.draw_text_ex(self._normal, label, rl.Vector2(cx - lb.x / 2, y + 180 * k), int(70 * k), 0, _fade(rl.Color(200, 200, 200, 255), a))
+    y += 330 * k
+
+    bar = rl.Rectangle(x, y, w, 90 * k)
+    total = sum(m for _, m in self._segments)
+    sx = bar.x
+    for status, m in self._segments:
+      sw = bar.width * m / total
+      rl.draw_rectangle_rec(rl.Rectangle(sx, bar.y, min(sw + 1, bar.x + bar.width - sx), bar.height), _fade(BORDER_COLORS[status], a))
+      sx += sw
+    rl.draw_rectangle_rounded_lines_ex(bar, 1.0, 20, 30 * k, _fade(rl.BLACK, a))
+
+    y += (90 + 70) * k
+
+    size = int(90 * k)
+    parts = []
+    for i, (value, unit) in enumerate(self._details):
+      if i:
+        parts.append(("     ", self._normal, None))
+      parts += [(value, self._bold, rl.WHITE), (" " + unit, self._normal, rl.Color(170, 170, 170, 255))]
+    widths = [measure_text_cached(f, t, size).x for t, f, _ in parts]
+    lx = x + (w - sum(widths)) / 2
+    for (text, font, color), tw in zip(parts, widths, strict=True):
+      if color is None:
+        rl.draw_circle(int(lx + tw / 2), int(y + size * 0.6), 12 * k, _fade(rl.Color(110, 110, 110, 255), a))
+      else:
+        rl.draw_text_ex(font, text, rl.Vector2(lx, y), size, 0, _fade(color, a))
+      lx += tw

openpilot/selfdrive/ui/sunnypilot/ui_state.py

@@ -48,6 +48,7 @@ class UIStateSP:
     self.model_runner_tinygrad: bool = False
     self.active_runner_tinygrad: bool = False
     self.blindspot: bool = False
+    self.trip_summary: bool = True
     self.chevron_metrics = None
     self.custom_interactive_timeout: int = 0
     self.developer_ui = None
@@ -185,6 +186,7 @@ class UIStateSP:
     self.standstill_timer = self.params.get_bool("StandstillTimer")
     self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
     self.torque_bar = self.params.get_bool("TorqueBar")
+    self.trip_summary = self.params.get_bool("TripSummary")
     self.enforce_torque_control = self.params.get_bool("EnforceTorqueControl")
     self.custom_torque_params = self.params.get_bool("CustomTorqueParams")
     self.torque_override_enabled = self.params.get_bool("TorqueParamsOverrideEnabled")

openpilot/sunnypilot/modeld_v2/compile_modeld.py

@@ -371,7 +371,7 @@ def _compile_warp_resolution_worker(cam_w, cam_h, model_w, model_h, benchmark_ru
 
 
 if __name__ == "__main__":
-  if ('USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT')) and not os.getenv('DEV', '').startswith('MOCK'):
+  if 'USB' in os.getenv('DEV', '') or os.getenv('CHESTNUT'):
     from openpilot.system.hardware.chestnut.flash import link_up
     for _ in range(10):
       if link_up():

openpilot/sunnypilot/modeld_v2/convert_upstream_pkl.py

@@ -194,8 +194,7 @@ def convert(jit, kwargs: dict, frame: dict, target) -> tuple[dict, memoryview]:
         base, at, nbytes = _address(argument_words[slot])
         args.append({"buffer": buffers.setdefault(base, len(buffers)), "offset": at, "nbytes": nbytes or base.max_numel() * base.dtype.itemsize, "dtype": u8})
     outs, ins = kernel[6]
-    device_target = dataclasses.asdict(dataclasses.replace(target, interface=target.interface.removeprefix("MOCK")))
-    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": device_target,
+    calls.append({"kind": "program", "name": re.sub(r"\x1b\[[0-9;]*m", "", kernel[1]), "lib": programs[image_alloc], "target": dataclasses.asdict(target),
                   "signature": [[f"data{i}", i, u8, [a.get("nbytes", 1)]] for i, a in enumerate(args)], "global_size": grid, "local_size": local,
                   "globals": list(range(len(args))), "outs": list(outs), "ins": list(ins), "args": args})
     needs_init |= {args[i]["buffer"] for i in ins if "buffer" in args[i] and args[i]["buffer"] not in written}

openpilot/sunnypilot/modeld_v2/mock_parity.py

@@ -1,152 +0,0 @@
-import json
-import os
-import shutil
-import struct
-import sys
-import tempfile
-import time
-
-os.environ.setdefault("DEV", "MOCKUSB+AMD")
-QCOM = "QCOM" in os.environ["DEV"]
-ON_MOCK = os.environ["DEV"].startswith("MOCK")
-ARCH, HARDWARE = ("a630", "comma 3x/4 (a630)") if QCOM else ("gfx1200", "chestnut")
-os.environ.setdefault("CHECK_OOB", "0")
-os.environ.setdefault("GMMU", "0")
-if sys.platform == "darwin" and os.environ["DEV"].startswith("MOCKUSB"):  # the mock's VRAM is a memfd, which macOS lacks: an unlinked file is the same
-  from tinygrad.runtime.autogen import libc
-
-  def _memfd_create(name, flags):
-    fd, path = tempfile.mkstemp()
-    os.unlink(path)
-    return fd
-  libc.memfd_create = _memfd_create
-
-import numpy as np
-
-from openpilot.sunnypilot.modeld_v2.helpers import ALIGNMENT, MAGIC, PlainJit, _device, read_parts
-
-
-class ParityError(RuntimeError):
-  pass
-
-
-def _emulator():
-  try:
-    if QCOM:
-      from test.mockgpu.qcom import emu
-    else:
-      from test.mockgpu.amd import emu
-  except ImportError as e:
-    raise ParityError(f"tinygrad's {'qcom' if QCOM else 'amd'} mock is not importable: put tinygrad_repo on PYTHONPATH") from e
-  if not hasattr(emu, "hw_unverified"):
-    raise ParityError(f"this tinygrad's emulator has no {ARCH} rounding model, its check frames would not match a {HARDWARE}")
-  return emu
-
-
-def unverified(header: dict, blob: memoryview) -> dict[str, int]:
-  emu, out = _emulator(), {}
-  for call in header["calls"]:
-    if call["kind"] != "program":
-      continue
-    if (arch := call["target"].get("arch", "")).split(",")[0] != ARCH:  # IMAGE builds append ",IMAGE_PITCH_ALIGNMENT=64"
-      out[f"arch={arch}"] = out.get(f"arch={arch}", 0) + 1
-      continue
-    for sig, n in emu.hw_unverified(bytes(blob[slice(*call["lib"])])).items():
-      out[sig] = out.get(sig, 0) + n
-  return out
-
-
-def _array(blob: memoryview, stored: dict) -> np.ndarray:
-  return np.frombuffer(blob[slice(*stored["data"])], dtype=np.dtype(stored["dtype"])).reshape(stored["shape"]).copy()
-
-
-def replay(header: dict, blob: memoryview, shared: dict) -> list[np.ndarray]:
-  from tinygrad import Tensor
-  check = header["check"]
-  jit = PlainJit(header, blob, None, verify=False, shared=shared)
-  kwargs: dict = {}
-  for path, stored, device in check["inputs"]:
-    tensor = Tensor(_array(blob, stored), device=_device(device, None)).realize()
-    kwargs[path[0]] = tensor if len(path) == 1 else {**kwargs.get(path[0], {}), path[1]: tensor}
-  result = jit(**kwargs)
-  outputs = kwargs[check["output_container"]].values() if check["output_container"] else result
-  return [t.numpy() for t in (outputs if isinstance(outputs, (list, tuple)) or check["output_container"] else [outputs])]
-
-
-def _parts_with_offsets(path: str) -> tuple[dict, dict]:
-  parts, _ = read_parts(path)
-  with open(path, "rb") as f:
-    head = f.read(len(MAGIC) + 8)
-    start = len(MAGIC) + 8 + struct.unpack_from("<Q", head, len(MAGIC))[0]
-    f.seek(len(MAGIC) + 8)
-    entries = json.loads(f.read(start - len(MAGIC) - 8))["parts"]
-  base = start + -start % ALIGNMENT
-  offsets = {tuple(e["key"]) if isinstance(e["key"], list) else e["key"]: base + e["blob"][0] for e in entries}
-  return parts, offsets
-
-
-def _gate(parts: dict) -> None:
-  missing: dict[str, int] = {}
-  for header, blob in parts.values():
-    if "check" not in header:
-      raise ParityError("artifact has no check frame")
-    for sig, n in unverified(header, blob).items():
-      missing[sig] = missing.get(sig, 0) + n
-  if missing:
-    raise ParityError(f"kernels use instructions the emulator is not verified against a {HARDWARE} for: " +
-                      ", ".join(f"{s} ({n}x)" for s, n in sorted(missing.items(), key=lambda kv: -kv[1])))
-
-
-def check(path: str) -> None:
-  parts, _ = read_parts(path)
-  if ON_MOCK:
-    _gate(parts)
-  shared: dict = {}
-  for key, (header, blob) in parts.items():
-    got = replay(header, blob, shared)
-    for i, (g, stored) in enumerate(zip(got, header["check"]["outputs"], strict=True)):
-      want = _array(blob, stored)
-      if g.shape != want.shape or not np.array_equal(g.view(np.uint8), want.view(np.uint8)):
-        n = int(np.count_nonzero(g != want)) if g.shape == want.shape else -1
-        raise ParityError(f"part {key} output {i}: the {'mock' if ON_MOCK else 'device'}'s check frame differs from the stored one in {n} of {want.size} values")
-
-
-def record(path: str, out: str) -> None:
-  parts, offsets = _parts_with_offsets(path)
-  _gate(parts)
-  shared, writes = {}, []
-  for key, (header, blob) in parts.items():
-    for g, stored in zip(replay(header, blob, shared), header["check"]["outputs"], strict=True):
-      want = np.dtype(stored["dtype"])
-      if tuple(g.shape) != tuple(stored["shape"]) or g.dtype != want:
-        raise ParityError(f"part {key}: replayed output {g.dtype}{g.shape} does not fit the stored {want}{tuple(stored['shape'])}")
-      writes.append((offsets[key] + stored["data"][0], np.ascontiguousarray(g).tobytes()))
-  shutil.copyfile(path, out)
-  with open(out, "r+b") as f:
-    for offset, data in writes:
-      f.seek(offset)
-      f.write(data)
-
-
-def main(argv: list[str]) -> int:
-  if len(argv) < 2 or argv[0] not in ("check", "record") or (argv[0] == "record" and len(argv) != 3):
-    print("usage: mock_parity check ARTIFACT... | record ARTIFACT OUT", file=sys.stderr)
-    return 2
-  try:
-    if argv[0] == "record":
-      st = time.perf_counter()
-      record(argv[1], argv[2])
-      print(f"{argv[2]}: check frame recorded on the mock in {time.perf_counter() - st:.0f}s")
-      return 0
-    for path in argv[1:]:
-      st = time.perf_counter()
-      check(path)
-      print(f"{os.path.basename(path)}: bit-identical to its {HARDWARE} check frame on the {'mock' if ON_MOCK else 'device'} ({time.perf_counter() - st:.0f}s)")
-    return 0
-  except ParityError as e:
-    print(f"PARITY FAIL: {e}", file=sys.stderr)
-    return 1
-
-
-if __name__ == "__main__":
-  sys.exit(main(sys.argv[1:]))

openpilot/sunnypilot/modeld_v2/plain_artifact_compiler.py

@@ -80,8 +80,7 @@ def serialize_jit(jit, kernel_linear, check: dict | None = None) -> tuple[dict,
     if ast.op is Ops.PROGRAM:
       elf, info = ast.to_elf(), ast.arg
       global_size, local_size = info.launch_dims({})
-      device_target = dataclasses.asdict(dataclasses.replace(elf.target, interface=elf.target.interface.removeprefix("MOCK")))
-      calls.append({"kind": "program", "name": elf.name, "lib": blob.add(bytes(elf.lib)), "target": device_target,
+      calls.append({"kind": "program", "name": elf.name, "lib": blob.add(bytes(elf.lib)), "target": dataclasses.asdict(elf.target),
                     "signature": kernel_signature(ast, elf),
                     "global_size": [int(x) for x in global_size], "local_size": [int(x) for x in local_size],
                     "globals": list(info.globals), "outs": list(info.outs), "ins": list(info.ins), "args": arguments})

openpilot/sunnypilot/sunnylink/settings_ui.json

@@ -1412,6 +1412,12 @@
                 }
               ]
             },
+            {
+              "key": "TripSummary",
+              "widget": "toggle",
+              "title": "Trip Summary",
+              "description": "Show a summary of distance and engagement when you shift into park after a drive."
+            },
             {
               "key": "RocketFuel",
               "widget": "toggle",

openpilot/sunnypilot/sunnylink/settings_ui_src/pages/visuals.yaml

@@ -39,6 +39,10 @@ sections:
     description: Show a timer on the HUD when the car is at a standstill.
     visibility:
     - $ref: '#/macros/hide_on_mici'
+  - key: TripSummary
+    widget: toggle
+    title: Trip Summary
+    description: Show a summary of distance and engagement when you shift into park after a drive.
   - key: RocketFuel
     widget: toggle
     title: Real-time Acceleration Bar