sunnypilot modeld: Sync Tinygrad (PR-1081)

.github/workflows/build-all-tinygrad-models.yaml

@@ -1,21 +1,23 @@
-name: Build All Tinygrad Models and Push to GitLab
+name: Build and push all tinygrad models 
 
 on:
   workflow_dispatch:
     inputs:
-      branch:
-        description: 'Branch to run workflow from'
-        required: false
-        default: 'master-new'
+      set_min_version:
+        description: 'Minimum selector version required for the models (see helpers.py or readme.md)'
+        required: true
         type: string
 
 jobs:
   setup:
     runs-on: ubuntu-latest
     outputs:
+      json_version: ${{ steps.get-json.outputs.json_version }}
+      recompiled_dir: ${{ steps.create-recompiled-dir.outputs.recompiled_dir }}
       json_file: ${{ steps.get-json.outputs.json_file }}
+      model_matrix: ${{ steps.set-matrix.outputs.model_matrix }}
     steps:
-      - name: Checkout docs repo
+      - name: Checkout docs repo (sunnypilot-docs, gh-pages)
         uses: actions/checkout@v4
         with:
           repository: sunnypilot/sunnypilot-docs
@@ -23,7 +25,7 @@ jobs:
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
 
-      - name: Get next JSON version to use
+      - name: Get next JSON version to use (from GitHub docs repo)
         id: get-json
         run: |
           cd docs/docs
@@ -31,19 +33,131 @@ jobs:
           next=$((latest+1))
           json_file="driving_models_v${next}.json"
           cp "driving_models_v${latest}.json" "$json_file"
-          echo "json_file=$json_file" >> $GITHUB_OUTPUT
+          echo "json_file=docs/docs/$json_file" >> $GITHUB_OUTPUT
+          echo "json_version=$((next+0))" >> $GITHUB_OUTPUT
+          echo "SRC_JSON_FILE=docs/docs/driving_models_v${latest}.json" >> $GITHUB_ENV
 
-      - name: Upload context for next jobs
-        uses: actions/upload-artifact@v4
+      - name: Extract tinygrad models
+        id: set-matrix
+        working-directory: docs/docs
+        run: |
+          jq -c '[.bundles[] | select(.runner=="tinygrad") | {ref, display_name: (.display_name | gsub(" \\([^)]*\\)"; "")), is_20hz}]' "$(basename "${SRC_JSON_FILE}")" > matrix.json
+          echo "model_matrix=$(cat matrix.json)" >> $GITHUB_OUTPUT
+
+      - name: Set up SSH
+        uses: webfactory/ssh-agent@v0.9.0
         with:
-          name: context
-          path: docs
+          ssh-private-key: ${{ secrets.GITLAB_SSH_PRIVATE_KEY }}
+      - run: |
+          mkdir -p ~/.ssh
+          ssh-keyscan -H gitlab.com >> ~/.ssh/known_hosts
 
-  build-all:
+      - name: Clone GitLab docs repo and create new recompiled dir
+        id: create-recompiled-dir
+        env:
+          GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
+        run: |
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai3.git gitlab_docs
+          cd gitlab_docs
+          git checkout main
+          git sparse-checkout set --no-cone models/
+          cd models
+          latest_dir=$(ls -d recompiled* 2>/dev/null | sed -E 's/recompiled([0-9]+)/\1/' | sort -n | tail -1)
+          if [[ -z "$latest_dir" ]]; then
+            next_dir=1
+          else
+            next_dir=$((latest_dir+1))
+          fi
+          recompiled_dir="${next_dir}"
+          mkdir -p "recompiled${recompiled_dir}"
+          touch "recompiled${recompiled_dir}/.gitkeep"
+          cd ../..
+          echo "recompiled_dir=$recompiled_dir" >> $GITHUB_OUTPUT
+
+      - name: Push empty recompiled dir to GitLab
+        run: |
+          cd gitlab_docs
+          git add models/recompiled${{ steps.create-recompiled-dir.outputs.recompiled_dir }}
+          git config --global user.name "GitHub Action"
+          git config --global user.email "action@github.com"
+          git commit -m "Add recompiled${{ steps.create-recompiled-dir.outputs.recompiled_dir }} for build-all" || echo "No changes to commit"
+          git push origin main
+
+      - name: Push new JSON to GitHub docs repo
+        run: |
+          cd docs
+          git pull origin gh-pages
+          git add docs/"$(basename ${{ steps.get-json.outputs.json_file }})"
+          git config --global user.name "GitHub Action"
+          git config --global user.email "action@github.com"
+          git commit -m "Add new ${{ steps.get-json.outputs.json_file }} for build-all" || echo "No changes to commit"
+          git push origin gh-pages
+
+  get_and_build:
+    needs: [setup]
+    strategy:
+      matrix:
+        model: ${{ fromJson(needs.setup.outputs.model_matrix) }}
+      fail-fast: false
+    uses: ./.github/workflows/build-single-tinygrad-model.yaml
+    with:
+      upstream_branch: ${{ matrix.model.ref }}
+      custom_name: ${{ matrix.model.display_name }}
+      recompiled_dir: ${{ needs.setup.outputs.recompiled_dir }}
+      json_version: ${{ needs.setup.outputs.json_version }}
+    secrets: inherit
+
+  retry_failed_models:
+    needs: [setup, get_and_build]
     runs-on: ubuntu-latest
-    needs: setup
+    if: ${{ needs.setup.result != 'failure' && (failure() && !cancelled()) }}
+    outputs:
+      retry_matrix: ${{ steps.set-retry-matrix.outputs.retry_matrix }}
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: model-*
+          path: output
+
+      - id: set-retry-matrix
+        run: |
+          echo '${{ needs.setup.outputs.model_matrix }}' > matrix.json
+          built=(); while IFS= read -r line; do built+=("$line"); done < <(
+            ls output | sed -E 's/^model-//' | sed -E 's/-[0-9]+$//' | sed -E 's/ \([^)]*\)//' | awk '{gsub(/^ +| +$/, ""); print}'
+          )
+          jq -c --argjson built "$(printf '%s\n' "${built[@]}" | jq -R . | jq -s .)" \
+            'map(select(.display_name as $n | ($built | index($n | gsub("^ +| +$"; "")) | not)))' matrix.json > retry_matrix.json
+          echo "retry_matrix=$(cat retry_matrix.json)" >> $GITHUB_OUTPUT
+
+  retry_get_and_build:
+    needs: [setup, get_and_build, retry_failed_models]
+    if: ${{ needs.get_and_build.result == 'failure' || (needs.retry_failed_models.outputs.retry_matrix != '[]' && needs.retry_failed_models.outputs.retry_matrix != '') }}
+    strategy:
+      matrix:
+        model: ${{ fromJson(needs.retry_failed_models.outputs.retry_matrix) }}
+      fail-fast: false
+    uses: ./.github/workflows/build-single-tinygrad-model.yaml
+    with:
+      upstream_branch: ${{ matrix.model.ref }}
+      custom_name: ${{ matrix.model.display_name }}
+      recompiled_dir: ${{ needs.setup.outputs.recompiled_dir }}
+      json_version: ${{ needs.setup.outputs.json_version }}
+      artifact_suffix: -retry
+    secrets: inherit
+
+  publish_models:
+    name: Publish models sequentially
+    needs: [setup, get_and_build, retry_failed_models, retry_get_and_build]
+    if: ${{ !cancelled() && (needs.get_and_build.result != 'failure' || needs.retry_get_and_build.result == 'success' || (needs.retry_failed_models.outputs.retry_matrix != '[]' && needs.retry_failed_models.outputs.retry_matrix != '')) }}
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        model: ${{ fromJson(needs.setup.outputs.model_matrix) }}
     env:
-      JSON_FILE: docs/docs/${{ needs.setup.outputs.json_file }}
+      RECOMPILED_DIR: recompiled${{ needs.setup.outputs.recompiled_dir }}
+      JSON_FILE: ${{ needs.setup.outputs.json_file }}
+      ARTIFACT_NAME_INPUT: ${{ matrix.model.display_name }}
     steps:
       - name: Set up SSH
         uses: webfactory/ssh-agent@v0.9.0
@@ -60,140 +174,75 @@ jobs:
           GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
         run: |
           echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai2.git gitlab_docs
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai3.git gitlab_docs
           cd gitlab_docs
+          echo "checkout models/${RECOMPILED_DIR}"
+          git sparse-checkout set --no-cone models/${RECOMPILED_DIR}
           git checkout main
           cd ..
 
-      - name: Set next recompiled dir
-        id: set-recompiled
-        run: |
-          cd gitlab_docs/models
-          latest_dir=$(ls -d recompiled* 2>/dev/null | sed -E 's/recompiled([0-9]+)/\1/' | sort -n | tail -1)
-          if [[ -z "$latest_dir" ]]; then
-            next_dir=1
-          else
-            next_dir=$((latest_dir+1))
-          fi
-          recompiled_dir="recompiled${next_dir}"
-          mkdir -p "$recompiled_dir"
-          echo "RECOMPILED_DIR=$recompiled_dir" >> $GITHUB_ENV
-
-      - name: Download context
-        uses: actions/download-artifact@v4
+      - name: Checkout docs repo
+        uses: actions/checkout@v4
         with:
-          name: context
-          path: .
+          repository: sunnypilot/sunnypilot-docs
+          ref: gh-pages
+          path: docs
+          ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
 
-      - name: Install dependencies
+      - name: Validate recompiled dir and JSON version
         run: |
-          sudo apt-get update
-          sudo apt-get install -y jq gh
-
-      - name: Build all tinygrad models
-        id: trigger-builds
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          set -e
-          > triggered_run_ids.txt
-          BRANCH="${{ github.event.inputs.branch }}"
-          jq -c '.bundles[] | select(.runner=="tinygrad")' "$JSON_FILE" | while read -r bundle; do
-            ref=$(echo "$bundle" | jq -r '.ref')
-            display_name=$(echo "$bundle" | jq -r '.display_name' | sed 's/ ([^)]*)//g')
-            is_20hz=$(echo "$bundle" | jq -r '.is_20hz')
-            echo "Triggering build for: $display_name ($ref) [20Hz: $is_20hz]"
-            START_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-            gh workflow run sunnypilot-build-model.yaml \
-              --repo sunnypilot/sunnypilot \
-              --ref "$BRANCH" \
-              -f upstream_branch="$ref" \
-              -f custom_name="$display_name" \
-              -f is_20hz="$is_20hz"
-            for i in {1..24}; do
-              RUN_ID=$(gh run list --repo sunnypilot/sunnypilot --workflow=sunnypilot-build-model.yaml --branch="$BRANCH" --created ">$START_TIME" --limit=1 --json databaseId --jq '.[0].databaseId')
-              if [ -n "$RUN_ID" ]; then
-                break
-              fi
-              sleep 5
-            done
-            if [ -z "$RUN_ID" ]; then
-              echo "ould not find the triggered workflow run for $display_name ($ref)"
-              exit 1
-            fi
-            echo "$RUN_ID" >> triggered_run_ids.txt
-          done
-
-      - name: Wait for all model builds to finish
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          set -e
-          SUCCESS_RUNS=()
-          FAILED_RUNS=()
-          declare -A RUN_ID_TO_NAME
-
-          while read -r RUN_ID; do
-            ARTIFACT_NAME=$(gh api repos/sunnypilot/sunnypilot/actions/runs/$RUN_ID/artifacts --jq '.artifacts[] | select(.name | startswith("model-")) | .name' || echo "unknown")
-            RUN_ID_TO_NAME["$RUN_ID"]="$ARTIFACT_NAME"
-          done < triggered_run_ids.txt
-
-          while read -r RUN_ID; do
-            echo "Watching run ID: $RUN_ID"
-            gh run watch "$RUN_ID" --repo sunnypilot/sunnypilot
-            CONCLUSION=$(gh run view "$RUN_ID" --repo sunnypilot/sunnypilot --json conclusion --jq '.conclusion')
-            ARTIFACT_NAME="${RUN_ID_TO_NAME[$RUN_ID]}"
-            echo "Run $RUN_ID ($ARTIFACT_NAME) concluded with: $CONCLUSION"
-            if [[ "$CONCLUSION" == "success" ]]; then
-              SUCCESS_RUNS+=("$RUN_ID")
-            else
-              FAILED_RUNS+=("$RUN_ID")
-            fi
-          done < triggered_run_ids.txt
-
-          if [[ ${#SUCCESS_RUNS[@]} -eq 0 ]]; then
-            echo "All model builds failed. Aborting."
+          if [ ! -d "gitlab_docs/models/$RECOMPILED_DIR" ]; then
+            echo "Recompiled dir $RECOMPILED_DIR does not exist in GitLab repo"
+            exit 1
+          fi
+          if [ ! -f "$JSON_FILE" ]; then
+            echo "JSON file $JSON_FILE does not exist!"
             exit 1
           fi
 
-          if [[ ${#FAILED_RUNS[@]} -gt 0 ]]; then
-            echo "WARNING: The following model builds failed:"
-            for RUN_ID in "${FAILED_RUNS[@]}"; do
-              echo "- $RUN_ID (${RUN_ID_TO_NAME[$RUN_ID]})"
-            done
-            echo "You may want to rerun these models manually."
-          fi
+      - name: Download artifact name file
+        uses: actions/download-artifact@v4
+        with:
+          name: artifact-name-${{ env.ARTIFACT_NAME_INPUT }}
+          path: artifact_name
 
-      - name: Download and extract all model artifacts
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Read artifact name
+        id: read-artifact-name
         run: |
-          ARTIFACT_DIR="gitlab_docs/models/$RECOMPILED_DIR"
-          SUCCESS_RUNS=()
-          while read -r RUN_ID; do
-            CONCLUSION=$(gh run view "$RUN_ID" --repo sunnypilot/sunnypilot --json conclusion --jq '.conclusion')
-            if [[ "$CONCLUSION" == "success" ]]; then
-              SUCCESS_RUNS+=("$RUN_ID")
-            fi
-          done < triggered_run_ids.txt
+          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
+          echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
 
-          for RUN_ID in "${SUCCESS_RUNS[@]}"; do
-            ARTIFACT_NAME=$(gh api repos/sunnypilot/sunnypilot/actions/runs/$RUN_ID/artifacts --jq '.artifacts[] | select(.name | startswith("model-")) | .name')
-            echo "Downloading artifact: $ARTIFACT_NAME from run: $RUN_ID"
-            mkdir -p "$ARTIFACT_DIR/$ARTIFACT_NAME"
-            echo "Created directory: $ARTIFACT_DIR/$ARTIFACT_NAME"
-            gh run download "$RUN_ID" --repo sunnypilot/sunnypilot -n "$ARTIFACT_NAME" --dir "$ARTIFACT_DIR/$ARTIFACT_NAME"
-            echo "Downloaded artifact zip(s) to: $ARTIFACT_DIR/$ARTIFACT_NAME"
-            ZIP_PATH=$(find "$ARTIFACT_DIR/$ARTIFACT_NAME" -type f -name '*.zip' | head -n1)
-            if [ -n "$ZIP_PATH" ]; then
-              echo "Unzipping $ZIP_PATH to $ARTIFACT_DIR/$ARTIFACT_NAME"
-              unzip -o "$ZIP_PATH" -d "$ARTIFACT_DIR/$ARTIFACT_NAME"
-              rm -f "$ZIP_PATH"
-              echo "Unzipped and removed $ZIP_PATH"
-            else
-              echo "No zip file found in $ARTIFACT_DIR/$ARTIFACT_NAME (This is NOT an error)."
+      - name: Download model artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
+          path: output
+
+      - name: Remove onnx files bc not needed for recompiled dir since they already exist from single build
+        run: |
+          find output -type f -name '*.onnx' -delete
+          find output -type f -name 'big_*.pkl' -delete
+          find output -type f -name 'dmonitoring_model_tinygrad.pkl' -delete
+
+      - name: Copy model artifacts to gitlab
+        env:
+          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
+        run: |
+          ARTIFACT_DIR="gitlab_docs/models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
+          mkdir -p "$ARTIFACT_DIR"
+          for path in output/*; do
+            if [ "$(basename "$path")" = "artifact_name.txt" ]; then
+              continue
+            fi
+            name="$(basename "$path")"
+            if [ -d "$path" ]; then
+              mkdir -p "$ARTIFACT_DIR/$name"
+              cp -r "$path"/* "$ARTIFACT_DIR/$name/"
+              echo "Copied dir $name -> $ARTIFACT_DIR/$name"
+            else
+              cp "$path" "$ARTIFACT_DIR/"
+              echo "Copied file $name -> $ARTIFACT_DIR/"
             fi
-            echo "Done processing $ARTIFACT_NAME"
           done
 
       - name: Push recompiled dir to GitLab
@@ -202,25 +251,35 @@ jobs:
         run: |
           cd gitlab_docs
           git checkout main
-          mkdir -p models/"$(basename $RECOMPILED_DIR)"
-          git add models/"$(basename $RECOMPILED_DIR)"
+          git pull origin main
+          for d in models/"$RECOMPILED_DIR"/*/; do
+            git sparse-checkout add "$d"
+          done
+          git add models/"$RECOMPILED_DIR"
           git config --global user.name "GitHub Action"
           git config --global user.email "action@github.com"
-          git commit -m "Add $(basename $RECOMPILED_DIR) from build-all-tinygrad-models"
+          git commit -m "Update $RECOMPILED_DIR with model from build-all-tinygrad-models" || echo "No changes to commit"
           git push origin main
+      - run: |
+          cd docs
+          git pull origin gh-pages
 
-      - name: Run json_parser.py to update JSON
+      - name: update json
         run: |
-          python3 docs/json_parser.py \
+          ARGS=""
+          [ -n "${{ inputs.set_min_version }}" ] && ARGS="$ARGS --set-min-version \"${{ inputs.set_min_version }}\""
+          ARGS="$ARGS --sort-by-date"
+          eval python3 docs/json_parser.py \
             --json-path "$JSON_FILE" \
-            --recompiled-dir "gitlab_docs/models/$RECOMPILED_DIR"
+            --recompiled-dir "gitlab_docs/models/$RECOMPILED_DIR" \
+            $ARGS
 
-      - name: Push updated JSON to GitHub docs repo
+      - name: Push updated json to GitHub
         run: |
           cd docs
           git config --global user.name "GitHub Action"
           git config --global user.email "action@github.com"
           git checkout gh-pages
           git add docs/"$(basename $JSON_FILE)"
-          git commit -m "Update $(basename $JSON_FILE) after recompiling models" || echo "No changes to commit"
+          git commit -m "Update $(basename $JSON_FILE) after recompiling model" || echo "No changes to commit"
           git push origin gh-pages

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

@@ -1,13 +1,36 @@
 name: Build Single Tinygrad Model and Push
 
 on:
+  workflow_call:
+    inputs:
+      upstream_branch:
+        description: 'Upstream commit to build from'
+        required: true
+        type: string
+      custom_name:
+        description: 'Custom name for the model (no date, only name)'
+        required: false
+        type: string
+      recompiled_dir:
+        description: 'Existing recompiled directory number (e.g. 3 for recompiled3)'
+        required: true
+        type: string
+      json_version:
+        description: 'driving_models version number to update (e.g. 5 for driving_models_v5.json)'
+        required: true
+        type: string
+      artifact_suffix:
+        description: 'Suffix for artifact name'
+        required: false
+        type: string
+        default: ''
+      bypass_push:
+        description: 'Bypass pushing to GitLab for build-all'
+        required: false
+        default: true
+        type: boolean
   workflow_dispatch:
     inputs:
-      build_model_ref:
-        description: 'Branch to use for build-model workflow'
-        required: false
-        default: 'master-new'
-        type: string
       upstream_branch:
         description: 'Upstream commit to build from'
         required: true
@@ -26,10 +49,12 @@ on:
         type: number
       model_folder:
         description: 'Model folder'
-        required: true
         type: choice
+        default: 'None'
         options:
+          - None
           - Simple Plan Models
+          - Space Lab Models
           - TR Models
           - DTR Models
           - Custom Merge Models
@@ -47,13 +72,27 @@ on:
         description: 'Minimum selector version'
         required: false
         type: number
+env:
+  RECOMPILED_DIR: recompiled${{ inputs.recompiled_dir }}
+  JSON_FILE: docs/docs/driving_models_v${{ inputs.json_version }}.json
 
 jobs:
-  build-single:
+  build_model:
+    uses: ./.github/workflows/sunnypilot-build-model.yaml
+    with:
+      upstream_branch: ${{ inputs.upstream_branch }}
+      custom_name: ${{ inputs.custom_name || inputs.upstream_branch }}
+      is_20hz: true
+      artifact_suffix: ${{ inputs.artifact_suffix }}
+    secrets: inherit
+
+  publish_model:
+    if: ${{ !inputs.bypass_push && !cancelled() }}
+    concurrency:
+      group: gitlab-push-${{ inputs.recompiled_dir }}
+      cancel-in-progress: false
+    needs: build_model
     runs-on: ubuntu-latest
-    env:
-      RECOMPILED_DIR: recompiled${{ github.event.inputs.recompiled_dir }}
-      JSON_FILE: docs/docs/driving_models_v${{ github.event.inputs.json_version }}.json
     steps:
       - name: Set up SSH
         uses: webfactory/ssh-agent@v0.9.0
@@ -70,7 +109,7 @@ jobs:
           GIT_SSH_COMMAND: 'ssh -o UserKnownHostsFile=~/.ssh/known_hosts'
         run: |
           echo "Cloning GitLab"
-          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai2.git gitlab_docs
+          git clone --depth 1 --filter=tree:0 --sparse git@gitlab.com:sunnypilot/public/docs.sunnypilot.ai3.git gitlab_docs
           cd gitlab_docs
           echo "checkout models/${RECOMPILED_DIR}"
           git sparse-checkout set --no-cone models/${RECOMPILED_DIR}
@@ -96,66 +135,49 @@ jobs:
             exit 1
           fi
 
-      - name: Install dependencies
+      - name: Download artifact name file
+        uses: actions/download-artifact@v4
+        with:
+          name: artifact-name-${{ inputs.custom_name || inputs.upstream_branch }}
+          path: artifact_name
+
+      - name: Read artifact name
+        id: read-artifact-name
         run: |
-          sudo apt-get update
-          sudo apt-get install -y jq gh
-
-      - name: Build model
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          START_TIME=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
-          gh workflow run sunnypilot-build-model.yaml \
-            --repo sunnypilot/sunnypilot \
-            --ref "${{ github.event.inputs.build_model_ref }}" \
-            -f upstream_branch="${{ github.event.inputs.upstream_branch }}" \
-            -f custom_name="${{ github.event.inputs.custom_name }}"
-
-          for i in {1..24}; do
-            RUN_ID=$(gh run list --repo sunnypilot/sunnypilot --workflow=sunnypilot-build-model.yaml --branch="${{ github.event.inputs.build_model_ref }}" --created ">$START_TIME" --limit=1 --json databaseId --jq '.[0].databaseId')
-            if [ -n "$RUN_ID" ]; then
-              break
-            fi
-            sleep 5
-          done
-
-          if [ -z "$RUN_ID" ]; then
-            echo "Could not find the triggered workflow run."
-            exit 1
-          fi
-
-          echo "Watching run ID: $RUN_ID"
-          gh run watch "$RUN_ID" --repo sunnypilot/sunnypilot
-          CONCLUSION=$(gh run view "$RUN_ID" --repo sunnypilot/sunnypilot --json conclusion --jq '.conclusion')
-          echo "Run concluded with: $CONCLUSION"
-          if [[ "$CONCLUSION" != "success" ]]; then
-            echo "Workflow run failed with conclusion: $CONCLUSION"
-            exit 1
-          fi
+          ARTIFACT_NAME=$(cat artifact_name/artifact_name.txt)
+          echo "artifact_name=$ARTIFACT_NAME" >> $GITHUB_OUTPUT
 
       - name: Download and extract model artifact
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ steps.read-artifact-name.outputs.artifact_name }}
+          path: output
+
+      - name: Remove unwanted files
         run: |
-          ARTIFACT_DIR="gitlab_docs/models/$RECOMPILED_DIR"
-          RUN_ID=$(gh run list --repo sunnypilot/sunnypilot --workflow=sunnypilot-build-model.yaml --branch="${{ github.event.inputs.build_model_ref }}" --limit=1 --json databaseId --jq '.[0].databaseId')
-          ARTIFACT_NAME=$(gh api repos/sunnypilot/sunnypilot/actions/runs/$RUN_ID/artifacts --jq '.artifacts[] | select(.name | startswith("model-")) | .name')
-          echo "Downloading artifact: $ARTIFACT_NAME from run: $RUN_ID"
-          mkdir -p "$ARTIFACT_DIR/$ARTIFACT_NAME"
-          echo "Created directory: $ARTIFACT_DIR/$ARTIFACT_NAME"
-          gh run download "$RUN_ID" --repo sunnypilot/sunnypilot -n "$ARTIFACT_NAME" --dir "$ARTIFACT_DIR/$ARTIFACT_NAME"
-          echo "Downloaded artifact zip(s) to: $ARTIFACT_DIR/$ARTIFACT_NAME"
-          ZIP_PATH=$(find "$ARTIFACT_DIR/$ARTIFACT_NAME" -type f -name '*.zip' | head -n1)
-          if [ -n "$ZIP_PATH" ]; then
-            echo "Unzipping $ZIP_PATH to $ARTIFACT_DIR/$ARTIFACT_NAME"
-            unzip -o "$ZIP_PATH" -d "$ARTIFACT_DIR/$ARTIFACT_NAME"
-            rm -f "$ZIP_PATH"
-            echo "Unzipped and removed $ZIP_PATH"
-          else
-            echo "No zip file found in $ARTIFACT_DIR/$ARTIFACT_NAME"
-          fi
-          echo "Done processing $ARTIFACT_NAME"
+          find output -type f -name 'dmonitoring_model_tinygrad.pkl' -delete
+          find output -type f -name 'dmonitoring_model.onnx' -delete
+
+      - name: Copy model artifact(s) to GitLab recompiled dir
+        env:
+          ARTIFACT_NAME: ${{ steps.read-artifact-name.outputs.artifact_name }}
+        run: |
+          ARTIFACT_DIR="gitlab_docs/models/${RECOMPILED_DIR}/${ARTIFACT_NAME}"
+          mkdir -p "$ARTIFACT_DIR"
+          for path in output/*; do
+            if [ "$(basename "$path")" = "artifact_name.txt" ]; then
+              continue
+            fi
+            name="$(basename "$path")"
+            if [ -d "$path" ]; then
+              mkdir -p "$ARTIFACT_DIR/$name"
+              cp -r "$path"/* "$ARTIFACT_DIR/$name/"
+              echo "Copied dir $name -> $ARTIFACT_DIR/$name"
+            else
+              cp "$path" "$ARTIFACT_DIR/"
+              echo "Copied file $name -> $ARTIFACT_DIR/"
+            fi
+          done
 
       - name: Push recompiled dir to GitLab
         env:
@@ -163,28 +185,36 @@ jobs:
         run: |
           cd gitlab_docs
           git checkout main
+          git pull origin main
           for d in models/"$RECOMPILED_DIR"/*/; do
             git sparse-checkout add "$d"
           done
           git add models/"$RECOMPILED_DIR"
           git config --global user.name "GitHub Action"
           git config --global user.email "action@github.com"
-          git commit -m "Update $RECOMPILED_DIR with new/updated model from build-single-tinygrad-model" || echo "No changes to commit"
+          git commit -m "Create/Update $RECOMPILED_DIR with new/updated model from build-single-tinygrad-model" || echo "No changes to commit"
           git push origin main
 
+      - run: |
+          cd docs
+          git pull origin gh-pages
+
       - name: Run json_parser.py to update JSON
         run: |
-          FOLDER="${{ github.event.inputs.model_folder }}"
+          FOLDER="${{ inputs.model_folder }}"
           if [ "$FOLDER" = "Other" ]; then
-            FOLDER="${{ github.event.inputs.custom_model_folder }}"
+            FOLDER="${{ inputs.custom_model_folder }}"
           fi
           ARGS=""
-          [ -n "$FOLDER" ] && ARGS="$ARGS --model-folder \"$FOLDER\""
-          [ -n "${{ github.event.inputs.generation }}" ] && ARGS="$ARGS --generation \"${{ github.event.inputs.generation }}\""
-          [ -n "${{ github.event.inputs.version }}" ] && ARGS="$ARGS --version \"${{ github.event.inputs.version }}\""
+          if [ "$FOLDER" != "None" ] && [ -n "$FOLDER" ]; then
+            ARGS="$ARGS --model-folder \"$FOLDER\""
+          fi
+          [ -n "${{ inputs.generation }}" ] && ARGS="$ARGS --generation \"${{ inputs.generation }}\""
+          [ -n "${{ inputs.version }}" ] && ARGS="$ARGS --version \"${{ inputs.version }}\""
           eval python3 docs/json_parser.py \
             --json-path "$JSON_FILE" \
             --recompiled-dir "gitlab_docs/models/$RECOMPILED_DIR" \
+            --sort-by-date \
             $ARGS
 
       - name: Push updated JSON to GitHub docs repo

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

@@ -9,6 +9,27 @@ env:
   MODELS_DIR: ${{ github.workspace }}/selfdrive/modeld/models
 
 on:
+  workflow_call:
+    inputs:
+      upstream_branch:
+        description: 'Upstream branch to build from'
+        required: true
+        default: 'master'
+        type: string
+      custom_name:
+        description: 'Custom name for the model (no date, only name)'
+        required: false
+        type: string
+      is_20hz:
+        description: 'Is this a 20Hz model'
+        required: false
+        type: boolean
+        default: true
+      artifact_suffix:
+        description: 'Suffix for artifact name'
+        required: false
+        type: string
+        default: ''
   workflow_dispatch:
     inputs:
       upstream_branch:
@@ -32,34 +53,53 @@ run-name: Build model [${{ inputs.custom_name || inputs.upstream_branch }}] from
 jobs:
   get_model:
     runs-on: ubuntu-latest
+    env:
+      REF: ${{ inputs.upstream_branch }}
     outputs:
       model_date: ${{ steps.commit-date.outputs.model_date }}
     steps:
-      - uses: actions/checkout@v4
+      # Note: To allow dynamic models from both openpilot and sunnypilot (merges/mashups), we try commaai as default,
+      # and fallback to sunnypilot if the ref checkout fails.
+      - name: Checkout commaai/openpilot
+        id: checkout_upstream
+        continue-on-error: true
+        uses: actions/checkout@v4
         with:
-          repository: ${{ env.UPSTREAM_REPO }}
-          ref: ${{ github.event.inputs.upstream_branch }}
+          repository: commaai/openpilot
+          ref: ${{ inputs.upstream_branch }}
           submodules: recursive
+          path: openpilot
+
+      - name: Fallback to sunnypilot/sunnypilot
+        if: steps.checkout_upstream.outcome == 'failure'
+        uses: actions/checkout@v4
+        with:
+          repository: sunnypilot/sunnypilot
+          ref: ${{ inputs.upstream_branch }}
+          submodules: recursive
+          path: openpilot
       - name: Get commit date
         id: commit-date
         run: |
-          # Get the commit date in YYYY-MM-DD format
+          cd ${{ github.workspace }}/openpilot
           commit_date=$(git log -1 --format=%cd --date=format:'%B %d, %Y')
           echo "model_date=${commit_date}" >> $GITHUB_OUTPUT
           cat $GITHUB_OUTPUT
-      - run: git lfs pull
+      - run: |
+          cd ${{ github.workspace }}/openpilot
+          git lfs pull
       - name: 'Upload Artifact'
         uses: actions/upload-artifact@v4
         with:
-          name: models
-          path: ${{ github.workspace }}/selfdrive/modeld/models/*.onnx
+          name: models-${{ env.REF }}${{ inputs.artifact_suffix  }}
+          path: ${{ github.workspace }}/openpilot/selfdrive/modeld/models/*.onnx
 
   build_model:
-    runs-on: self-hosted
+    runs-on: [self-hosted, tici]
     needs: get_model
     env:
       MODEL_NAME: ${{ inputs.custom_name || inputs.upstream_branch }} (${{ needs.get_model.outputs.model_date }})
-
+      REF: ${{ inputs.upstream_branch }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -71,7 +111,7 @@ jobs:
         with:
           path: ${{env.SCONS_CACHE_DIR}}
           key: scons-${{ runner.os }}-${{ runner.arch }}-${{ github.head_ref || github.ref_name }}-model-${{ github.sha }}
-          # Note: GitHub Actions enforces cache isolation between different build sources (PR builds, workflow dispatches, etc.) 
+          # Note: GitHub Actions enforces cache isolation between different build sources (PR builds, workflow dispatches, etc.)
           #   for security. Only caches from the default branch are shared across all builds. This is by design and cannot be overridden.
           restore-keys: |
             scons-${{ runner.os }}-${{ runner.arch }}-${{ github.head_ref || github.ref_name }}-model
@@ -114,7 +154,7 @@ jobs:
       - name: Download model artifacts
         uses: actions/download-artifact@v4
         with:
-          name: models
+          name: models-${{ env.REF }}${{ inputs.artifact_suffix }}
           path: ${{ github.workspace }}/selfdrive/modeld/models
 
       - name: Build Model
@@ -157,12 +197,22 @@ jobs:
             --upstream-branch "${{ inputs.upstream_branch }}" \
             ${{ inputs.is_20hz && '--is-20hz' || '' }}
 
+      - name: Write artifact name to file
+        run: echo "model-${{ env.MODEL_NAME }}${{ inputs.artifact_suffix }}-${{ github.run_number }}" > ${{ env.OUTPUT_DIR }}/artifact_name.txt
+
       - name: Upload Build Artifacts
+        id: upload-artifact
         uses: actions/upload-artifact@v4
         with:
-          name: model-${{ env.MODEL_NAME }}-${{ github.run_number }}
+          name: model-${{ env.MODEL_NAME }}${{ inputs.artifact_suffix }}-${{ github.run_number }}
           path: ${{ env.OUTPUT_DIR }}
 
+      - name: Upload artifact name file
+        uses: actions/upload-artifact@v4
+        with:
+          name: artifact-name-${{ inputs.custom_name || inputs.upstream_branch }}
+          path: ${{ env.OUTPUT_DIR }}/artifact_name.txt
+
       - name: Re-enable powersave
         if: always()
         run: |

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

@@ -50,7 +50,7 @@ jobs:
     concurrency:
       group: build-${{ github.head_ref || github.ref_name }}
       cancel-in-progress: false
-    runs-on: self-hosted
+    runs-on: [self-hosted, tici]
     outputs:
       new_branch: ${{ steps.set-env.outputs.new_branch }}
       version: ${{ steps.set-env.outputs.version }}

cereal/custom.capnp

@@ -101,6 +101,7 @@ struct ModelManagerSP @0xaedffd8f31e7b55d {
 
 struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
   dec @0 :DynamicExperimentalControl;
+  accelPersonality @1 :AccelerationPersonality;
 
   struct DynamicExperimentalControl {
     state @0 :DynamicExperimentalControlState;
@@ -112,6 +113,12 @@ struct LongitudinalPlanSP @0xf35cc4560bbf6ec2 {
       blended @1;
     }
   }
+
+  enum AccelerationPersonality {
+    sport @0;
+    normal @1;
+    eco @2;
+  }
 }
 
 struct OnroadEventSP @0xda96579883444c35 {

common/params_keys.h

@@ -123,6 +123,7 @@ inline static std::unordered_map<std::string, uint32_t> keys = {
     {"Version", PERSISTENT},
 
     // --- sunnypilot params --- //
+    {"AccelPersonality", PERSISTENT},
     {"ApiCache_DriveStats", PERSISTENT},
     {"AutoLaneChangeBsmDelay", PERSISTENT | BACKUP},
     {"AutoLaneChangeTimer", PERSISTENT | BACKUP},
@@ -147,6 +148,9 @@ inline static std::unordered_map<std::string, uint32_t> keys = {
     {"QuickBootToggle", PERSISTENT | BACKUP},
     {"QuietMode", PERSISTENT | BACKUP},
     {"ShowAdvancedControls", PERSISTENT | BACKUP},
+    {"VibePersonalityEnabled", PERSISTENT},
+    {"VibeAccelPersonalityEnabled", PERSISTENT},
+    {"VibeFollowPersonalityEnabled", PERSISTENT},
 
     // MADS params
     {"Mads", PERSISTENT | BACKUP},

release/ci/model_generator.py

@@ -13,17 +13,32 @@ def create_short_name(full_name):
   words = [re.sub(r'[^a-zA-Z0-9]', '', word) for word in clean_name.split() if re.sub(r'[^a-zA-Z0-9]', '', word)]
 
   if len(words) == 1:
-    # If there's only one word, return it as is, lowercased, truncated to 8 characters
-    truncated = words[0][:8]
-    return truncated.lower() if truncated.isupper() else truncated
+    return words[0][:8].upper()
 
   # Handle special case: Name + Version (e.g., "Word A1" -> "WordA1")
   if len(words) == 2 and re.match(r'^[A-Za-z]\d+$', words[1]):
-    first_word = words[0].lower() if words[0].isupper() else words[0]
-    return (first_word + words[1])[:8]
+    return (words[0] + words[1])[:8].upper()
 
-  # Normal case: first letter and trailing numbers from each word
-  result = ''.join(word if word.isdigit() else word[0] + (re.search(r'\d+$', word) or [''])[0] for word in words)
+  result = ""
+  for word in words:
+    # Version or number patterns
+    if (re.match(r'^\d+[a-zA-Z]+$', word) or
+        re.match(r'^\d+[vVbB]\d+$', word) or
+        re.match(r'^[vVbB]\d+$', word) or
+        re.match(r'^\d{4}$', word)):
+      result += word.upper()
+    # All uppercase abbreviations (2-3 letters)
+    elif re.match(r'^[A-Z]{2,3}$', word):
+      result += word
+    # Letters+digits (for example tr15 rev2)
+    elif re.match(r'^[a-zA-Z]+[0-9]+$', word):
+      result += word[0].upper() + ''.join(re.findall(r'\d+', word))
+    elif word.isalpha():
+      result += word[0].upper()
+    elif word.isdigit():
+      result += word
+    else:
+      result += word[0].upper()
   return result[:8]
 
 
@@ -58,14 +73,14 @@ def generate_metadata(model_path: Path, output_dir: Path, short_name: str):
     "artifact": {
       "file_name": tinygrad_file.name,
       "download_uri": {
-        "url": "https://gitlab.com/sunnypilot/public/docs.sunnypilot.ai/-/raw/main/<FILLME>",
+        "url": "https://gitlab.com/sunnypilot/public/docs.sunnypilot.ai/-/raw/main/",
         "sha256": tinygrad_hash
       }
     },
     "metadata": {
       "file_name": metadata_file.name,
       "download_uri": {
-        "url": "https://gitlab.com/sunnypilot/public/docs.sunnypilot.ai/-/raw/main/<FILLME>",
+        "url": "https://gitlab.com/sunnypilot/public/docs.sunnypilot.ai/-/raw/main/",
         "sha256": metadata_hash
       }
     }
@@ -83,12 +98,12 @@ def create_metadata_json(models: list, output_dir: Path, custom_name=None, short
     "ref": upstream_branch,
     "environment": "development",
     "runner": "tinygrad",
-    "build_time": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
-    "models": models,
-    "overrides": {},
     "index": -1,
     "minimum_selector_version": "-1",
     "generation": "-1",
+    "build_time": datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ"),
+    "overrides": {},
+    "models": models,
   }
 
   # Write metadata to output_dir

selfdrive/controls/lib/longitudinal_mpc_lib/long_mpc.py

@@ -10,6 +10,8 @@ from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.modeld.constants import index_function
 from openpilot.selfdrive.controls.radard import _LEAD_ACCEL_TAU
 
+from openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality import VibePersonalityController
+
 if __name__ == '__main__':  # generating code
   from openpilot.third_party.acados.acados_template import AcadosModel, AcadosOcp, AcadosOcpSolver
 else:
@@ -228,6 +230,7 @@ class LongitudinalMpc:
     self.solver = AcadosOcpSolverCython(MODEL_NAME, ACADOS_SOLVER_TYPE, N)
     self.reset()
     self.source = SOURCES[2]
+    self.vibe_controller = VibePersonalityController()
 
   def reset(self):
     # self.solver = AcadosOcpSolverCython(MODEL_NAME, ACADOS_SOLVER_TYPE, N)
@@ -328,10 +331,31 @@ class LongitudinalMpc:
     return lead_xv
 
   def update(self, radarstate, v_cruise, x, v, a, j, personality=log.LongitudinalPersonality.standard):
-    t_follow = get_T_FOLLOW(personality)
     v_ego = self.x0[1]
+
+    # Get following distance
+    if self.vibe_controller.is_follow_enabled():
+      t_follow = self.vibe_controller.get_follow_distance_multiplier(v_ego)
+      if t_follow is None:
+        # Fallback to stock behavior when vibe controller can't provide a value
+        t_follow = get_T_FOLLOW(personality)
+    else:
+      t_follow = get_T_FOLLOW(personality)
+
     self.status = radarstate.leadOne.status or radarstate.leadTwo.status
 
+    # Get acceleration limits
+    if self.vibe_controller.is_accel_enabled():
+      accel_limits = self.vibe_controller.get_accel_limits(v_ego)
+      if accel_limits is not None:
+        min_accel = accel_limits[0]
+      else:
+        min_accel = CRUISE_MIN_ACCEL
+    else:
+      min_accel = CRUISE_MIN_ACCEL
+
+    a_cruise_min = min_accel
+
     lead_xv_0 = self.process_lead(radarstate.leadOne)
     lead_xv_1 = self.process_lead(radarstate.leadTwo)
 
@@ -350,7 +374,7 @@ class LongitudinalMpc:
 
       # Fake an obstacle for cruise, this ensures smooth acceleration to set speed
       # when the leads are no factor.
-      v_lower = v_ego + (T_IDXS * CRUISE_MIN_ACCEL * 1.05)
+      v_lower = v_ego + (T_IDXS * a_cruise_min * 1.05)
       # TODO does this make sense when max_a is negative?
       v_upper = v_ego + (T_IDXS * CRUISE_MAX_ACCEL * 1.05)
       v_cruise_clipped = np.clip(v_cruise * np.ones(N+1),

selfdrive/controls/lib/longitudinal_planner.py

@@ -124,9 +124,22 @@ class LongitudinalPlanner(LongitudinalPlannerSP):
     prev_accel_constraint = not (reset_state or sm['carState'].standstill)
 
     if self.mode == 'acc':
-      accel_clip = [ACCEL_MIN, get_max_accel(v_ego)]
-      steer_angle_without_offset = sm['carState'].steeringAngleDeg - sm['liveParameters'].angleOffsetDeg
-      accel_clip = limit_accel_in_turns(v_ego, steer_angle_without_offset, accel_clip, self.CP)
+      if self.vibe_controller.is_accel_enabled():
+        # Only get max acceleration from vibe controller, use default ACCEL_MIN for minimum
+        accel_limits = self.vibe_controller.get_accel_limits(v_ego)
+        if accel_limits is not None:
+          max_accel = accel_limits[1]
+          accel_clip = [ACCEL_MIN, max_accel]
+        else:
+          # Fallback to stock if vibe controller returns None
+          accel_clip = [ACCEL_MIN, get_max_accel(v_ego)]
+        # Recalculate limit turn according to the new max limit
+        steer_angle_without_offset = sm['carState'].steeringAngleDeg - sm['liveParameters'].angleOffsetDeg
+        accel_clip = limit_accel_in_turns(v_ego, steer_angle_without_offset, accel_clip, self.CP)
+      else:
+        accel_clip = [ACCEL_MIN, get_max_accel(v_ego)]
+        steer_angle_without_offset = sm['carState'].steeringAngleDeg - sm['liveParameters'].angleOffsetDeg
+        accel_clip = limit_accel_in_turns(v_ego, steer_angle_without_offset, accel_clip, self.CP)
     else:
       accel_clip = [ACCEL_MIN, ACCEL_MAX]
 

selfdrive/ui/qt/offroad/settings.cc

@@ -92,7 +92,15 @@ TogglesPanel::TogglesPanel(SettingsWindow *parent) : ListWidget(parent) {
                                              "your steering wheel distance button."),
                                           "../assets/icons/speed_limit.png",
                                           longi_button_texts);
-
+  // accel controller
+  std::vector<QString> accel_personality_texts{tr("Sport"), tr("Normal"), tr("Eco")};
+  accel_personality_setting = new ButtonParamControlSP("AccelPersonality", tr("Acceleration Personality"),
+                                          tr("Normal is recommended. In sport mode, sunnypilot will provide aggressive acceleration for a dynamic driving experience. "
+                                             "In eco mode, sunnypilot will apply smoother and more relaxed acceleration. On supported cars, you can cycle through these "
+                                             "acceleration personality within Onroad Settings on the driving screen."),
+                                          "",
+                                          accel_personality_texts);
+  accel_personality_setting->showDescription();
   // set up uiState update for personality setting
   QObject::connect(uiState(), &UIState::uiUpdate, this, &TogglesPanel::updateState);
 
@@ -120,6 +128,7 @@ TogglesPanel::TogglesPanel(SettingsWindow *parent) : ListWidget(parent) {
     // insert longitudinal personality after NDOG toggle
     if (param == "DisengageOnAccelerator") {
       addItem(long_personality_setting);
+      addItem(accel_personality_setting);
     }
   }
 
@@ -140,6 +149,13 @@ void TogglesPanel::updateState(const UIState &s) {
     }
     uiState()->scene.personality = personality;
   }
+  if (sm.updated("longitudinalPlanSP")) {
+    auto accel_personality = sm["longitudinalPlanSP"].getLongitudinalPlanSP().getAccelPersonality();
+    if (accel_personality != s.scene.accel_personality && s.scene.started && isVisible()) {
+      accel_personality_setting->setCheckedButton(static_cast<int>(accel_personality));
+    }
+    uiState()->scene.accel_personality = accel_personality;
+  }
 }
 
 void TogglesPanel::expandToggleDescription(const QString &param) {
@@ -186,10 +202,12 @@ void TogglesPanel::updateToggles() {
       experimental_mode_toggle->setEnabled(true);
       experimental_mode_toggle->setDescription(e2e_description);
       long_personality_setting->setEnabled(true);
+      accel_personality_setting->setEnabled(true);
     } else {
       // no long for now
       experimental_mode_toggle->setEnabled(false);
       long_personality_setting->setEnabled(false);
+      accel_personality_setting->setEnabled(true);
       params.remove("ExperimentalMode");
 
       const QString unavailable = tr("Experimental mode is currently unavailable on this car since the car's stock ACC is used for longitudinal control.");

selfdrive/ui/qt/offroad/settings.h

@@ -88,6 +88,7 @@ protected:
   Params params;
   std::map<std::string, ParamControl*> toggles;
   ButtonParamControl *long_personality_setting;
+  ButtonParamControl *accel_personality_setting;
 
   virtual void updateToggles();
 };

selfdrive/ui/qt/onroad/model.cc

@@ -34,7 +34,6 @@ void ModelRenderer::draw(QPainter &painter, const QRect &surface_rect) {
       drawLead(painter, lead_two, lead_vertices[1], surface_rect);
     }
   }
-  drawLeadStatus(painter, surface_rect.height(), surface_rect.width());
 
   painter.restore();
 }
@@ -175,172 +174,6 @@ QColor ModelRenderer::blendColors(const QColor &start, const QColor &end, float
 }
 
 
-void ModelRenderer::drawLeadStatus(QPainter &painter, int height, int width) {
-    auto *s = uiState();
-    auto &sm = *(s->sm);
-
-    if (!sm.alive("radarState")) return;
-
-    const auto &radar_state = sm["radarState"].getRadarState();
-    const auto &lead_one = radar_state.getLeadOne();
-    const auto &lead_two = radar_state.getLeadTwo();
-
-    // Check if we have any active leads
-    bool has_lead_one = lead_one.getStatus();
-    bool has_lead_two = lead_two.getStatus();
-
-    if (!has_lead_one && !has_lead_two) {
-        // Fade out status display
-        lead_status_alpha = std::max(0.0f, lead_status_alpha - 0.05f);
-        if (lead_status_alpha <= 0.0f) return;
-    } else {
-        // Fade in status display
-        lead_status_alpha = std::min(1.0f, lead_status_alpha + 0.1f);
-    }
-
-    // Draw status for each lead vehicle under its chevron
-    if (true) {
-        drawLeadStatusAtPosition(painter, lead_one, lead_vertices[0], height, width, "L1");
-    }
-
-    if (has_lead_two && std::abs(lead_one.getDRel() - lead_two.getDRel()) > 3.0) {
-        drawLeadStatusAtPosition(painter, lead_two, lead_vertices[1], height, width, "L2");
-    }
-}
-
-void ModelRenderer::drawLeadStatusAtPosition(QPainter &painter,
-                                           const cereal::RadarState::LeadData::Reader &lead_data,
-                                           const QPointF &chevron_pos,
-                                           int height, int width,
-                                           const QString &label) {
-
-    float d_rel = lead_data.getDRel();
-    float v_rel = lead_data.getVRel();
-    auto *s = uiState();
-    auto &sm = *(s->sm);
-    float v_ego = sm["carState"].getCarState().getVEgo();
-
-    int chevron_data = std::atoi(Params().get("ChevronInfo").c_str());
-
-    // Calculate chevron size (same logic as drawLead)
-    float sz = std::clamp((25 * 30) / (d_rel / 3 + 30), 15.0f, 30.0f) * 2.35;
-
-    QFont content_font = painter.font();
-    content_font.setPixelSize(35);
-    content_font.setBold(true);
-    painter.setFont(content_font);
-
-    QFontMetrics fm(content_font);
-    bool is_metric = s->scene.is_metric;
-
-    QStringList text_lines;
-
-    const int chevron_types = 3;
-    const int chevron_all = chevron_types + 1;  // All metrics (value 4)
-    QStringList chevron_text[chevron_types];
-    int position;
-    float val;
-
-    // Distance display (chevron_data == 1 or all)
-    if (chevron_data == 1 || chevron_data == chevron_all) {
-        position = 0;
-        val = std::max(0.0f, d_rel);
-        QString distance_unit = is_metric ? "m" : "ft";
-        if (!is_metric) {
-            val *= 3.28084f; // Convert meters to feet
-        }
-        chevron_text[position].append(QString::number(val, 'f', 0) + " " + distance_unit);
-    }
-
-    // Absolute velocity display (chevron_data == 2 or all)
-    if (chevron_data == 2 || chevron_data == chevron_all) {
-        position = (chevron_data == 2) ? 0 : 1;
-        val = std::max(0.0f, (v_rel + v_ego) * (is_metric ? static_cast<float>(MS_TO_KPH) : static_cast<float>(MS_TO_MPH)));
-        chevron_text[position].append(QString::number(val, 'f', 0) + " " + (is_metric ? "km/h" : "mph"));
-    }
-
-    // Time-to-contact display (chevron_data == 3 or all)
-    if (chevron_data == 3 || chevron_data == chevron_all) {
-        position = (chevron_data == 3) ? 0 : 2;
-        val = (d_rel > 0 && v_ego > 0) ? std::max(0.0f, d_rel / v_ego) : 0.0f;
-        QString ttc_str = (val > 0 && val < 200) ? QString::number(val, 'f', 1) + "s" : "---";
-        chevron_text[position].append(ttc_str);
-    }
-
-    // Collect all non-empty text lines
-    for (int i = 0; i < chevron_types; ++i) {
-        if (!chevron_text[i].isEmpty()) {
-            text_lines.append(chevron_text[i]);
-        }
-    }
-
-    // If no text to display, return early
-    if (text_lines.isEmpty()) {
-        return;
-    }
-
-    // Text box dimensions
-    float str_w = 150;  // Width of text area
-    float str_h = 45;   // Height per line
-
-    // Position text below chevron, centered horizontally
-    float text_x = chevron_pos.x() - str_w / 2;
-    float text_y = chevron_pos.y() + sz + 15;
-
-    // Clamp to screen bounds
-    text_x = std::clamp(text_x, 10.0f, (float)width - str_w - 10);
-
-    // Shadow offset
-    QPoint shadow_offset(2, 2);
-
-    // Draw each line of text with shadow
-    for (int i = 0; i < text_lines.size(); ++i) {
-        if (!text_lines[i].isEmpty()) {
-            QRect textRect(text_x, text_y + (i * str_h), str_w, str_h);
-
-            // Draw shadow
-            painter.setPen(QColor(0x0, 0x0, 0x0, (int)(200 * lead_status_alpha)));
-            painter.drawText(textRect.translated(shadow_offset.x(), shadow_offset.y()),
-                           Qt::AlignBottom | Qt::AlignHCenter, text_lines[i]);
-
-            // Determine text color based on content and danger level
-            QColor text_color;
-
-            // Check if this is a distance line (contains 'm' or 'ft')
-            if (text_lines[i].contains("m") || text_lines[i].contains("ft")) {
-                if (d_rel < 20.0f) {
-                    text_color = QColor(255, 80, 80, (int)(255 * lead_status_alpha)); // Red - danger
-                } else if (d_rel < 40.0f) {
-                    text_color = QColor(255, 200, 80, (int)(255 * lead_status_alpha)); // Yellow - caution
-                } else {
-                    text_color = QColor(80, 255, 120, (int)(255 * lead_status_alpha)); // Green - safe
-                }
-            }
-            // Enhanced color coding for time-to-contact
-            else if (text_lines[i].contains("s") && !text_lines[i].contains("---")) {
-                float ttc_val = text_lines[i].left(text_lines[i].length() - 1).toFloat();
-                if (ttc_val < 3.0f) {
-                    text_color = QColor(255, 80, 80, (int)(255 * lead_status_alpha)); // Red - urgent
-                } else if (ttc_val < 6.0f) {
-                    text_color = QColor(255, 200, 80, (int)(255 * lead_status_alpha)); // Yellow - caution
-                } else {
-                    text_color = QColor(0xff, 0xff, 0xff, (int)(255 * lead_status_alpha)); // White - safe
-                }
-            }
-            else {
-                text_color = QColor(0xff, 0xff, 0xff, (int)(255 * lead_status_alpha)); // White for other lines
-            }
-
-            // Draw main text
-            painter.setPen(text_color);
-            painter.drawText(textRect, Qt::AlignBottom | Qt::AlignHCenter, text_lines[i]);
-        }
-    }
-
-    // Reset pen
-    painter.setPen(Qt::NoPen);
-}
-
 void ModelRenderer::drawLead(QPainter &painter, const cereal::RadarState::LeadData::Reader &lead_data,
                              const QPointF &vd, const QRect &surface_rect) {
   const float speedBuff = 10.;
@@ -402,4 +235,4 @@ void ModelRenderer::mapLineToPolygon(const cereal::XYZTData::Reader &line, float
       pvd->push_front(right);
     }
   }
-}
+}

selfdrive/ui/qt/onroad/model.h

@@ -34,12 +34,6 @@ protected:
   bool mapToScreen(float in_x, float in_y, float in_z, QPointF *out);
   void mapLineToPolygon(const cereal::XYZTData::Reader &line, float y_off, float z_off,
                         QPolygonF *pvd, int max_idx, bool allow_invert = true);
-  void drawLeadStatus(QPainter &painter, int height, int width);
-  void drawLeadStatusAtPosition(QPainter &painter,
-                             const cereal::RadarState::LeadData::Reader &lead_data,
-                             const QPointF &chevron_pos,
-                             int height, int width,
-                             const QString &label);
   void drawLead(QPainter &painter, const cereal::RadarState::LeadData::Reader &lead_data, const QPointF &vd, const QRect &surface_rect);
   void update_leads(const cereal::RadarState::Reader &radar_state, const cereal::XYZTData::Reader &line);
   virtual void update_model(const cereal::ModelDataV2::Reader &model, const cereal::RadarState::LeadData::Reader &lead);
@@ -65,8 +59,4 @@ protected:
   Eigen::Matrix3f car_space_transform = Eigen::Matrix3f::Zero();
   QRectF clip_region;
 
-  float lead_status_alpha = 0.0f;
-  QPointF lead_status_pos;
-  QString lead_status_text;
-  QColor lead_status_color;
 };

selfdrive/ui/sunnypilot/qt/offroad/settings/longitudinal_panel.cc

@@ -23,6 +23,35 @@ LongitudinalPanel::LongitudinalPanel(QWidget *parent) : QWidget(parent) {
 
   QObject::connect(uiState(), &UIState::offroadTransition, this, &LongitudinalPanel::refresh);
 
+
+  // Vibe Personality Controller
+  vibePersonalityControl = new ParamControlSP("VibePersonalityEnabled",
+    tr("Vibe Personality Controller"),
+    tr("Advanced driving personality system with separate controls for acceleration behavior (Eco/Normal/Sport) and following distance/braking (Relaxed/Standard/Aggressive). "
+      "Customize your driving experience with independent acceleration and distance personalities."),
+    "../assets/offroad/icon_shell.png");
+  list->addItem(vibePersonalityControl);
+
+  connect(vibePersonalityControl, &ParamControlSP::toggleFlipped, [=]() {
+    refresh(offroad);
+  });
+
+  // Vibe Acceleration Personality
+  vibeAccelPersonalityControl = new ParamControlSP("VibeAccelPersonalityEnabled",
+    tr("Acceleration Personality"),
+    tr("Controls acceleration behavior: Eco (efficient), Normal (balanced), Sport (responsive). "
+      "Adjust how aggressively the vehicle accelerates while maintaining smooth operation."),
+    "../assets/offroad/icon_shell.png");
+  list->addItem(vibeAccelPersonalityControl);
+
+  // Vibe Following Distance Personality
+  vibeFollowPersonalityControl = new ParamControlSP("VibeFollowPersonalityEnabled",
+    tr("Following Distance Personality"),
+    tr("Controls following distance and braking behavior: Relaxed (longer distance, gentler braking), Standard (balanced), Aggressive (shorter distance, firmer braking). "
+      "Fine-tune your comfort level in traffic situations."),
+    "../assets/offroad/icon_shell.png");
+  list->addItem(vibeFollowPersonalityControl);
+
   main_layout->addWidget(cruisePanelScreen);
   main_layout->setCurrentWidget(cruisePanelScreen);
   refresh(offroad);
@@ -70,10 +99,26 @@ void LongitudinalPanel::refresh(bool _offroad) {
       customAccIncrement->showDescription();
     }
   }
+  bool vibePersonalityEnabled = params.getBool("VibePersonalityEnabled");
+  if (vibePersonalityEnabled) {
+    vibeAccelPersonalityControl->setVisible(true);
+    vibeFollowPersonalityControl->setVisible(true);
+  } else {
+    vibeAccelPersonalityControl->setVisible(false);
+    vibeFollowPersonalityControl->setVisible(false);
+  }
 
   // enable toggle when long is available and is not PCM cruise
   customAccIncrement->setEnabled(has_longitudinal_control && !is_pcm_cruise && !offroad);
   customAccIncrement->refresh();
 
+  // Vibe Personality controls - always enabled for toggling
+  vibePersonalityControl->setEnabled(true);
+  vibeAccelPersonalityControl->setEnabled(true);
+  vibeFollowPersonalityControl->setEnabled(true);
+  vibePersonalityControl->refresh();
+  vibeAccelPersonalityControl->refresh();
+  vibeFollowPersonalityControl->refresh();
+
   offroad = _offroad;
 }

selfdrive/ui/sunnypilot/qt/offroad/settings/longitudinal_panel.h

@@ -29,4 +29,8 @@ private:
   ScrollViewSP *cruisePanelScroller = nullptr;
   QWidget *cruisePanelScreen = nullptr;
   CustomAccIncrement *customAccIncrement = nullptr;
+
+  ParamControlSP *vibePersonalityControl;
+  ParamControlSP *vibeAccelPersonalityControl;
+  ParamControlSP *vibeFollowPersonalityControl;
 };

selfdrive/ui/sunnypilot/qt/offroad/settings/models_panel.cc

@@ -68,6 +68,14 @@ ModelsPanel::ModelsPanel(QWidget *parent) : QWidget(parent) {
   connect(uiStateSP(), &UIStateSP::uiUpdate, this, &ModelsPanel::updateLabels);
   list->addItem(currentModelLblBtn);
 
+  refreshAvailableModelsBtn = new ButtonControlSP(tr("Refresh Model List"), tr("REFRESH"), "", this);
+  connect(refreshAvailableModelsBtn, &ButtonControlSP::clicked, this, [=]() {
+    params.put("ModelManager_LastSyncTime", "0");
+    ConfirmationDialog::alert(tr("Fetching Latest Models"), this);
+  });
+
+  list->addItem(refreshAvailableModelsBtn);
+
   clearModelCacheBtn = new ButtonControlSP(tr("Clear Model Cache"), tr("CLEAR"), "", this);
   connect(clearModelCacheBtn, &ButtonControlSP::clicked, this, &ModelsPanel::clearModelCache);
 

selfdrive/ui/sunnypilot/qt/offroad/settings/models_panel.h

@@ -79,5 +79,6 @@ private:
   QFrame *policyFrame;
   Params params;
   ButtonControlSP *clearModelCacheBtn;
+  ButtonControlSP *refreshAvailableModelsBtn;
 
 };

selfdrive/ui/sunnypilot/qt/onroad/model.cc

@@ -48,5 +48,162 @@ void ModelRendererSP::drawPath(QPainter &painter, const cereal::ModelDataV2::Rea
       painter.drawPolygon(right_blindspot_vertices);
     }
   }
+
   ModelRenderer::drawPath(painter, model, surface_rect.height());
+
+  drawLeadStatus(painter, surface_rect.height(), surface_rect.width());
+}
+
+void ModelRendererSP::drawLeadStatus(QPainter &painter, int height, int width) {
+    auto *s = uiState();
+    auto &sm = *(s->sm);
+
+    if (!sm.alive("radarState")) return;
+
+    const auto &radar_state = sm["radarState"].getRadarState();
+    const auto &lead_one = radar_state.getLeadOne();
+    const auto &lead_two = radar_state.getLeadTwo();
+
+    // Check if we have any active leads
+    bool has_lead_one = lead_one.getStatus();
+    bool has_lead_two = lead_two.getStatus();
+
+    if (!has_lead_one && !has_lead_two) {
+        // Fade out status display
+        lead_status_alpha = std::max(0.0f, lead_status_alpha - 0.05f);
+        if (lead_status_alpha <= 0.0f) return;
+    } else {
+        // Fade in status display
+        lead_status_alpha = std::min(1.0f, lead_status_alpha + 0.1f);
+    }
+
+    if (has_lead_one) {
+        drawLeadStatusAtPosition(painter, lead_one, lead_vertices[0], height, width, "L1");
+    }
+
+    if (has_lead_two && std::abs(lead_one.getDRel() - lead_two.getDRel()) > 3.0) {
+        drawLeadStatusAtPosition(painter, lead_two, lead_vertices[1], height, width, "L2");
+    }
+}
+
+void ModelRendererSP::drawLeadStatusAtPosition(QPainter &painter,
+                                           const cereal::RadarState::LeadData::Reader &lead_data,
+                                           const QPointF &chevron_pos,
+                                           int height, int width,
+                                           const QString &label) {
+
+    float d_rel = lead_data.getDRel();
+    float v_rel = lead_data.getVRel();
+    auto *s = uiState();
+    auto &sm = *(s->sm);
+    float v_ego = sm["carState"].getCarState().getVEgo();
+
+    int chevron_data = std::atoi(Params().get("ChevronInfo").c_str());
+
+    // Calculate chevron size (same logic as drawLead)
+    float sz = std::clamp((25 * 30) / (d_rel / 3 + 30), 15.0f, 30.0f) * 2.35;
+
+    QFont content_font = painter.font();
+    content_font.setPixelSize(42);
+    content_font.setBold(true);
+    painter.setFont(content_font);
+
+    QFontMetrics fm(content_font);
+    bool is_metric = s->scene.is_metric;
+
+    QStringList text_lines;
+
+    const int chevron_types = 3;
+    const int chevron_all = chevron_types + 1;  // All metrics (value 4)
+    QStringList chevron_text[chevron_types];
+    int position;
+    float val;
+
+    // Distance display (chevron_data == 1 or all)
+    if (chevron_data == 1 || chevron_data == chevron_all) {
+        position = 0;
+        val = std::max(0.0f, d_rel);
+        QString distance_unit = is_metric ? "m" : "ft";
+        if (!is_metric) {
+            val *= 3.28084f; // Convert meters to feet
+        }
+        chevron_text[position].append(QString::number(val, 'f', 0) + " " + distance_unit);
+    }
+
+    // Absolute velocity display (chevron_data == 2 or all)
+    if (chevron_data == 2 || chevron_data == chevron_all) {
+        position = (chevron_data == 2) ? 0 : 1;
+        val = std::max(0.0f, (v_rel + v_ego) * (is_metric ? static_cast<float>(MS_TO_KPH) : static_cast<float>(MS_TO_MPH)));
+        chevron_text[position].append(QString::number(val, 'f', 0) + " " + (is_metric ? "km/h" : "mph"));
+    }
+
+    // Time-to-contact display (chevron_data == 3 or all)
+    if (chevron_data == 3 || chevron_data == chevron_all) {
+        position = (chevron_data == 3) ? 0 : 2;
+        val = (d_rel > 0 && v_ego > 0) ? std::max(0.0f, d_rel / v_ego) : 0.0f;
+        QString ttc_str = (val > 0 && val < 200) ? QString::number(val, 'f', 1) + "s" : "---";
+        chevron_text[position].append(ttc_str);
+    }
+
+    // Collect all non-empty text lines
+    for (int i = 0; i < chevron_types; ++i) {
+        if (!chevron_text[i].isEmpty()) {
+            text_lines.append(chevron_text[i]);
+        }
+    }
+
+    // If no text to display, return early
+    if (text_lines.isEmpty()) {
+        return;
+    }
+
+    // Text box dimensions
+    float str_w = 150;  // Width of text area
+    float str_h = 45;   // Height per line
+
+    // Position text below chevron, centered horizontally
+    float text_x = chevron_pos.x() - str_w / 2;
+    float text_y = chevron_pos.y() + sz + 15;
+
+    // Clamp to screen bounds
+    text_x = std::clamp(text_x, 10.0f, (float)width - str_w - 10);
+
+    // Shadow offset
+    QPoint shadow_offset(2, 2);
+
+    // Draw each line of text with shadow
+    for (int i = 0; i < text_lines.size(); ++i) {
+        if (!text_lines[i].isEmpty()) {
+            QRect textRect(text_x, text_y + (i * str_h), str_w, str_h);
+
+            // Draw shadow
+            painter.setPen(QColor(0x0, 0x0, 0x0, (int)(200 * lead_status_alpha)));
+            painter.drawText(textRect.translated(shadow_offset.x(), shadow_offset.y()),
+                           Qt::AlignBottom | Qt::AlignHCenter, text_lines[i]);
+
+            // Determine text color based on content and danger level
+            QColor text_color;
+
+            // Check if this is a distance line (contains 'm' or 'ft')
+            if (text_lines[i].contains("m") || text_lines[i].contains("ft")) {
+                if (d_rel < 20.0f) {
+                    text_color = QColor(255, 80, 80, (int)(255 * lead_status_alpha)); // Red - danger
+                } else if (d_rel < 40.0f) {
+                    text_color = QColor(255, 200, 80, (int)(255 * lead_status_alpha)); // Yellow - caution
+                } else {
+                    text_color = QColor(80, 255, 120, (int)(255 * lead_status_alpha)); // Green - safe
+                }
+            }
+            else {
+                text_color = QColor(0xff, 0xff, 0xff, (int)(255 * lead_status_alpha)); // White for other lines
+            }
+
+            // Draw main text
+            painter.setPen(text_color);
+            painter.drawText(textRect, Qt::AlignBottom | Qt::AlignHCenter, text_lines[i]);
+        }
+    }
+
+    // Reset pen
+    painter.setPen(Qt::NoPen);
 }

selfdrive/ui/sunnypilot/qt/onroad/model.h

@@ -17,6 +17,17 @@ private:
   void update_model(const cereal::ModelDataV2::Reader &model, const cereal::RadarState::LeadData::Reader &lead) override;
   void drawPath(QPainter &painter, const cereal::ModelDataV2::Reader &model, const QRect &rect) override;
 
+  // Lead status display methods
+  void drawLeadStatus(QPainter &painter, int height, int width);
+  void drawLeadStatusAtPosition(QPainter &painter,
+                               const cereal::RadarState::LeadData::Reader &lead_data,
+                               const QPointF &chevron_pos,
+                               int height, int width,
+                               const QString &label);
+
   QPolygonF left_blindspot_vertices;
   QPolygonF right_blindspot_vertices;
-};
+
+  // Lead status animation
+  float lead_status_alpha = 0.0f;
+};

selfdrive/ui/ui.h

@@ -60,6 +60,7 @@ typedef struct UIScene {
   cereal::PandaState::PandaType pandaType;
 
   cereal::LongitudinalPersonality personality;
+  cereal::LongitudinalPlanSP::AccelerationPersonality accel_personality;
 
   float light_sensor = -1;
   bool started, ignition, is_metric, recording_audio;

sunnypilot/models/README.md

@@ -0,0 +1,63 @@
+# Model Selector Version Compatibility
+
+This document explains the version compatibility mechanism used by the Model Selector system, and the rationale behind certain version constraints and JSON file management strategies.
+
+## Overview
+
+The Model Selector is responsible for selecting and validating model bundles based on their metadata and version constraints. Each model bundle is distributed via a JSON file and includes a `minimumSelectorVersion` field indicating the minimum selector version required to load it.
+
+To ensure robust compatibility and prevent mismatches between model expectations and selector capabilities, the selector enforces two version boundaries:
+
+* **`REQUIRED_MIN_SELECTOR_VERSION`**: the oldest selector version we support.
+* **`CURRENT_SELECTOR_VERSION`**: the current version of the selector logic.
+
+## Version Compatibility Check
+
+A model bundle is considered compatible if:
+
+```python
+REQUIRED_MIN_SELECTOR_VERSION <= bundle["minimumSelectorVersion"] <= CURRENT_SELECTOR_VERSION
+```
+
+This ensures:
+
+* **Old bundles are rejected** if they rely on deprecated selector behavior.
+* **Future bundles are ignored** if they expect logic that the current selector doesn't yet implement.
+
+## Handling Breaking Changes
+
+When a deep change in selector behavior requires *all* models to be recompiled (e.g., due to a major architectural update), we:
+
+1. **Create a new JSON file** (e.g., from `models_v4.json` to `models_v5.json`).
+2. **Assign updated `minimumSelectorVersion` values** in the new bundles.
+
+This allows older selector versions to continue using the previous JSON file, while newer versions point to the new one, preventing cross-contamination.
+
+## Why `REQUIRED_MIN_SELECTOR_VERSION` Still Matters
+
+Despite using new JSON files to isolate breaking changes, `REQUIRED_MIN_SELECTOR_VERSION` plays a critical role:
+
+### 1. **Cached Bundle Validation**
+
+Model bundles are cached locally (e.g., in-memory or on disk). A user might have previously loaded a now-invalid bundle from an older JSON file.
+
+`REQUIRED_MIN_SELECTOR_VERSION` prevents the selector from reloading or trusting that stale cached bundle, even if the original JSON is gone.
+
+### 2. **Explicit Deprecation Boundary**
+
+By raising `REQUIRED_MIN_SELECTOR_VERSION`, we declare older bundles officially unsupported, even if they technically still exist in a legacy JSON file.
+
+### 3. **Avoiding Race Conditions**
+
+Some clients may have intermittent access to updated JSONs. The runtime check ensures version compatibility is enforced independently of external file state.
+
+## Summary
+
+| Component                       | Purpose                                                               |
+| ------------------------------- | --------------------------------------------------------------------- |
+| `minimumSelectorVersion`        | Declares the minimum selector version required to load a model bundle |
+| `REQUIRED_MIN_SELECTOR_VERSION` | Prevents loading bundles that are too old (e.g., from stale cache)    |
+| `CURRENT_SELECTOR_VERSION`      | Prevents loading bundles that are too new or forward-incompatible     |
+| JSON file renaming              | Isolates bundles by selector generation to handle full recompiles     |
+
+This layered strategy ensures safe evolution of the model selection system while maintaining backward compatibility and runtime protection against stale or incompatible bundles.

sunnypilot/models/fetcher.py

@@ -115,7 +115,7 @@ class ModelCache:
 
 class ModelFetcher:
   """Handles fetching and caching of model data from remote source"""
-  MODEL_URL = "https://docs.sunnypilot.ai/driving_models_v4.json"
+  MODEL_URL = "https://docs.sunnypilot.ai/driving_models_v6.json"
 
   def __init__(self, params: Params):
     self.params = params

sunnypilot/models/helpers.py

@@ -19,8 +19,9 @@ from openpilot.system.hardware import PC
 from openpilot.system.hardware.hw import Paths
 from pathlib import Path
 
-CURRENT_SELECTOR_VERSION = 7
-REQUIRED_MIN_SELECTOR_VERSION = 5
+# see the README.md for more details on the model selector versioning
+CURRENT_SELECTOR_VERSION = 8
+REQUIRED_MIN_SELECTOR_VERSION = 6
 
 USE_ONNX = os.getenv('USE_ONNX', PC)
 

sunnypilot/selfdrive/controls/lib/longitudinal_planner.py

@@ -10,12 +10,14 @@ from opendbc.car import structs
 from openpilot.sunnypilot.selfdrive.controls.lib.dec.dec import DynamicExperimentalController
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 
+from openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality import VibePersonalityController
 DecState = custom.LongitudinalPlanSP.DynamicExperimentalControl.DynamicExperimentalControlState
 
 
 class LongitudinalPlannerSP:
   def __init__(self, CP: structs.CarParams, mpc):
     self.dec = DynamicExperimentalController(CP, mpc)
+    self.vibe_controller = VibePersonalityController()
     self.generation = int(model_bundle.generation) if (model_bundle := get_active_bundle()) else None
 
   @property
@@ -31,6 +33,7 @@ class LongitudinalPlannerSP:
 
   def update(self, sm: messaging.SubMaster) -> None:
     self.dec.update(sm)
+    self.vibe_controller.update()
 
   def publish_longitudinal_plan_sp(self, sm: messaging.SubMaster, pm: messaging.PubMaster) -> None:
     plan_sp_send = messaging.new_message('longitudinalPlanSP')

sunnypilot/selfdrive/controls/lib/vibe_personality/tests/test_vibe.py

@@ -0,0 +1,286 @@
+"""
+Test suite for VibePersonalityController
+
+Tests the core functionality of the vibe personality system including
+acceleration profiles, following distance, and personality management.
+"""
+
+import pytest
+import numpy as np
+from pytest_mock import MockerFixture
+from cereal import log, custom
+
+from openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality import VibePersonalityController
+
+AccelPersonality = custom.LongitudinalPlanSP.AccelerationPersonality
+LongPersonality = log.LongitudinalPersonality
+
+
+class TestVibePersonalityController:
+  """Test suite for VibePersonalityController"""
+
+  @pytest.fixture
+  def mock_params(self, mocker: MockerFixture):
+    """Mock Params with realistic behavior"""
+    mock = mocker.Mock()
+    mock.get.return_value = None
+    mock.get_bool.return_value = True
+    mock.put.return_value = None
+    mock.put_bool.return_value = None
+    return mock
+
+  @pytest.fixture
+  def controller(self, mock_params, mocker: MockerFixture):
+    """Create controller with mocked dependencies"""
+    mocker.patch('openpilot.sunnypilot.selfdrive.controls.lib.vibe_personality.vibe_personality.Params', return_value=mock_params)
+    controller = VibePersonalityController()
+    controller.params = mock_params
+    return controller
+
+  def test_initialization_sets_correct_defaults(self, controller):
+    """Controller should initialize with expected default values"""
+    assert controller.accel_personality == AccelPersonality.normal
+    assert controller.long_personality == LongPersonality.standard
+    assert controller.frame == 0
+    assert hasattr(controller, 'max_accel_slopes')
+    assert hasattr(controller, 'min_accel_slopes')
+    assert hasattr(controller, 'follow_distance_slopes')
+
+  def test_accel_personality_management(self, controller):
+    """Test acceleration personality setting and cycling"""
+    # Valid personality setting
+    result = controller.set_accel_personality(AccelPersonality.sport)
+    assert result is True
+    assert controller.accel_personality == AccelPersonality.sport
+    controller.params.put.assert_called_with('AccelPersonality', str(AccelPersonality.sport))
+
+    # Invalid personality setting
+    result = controller.set_accel_personality(999)
+    assert result is False
+    assert controller.accel_personality == AccelPersonality.sport  # unchanged
+
+    # Cycling behavior
+    controller.set_accel_personality(AccelPersonality.eco)
+    assert controller.cycle_accel_personality() == AccelPersonality.normal
+    assert controller.cycle_accel_personality() == AccelPersonality.sport
+    assert controller.cycle_accel_personality() == AccelPersonality.eco
+
+  def test_long_personality_management(self, controller):
+    """Test longitudinal personality setting and cycling"""
+    # Valid setting
+    result = controller.set_long_personality(LongPersonality.aggressive)
+    assert result is True
+    assert controller.long_personality == LongPersonality.aggressive
+
+    # Invalid setting
+    result = controller.set_long_personality(-1)
+    assert result is False
+
+    # Cycling
+    controller.set_long_personality(LongPersonality.relaxed)
+    assert controller.cycle_long_personality() == LongPersonality.standard
+    assert controller.cycle_long_personality() == LongPersonality.aggressive
+    assert controller.cycle_long_personality() == LongPersonality.relaxed
+
+  def test_enable_disable_logic(self, controller):
+    """Test feature enable/disable states"""
+    # Mock enabled state
+    controller.params.get_bool.return_value = True
+    assert controller.is_enabled() is True
+    assert controller.is_accel_enabled() is True
+    assert controller.is_follow_enabled() is True
+
+    # Mock disabled state
+    controller.params.get_bool.return_value = False
+    assert controller.is_enabled() is False
+    assert controller.is_accel_enabled() is False
+    assert controller.is_follow_enabled() is False
+
+    # Test partial disable (only main toggle off)
+    def mock_get_bool(key):
+      return key != 'VibePersonalityEnabled'
+    controller.params.get_bool.side_effect = mock_get_bool
+    assert controller.is_accel_enabled() is False
+    assert controller.is_follow_enabled() is False
+
+  def test_get_accel_limits_returns_valid_range(self, controller):
+    """Acceleration limits should return valid min/max values"""
+    controller.params.get_bool.return_value = True
+
+    # Test at multiple speeds
+    for speed in [0.0, 15.0, 30.0]:
+      limits = controller.get_accel_limits(speed)
+      assert limits is not None, f"Failed at speed {speed}"
+
+      min_a, max_a = limits
+      assert isinstance(min_a, float)
+      assert isinstance(max_a, float)
+      assert min_a < 0, "Min acceleration should be negative (braking)"
+      assert max_a > 0, "Max acceleration should be positive"
+      assert min_a < max_a, "Min should be less than max"
+
+  def test_get_accel_limits_returns_none_when_disabled(self, controller):
+    """Should return None when acceleration control is disabled"""
+    controller.params.get_bool.return_value = False
+    assert controller.get_accel_limits(20.0) is None
+
+  def test_get_follow_distance_multiplier_returns_positive_value(self, controller):
+    """Follow distance multiplier should be positive"""
+    controller.params.get_bool.return_value = True
+
+    multiplier = controller.get_follow_distance_multiplier(20.0)
+    assert multiplier is not None
+    assert isinstance(multiplier, float)
+    assert multiplier > 0
+
+  def test_get_follow_distance_multiplier_returns_none_when_disabled(self, controller):
+    """Should return None when follow distance control is disabled"""
+    controller.params.get_bool.return_value = False
+    assert controller.get_follow_distance_multiplier(20.0) is None
+
+  def test_personality_differences_produce_different_results(self, controller):
+    """Different personalities should produce measurably different outputs"""
+    controller.params.get_bool.return_value = True
+
+    # Test acceleration personality differences
+    controller.set_accel_personality(AccelPersonality.eco)
+    eco_limits = controller.get_accel_limits(15.0)
+
+    controller.set_accel_personality(AccelPersonality.sport)
+    sport_limits = controller.get_accel_limits(15.0)
+
+    assert sport_limits[1] > eco_limits[1], "Sport should allow higher acceleration than eco"
+
+    # Test following distance personality differences
+    controller.set_long_personality(LongPersonality.relaxed)
+    relaxed_dist = controller.get_follow_distance_multiplier(20.0)
+
+    controller.set_long_personality(LongPersonality.aggressive)
+    aggressive_dist = controller.get_follow_distance_multiplier(20.0)
+
+    assert relaxed_dist > aggressive_dist, "Relaxed should have longer following distance"
+
+  def test_interpolation_functions_work_correctly(self, controller):
+    """Test mathematical interpolation functions"""
+    # Test slope computation
+    x = np.array([0., 10., 20.])
+    y = np.array([1.0, 2.0, 1.5])
+    slopes = controller._compute_slopes(x, y)
+
+    assert len(slopes) == len(x)
+    assert all(np.isfinite(slope) for slope in slopes)
+
+    # Test interpolation accuracy at known points
+    result_0 = controller._interpolate(0.0, x, y, slopes)
+    result_10 = controller._interpolate(10.0, x, y, slopes)
+
+    assert abs(result_0 - 1.0) < 1e-6, "Interpolation should be exact at breakpoints"
+    assert abs(result_10 - 2.0) < 1e-6, "Interpolation should be exact at breakpoints"
+
+    # Test interpolation bounds
+    result_below = controller._interpolate(-5.0, x, y, slopes)
+    result_above = controller._interpolate(25.0, x, y, slopes)
+    assert abs(result_below - y[0]) < 1e-6, "Should clamp to first value"
+    assert abs(result_above - y[-1]) < 1e-6, "Should clamp to last value"
+
+  def test_get_personality_info_returns_complete_info(self, controller):
+    """Personality info should contain all required fields"""
+    info = controller.get_personality_info()
+
+    required_fields = [
+      'accel_personality', 'accel_personality_int',
+      'long_personality', 'long_personality_int',
+      'enabled', 'accel_enabled', 'follow_enabled'
+    ]
+
+    for field in required_fields:
+      assert field in info, f"Missing required field: {field}"
+
+    assert info['accel_personality'] in ['Eco', 'Normal', 'Sport']
+    assert info['long_personality'] in ['Relaxed', 'Standard', 'Aggressive']
+    assert isinstance(info['enabled'], bool)
+
+  def test_toggle_functions_change_state(self, controller):
+    """Toggle functions should change parameter states"""
+    # Mock current enabled state
+    controller.params.get_bool.return_value = True
+
+    # Test main toggle
+    result = controller.toggle_personality()
+    assert result is False  # should return new state
+    controller.params.put_bool.assert_called_with('VibePersonalityEnabled', False)
+
+    # Test specific toggles
+    controller.params.get_bool.return_value = True
+    controller.toggle_accel_personality()
+    controller.params.put_bool.assert_called_with('VibeAccelPersonalityEnabled', False)
+
+    controller.toggle_follow_distance_personality()
+    controller.params.put_bool.assert_called_with('VibeFollowPersonalityEnabled', False)
+
+  def test_reset_restores_defaults(self, controller):
+    """Reset should restore controller to default state"""
+    # Change from defaults
+    controller.set_accel_personality(AccelPersonality.sport)
+    controller.set_long_personality(LongPersonality.aggressive)
+    controller.frame = 1000
+
+    # Reset and verify defaults
+    controller.reset()
+    assert controller.accel_personality == AccelPersonality.normal
+    assert controller.long_personality == LongPersonality.standard
+    assert controller.frame == 0
+
+  def test_update_increments_frame_counter(self, controller):
+    """Update should increment frame counter with wraparound"""
+    initial_frame = controller.frame
+    controller.update()
+    assert controller.frame == initial_frame + 1
+
+    # Test wraparound
+    controller.frame = 999999
+    controller.update()
+    assert controller.frame == 0
+
+  def test_individual_accel_methods(self, controller):
+    """Test individual min/max accel convenience methods"""
+    controller.params.get_bool.return_value = True
+
+    min_accel = controller.get_min_accel(15.0)
+    max_accel = controller.get_max_accel(15.0)
+
+    assert min_accel is not None
+    assert max_accel is not None
+    assert min_accel < 0
+    assert max_accel > 0
+
+    # Test disabled state
+    controller.params.get_bool.return_value = False
+    assert controller.get_min_accel(15.0) is None
+    assert controller.get_max_accel(15.0) is None
+
+  @pytest.mark.parametrize("speed", [0.0, 5.0, 15.0, 25.0, 40.0, 55.0])
+  def test_accel_limits_at_various_speeds(self, controller, speed):
+    """Test acceleration limits across speed range"""
+    controller.params.get_bool.return_value = True
+
+    limits = controller.get_accel_limits(speed)
+    assert limits is not None
+
+    min_a, max_a = limits
+    assert min_a < max_a
+    assert -2.0 < min_a < 0  # Reasonable braking range
+    assert 0 < max_a < 3.0   # Reasonable acceleration range
+
+  def test_error_handling_in_interpolation(self, controller):
+    """Test interpolation handles edge cases gracefully"""
+    # Test with minimal points
+    x = [0., 1.]
+    y = [1.0, 2.0]
+    slopes = controller._compute_slopes(x, y)
+    result = controller._interpolate(0.5, x, y, slopes)
+    assert 1.0 <= result <= 2.0
+
+    # Test with insufficient points
+    with pytest.raises(ValueError):
+      controller._compute_slopes([0.], [1.0])

sunnypilot/selfdrive/controls/lib/vibe_personality/vibe_personality.py

@@ -0,0 +1,306 @@
+"""
+Copyright (c) 2021-, rav4kumar, 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.
+"""
+
+from cereal import log, custom
+import numpy as np
+from openpilot.common.realtime import DT_MDL
+from openpilot.common.params import Params
+
+LongPersonality = log.LongitudinalPersonality
+AccelPersonality = custom.LongitudinalPlanSP.AccelerationPersonality
+
+# Acceleration Profiles mapped to AccelPersonality (eco/normal/sport)
+MAX_ACCEL_PROFILES = {
+  AccelPersonality.eco:       [2.00, 2.00, 1.32, 0.85, .58,  .46, .365, .317, .089],  # eco
+  AccelPersonality.normal:    [2.00, 2.00, 1.42, 1.10, .65,  .56, .43, .36, .12],   # normal
+  AccelPersonality.sport:     [2.00, 2.00, 1.52, 1.40, .80,  .70, .53, .46, .20],   # sport
+}
+MAX_ACCEL_BREAKPOINTS =       [0.,   6.,   9.,   11.,  16.,  20., 25., 30., 55.]
+
+# Braking profiles mapped to LongPersonality (relaxed/standard/aggressive)
+MIN_ACCEL_PROFILES = {
+  LongPersonality.relaxed:    [-1.20, -1.20],  # gentler braking
+  LongPersonality.standard:   [-1.30, -1.30],  # normal braking
+  LongPersonality.aggressive: [-1.40, -1.40],  # more aggressive braking
+}
+MIN_ACCEL_BREAKPOINTS =       [0., 50.]
+
+# Following Distance Profiles mapped to LongPersonality (relaxed/standard/aggressive)
+FOLLOW_DISTANCE_PROFILES = {
+  LongPersonality.relaxed: {
+    'x_vel':  [0.,   19.7, 22.2, 40.],
+    'y_dist': [1.40, 1.40, 1.65, 1.65]  # longer following distance
+  },
+  LongPersonality.standard: {
+    'x_vel':  [0.,   19.7, 22.2, 40.],
+    'y_dist': [1.35, 1.35, 1.40, 1.40]  # normal following distance
+  },
+  LongPersonality.aggressive: {
+    'x_vel':  [0.,   19.7, 22.2, 40.],
+    'y_dist': [1.20, 1.20, 1.30, 1.30]  # shorter following distance
+  }
+}
+
+class VibePersonalityController:
+  """
+  Controller for managing separated acceleration and distance controls:
+  - AccelPersonality controls acceleration behavior (eco, normal, sport)
+  - LongPersonality controls braking and following distance (relaxed, standard, aggressive)
+  """
+
+  def __init__(self):
+    self.params = Params()
+    self.frame = 0
+
+    # Separate personalities for acceleration and distance control
+    self.accel_personality = AccelPersonality.normal
+    self.long_personality = LongPersonality.standard
+
+    # Parameter keys
+    self.param_keys = {
+      'accel_personality': 'AccelPersonality',        # eco=0, normal=1, sport=2
+      'long_personality': 'LongitudinalPersonality',  # relaxed=0, standard=1, aggressive=2
+      'enabled': 'VibePersonalityEnabled',
+      'accel_enabled': 'VibeAccelPersonalityEnabled',
+      'follow_enabled': 'VibeFollowPersonalityEnabled'
+    }
+
+    # Precompute slopes for all personalities
+    self._precompute_slopes()
+
+  def _precompute_slopes(self):
+    """Precompute all interpolation slopes for efficiency"""
+    self.max_accel_slopes = {}
+    self.min_accel_slopes = {}
+    self.follow_distance_slopes = {}
+
+    # Precompute for AccelPersonality (acceleration)
+    for personality in [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]:
+      if personality in MAX_ACCEL_PROFILES:
+        self.max_accel_slopes[personality] = self._compute_slopes(MAX_ACCEL_BREAKPOINTS, MAX_ACCEL_PROFILES[personality])
+
+    # Precompute for LongPersonality (braking and following)
+    for personality in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
+      if personality in MIN_ACCEL_PROFILES:
+        self.min_accel_slopes[personality] = self._compute_slopes(MIN_ACCEL_BREAKPOINTS, MIN_ACCEL_PROFILES[personality])
+
+      if personality in FOLLOW_DISTANCE_PROFILES:
+        profile = FOLLOW_DISTANCE_PROFILES[personality]
+        self.follow_distance_slopes[personality] = self._compute_slopes(profile['x_vel'], profile['y_dist'])
+
+  def _update_from_params(self):
+    """Update personalities from params (rate limited)"""
+    if self.frame % int(1. / DT_MDL) != 0:
+      return
+
+    # Update AccelPersonality
+    try:
+      accel_personality_str = self.params.get(self.param_keys['accel_personality'], encoding='utf-8')
+      if accel_personality_str:
+        accel_personality_int = int(accel_personality_str)
+        if accel_personality_int in [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]:
+          self.accel_personality = accel_personality_int
+    except (ValueError, TypeError):
+      pass
+
+    # Update LongPersonality
+    try:
+      long_personality_str = self.params.get(self.param_keys['long_personality'], encoding='utf-8')
+      if long_personality_str:
+        long_personality_int = int(long_personality_str)
+        if long_personality_int in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
+          self.long_personality = long_personality_int
+    except (ValueError, TypeError):
+      pass
+
+  def _get_toggle_state(self, key: str, default: bool = True) -> bool:
+    """Get toggle state with default fallback"""
+    return self.params.get_bool(self.param_keys.get(key, key)) if key in self.param_keys else default
+
+  def _set_toggle_state(self, key: str, value: bool):
+    """Set toggle state in params"""
+    if key in self.param_keys:
+      self.params.put_bool(self.param_keys[key], value)
+
+  # AccelPersonality Management (for acceleration)
+  def set_accel_personality(self, personality: int) -> bool:
+    """Set AccelPersonality (eco=0, normal=1, sport=2)"""
+    if personality in [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]:
+      self.accel_personality = personality
+      self.params.put(self.param_keys['accel_personality'], str(personality))
+      return True
+    return False
+
+  def cycle_accel_personality(self) -> int:
+    """Cycle through AccelPersonality: eco -> normal -> sport -> eco"""
+    personalities = [AccelPersonality.eco, AccelPersonality.normal, AccelPersonality.sport]
+    current_idx = personalities.index(self.accel_personality)
+    next_personality = personalities[(current_idx + 1) % len(personalities)]
+    self.set_accel_personality(next_personality)
+    return int(next_personality)
+
+  def get_accel_personality(self) -> int:
+    """Get current AccelPersonality"""
+    self._update_from_params()
+    return int(self.accel_personality)
+
+  # LongPersonality Management (for braking and following distance)
+  def set_long_personality(self, personality: int) -> bool:
+    """Set LongPersonality (relaxed=0, standard=1, aggressive=2)"""
+    if personality in [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]:
+      self.long_personality = personality
+      self.params.put(self.param_keys['long_personality'], str(personality))
+      return True
+    return False
+
+  def cycle_long_personality(self) -> int:
+    """Cycle through LongPersonality: relaxed -> standard -> aggressive -> relaxed"""
+    personalities = [LongPersonality.relaxed, LongPersonality.standard, LongPersonality.aggressive]
+    current_idx = personalities.index(self.long_personality)
+    next_personality = personalities[(current_idx + 1) % len(personalities)]
+    self.set_long_personality(next_personality)
+    return int(next_personality)
+
+  def get_long_personality(self) -> int:
+    """Get current LongPersonality"""
+    self._update_from_params()
+    return int(self.long_personality)
+
+  # Toggle Functions
+  def toggle_personality(self): return self._toggle_flag('enabled')
+  def toggle_accel_personality(self): return self._toggle_flag('accel_enabled')
+  def toggle_follow_distance_personality(self): return self._toggle_flag('follow_enabled')
+
+  def _toggle_flag(self, key):
+    current = self._get_toggle_state(key)
+    self._set_toggle_state(key, not current)
+    return not current
+
+  def set_personality_enabled(self, enabled: bool): self._set_toggle_state('enabled', enabled)
+
+  # Feature-specific enable checks
+  def is_accel_enabled(self) -> bool:
+    self._update_from_params()
+    return self._get_toggle_state('enabled') and self._get_toggle_state('accel_enabled')
+
+  def is_follow_enabled(self) -> bool:
+    self._update_from_params()
+    return self._get_toggle_state('enabled') and self._get_toggle_state('follow_enabled')
+
+  def is_enabled(self) -> bool:
+    self._update_from_params()
+    return (self._get_toggle_state('enabled') and
+            (self._get_toggle_state('accel_enabled') or self._get_toggle_state('follow_enabled')))
+
+  def get_accel_limits(self, v_ego: float) -> tuple[float, float] | None:
+    """
+    Get acceleration limits based on current personalities.
+    - Max acceleration from AccelPersonality (eco/normal/sport)
+    - Min acceleration (braking) from LongPersonality (relaxed/standard/aggressive)
+    Returns None if controller is disabled.
+    """
+    self._update_from_params()
+    if not self.is_accel_enabled():
+      return None
+
+    try:
+      # Max acceleration from AccelPersonality
+      max_a = self._interpolate(v_ego, MAX_ACCEL_BREAKPOINTS, MAX_ACCEL_PROFILES[self.accel_personality],
+                                self.max_accel_slopes[self.accel_personality])
+
+      # Min acceleration (braking) from LongPersonality
+      min_a = self._interpolate(v_ego, MIN_ACCEL_BREAKPOINTS, MIN_ACCEL_PROFILES[self.long_personality],
+                                self.min_accel_slopes[self.long_personality])
+
+      return float(min_a), float(max_a)
+    except (KeyError, IndexError):
+      return None
+
+  def get_follow_distance_multiplier(self, v_ego: float) -> float | None:
+    """Get following distance multiplier based on LongPersonality only"""
+    self._update_from_params()
+    if not self.is_follow_enabled():
+      return None
+
+    try:
+      profile = FOLLOW_DISTANCE_PROFILES[self.long_personality]
+      multiplier = float(self._interpolate(v_ego, profile['x_vel'], profile['y_dist'],
+                                           self.follow_distance_slopes[self.long_personality]))
+      return multiplier
+    except (KeyError, IndexError):
+      return None
+
+  def get_personality_info(self) -> dict:
+    """Get comprehensive info about current personalities and settings"""
+    self._update_from_params()
+
+    accel_names = {AccelPersonality.eco: "Eco", AccelPersonality.normal: "Normal", AccelPersonality.sport: "Sport"}
+    long_names = {LongPersonality.relaxed: "Relaxed", LongPersonality.standard: "Standard", LongPersonality.aggressive: "Aggressive"}
+
+    info = {
+      "accel_personality": accel_names.get(self.accel_personality, "Unknown"),
+      "accel_personality_int": self.accel_personality,
+      "long_personality": long_names.get(self.long_personality, "Unknown"),
+      "long_personality_int": self.long_personality,
+      "enabled": self._get_toggle_state('enabled'),
+      "accel_enabled": self._get_toggle_state('accel_enabled'),
+      "follow_enabled": self._get_toggle_state('follow_enabled'),
+      "accel_description": f"Acceleration: {accel_names.get(self.accel_personality, 'Unknown')}",
+      "long_description": f"Following/Braking: {long_names.get(self.long_personality, 'Unknown')}",
+    }
+
+    return info
+
+  def get_min_accel(self, v_ego: float) -> float | None:
+    """Get minimum acceleration (braking) from distance mode"""
+    limits = self.get_accel_limits(v_ego)
+    return limits[0] if limits else None
+
+  def get_max_accel(self, v_ego: float) -> float | None:
+    """Get maximum acceleration from drive mode"""
+    limits = self.get_accel_limits(v_ego)
+    return limits[1] if limits else None
+
+  def reset(self):
+    """Reset to default modes"""
+    self.accel_personality = AccelPersonality.normal
+    self.long_personality = LongPersonality.standard
+    self.frame = 0
+
+  def update(self):
+    """Update frame counter"""
+    self.frame = (self.frame + 1) % 1000000
+
+  def _compute_slopes(self, x, y):
+    """Compute slopes for Hermite interpolation using symmetric difference method."""
+    n = len(x)
+    if n < 2:
+      raise ValueError("At least two points required")
+
+    m = np.zeros(n)
+    for i in range(n):
+      if i == 0:
+        m[i] = (y[1] - y[0]) / (x[1] - x[0])
+      elif i == n-1:
+        m[i] = (y[i] - y[i-1]) / (x[i] - x[i-1])
+      else:
+        m[i] = ((y[i+1] - y[i]) / (x[i+1] - x[i]) + (y[i] - y[i-1]) / (x[i] - x[i-1])) / 2
+    return m
+
+  def _interpolate(self, x, xp, yp, slopes):
+    """Perform cubic Hermite interpolation."""
+    x = np.clip(x, xp[0], xp[-1])
+    idx = np.clip(np.searchsorted(xp, x) - 1, 0, len(slopes) - 2)
+
+    x0, x1 = xp[idx], xp[idx+1]
+    y0, y1 = yp[idx], yp[idx+1]
+    m0, m1 = slopes[idx], slopes[idx+1]
+
+    t = (x - x0) / (x1 - x0)
+    h = [2*t**3 - 3*t**2 + 1, t**3 - 2*t**2 + t, -2*t**3 + 3*t**2, t**3 - t**2]
+
+    return h[0]*y0 + h[1]*(x1 - x0)*m0 + h[2]*y1 + h[3]*(x1 - x0)*m1

system/manager/manager.py

@@ -45,6 +45,7 @@ def manager_init() -> None:
   ]
 
   sunnypilot_default_params: list[tuple[str, str | bytes]] = [
+    ("AccelPersonality", "1"),
     ("AutoLaneChangeTimer", "0"),
     ("AutoLaneChangeBsmDelay", "0"),
     ("BlindSpot", "0"),
@@ -74,6 +75,10 @@ def manager_init() -> None:
     ("QuickBootToggle", "0"),
     ("QuietMode", "0"),
     ("ShowAdvancedControls", "0" if build_metadata.tested_channel else "1"),
+    ("VibePersonalityEnabled", "0"),
+    ("VibeAccelPersonalityEnabled", "0"),
+    ("VibeFollowPersonalityEnabled", "0"),
+
   ]
 
   # device boot mode