scope classification attributes to allowed cameras

Recording fixes (#24072 )
* pin genai review frames to the main stream * retain previews as long as either stream has recordings * watch sub stream recording health separately from main * reject record_sub on the same input as record and document the role * derive recording paths from the cache segment timestamp Recording paths carry one second of resolution, but since sub stream recording start times are resolved to fractional wall clock, anchored to the cache file mtime and chained to the previous segment's end. A stream cutting segments faster than once a second resolves consecutive segments into the same second, so two rows collide on the unique path index and the batch insert fails. The cache segment name is unique per camera stream and second by construction because ffmpeg names segments with strftime, so the recording path is now built from that timestamp while the row keeps the resolved start time. This also restores the path semantics from before sub stream recording, when start times came straight from the cache filename. Nothing derives times from recording paths: playback offsets, stream switching, and export all use the row's start time, which is unchanged, and the recordings sync matches files by exact path string. * keep the rest of a recording batch when one row conflicts * only publish record_sub status when a sub stream is configured * don't shadow camera_cfg when publishing empty cache streams * back off restarts when a recording stream goes stale * give the shared sub stream grace on any capture thread reset * include segment details in recording discard warnings
2026-09-10 04:27:47 -04:00 · 2026-08-25 14:40:13 -05:00 · 2026-08-25 11:51:58 -06:00 · 2026-08-23 14:40:32 -06:00 · 2026-08-23 10:50:03 -06:00 · 2026-08-23 10:31:31 -06:00
261 changed files with 1820 additions and 18938 deletions
@@ -59,16 +59,10 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Start container
        run: |
-          mkdir -p /tmp/frigate-config /tmp/frigate-media
+          mkdir -p /tmp/frigate-config
          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config/config.yml
-          # simulate a root-era install: root-owned 0600 jwt secret pre-exists
-          docker run --rm -v /tmp/frigate-config:/config --entrypoint bash \
-            ${{ steps.setup.outputs.image-name }}-amd64 \
-            -c "python3 -c 'import secrets; open(\"/config/.jwt_secret\",\"w\").write(secrets.token_hex(64))' && chmod 600 /config/.jwt_secret && chown 0:0 /config/.jwt_secret"
          docker run -d --name frigate --shm-size 256m \
            -v /tmp/frigate-config:/config \
-            -v /tmp/frigate-media:/media/frigate \
-            --mount type=tmpfs,target=/tmp/cache,tmpfs-size=100000000 \
            -p 5000:5000 -p 8971:8971 \
            ${{ steps.setup.outputs.image-name }}-amd64
      - name: Wait for API
@@ -97,181 +91,16 @@ jobs:
            echo "response carries frame-ancestors, which breaks cross-origin iframe embedding"
            exit 1
          fi
-          # -t as root would chown the live cache and temp dirs to the `user`
-          # directive user; stdout discarded because -t reopens the config's
-          # /dev/stdout logs and the docker exec pipe is root-owned
-          docker exec frigate /command/s6-setuidgid frigate bash -c '/usr/local/nginx/sbin/nginx -e stderr -t -c /tmp/nginx/conf/nginx.conf >/dev/null'
-          docker exec frigate stat -c %a /config/tls/privkey.pem | grep -qx 600
+          docker exec frigate /usr/local/nginx/sbin/nginx -t
+          docker exec frigate stat -c %a /etc/letsencrypt/live/frigate/privkey.pem | grep -qx 600
          docker exec frigate stat -c %a /dev/shm/go2rtc.yaml | grep -qx 640
-      - name: Assert services run as non-root
-        run: |
-          ps_out=$(docker exec frigate ps -eo user=,comm=)
-          echo "$ps_out"
-          assert_nonroot() {
-            # the process must exist AND no instance of it may run as root
-            echo "$ps_out" | grep -qw "$1" || { echo "$1 is not running"; exit 1; }
-            if echo "$ps_out" | grep -w "$1" | grep -q '^root'; then
-              echo "$1 is running as root"; exit 1
-            fi
-          }
-          assert_nonroot python3
-          assert_nonroot go2rtc
-          assert_nonroot nginx
-          # root-era jwt secret must have been captured by the sweep and the
-          # auth stack must be functional: wrong creds => clean 401, not 500
-          docker exec frigate stat -c %u /config/.jwt_secret | grep -qx "$(docker exec frigate id -u frigate)"
-          code=$(curl -s -o /dev/null -w '%{http_code}' -X POST http://127.0.0.1:5000/api/login \
-            -H 'content-type: application/json' -d '{"user":"admin","password":"definitely-wrong"}')
-          [ "$code" = "401" ] || { echo "login endpoint returned $code"; exit 1; }
-          # a root nginx -t above would have chowned the runtime dirs to root
-          owners=$(docker exec frigate stat -c %U /tmp/nginx /dev/shm/nginx_cache)
-          echo "$owners"
-          if echo "$owners" | grep -qvx frigate; then
-            echo "nginx runtime dirs are not owned by frigate"; exit 1
-          fi
-          # runtime user can write recordings storage
-          docker exec frigate /command/s6-setuidgid frigate touch /media/frigate/.write-probe
-          docker exec frigate rm /media/frigate/.write-probe
-          # tmpfs mount per the docs: arrives root-owned, holds the ZMQ IPC sockets
-          docker exec frigate /command/s6-setuidgid frigate touch /tmp/cache/.write-probe
-          docker exec frigate rm /tmp/cache/.write-probe
-          # models are baked in as root and archive members can carry root-only modes
-          docker exec frigate /command/s6-setuidgid frigate sh -c '
-            for f in /cpu_model.tflite /edgetpu_model.tflite /cpu_audio_model.tflite \
-                     /labelmap.txt /audio-labelmap.txt /openvino-model/*; do
-              [ -e "$f" ] || continue
-              test -r "$f" || { echo "$f is not readable by the runtime user"; exit 1; }
-            done'
-      - name: Assert device access grants
-        run: |
-          # a fake accelerator node created after boot, then the oneshot re-run
-          docker exec frigate mknod /dev/apex_9 c 120 99
-          docker exec frigate /etc/s6-overlay/s6-rc.d/init-devices/run
-          acl=$(docker exec frigate getfacl -p /dev/apex_9)
-          echo "$acl"
-          echo "$acl" | grep -q "user:frigate:rw-"
-          echo "$acl" | grep -q "user:go2rtc:rw-"
-          # the usb tree gets recursive grants plus a default ACL that
-          # newly created nodes inherit (the Coral re-enumeration path)
-          docker exec frigate sh -c 'mkdir -p /dev/bus/usb/001 && mknod /dev/bus/usb/001/002 c 189 1'
-          docker exec frigate /etc/s6-overlay/s6-rc.d/init-devices/run
-          docker exec frigate getfacl -p /dev/bus/usb/001 | grep -q "user:frigate:rwx"
-          docker exec frigate sh -c 'mknod /dev/bus/usb/001/099 c 189 98 && chmod 664 /dev/bus/usb/001/099'
-          inherited=$(docker exec frigate getfacl -p /dev/bus/usb/001/099)
-          echo "$inherited"
-          echo "$inherited" | grep -q "user:frigate:rw-"
-          # getfacl prints granted perms even when the mask clamps them to
-          # nothing, with a trailing "#effective:" comment; a clamped ACL must
-          # fail this assertion, not sneak past it. The check is scoped to the
-          # runtime users because the inherited group:: entry is always clamped
-          # on a non-directory, so an unscoped grep could never pass.
-          if echo "$inherited" | grep -E "^user:(frigate|go2rtc):" | grep -q "effective"; then
-            echo "inherited ACL is mask-clamped and grants no real access"; exit 1
-          fi
-          # hardware that is absent must stay silent: the literal table entries
-          # are not globs, so nullglob does not drop them and only an existence
-          # check keeps them from warning on every boot
-          out=$(docker exec frigate /etc/s6-overlay/s6-rc.d/init-devices/run)
-          echo "$out"
-          if echo "$out" | grep -q "WARN"; then
-            echo "grant warned about device nodes that do not exist"; exit 1
-          fi
-      - name: Assert escape hatch restores root
-        run: |
-          mkdir -p /tmp/frigate-config-root
-          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-root/config.yml
-          # pre-seed so the absence check proves the rm -f, not a vacuous pass
-          echo "2:1000:1000" > /tmp/frigate-config-root/.permissions_version
-          docker run -d --name frigate-root --shm-size 256m \
-            -e FRIGATE_RUN_AS_ROOT=true \
-            -v /tmp/frigate-config-root:/config \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-root curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "escape hatch container never healthy"; docker logs frigate-root; exit 1; fi
-          ps_out=$(docker exec frigate-root ps -eo user=,comm=)
-          echo "$ps_out"
-          echo "$ps_out" | grep -w python3 | grep -q '^root'
-          echo "$ps_out" | grep -w go2rtc  | grep -q '^root'
-          echo "$ps_out" | grep -w nginx   | grep -q '^root'
-          # an if, not ! test: bash exempts negated commands from set -e
-          if docker exec frigate-root test -f /config/.permissions_version; then
-            echo "escape hatch did not delete the sweep sentinel"; exit 1
-          fi
-          docker rm -f frigate-root
-      - name: Assert granular root services
-        run: |
-          mkdir -p /tmp/frigate-config-granular /tmp/frigate-media-granular
-          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-granular/config.yml
-          docker run -d --name frigate-granular --shm-size 256m \
-            -e FRIGATE_ROOT_SERVICES=frigate \
-            -v /tmp/frigate-config-granular:/config \
-            -v /tmp/frigate-media-granular:/media/frigate \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-granular curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "granular container never became healthy"; docker logs frigate-granular; exit 1; fi
-          ps_out=$(docker exec frigate-granular ps -eo user=,comm=)
-          echo "$ps_out"
-          # the listed service runs as root
-          echo "$ps_out" | grep -w python3 | grep -q '^root'
-          # unlisted services still drop; ifs because set -e exempts negated commands
-          if echo "$ps_out" | grep -w go2rtc | grep -q '^root'; then
-            echo "go2rtc is unexpectedly running as root"; exit 1
-          fi
-          if echo "$ps_out" | grep -w nginx | grep -q '^root'; then
-            echo "nginx is unexpectedly running as root"; exit 1
-          fi
-          # the sweep still ran and the sentinel records the mode
-          docker exec frigate-granular cat /config/.permissions_version | grep -qx "2:1000:1000:frigate"
-          # the root frigate process chowns the db it creates (first-boot immediacy)
-          docker exec frigate-granular stat -c %u /config/frigate.db | grep -qx 1000
-          # plant a root-owned straggler; the per-boot sweep must reclaim it on restart
-          docker exec frigate-granular sh -c 'mkdir -p /media/frigate/clips && touch /media/frigate/clips/straggler.webp'
-          docker restart frigate-granular
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-granular curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "granular container never came back after restart"; docker logs frigate-granular; exit 1; fi
-          docker exec frigate-granular stat -c %u /media/frigate/clips/straggler.webp | grep -qx 1000
-          docker rm -f frigate-granular
-      - name: Assert unknown root service fails fast
-        run: |
-          mkdir -p /tmp/frigate-config-badsvc
-          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-badsvc/config.yml
-          docker run -d --name frigate-badsvc --shm-size 256m \
-            -e FRIGATE_ROOT_SERVICES=frigatee \
-            -v /tmp/frigate-config-badsvc:/config \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          found=0
-          for i in $(seq 1 12); do
-            if docker logs frigate-badsvc 2>&1 | grep -q "unknown service 'frigatee'"; then found=1; break; fi
-            sleep 5
-          done
-          if [ "$found" -ne 1 ]; then
-            echo "no fail-fast error for an unknown service name"; docker logs frigate-badsvc; exit 1
-          fi
-          # the failed oneshot blocks startup through the dependency chain
-          if docker exec frigate-badsvc curl -fs http://127.0.0.1:5000/api/version; then
-            echo "container came up despite an invalid FRIGATE_ROOT_SERVICES"; exit 1
-          fi
-          docker rm -f frigate-badsvc
      - name: Assert PUID/PGID remapping
        run: |
-          mkdir -p /tmp/frigate-config-puid /tmp/frigate-media-puid
+          mkdir -p /tmp/frigate-config-puid
          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-puid/config.yml
          docker run -d --name frigate-puid --shm-size 256m \
            -e PUID=1500 -e PGID=1500 \
            -v /tmp/frigate-config-puid:/config \
-            -v /tmp/frigate-media-puid:/media/frigate \
            ${{ steps.setup.outputs.image-name }}-amd64
          up=0
          for i in $(seq 1 60); do
@@ -281,7 +110,7 @@ jobs:
          if [ "$up" -ne 1 ]; then echo "PUID container never became healthy"; docker logs frigate-puid; exit 1; fi
          docker exec frigate-puid id -u frigate | grep -qx 1500
          docker exec frigate-puid id -g frigate | grep -qx 1500
-          docker exec frigate-puid cat /config/.permissions_version | grep -qx "2:1500:1500"
+          docker exec frigate-puid cat /config/.permissions_version | grep -qx "1:1500:1500"
          # second boot must skip the sweep (sentinel hit). Poll rather than
          # sleep: the string can only come from the second boot (the first
          # had no sentinel), so grepping the full log is unambiguous.
@@ -293,129 +122,6 @@ jobs:
          done
          if [ "$ok" -ne 1 ]; then echo "sentinel skip never logged"; docker logs frigate-puid; exit 1; fi
          docker rm -f frigate-puid
-      - name: Assert read-only rootfs with --user works
-        run: |
-          mkdir -p /tmp/frigate-config-ro /tmp/frigate-media-ro
-          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-ro/config.yml
-          sudo chown -R 1000:1000 /tmp/frigate-config-ro /tmp/frigate-media-ro
-          # /run must allow exec: S6_READ_ONLY_ROOT has s6 copy its service
-          # scripts there and run them, and --tmpfs defaults to noexec
-          docker run -d --name frigate-ro --shm-size 256m \
-            --read-only --tmpfs /tmp:rw,size=1g --tmpfs /run:exec,nosuid,nodev,mode=0755 \
-            --user 1000:1000 \
-            --security-opt no-new-privileges:true \
-            -v /tmp/frigate-config-ro:/config \
-            -v /tmp/frigate-media-ro:/media/frigate \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-ro curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "read-only container never healthy"; docker logs frigate-ro; exit 1; fi
-          # an if, not "! grep": bash exempts a negated command from set -e and
-          # the assertion would never fail
-          if docker logs frigate-ro 2>&1 | grep -i "read-only file system"; then
-            echo "a service tried to write to the read-only rootfs"; exit 1
-          fi
-          # the self-signed cert has to land in /config, the only writable path
-          docker exec frigate-ro test -f /config/tls/privkey.pem
-          # and nginx must serve it, which is what proves the templated cert path
-          docker exec frigate-ro curl -ksSI https://127.0.0.1:8971/ >/dev/null
-          # logging must work via the s6-log fallback (no logutil-service as non-root)
-          docker exec frigate-ro test -s /dev/shm/logs/frigate/current
-          # runtime user can write recordings storage
-          docker exec frigate-ro touch /media/frigate/.write-probe
-          docker exec frigate-ro rm /media/frigate/.write-probe
-          docker rm -f frigate-ro
-      - name: Assert PUID with read-only fails fast with clear error
-        run: |
-          docker run -d --name frigate-ro-puid --shm-size 256m \
-            --read-only --tmpfs /tmp:rw,size=1g --tmpfs /run:exec,nosuid,nodev,mode=0755 \
-            -e PUID=1500 -e PGID=1500 \
-            -v /tmp/frigate-config-ro:/config \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          found=0
-          for i in $(seq 1 12); do
-            if docker logs frigate-ro-puid 2>&1 | grep -q "not compatible with read_only"; then found=1; break; fi
-            sleep 5
-          done
-          if [ "$found" -ne 1 ]; then
-            echo "no fail-fast error for PUID with a read-only rootfs"; docker logs frigate-ro-puid; exit 1
-          fi
-          docker rm -f frigate-ro-puid
-      - name: Assert EXTRA_GROUPS with read-only fails fast with clear error
-        run: |
-          docker run -d --name frigate-ro-groups --shm-size 256m \
-            --read-only --tmpfs /tmp:rw,size=1g --tmpfs /run:exec,nosuid,nodev,mode=0755 \
-            -e EXTRA_GROUPS=44 \
-            -v /tmp/frigate-config-ro:/config \
-            -v /tmp/frigate-media-ro:/media/frigate \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          found=0
-          for i in $(seq 1 12); do
-            if docker logs frigate-ro-groups 2>&1 | grep -q "EXTRA_GROUPS needs a writable /etc"; then found=1; break; fi
-            sleep 5
-          done
-          if [ "$found" -ne 1 ]; then
-            echo "no fail-fast error for EXTRA_GROUPS with a read-only rootfs"; docker logs frigate-ro-groups; exit 1
-          fi
-          docker rm -f frigate-ro-groups
-      - name: Assert read-only rootfs in the default mode works
-        run: |
-          mkdir -p /tmp/frigate-config-rod /tmp/frigate-media-rod
-          printf 'mqtt:\n  enabled: false\ncameras: {}\n' > /tmp/frigate-config-rod/config.yml
-          docker run -d --name frigate-rod --shm-size 256m \
-            --read-only --tmpfs /tmp:rw,size=1g --tmpfs /run:exec,nosuid,nodev,mode=0755 \
-            --security-opt no-new-privileges:true \
-            -v /tmp/frigate-config-rod:/config \
-            -v /tmp/frigate-media-rod:/media/frigate \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-rod curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "read-only default-mode container never healthy"; docker logs frigate-rod; exit 1; fi
-          if docker logs frigate-rod 2>&1 | grep -i "read-only file system"; then
-            echo "a service tried to write to the read-only rootfs"; exit 1
-          fi
-          # the point of this mode over docker's user:: the drop still happens
-          # and go2rtc still gets its own separate user
-          ps_out=$(docker exec frigate-rod ps -eo user=,comm=)
-          echo "$ps_out"
-          for svc in python3 nginx; do
-            if echo "$ps_out" | grep -w "$svc" | grep -q '^root'; then
-              echo "$svc is running as root"; exit 1
-            fi
-          done
-          echo "$ps_out" | grep -w go2rtc | grep -q '^go2rtc'
-          # the ownership sweep still ran and recorded itself in /config
-          docker exec frigate-rod cat /config/.permissions_version | grep -qx "2:1000:1000"
-          # setfacl under a read-only rootfs, which nothing else covers:
-          # init-devices exits early under --user, so that path is never reached
-          docker exec frigate-rod mknod /dev/apex_9 c 120 99
-          docker exec frigate-rod /etc/s6-overlay/s6-rc.d/init-devices/run
-          docker exec frigate-rod getfacl -p /dev/apex_9 | grep -q "user:frigate:rw-"
-          docker rm -f frigate-rod
-      - name: "Assert switching that install to user: still starts"
-        run: |
-          # the config dir above now holds a go2rtc-owned go2rtc_homekit.yml,
-          # which user: keeps readable but not writable (no supplementary groups)
-          docker run -d --name frigate-rod-user --shm-size 256m \
-            --read-only --tmpfs /tmp:rw,size=1g --tmpfs /run:exec,nosuid,nodev,mode=0755 \
-            --user 1000:1000 \
-            -v /tmp/frigate-config-rod:/config \
-            -v /tmp/frigate-media-rod:/media/frigate \
-            ${{ steps.setup.outputs.image-name }}-amd64
-          up=0
-          for i in $(seq 1 60); do
-            docker exec frigate-rod-user curl -fs http://127.0.0.1:5000/api/version && up=1 && break
-            sleep 5
-          done
-          if [ "$up" -ne 1 ]; then echo "container did not survive the switch to user:"; docker logs frigate-rod-user; exit 1; fi
-          docker logs frigate-rod-user 2>&1 | grep -q "HomeKit pairing changes will not persist"
-          docker rm -f frigate-rod-user
      - name: Teardown
        if: always()
        run: docker rm -f frigate || true
@@ -28,7 +28,3 @@ core
 docs/src/components/DockerComposeGenerator/config/devices.ts
 docs/src/components/DockerComposeGenerator/config/hardware.ts
 docs/src/components/DockerComposeGenerator/config/ports.ts
-
-# GenAI review prompt tester local data (frames from real cameras)
-testing-scripts/genai-review-examples/*
-!testing-scripts/genai-review-examples/README.md
@@ -146,8 +146,6 @@ RUN wget -q https://github.com/openvinotoolkit/open_model_zoo/raw/master/data/da
 RUN wget -qO - https://www.kaggle.com/api/v1/models/google/yamnet/tfLite/classification-tflite/1/download | tar xvz && mv 1.tflite cpu_audio_model.tflite
 COPY audio-labelmap.txt .

-RUN chmod -R a+rX /rootfs
-

 FROM wget AS s6-overlay
 ARG TARGETARCH
@@ -202,6 +200,10 @@ RUN pip3 wheel --wheel-dir=/wheels -r /requirements-wheels.txt && \
        pip3 wheel --wheel-dir=/wheels -r /requirements-dev.txt; \
    fi

+# Install HailoRT & Wheels
+RUN --mount=type=bind,source=docker/main/install_hailort.sh,target=/deps/install_hailort.sh \
+    /deps/install_hailort.sh
+
 # Collect deps in a single layer
 FROM scratch AS deps-rootfs
 COPY --from=nginx /usr/local/nginx/ /usr/local/nginx/
@@ -212,6 +214,7 @@ COPY --from=libusb-build /usr/local/lib /usr/local/lib
 COPY --from=tempio /rootfs/ /
 COPY --from=s6-overlay /rootfs/ /
 COPY --from=models /rootfs/ /
+COPY --from=wheels /rootfs/ /
 COPY docker/main/rootfs/ /


@@ -289,12 +292,16 @@ RUN wget -q https://bootstrap.pypa.io/get-pip.py -O get-pip.py \
 RUN --mount=type=bind,from=wheels,source=/wheels,target=/deps/wheels \
    pip3 install -U /deps/wheels/*.whl

-# The Hailo, MemryX, and Axera runtimes are installed at first start by
-# frigate/util/runtime_deps.py, only when that detector is configured.
-# Axera's native libraries are bind mounted from the host.
+# Install Axera Engine
+RUN pip3 install https://github.com/AXERA-TECH/pyaxengine/releases/download/0.1.3-frigate/axengine-0.1.3-py3-none-any.whl
+
 ENV PATH="${PATH}:/usr/bin/axcl"
 ENV LD_LIBRARY_PATH="${LD_LIBRARY_PATH}:/usr/lib/axcl"

+# Install MemryX runtime (requires libgomp (OpenMP) in the final docker image)
+RUN --mount=type=bind,source=docker/main/install_memryx.sh,target=/deps/install_memryx.sh \
+    bash -c "bash /deps/install_memryx.sh"
+
 COPY --from=deps-rootfs / /

 RUN ldconfig
@@ -307,9 +314,6 @@ EXPOSE 8555/tcp 8555/udp
 ENV S6_LOGGING_SCRIPT="T 1 n0 s10000000 T"
 # Do not fail on long-running download scripts
 ENV S6_CMD_WAIT_FOR_SERVICES_MAXTIME=0
-# Allow running with a read-only root filesystem: s6 copies its scan dir into
-# /run and executes service scripts from there, so /run must allow exec
-ENV S6_READ_ONLY_ROOT=1

 ENTRYPOINT ["/init"]
 CMD []
@@ -381,7 +385,3 @@ FROM deps AS frigate

 WORKDIR /opt/frigate/
 COPY --from=rootfs / /
-
-# Pre-compile bytecode so a read-only rootfs doesn't force re-parsing the
-# source tree on every boot (pip-installed packages are already compiled)
-RUN python3 -m compileall -q -j0 /opt/frigate/frigate
@@ -3,7 +3,7 @@
 set -euxo pipefail

 NGINX_VERSION="1.27.4"
-VOD_MODULE_VERSION="v1.9.1"
+VOD_MODULE_VERSION="1.31"
 SECURE_TOKEN_MODULE_VERSION="1.5"
 SET_MISC_MODULE_VERSION="v0.33"
 NGX_DEVEL_KIT_VERSION="v0.3.3"
@@ -31,24 +31,24 @@ wget -nv https://nginx.org/download/nginx-${NGINX_VERSION}.tar.gz
 tar -zxf nginx-${NGINX_VERSION}.tar.gz -C /tmp/nginx --strip-components=1
 rm nginx-${NGINX_VERSION}.tar.gz
 mkdir /tmp/nginx-vod-module
-wget -nv https://github.com/dio-az/nginx-vod-module/archive/refs/tags/${VOD_MODULE_VERSION}.tar.gz
+wget -nv https://github.com/kaltura/nginx-vod-module/archive/refs/tags/${VOD_MODULE_VERSION}.tar.gz
 tar -zxf ${VOD_MODULE_VERSION}.tar.gz -C /tmp/nginx-vod-module --strip-components=1
 rm ${VOD_MODULE_VERSION}.tar.gz
    # Patch MAX_CLIPS to allow more clips to be added than the default 128
 sed -i 's/MAX_CLIPS (128)/MAX_CLIPS (1080)/g' /tmp/nginx-vod-module/vod/media_set.h
 patch -d /tmp/nginx-vod-module/ -p1 << 'EOF'
--- a/vod/avc_hevc_parser.c
-+++ b/vod/avc_hevc_parser.c
-@@ -2,6 +2,9 @@
-
+--- a/vod/avc_hevc_parser.c       2022-06-27 11:38:10.000000000 +0000
+++ b/vod/avc_hevc_parser.c       2023-01-16 11:25:10.900521298 +0000
+@@ -3,6 +3,9 @@
 bool_t
- avc_hevc_parser_rbsp_trailing_bits(bit_reader_state_t* reader) {
+ avc_hevc_parser_rbsp_trailing_bits(bit_reader_state_t* reader)
+ {
 +	// https://github.com/blakeblackshear/frigate/issues/4572
 +	return TRUE;
 +
 	uint32_t one_bit;

- 	if (reader->stream.eof_reached) {
+ 	if (reader->stream.eof_reached)
 EOF


@@ -10,7 +10,7 @@ apt-get -qq install --no-install-recommends -y \
    gnupg \
    wget \
    lbzip2 \
-    procps vainfo acl \
+    procps vainfo \
    unzip locales tzdata libxml2 xz-utils \
    python3.11 \
    curl \
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -euxo pipefail
+
+hailo_version="4.21.0"
+
+# sha256 digests of the release artifacts; update when bumping hailo_version.
+# The runtime tarball is keyed by TARGETARCH, the wheel by the python arch tag.
+declare -A hailort_checksums=(
+    ["amd64"]="0a57ac5f7cc8c2c3668133189d9285b55f498e8cb219797e203f6f5015fec4b3"
+    ["arm64"]="dd840548eb5d0d147c99aee2cb013d39d64be09c5bc63061171fcfacf4547b3f"
+    ["x86_64"]="8112a973ab48095399b29d883f31987828df5861b8553f614c89f098a67b3fb6"
+    ["aarch64"]="658432a43573280d472f6402d7934669effe7f163ba3dffa31c50bbeeaa7c01d"
+)
+
+if [[ "${TARGETARCH}" == "amd64" ]]; then
+    arch="x86_64"
+elif [[ "${TARGETARCH}" == "arm64" ]]; then
+    arch="aarch64"
+fi
+
+# downloaded rather than streamed into tar because streaming and verifying the
+# digest before extraction are mutually exclusive
+wget -qO /tmp/hailort.tar.gz "https://github.com/frigate-nvr/hailort/releases/download/v${hailo_version}/hailort-debian12-${TARGETARCH}.tar.gz"
+echo "${hailort_checksums[${TARGETARCH}]}  /tmp/hailort.tar.gz" | sha256sum -c -
+tar -C / -xzf /tmp/hailort.tar.gz
+rm -f /tmp/hailort.tar.gz
+
+wheel="/wheels/hailort-${hailo_version}-cp311-cp311-linux_${arch}.whl"
+mkdir -p /wheels
+wget -qO "${wheel}" "https://github.com/frigate-nvr/hailort/releases/download/v${hailo_version}/hailort-${hailo_version}-cp311-cp311-linux_${arch}.whl"
+echo "${hailort_checksums[${arch}]}  ${wheel}" | sha256sum -c -
@@ -0,0 +1,31 @@
+#!/bin/bash
+set -e
+
+# Download the MxAccl for Frigate github release
+wget https://github.com/memryx/mx_accl_frigate/archive/refs/tags/v2.1.0.zip -O /tmp/mxaccl.zip
+unzip /tmp/mxaccl.zip -d /tmp
+mv /tmp/mx_accl_frigate-2.1.0 /opt/mx_accl_frigate
+rm /tmp/mxaccl.zip
+
+# Install Python dependencies
+pip3 install -r /opt/mx_accl_frigate/freeze
+
+# Link the Python package dynamically
+SITE_PACKAGES=$(python3 -c "import site; print(site.getsitepackages()[0])")
+ln -s /opt/mx_accl_frigate/memryx "$SITE_PACKAGES/memryx"
+
+# Copy architecture-specific shared libraries
+ARCH=$(uname -m)
+if [[ "$ARCH" == "x86_64" ]]; then
+    cp /opt/mx_accl_frigate/memryx/x86/libmemx.so* /usr/lib/x86_64-linux-gnu/
+    cp /opt/mx_accl_frigate/memryx/x86/libmx_accl.so* /usr/lib/x86_64-linux-gnu/
+elif [[ "$ARCH" == "aarch64" ]]; then
+    cp /opt/mx_accl_frigate/memryx/arm/libmemx.so* /usr/lib/aarch64-linux-gnu/
+    cp /opt/mx_accl_frigate/memryx/arm/libmx_accl.so* /usr/lib/aarch64-linux-gnu/
+else
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+
+# Refresh linker cache
+ldconfig
@@ -57,12 +57,19 @@ pywebpush == 2.0.*
 pyclipper == 1.3.*
 shapely == 2.0.*
 rapidfuzz==3.12.*
-# HailoRT
+# HailoRT Wheels
+appdirs==1.4.*
 argcomplete==2.0.*
 contextlib2==0.6.*
+distlib==0.3.*
+filelock==3.8.*
 future==0.18.*
+importlib-metadata==5.1.*
+importlib-resources==5.1.*
 netaddr==0.8.*
 netifaces==0.10.*
+verboselogs==1.7.*
+virtualenv==20.17.*
 prometheus-client == 0.21.*
 # TFLite
 tflite_runtime @ https://github.com/frigate-nvr/TFlite-builds/releases/download/v2.17.1/tflite_runtime-2.17.1-cp311-cp311-linux_x86_64.whl; platform_machine == 'x86_64'
@@ -6,35 +6,9 @@ set -o errexit -o nounset -o pipefail

 # Logs should be sent to stdout so that s6 can collect them

-# Not `nginx -s reload`: that has root parse /tmp/nginx/conf, which the
-# unprivileged nginx user can rewrite, and nginx chowns path directives on load.
-function reload_nginx() {
-    local pid
-
-    if ! pid=$(cat /tmp/nginx/nginx.pid 2>/dev/null); then
-        echo "[ERROR] No nginx pid file found, not reloading"
-        return 0
-    fi
-
-    if [[ ! "$pid" =~ ^[0-9]+$ ]] || [[ "$(cat "/proc/${pid}/comm" 2>/dev/null)" != "nginx" ]]; then
-        echo "[ERROR] nginx pid file does not name a running nginx process, not reloading"
-        return 0
-    fi
-
-    kill -HUP "$pid"
-}
-
 echo "[INFO] Starting certsync..."

-# Resolved once, and the condition must stay identical to the nginx run
-# script's. Testing only fullchain.pem here would pick the mounted cert on a
-# half-populated mount that nginx rejected, and the two fingerprints would then
-# never agree, reloading nginx every cycle forever.
-if [ -f /etc/letsencrypt/live/frigate/privkey.pem ] && [ -f /etc/letsencrypt/live/frigate/fullchain.pem ]; then
-    lefile="/etc/letsencrypt/live/frigate/fullchain.pem"
-else
-    lefile="/config/tls/fullchain.pem"
-fi
+lefile="/etc/letsencrypt/live/frigate/fullchain.pem"

 tls_enabled=`python3 /usr/local/nginx/get_nginx_settings.py | jq -r .tls.enabled`
 listen_external_port=`python3 /usr/local/nginx/get_nginx_settings.py | jq -r .listen.external_port`
@@ -75,7 +49,7 @@ do
    then
        echo "[INFO] Reloading nginx to refresh TLS certificate"
        echo "$lefile: $leprint"
-        reload_nginx
+        /usr/local/nginx/sbin/nginx -s reload
    fi

    sleep 60
@@ -4,24 +4,6 @@

 set -o errexit -o nounset -o pipefail

-runs_as_root=0
-if [[ "$(id -u)" -eq 0 ]]; then
-    if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]] || /usr/local/bin/service-runs-as-root frigate; then
-        runs_as_root=1
-    fi
-fi
-
-# /root survives s6-setuidgid and breaks cache writes after the drop; set
-# before opt_in_out so the opt-out marker lands where the service will look
-if [[ "$runs_as_root" -eq 0 ]]; then
-    export HOME=/config
-fi
-
-# detector runtimes installed at first start (pip install --user) live under
-# $HOME/.local; the dynamic loader only reads LD_LIBRARY_PATH at exec time
-export LD_LIBRARY_PATH="${LD_LIBRARY_PATH:+${LD_LIBRARY_PATH}:}${HOME}/.local/lib"
-export PATH="${PATH}:${HOME}/.local/bin"
-
 # opt out of openvino telemetry
 if [ -e /usr/local/bin/opt_in_out ]; then
  /usr/local/bin/opt_in_out --opt_out > /dev/null 2>&1
@@ -48,8 +30,4 @@ cd /opt/frigate || echo "[ERROR] Failed to change working directory to /opt/frig

 # Replace the bash process with the Frigate process, redirecting stderr to stdout
 exec 2>&1
-if [[ "$(id -u)" -ne 0 || "$runs_as_root" -eq 1 ]]; then
-    exec python3 -u -m frigate
-else
-    exec s6-setuidgid frigate python3 -u -m frigate
-fi
+exec python3 -u -m frigate
@@ -4,20 +4,6 @@

 set -o errexit -o nounset -o pipefail

-runs_as_root=0
-if [[ "$(id -u)" -eq 0 ]]; then
-    if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]] || /usr/local/bin/service-runs-as-root go2rtc; then
-        runs_as_root=1
-    fi
-fi
-
-# Root via FRIGATE_ROOT_SERVICES only; the escape hatch sweeps nothing and
-# leaves no unprivileged service, so /config/go2rtc stays as safe as pre-drop.
-granular_root=0
-if [[ "$runs_as_root" -eq 1 && "${FRIGATE_RUN_AS_ROOT:-false}" != "true" ]]; then
-    granular_root=1
-fi
-
 # Logs should be sent to stdout so that s6 can collect them

 function get_ip_and_port_from_supervisor() {
@@ -64,6 +50,42 @@ function set_libva_version() {
    export LIBAVFORMAT_VERSION_MAJOR
 }

+function setup_homekit_config() {
+    local config_path="$1"
+
+    if [[ ! -f "${config_path}" ]]; then
+        echo "[INFO] Creating empty config file for HomeKit..."
+        : > "${config_path}"
+    fi
+
+    # Convert YAML to JSON for jq processing
+    local temp_json="/tmp/cache/homekit_config.json"
+    yq eval -o=json "${config_path}" > "${temp_json}" 2>/dev/null || {
+        echo "[WARNING] Failed to convert HomeKit config to JSON, skipping cleanup"
+        return 0
+    }
+
+    # Use jq to extract the homekit section, if it exists
+    local homekit_json
+    homekit_json=$(jq '
+        if has("homekit") then {homekit: .homekit} else null end
+    ' "${temp_json}" 2>/dev/null) || homekit_json="null"
+
+    # If no homekit section, write an empty config file
+    if [[ "${homekit_json}" == "null" ]]; then
+        : > "${config_path}"
+    else
+        # Convert homekit JSON back to YAML and write to the config file
+        echo "${homekit_json}" | yq eval -P - > "${config_path}" 2>/dev/null || {
+            echo "[WARNING] Failed to convert cleaned config to YAML, creating minimal config"
+            : > "${config_path}"
+        }
+    fi
+
+    # Clean up temp files
+    rm -f "${temp_json}"
+}
+
 set_libva_version

 if [[ -f "/dev/shm/go2rtc.yaml" ]]; then
@@ -84,23 +106,13 @@ else
    echo "[WARNING] Unable to remove existing go2rtc config. Changes made to your frigate config file may not be recognized. Please remove the /dev/shm/go2rtc.yaml from your docker host manually."
 fi

-# HomeKit persistence. The helper is symlink-safe; hand off to go2rtc only when dropping.
+# HomeKit configuration persistence setup
 readonly homekit_config_path="/config/go2rtc_homekit.yml"
-if [[ "$(id -u)" -eq 0 && "$runs_as_root" -eq 0 ]]; then
-    python3 /usr/local/go2rtc/prepare_homekit.py "${homekit_config_path}" --chown
-    chown go2rtc:go2rtc /dev/shm/go2rtc.yaml 2>/dev/null || true
-else
-    python3 /usr/local/go2rtc/prepare_homekit.py "${homekit_config_path}"
-fi
+setup_homekit_config "${homekit_config_path}"

 readonly config_path="/config"

-# the sweep hands /config to uid 1000, so a root service must not exec from it
-if [[ "$granular_root" -eq 1 && -x "${config_path}/go2rtc" ]]; then
-  echo "[WARN] Ignoring '${config_path}/go2rtc' because FRIGATE_ROOT_SERVICES runs this service as root and /config is owned by the runtime user; using the embedded binary"
-  echo "[WARN] Use FRIGATE_RUN_AS_ROOT=true instead if you need both a custom go2rtc build and root"
-  readonly binary_path="/usr/local/go2rtc/bin/go2rtc"
-elif [[ -x "${config_path}/go2rtc" ]]; then
+if [[ -x "${config_path}/go2rtc" ]]; then
  readonly binary_path="${config_path}/go2rtc"
  echo "[WARN] Using go2rtc binary from '${binary_path}' instead of the embedded one"
 else
@@ -113,8 +125,4 @@ echo "[INFO] Starting go2rtc..."
 # Use HomeKit config as the primary config so writebacks go there
 # The main config from Frigate will be loaded as a secondary config
 exec 2>&1
-if [[ "$(id -u)" -ne 0 || "$runs_as_root" -eq 1 ]]; then
-    exec "${binary_path}" -config="${homekit_config_path}" -config=/dev/shm/go2rtc.yaml
-else
-    exec s6-setuidgid go2rtc "${binary_path}" -config="${homekit_config_path}" -config=/dev/shm/go2rtc.yaml
-fi
+exec "${binary_path}" -config="${homekit_config_path}" -config=/dev/shm/go2rtc.yaml
@@ -1,104 +0,0 @@
-#!/command/with-contenv bash
-# shellcheck shell=bash
-# Grant the runtime users access to mapped-in device nodes with POSIX ACLs,
-# so --device works without host-side group or udev setup.
-# No-op when: started with --user (euid != 0), FRIGATE_RUN_AS_ROOT=true,
-# or FRIGATE_DEVICE_ACLS=false.
-
-set -o errexit -o nounset -o pipefail
-
-if [[ "$(id -u)" -ne 0 ]]; then
-    exit 0
-fi
-
-if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]]; then
-    exit 0
-fi
-
-if [[ "${FRIGATE_DEVICE_ACLS:-true}" == "false" ]]; then
-    echo "[INFO] FRIGATE_DEVICE_ACLS=false: skipping device access grants"
-    exit 0
-fi
-
-shopt -s nullglob
-
-device_globs=(
-    "/dev/dri/*"
-    "/dev/accel/*"
-    "/dev/apex_*"
-    "/dev/hailo*"
-    "/dev/video*"
-    "/dev/kfd"
-    "/dev/rknpu*"
-    "/dev/mpp_service"
-    "/dev/rga"
-    "/dev/dma_heap/*"
-    "/dev/nvhost*"
-    "/dev/nvmap"
-    "/dev/nvidia*"
-    "/dev/memx*"
-)
-
-IFS=',' read -ra extra_globs <<< "${DEVICE_ACL_PATHS:-}"
-for extra in "${extra_globs[@]}"; do
-    extra="${extra//[[:space:]]/}"
-    if [[ -z "$extra" ]]; then
-        continue
-    fi
-    if [[ "$extra" != /dev/* || "$extra" == *..* ]]; then
-        echo "[ERROR] DEVICE_ACL_PATHS entries must be under /dev, got '${extra}'" >&2
-        exit 1
-    fi
-    device_globs+=("$extra")
-done
-
-granted=0
-failed=0
-
-grant() {
-    local node="$1"
-    # nullglob only drops patterns that hold a metacharacter, so a literal
-    # table entry for absent hardware arrives here verbatim. Warn only about
-    # nodes that exist and could not be granted.
-    if [[ ! -e "$node" ]]; then
-        return 0
-    fi
-    local spec="u:frigate:rw,u:go2rtc:rw"
-    # directories need traverse or nothing under them is reachable
-    if [[ -d "$node" ]]; then
-        spec="u:frigate:rwx,u:go2rtc:rwx"
-    fi
-    if setfacl -m "$spec" "$node" 2>/dev/null; then
-        granted=$((granted + 1))
-    else
-        failed=$((failed + 1))
-        echo "[WARN] could not grant device access on ${node}; see EXTRA_GROUPS in the non-root docs for the fallback"
-    fi
-}
-
-for glob in "${device_globs[@]}"; do
-    # shellcheck disable=SC2231
-    for node in $glob; do
-        grant "$node"
-    done
-done
-
-# USB devices re-enumerate (the Coral uploads firmware and reattaches as a new
-# node), so the directories also get a default ACL new nodes inherit. The
-# inherited grant is clamped by the creating mode's group bits, which is rw on
-# udev hosts (0664) and nothing on raw devtmpfs (0600); hardware-verified.
-if [[ -d /dev/bus/usb ]]; then
-    while IFS= read -r -d '' node; do
-        grant "$node"
-    done < <(find /dev/bus/usb -mindepth 1 -print0)
-    while IFS= read -r -d '' dir; do
-        setfacl -d -m "u:frigate:rw,u:go2rtc:rw" "$dir" 2>/dev/null || \
-            echo "[WARN] could not set a default ACL on ${dir}; a re-enumerating USB device may lose access"
-    done < <(find /dev/bus/usb -type d -print0)
-fi
-
-if [[ "$failed" -gt 0 ]]; then
-    echo "[INFO] device access: granted ${granted} node(s), ${failed} failed"
-elif [[ "$granted" -gt 0 ]]; then
-    echo "[INFO] device access: granted ${granted} node(s) to the runtime users"
-fi
@@ -1 +0,0 @@
-oneshot
@@ -1 +0,0 @@
-/etc/s6-overlay/s6-rc.d/init-devices/run
@@ -2,7 +2,7 @@
 # shellcheck shell=bash
 # Remap the frigate user to PUID/PGID and register EXTRA_GROUPS.
 # No-op when: started with --user (euid != 0), FRIGATE_RUN_AS_ROOT=true,
-# or PUID/PGID already match. FRIGATE_ROOT_SERVICES is validated here too.
+# or PUID/PGID already match.

 set -o errexit -o nounset -o pipefail

@@ -12,31 +12,10 @@ if [[ "$(id -u)" -ne 0 ]]; then
 fi

 if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]]; then
-    if [[ -n "${FRIGATE_ROOT_SERVICES:-}" ]]; then
-        echo "[INFO] FRIGATE_RUN_AS_ROOT=true: ignoring FRIGATE_ROOT_SERVICES"
-    fi
    echo "[INFO] FRIGATE_RUN_AS_ROOT=true: skipping user remapping"
    exit 0
 fi

-# a typo must fail the boot, not silently drop a service to non-root
-if [[ -n "${FRIGATE_ROOT_SERVICES:-}" ]]; then
-    IFS=',' read -ra root_services <<< "${FRIGATE_ROOT_SERVICES}"
-    for entry in "${root_services[@]}"; do
-        entry="${entry//[[:space:]]/}"
-        if [[ -z "$entry" ]]; then
-            continue
-        fi
-        case "$entry" in
-            frigate|go2rtc|nginx) ;;
-            *)
-                echo "[ERROR] FRIGATE_ROOT_SERVICES contains unknown service '${entry}'; valid names are frigate, go2rtc, nginx" >&2
-                exit 1
-                ;;
-        esac
-    done
-fi
-
 puid="${PUID:-1000}"
 pgid="${PGID:-1000}"

@@ -53,15 +32,6 @@ if [[ "$puid" -eq 0 || "$pgid" -eq 0 ]]; then
    exit 1
 fi

-# Colliding with the go2rtc ids would merge the two users and collapse the
-# separation between the main process and the network-facing restreamer.
-go2rtc_uid="$(id -u go2rtc)"
-go2rtc_gid="$(id -g go2rtc)"
-if [[ "$puid" -eq "$go2rtc_uid" || "$pgid" -eq "$go2rtc_gid" ]]; then
-    echo "[ERROR] PUID/PGID must not equal the go2rtc service ids (${go2rtc_uid}:${go2rtc_gid})." >&2
-    exit 1
-fi
-
 current_uid="$(id -u frigate)"
 current_gid="$(id -g frigate)"

@@ -79,20 +49,7 @@ fi

 # EXTRA_GROUPS: numeric host GIDs granting device access (e.g. host render/video)
 if [[ -n "${EXTRA_GROUPS:-}" ]]; then
-    # groupadd and usermod -aG both write /etc/group. Checked up front so a
-    # read-only rootfs reports the real problem instead of dying mid-loop.
-    if [[ ! -w /etc/group ]]; then
-        echo "[ERROR] EXTRA_GROUPS needs a writable /etc and is not compatible with read_only: true." >&2
-        echo "[ERROR] Use docker's group_add: with the same GIDs instead; it needs no writes inside the container." >&2
-        echo "[ERROR] See https://docs.frigate.video/configuration/non_root for the compatibility matrix." >&2
-        exit 1
-    fi
-
    for gid in ${EXTRA_GROUPS//,/ }; do
-        if ! [[ "$gid" =~ ^[0-9]+$ ]] || [[ "$gid" -eq 0 ]]; then
-            echo "[ERROR] EXTRA_GROUPS must be nonzero numeric GIDs, got '${gid}'" >&2
-            exit 1
-        fi
        if ! getent group "$gid" >/dev/null; then
            groupadd -o -g "$gid" "frigate-extra-${gid}"
        fi
@@ -2,4 +2,4 @@
 set -e

 # Wait for PID file to exist.
-while ! test -f /tmp/nginx/nginx.pid; do sleep 1; done
+while ! test -f /run/nginx.pid; do sleep 1; done
@@ -4,13 +4,6 @@

 set -o errexit -o nounset -o pipefail

-runs_as_root=0
-if [[ "$(id -u)" -eq 0 ]]; then
-    if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]] || /usr/local/bin/service-runs-as-root nginx; then
-        runs_as_root=1
-    fi
-fi
-
 # Logs should be sent to stdout so that s6 can collect them

 echo "[INFO] Starting NGINX..."
@@ -66,105 +59,43 @@ function set_worker_processes() {
        cpus=4
    fi

-    sed -i "s/worker_processes auto;/worker_processes ${cpus};/" /tmp/nginx/conf/nginx.conf
+    # we need to catch any errors because sed will fail if user has bind mounted a custom nginx file
+    sed -i "s/worker_processes auto;/worker_processes ${cpus};/" /usr/local/nginx/conf/nginx.conf || true
 }

-# Rebuilt root-owned every start: a symlink planted by the previously
-# unprivileged nginx would redirect the root cp/tempio writes below onto any
-# root file. rm does not traverse symlinks; the bare mkdir fails closed if raced.
-rm -rf /tmp/nginx
-mkdir /tmp/nginx
-mkdir -p /tmp/nginx/conf /tmp/nginx/client_body /tmp/nginx/proxy \
-         /tmp/nginx/fastcgi /tmp/nginx/uwsgi /tmp/nginx/scgi
-cp -r /usr/local/nginx/conf/. /tmp/nginx/conf/
-
 set_worker_processes

-# TLS certs: user-mounted certs at /etc/letsencrypt/live/frigate (documented
-# contract) always win; otherwise fall back to a self-signed cert persisted in
-# /config/tls, which stays writable under a read-only root filesystem.
+# ensure the directory for ACME challenges exists
+mkdir -p /etc/letsencrypt/www
+
+# Create self signed certs if needed
 letsencrypt_path=/etc/letsencrypt/live/frigate
-selfsigned_path=/config/tls
+mkdir -p $letsencrypt_path

-if [ -f "$letsencrypt_path/privkey.pem" ] && [ -f "$letsencrypt_path/fullchain.pem" ]; then
-    cert_path="$letsencrypt_path"
-else
-    cert_path="$selfsigned_path"
-
-    # Root writing into /config follows any symlink planted there, and /config
-    # is owned by whoever the host mount says, not by root. Generate as the
-    # runtime user wherever we are going to drop to it; the escape hatch keeps
-    # root all the way through, so that path is refused rather than dropped.
-    gen=()
-    if [[ "$(id -u)" -eq 0 && "${FRIGATE_RUN_AS_ROOT:-false}" != "true" ]]; then
-        gen=(s6-setuidgid frigate)
-    elif [[ "$(id -u)" -eq 0 ]]; then
-        for link in "$cert_path" "$cert_path/privkey.pem" "$cert_path/fullchain.pem"; do
-            if [[ -L "$link" ]]; then
-                echo "[ERROR] ${link} is a symlink; refusing to write TLS material through it as root" >&2
-                exit 1
-            fi
-        done
-    fi
-
-    "${gen[@]}" mkdir -p "$cert_path"
-
-    if [ ! \( -f "$cert_path/privkey.pem" -a -f "$cert_path/fullchain.pem" \) ]; then
-        echo "[INFO] No TLS certificate found. Generating a self signed certificate..."
-        "${gen[@]}" openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \
-            -subj "/O=FRIGATE DEFAULT CERT/CN=*" \
-            -keyout "$cert_path/privkey.pem" -out "$cert_path/fullchain.pem" 2>/dev/null
-        "${gen[@]}" chmod 600 "$cert_path/privkey.pem"
-        "${gen[@]}" chmod 644 "$cert_path/fullchain.pem"
-    fi
+if [ ! \( -f "$letsencrypt_path/privkey.pem" -a -f "$letsencrypt_path/fullchain.pem" \) ]; then
+    echo "[INFO] No TLS certificate found. Generating a self signed certificate..."
+    openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \
+        -subj "/O=FRIGATE DEFAULT CERT/CN=*" \
+        -keyout "$letsencrypt_path/privkey.pem" -out "$letsencrypt_path/fullchain.pem" 2>/dev/null
+    chmod 600 "$letsencrypt_path/privkey.pem"
+    chmod 644 "$letsencrypt_path/fullchain.pem"
 fi

-# ACME challenges are only served from a writable rootfs; skipping the mkdir
-# under read_only leaves the location 404ing, which is the same as unused
-mkdir -p /etc/letsencrypt/www 2>/dev/null || true
-
 # nginx settings are read once; both templates consume them
 nginx_settings=$(python3 /usr/local/nginx/get_nginx_settings.py)

 # build templates for optional FRIGATE_BASE_PATH environment variable
 echo "$nginx_settings" | \
    tempio -template /usr/local/nginx/templates/base_path.gotmpl \
-           -out /tmp/nginx/conf/base_path.conf
+           -out /usr/local/nginx/conf/base_path.conf

-# build templates for additional network settings; listen.conf is the only
-# template that needs the resolved cert directory
+# build templates for additional network settings
 echo "$nginx_settings" | \
-    jq --arg p "$cert_path" '.tls.cert_path = $p' | \
    tempio -template /usr/local/nginx/templates/listen.gotmpl \
-           -out /tmp/nginx/conf/listen.conf
-
-if [[ "$(id -u)" -eq 0 && "$runs_as_root" -eq 0 ]]; then
-    chown -R frigate:frigate /tmp/nginx
-    # heal the cache: a root `nginx -t` chowns every cycle path to the `user` directive user
-    if [ -d /dev/shm/nginx_cache ]; then
-        chown -R frigate:frigate /dev/shm/nginx_cache
-    fi
-    # nginx reopens /dev/stdout by path for its logs, and s6 made the pipe
-    # root-owned 0600; without this the non-root master exits EACCES
-    chown frigate /dev/stdout
-    # Only mounted certs need handing over; the self-signed pair is already
-    # owned by the runtime user that generated it. Never chown the /config copy:
-    # chown follows symlinks, so it would retarget onto any root file the
-    # runtime user pointed it at. Tolerant because mounted certs may be :ro.
-    if [ "$cert_path" = "$letsencrypt_path" ] && [ -f "$cert_path/privkey.pem" ]; then
-        chown frigate:frigate "$cert_path/privkey.pem" "$cert_path/fullchain.pem" 2>/dev/null || true
-    fi
-fi
+           -out /usr/local/nginx/conf/listen.conf

 # Replace the bash process with the NGINX process, redirecting stderr to stdout
 exec 2>&1
-# -e stderr: the compiled-in error log path is not writable by the runtime user
-if [[ "$(id -u)" -ne 0 || "$runs_as_root" -eq 1 ]]; then
-    exec \
-        s6-notifyoncheck -t 30000 -n 1 \
-        nginx -e stderr -c /tmp/nginx/conf/nginx.conf
-else
-    exec \
-        s6-notifyoncheck -t 30000 -n 1 \
-        s6-setuidgid frigate nginx -e stderr -c /tmp/nginx/conf/nginx.conf
-fi
+exec \
+    s6-notifyoncheck -t 30000 -n 1 \
+    nginx
@@ -153,57 +153,7 @@ if [[ "$(id -u)" -eq 0 ]]; then
    if [[ "${FRIGATE_RUN_AS_ROOT:-false}" == "true" ]]; then
        rm -f /config/.permissions_version
    else
-        # Only when a mount backs /media/frigate itself: under a parent /media
-        # mount, a dedicated volume added later would be shadowed and skipped
-        sentinel_args=(--sentinel /config/.permissions_version)
-        root_services_mode=""
-        if [[ -n "${FRIGATE_ROOT_SERVICES:-}" ]]; then
-            # || true: an all-empty list (",") fails grep -v and errexit would kill the boot
-            root_services_mode=$(tr ',' '\n' <<< "${FRIGATE_ROOT_SERVICES//[[:space:]]/}" | grep -v '^$' | sort -u | paste -sd, - || true)
-            if [[ -n "$root_services_mode" ]]; then
-                sentinel_args+=(--mode "$root_services_mode")
-            fi
-        fi
-        if ! awk '$2 == "/media/frigate" || $2 ~ /^\/media\/frigate\//' /proc/mounts | grep -q .; then
-            sentinel_args=()
-        fi
-        /usr/local/bin/fix-ownership "${sentinel_args[@]}" \
+        /usr/local/bin/fix-ownership --sentinel /config/.permissions_version \
            "${PUID:-1000}" "${PGID:-1000}" /config /media/frigate
-
-        # Root services write clips stragglers and caches mid-run; realign the
-        # small trees every boot. Recordings are chowned at create instead.
-        if [[ -n "$root_services_mode" ]]; then
-            # only sweep what exists; clips and exports appear after the first run
-            boot_sweep_paths=(/config)
-            for extra in /media/frigate/clips /media/frigate/exports; do
-                if [[ -d "$extra" ]]; then
-                    boot_sweep_paths+=("$extra")
-                fi
-            done
-            /usr/local/bin/fix-ownership \
-                "${PUID:-1000}" "${PGID:-1000}" "${boot_sweep_paths[@]}"
-        fi
    fi
 fi
-
-# Must stay after the sweep, which reads an absent /media/frigate as an
-# unmounted volume rather than a swept one
-if [[ "$(id -u)" -eq 0 && ! -d /media/frigate ]]; then
-    # The image does not ship this directory, so on a read-only rootfs it can
-    # only come from a mount. Report that rather than failing under errexit.
-    if ! mkdir -p /media/frigate 2>/dev/null; then
-        echo "[ERROR] /media/frigate does not exist and could not be created, which is what happens with read_only: true and no recordings volume." >&2
-        echo "[ERROR] Mount a volume at /media/frigate." >&2
-        echo "[ERROR] See https://docs.frigate.video/configuration/non_root for the compatibility matrix." >&2
-        exit 1
-    fi
-    if [[ "${FRIGATE_RUN_AS_ROOT:-false}" != "true" ]]; then
-        chown "${PUID:-1000}:${PGID:-1000}" /media/frigate
-    fi
-fi
-
-# usually a tmpfs mount: root-owned on arrival and outside the swept volumes
-if [[ "$(id -u)" -eq 0 && "${FRIGATE_RUN_AS_ROOT:-false}" != "true" ]]; then
-    mkdir -p /tmp/cache
-    chown "${PUID:-1000}:${PGID:-1000}" /tmp/cache
-fi
@@ -1,17 +1,15 @@
 #!/bin/bash
 # Single source of truth for aligning volume ownership with the runtime user.
 #
-# Usage: fix-ownership [--dry-run] [--sentinel FILE] [--mode STRING] UID GID PATH [PATH...]
+# Usage: fix-ownership [--dry-run] [--sentinel FILE] UID GID PATH [PATH...]
 #
 #   --dry-run    report what would change, touch nothing
 #   --sentinel   skip entirely when FILE already records "SCHEMA:UID:GID";
 #                write it after a successful run (used by the boot path so
 #                multi-TB volumes are swept once per UID/schema change, not
 #                on every boot)
-#   --mode       append STRING to the sentinel, so changing it re-sweeps once
 #
 # Only files whose uid OR gid differs are touched, so re-runs are cheap.
-# lost+found is skipped: fsck fills it with root-only recovered fragments.
 # Top-level /config additionally grants group frigate-data TRAVERSE ONLY
 # (g+rx) so the separate go2rtc user can reach its pre-created HomeKit file
 # on hosts where /config is mounted 0700. Never g+w: directory write means
@@ -24,11 +22,10 @@ set -o errexit -o nounset -o pipefail
 # Permissions-layout epoch. Bump to force a one-time re-sweep on upgrade
 # (e.g. when the privilege-drop release must capture files created as root
 # since the previous sweep).
-schema=2
+schema=1

 dry_run=0
 sentinel=""
-mode=""

 while [[ "${1:-}" == --* ]]; do
    case "$1" in
@@ -39,18 +36,12 @@ while [[ "${1:-}" == --* ]]; do
                exit 2
            fi
            sentinel="$2"; shift 2 ;;
-        --mode)
-            if [[ -z "${2:-}" ]]; then
-                echo "[ERROR] fix-ownership: --mode requires a value" >&2
-                exit 2
-            fi
-            mode="$2"; shift 2 ;;
        *) echo "[ERROR] fix-ownership: unknown option $1" >&2; exit 2 ;;
    esac
 done

 if [[ $# -lt 3 ]]; then
-    echo "Usage: fix-ownership [--dry-run] [--sentinel FILE] [--mode STRING] UID GID PATH..." >&2
+    echo "Usage: fix-ownership [--dry-run] [--sentinel FILE] UID GID PATH..." >&2
    exit 2
 fi

@@ -63,21 +54,11 @@ if [[ "$(id -u)" -ne 0 ]]; then
    exit 0
 fi

-# The list folds into the sentinel so entering or leaving a granular root mode
-# re-sweeps once, catching whatever the other ownership mechanisms missed.
-sentinel_content="${schema}:${target_uid}:${target_gid}"
-if [[ -n "$mode" ]]; then
-    sentinel_content="${sentinel_content}:${mode}"
-fi
-
-# safe-sentinel reports only a root-owned regular file, so a forged or
-# symlinked sentinel in the runtime-user-owned /config can't suppress the sweep
-if [[ "$dry_run" -eq 0 && -n "$sentinel" ]]; then
-    if existing=$(/usr/local/bin/safe-sentinel read "$sentinel" 2>/dev/null) && \
-        [[ "$existing" == "$sentinel_content" ]]; then
-        echo "[INFO] fix-ownership: ${target_uid}:${target_gid} (schema ${schema}) already applied, skipping"
-        exit 0
-    fi
+# A dry run always inspects: the sentinel records what a past sweep did, not
+# what the volume looks like now, and reporting from it would hide later drift.
+if [[ "$dry_run" -eq 0 && -n "$sentinel" && -f "$sentinel" && "$(cat "$sentinel")" == "${schema}:${target_uid}:${target_gid}" ]]; then
+    echo "[INFO] fix-ownership: ${target_uid}:${target_gid} (schema ${schema}) already applied, skipping"
+    exit 0
 fi

 # A sweep that could not chown everything must not be recorded as complete:
@@ -85,26 +66,6 @@ fi
 # unreachable once services run unprivileged.
 swept_clean=1

-# Entries another mechanism deliberately owns. Chowning them undoes that work
-# and leaves the same "mismatch" waiting for the next boot, so /config could
-# never report itself clean: /config is chgrp'd to frigate-data below so go2rtc
-# can traverse it, and the HomeKit file is handed to the go2rtc user by the
-# go2rtc service. Only the GROUP on /config is exempt; a root-owned /config
-# must still be chowned or the runtime user cannot write there at all.
-# Shared by the counting and the chowning walk so the two cannot disagree.
-mismatch_expr=(
-    "(" -not -uid "$target_uid"
-        -o "(" -not -gid "$target_gid" -a ! -path /config ")"
-    ")"
-    -a ! -path /config/go2rtc_homekit.yml
-)
-if [[ -n "$sentinel" ]]; then
-    # safe-sentinel keeps the sentinel root-owned on purpose and rejects one
-    # owned by anybody else, so chowning it here would suppress the skip and
-    # make every boot re-sweep. Only the trailing write puts it back today.
-    mismatch_expr+=(-a ! -path "$sentinel")
-fi
-
 for path in "$@"; do
    # An absent root is an incomplete sweep, not a finished one: /media/frigate
    # is not in the image, so a boot before the volume is mounted would
@@ -115,13 +76,11 @@ for path in "$@"; do
        continue
    fi

-    echo "[INFO] fix-ownership: scanning ${path} for ownership mismatches; this may take a while on large filesystems"
-
    # find may fail mid-walk on a live volume (file deleted under it) or on a
    # stale mount. Tolerate it rather than aborting under errexit, but never
    # read a failed scan as "nothing to do": that would record the sweep as
    # complete without having looked.
-    if ! count=$(find "$path" -name lost+found -prune -o "${mismatch_expr[@]}" -printf '.' 2>/dev/null | wc -c); then
+    if ! count=$(find "$path" \( -not -uid "$target_uid" -o -not -gid "$target_gid" \) -printf '.' 2>/dev/null | wc -c); then
        swept_clean=0
        echo "[WARN] fix-ownership: could not scan ${path}; will retry on next boot"
        continue
@@ -139,41 +98,17 @@ for path in "$@"; do
        echo "[WARN] fix-ownership: ${path} contains symlinked directories; ownership behind them is not managed and must be aligned by hand"
    fi

-    echo "[WARN] fix-ownership: adjusting ownership of ${count} entries under ${path}"
+    echo "[WARN] fix-ownership: adjusting ownership of ${count} entries under ${path}; on large recordings volumes this can take a long time"
    if [[ "$dry_run" -eq 1 ]]; then
        echo "[INFO] fix-ownership: dry run, not changing ${path}"
        continue
    fi

-    # -execdir chowns from the entry's own directory, so a parent swapped for a
-    # symlink mid-walk can't redirect the chown out of the volume
-    started=$SECONDS
-    if find "$path" -name lost+found -prune -o "${mismatch_expr[@]}" \
-        -print -execdir chown -h "${target_uid}:${target_gid}" {} + \
-        | awk -v total="$count" -v path="$path" '
-            BEGIN { next_pct = 5 }
-            {
-                pct = int(NR * 100 / total)
-                if (pct > 100) pct = 100
-                if (pct >= next_pct) {
-                    printf "[INFO] fix-ownership: %s %d%% (%d/%d entries)\n", path, pct, NR, total
-                    # mawk block-buffers to a pipe; without fflush the whole
-                    # progress log arrives at once
-                    fflush()
-                    while (next_pct <= pct) next_pct += 5
-                }
-            }'; then
-        elapsed=$((SECONDS - started))
-        if [[ "$elapsed" -ge 60 ]]; then
-            elapsed="$((elapsed / 60))m $((elapsed % 60))s"
-        else
-            elapsed="${elapsed}s"
-        fi
-        echo "[INFO] fix-ownership: finished ${path} in ${elapsed}"
-    else
+    find "$path" \( -not -uid "$target_uid" -o -not -gid "$target_gid" \) \
+        -exec chown -h "${target_uid}:${target_gid}" {} + || {
        swept_clean=0
        echo "[WARN] fix-ownership: some entries under ${path} could not be updated (deleted mid-sweep or chown denied); will retry on next mismatch"
-    fi
+    }
 done

 # go2rtc (separate user) must be able to REACH its HomeKit state in /config.
@@ -189,6 +124,6 @@ if [[ "$dry_run" -eq 0 && -d /config ]]; then
 fi

 if [[ "$dry_run" -eq 0 && -n "$sentinel" && "$swept_clean" -eq 1 ]]; then
-    /usr/local/bin/safe-sentinel write "$sentinel" "$sentinel_content" || \
+    echo "${schema}:${target_uid}:${target_gid}" > "$sentinel" || \
        echo "[WARN] fix-ownership: could not write ${sentinel}; the sweep will run again on next boot"
 fi
@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""Read or write the ownership sweep sentinel without following symlinks.
-
-The sentinel lives in /config, which the unprivileged runtime user owns, so it
-can be swapped for a symlink. read trusts only a root-owned regular file; write
-never follows a symlink or fifo onto another file.
-
-Usage:
-  safe-sentinel read PATH            print content, exit 0 only if root-owned regular file
-  safe-sentinel write PATH CONTENT   write CONTENT to a regular file at PATH
-"""
-
-import errno
-import os
-import stat
-import sys
-
-MODE = 0o644
-
-
-def do_read(path: str) -> int:
-    try:
-        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
-    except OSError:
-        return 1
-    try:
-        st = os.fstat(fd)
-        if not stat.S_ISREG(st.st_mode) or st.st_uid != 0:
-            return 1
-        sys.stdout.buffer.write(os.read(fd, 4096))
-    finally:
-        os.close(fd)
-    return 0
-
-
-def do_write(path: str, content: str) -> int:
-    # O_NONBLOCK so a fifo fails fast (ENXIO) instead of blocking the open.
-    flags = os.O_WRONLY | os.O_CREAT | os.O_NOFOLLOW | os.O_NONBLOCK
-    replace = (errno.ELOOP, errno.ENXIO)
-    try:
-        fd = os.open(path, flags, MODE)
-        if not stat.S_ISREG(os.fstat(fd).st_mode):
-            os.close(fd)
-            raise OSError(errno.ELOOP, "not a regular file")
-    except OSError as err:
-        if err.errno not in replace:
-            raise
-        os.unlink(path)
-        fd = os.open(path, flags | os.O_EXCL, MODE)
-    try:
-        os.ftruncate(fd, 0)
-        os.write(fd, content.encode())
-        # keep it root-owned so a later sweep that chowned the old sentinel to
-        # the runtime user can't make the next read reject and re-sweep
-        os.fchown(fd, 0, 0)
-    finally:
-        os.close(fd)
-    return 0
-
-
-def main(argv: list[str]) -> int:
-    if len(argv) == 3 and argv[1] == "read":
-        return do_read(argv[2])
-    if len(argv) == 4 and argv[1] == "write":
-        try:
-            return do_write(argv[2], argv[3])
-        except OSError:
-            return 1
-    print("usage: safe-sentinel read PATH | write PATH CONTENT", file=sys.stderr)
-    return 2
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))
@@ -1,18 +0,0 @@
-#!/bin/bash
-# Exit 0 when FRIGATE_ROOT_SERVICES names the given service. Membership only:
-# the euid and FRIGATE_RUN_AS_ROOT checks stay in the callers.
-#
-# Usage: service-runs-as-root SERVICE
-
-set -o nounset
-
-service="${1:?usage: service-runs-as-root SERVICE}"
-
-IFS=',' read -ra entries <<< "${FRIGATE_ROOT_SERVICES:-}"
-for entry in "${entries[@]}"; do
-    entry="${entry//[[:space:]]/}"
-    if [[ "$entry" == "$service" ]]; then
-        exit 0
-    fi
-done
-exit 1
@@ -1,107 +0,0 @@
-"""Normalize the go2rtc HomeKit file and hand it to go2rtc, as root.
-
-Runs before the drop. The file is in the runtime-user-owned /config, so a
-planted symlink could redirect the root write or chown onto another file;
-every operation goes through an O_NOFOLLOW fd to prevent that.
-
-Usage: prepare_homekit.py PATH [--chown]
-"""
-
-import errno
-import grp
-import io
-import os
-import pwd
-import stat
-import sys
-
-from ruamel.yaml import YAML
-
-RUNTIME_OWNER = "go2rtc"
-SHARED_GROUP = "frigate-data"
-MODE = 0o664
-MAX_BYTES = 10 * 1024 * 1024
-
-
-def open_nofollow(path: str) -> int:
-    """Return an fd to a regular file at path, never following a symlink."""
-    flags = os.O_RDWR | os.O_CREAT | os.O_NOFOLLOW
-    try:
-        fd = os.open(path, flags, MODE)
-    except OSError as err:
-        if err.errno != errno.ELOOP:
-            raise
-        os.unlink(path)
-        return os.open(path, flags | os.O_EXCL, MODE)
-
-    # A fifo or other non-regular file would hang or misbehave on read; replace it.
-    if not stat.S_ISREG(os.fstat(fd).st_mode):
-        os.close(fd)
-        os.unlink(path)
-        return os.open(path, flags | os.O_EXCL, MODE)
-    return fd
-
-
-def normalize(content: str) -> str:
-    """Keep only the homekit section, matching the previous yq/jq behavior."""
-    yaml = YAML(typ="safe")
-    try:
-        data = yaml.load(content)
-    except Exception:
-        return ""
-
-    if not isinstance(data, dict) or "homekit" not in data:
-        return ""
-
-    buf = io.StringIO()
-    yaml.dump({"homekit": data["homekit"]}, buf)
-    return buf.getvalue()
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print("[ERROR] prepare_homekit: PATH is required", file=sys.stderr)
-        return 2
-
-    path = sys.argv[1]
-    do_chown = "--chown" in sys.argv[2:]
-
-    try:
-        fd = open_nofollow(path)
-    except PermissionError:
-        print(
-            f"[WARN] {path} is not writable by uid {os.geteuid()}, so HomeKit "
-            "pairing changes will not persist. It is owned by the go2rtc user "
-            "from an earlier run in the default mode. To fix, on the host run: "
-            f"chown {os.geteuid()}:{os.getegid()} <your config dir>/{os.path.basename(path)}"
-        )
-        return 0
-
-    try:
-        content = os.read(fd, MAX_BYTES).decode("utf-8", "replace")
-        normalized = normalize(content)
-        os.ftruncate(fd, 0)
-        os.lseek(fd, 0, os.SEEK_SET)
-        os.write(fd, normalized.encode("utf-8"))
-
-        if do_chown:
-            # tolerate a chown-refusing mount (NFS root_squash): pairing
-            # persistence degrades, the service does not
-            try:
-                uid = pwd.getpwnam(RUNTIME_OWNER).pw_uid
-                gid = grp.getgrnam(SHARED_GROUP).gr_gid
-                os.fchown(fd, uid, gid)
-                os.fchmod(fd, MODE)
-            except (KeyError, OSError):
-                print(
-                    f"[WARN] Could not hand {path} to the go2rtc user; "
-                    "HomeKit pairing changes may not persist"
-                )
-    finally:
-        os.close(fd)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())
@@ -1,13 +1,9 @@
-# Loaded with -c from the /tmp/nginx/conf copy: relative includes follow the -c
-# file, all other path directives follow --prefix and must stay absolute.
-
 daemon off;
-# ignored by a non-root master; keeps workers root under FRIGATE_RUN_AS_ROOT
 user root;
 worker_processes auto;

 error_log /dev/stdout warn;
-pid /tmp/nginx/nginx.pid;
+pid /var/run/nginx.pid;

 events {
    worker_connections 1024;
@@ -17,12 +13,6 @@ http {
    map_hash_bucket_size 256;
    server_tokens off;

-    client_body_temp_path /tmp/nginx/client_body;
-    proxy_temp_path /tmp/nginx/proxy;
-    fastcgi_temp_path /tmp/nginx/fastcgi;
-    uwsgi_temp_path /tmp/nginx/uwsgi;
-    scgi_temp_path /tmp/nginx/scgi;
-
    include mime.types;
    default_type application/octet-stream;

@@ -132,10 +122,6 @@ http {
            # Smaller segments, faster generation, better browser compatibility
            vod_hls_container_format fmp4;

-            # fMP4 playlists use EXT-X-MAP, which requires HLS protocol
-            # version 6 (RFC 8216 section 7); the module default is 4
-            vod_hls_version 6;
-
            secure_token $args;
            secure_token_types application/vnd.apple.mpegurl;

@@ -144,6 +130,14 @@ http {
            expires off;

            keepalive_disable safari;
+
+            # vod module returns 502 for non-existent media
+            # https://github.com/kaltura/nginx-vod-module/issues/468
+            error_page 502 =404 /vod-not-found;
+        }
+
+        location = /vod-not-found {
+            return 404;
        }

        location /stream/ {
@@ -8,8 +8,8 @@ listen {{ .listen.internal }};
    listen {{ .listen.external }} ssl;
    {{ if .ipv6.enabled }}listen [::]:{{ .listen.external_port }} ssl;{{ end }}

-    ssl_certificate {{ .tls.cert_path }}/fullchain.pem;
-    ssl_certificate_key {{ .tls.cert_path }}/privkey.pem;
+    ssl_certificate /etc/letsencrypt/live/frigate/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/frigate/privkey.pem;

    # generated 2024-06-01, Mozilla Guideline v5.7, nginx 1.25.3, OpenSSL 1.1.1w, modern configuration, no OCSP
    # https://ssl-config.mozilla.org/#server=nginx&version=1.25.3&config=modern&openssl=1.1.1w&ocsp=false&guideline=5.7
@@ -36,16 +36,6 @@ if ! [[ "$puid" =~ ^[0-9]+$ && "$pgid" =~ ^[0-9]+$ ]]; then
 fi

 echo "[INFO] Using image ${IMAGE} (override with FRIGATE_IMAGE=...)"
-if ! docker image inspect "${IMAGE}" >/dev/null 2>&1; then
-    echo "[INFO] ${IMAGE} is not present locally and has to be pulled first; this may take a while"
-fi
-
-if [[ -n "$dry_run_flag" ]]; then
-    echo "[INFO] Dry run: reporting what would change under ${config_dir} and ${media_dir}, changing nothing"
-else
-    echo "[INFO] Aligning ${config_dir} and ${media_dir} to ${puid}:${pgid}; this may take a while on large filesystems"
-fi
-
 # shellcheck disable=SC2086
 docker run --rm \
    -v "${config_dir}:/config" \
@@ -13,16 +13,6 @@ TRT_VER=${TRT_VER:-$(cat /etc/TENSORRT_VER)}
 OUTPUT_FOLDER="${MODEL_CACHE_DIR}/${TRT_VER}"
 YOLO_MODELS=${YOLO_MODELS:-""}

-# This runs as root after prepare's sentinel-guarded sweep, so the dirs and
-# engines it creates below are the runtime user's to fix up, on every exit path
-function hand_off_ownership() {
-    if [[ "$(id -u)" -eq 0 && "${FRIGATE_RUN_AS_ROOT:-false}" != "true" ]]; then
-        /usr/local/bin/fix-ownership "${PUID:-1000}" "${PGID:-1000}" \
-            /config/model_cache "${MODEL_CACHE_DIR}"
-    fi
-}
-trap hand_off_ownership EXIT
-
 # Create output folder
 mkdir -p ${OUTPUT_FOLDER}

@@ -496,11 +496,6 @@ review:
      - Animals in the garden
    # Optional: Preferred response language (default: English)
    preferred_language: English
-    # Optional: Writing style preset for generated descriptions (default: shown below)
-    # Options: "default", "natural", "concise", "detailed"
-    # Presets adjust the tone and level of detail of the user-facing title,
-    # summary, and scene description; "default" leaves the built-in prompt unchanged.
-    response_style: default
    # Optional: Save thumbnails sent to the GenAI provider for review/debugging purposes (default: shown below)
    debug_save_thumbnails: False

@@ -397,10 +397,6 @@ To do this:
 2. Update the `ffmpeg.path` in your Frigate config to `/config/custom-ffmpeg`.
 3. Restart Frigate and the custom version will be used if the steps above were done correctly.

-Both binaries have to be executable by Frigate's unprivileged runtime user, so `chmod 755` them after extracting. The startup ownership sweep runs only once, so anything you add to `/config` later keeps whatever ownership and mode you gave it.
-
-There is one exception, and it only affects [`FRIGATE_ROOT_SERVICES`](/configuration/non_root#keeping-individual-services-root) listing `frigate`. That mode runs Frigate as root while still handing `/config` to the unprivileged runtime user, so anything running as that user could swap the binary and gain root. A build inside any of Frigate's writable volumes (`/config`, `/media/frigate`, the cache and shm dirs) is ignored there and the bundled one is used, with a warning in the log. Keep the build somewhere root-owned (any absolute `ffmpeg.path` works, so a read-only bind mount such as `/opt/custom-ffmpeg` is enough) if you need both. The default mode and `FRIGATE_RUN_AS_ROOT=true` are unaffected and behave exactly as they always have.
-
 ### Custom go2rtc version

 Frigate currently includes go2rtc v1.9.14, there may be certain cases where you want to run a different version of go2rtc.
@@ -409,11 +405,9 @@ To do this:

 1. Download the go2rtc build to the `/config` folder.
 2. Rename the build to `go2rtc`.
-3. Give `go2rtc` execute permission for all users (`chmod 755`). It runs as its own `go2rtc` user, which doesn't own the file, so owner-only execute permission isn't enough.
+3. Give `go2rtc` execute permission.
 4. Restart Frigate and the custom version will be used, you can verify by checking go2rtc logs.

-The same exception applies, and again only to [`FRIGATE_ROOT_SERVICES`](/configuration/non_root#keeping-individual-services-root) listing `go2rtc`: the binary is ignored there and the embedded one is used, with a warning in the log. Unlike `ffmpeg.path`, the go2rtc binary location is not configurable, so there is no outside-`/config` alternative. Use `FRIGATE_RUN_AS_ROOT=true` instead if you need both a custom go2rtc build and root. The default mode and the escape hatch both honor `/config/go2rtc` exactly as they always have.
-
 ## Validating your config.yml file updates

 When frigate starts up, it checks whether your config file is valid, and if it is not, the process exits. To minimize interruptions when updating your config, you have three options -- you can edit the config via the WebUI which has built in validation, use the config API, or you can validate on the command line using the frigate docker container.
@@ -22,9 +22,7 @@ The following ports are available to access the Frigate web UI.

 ## Onboarding

-On startup, an admin user and password are generated and printed in the logs. It is recommended to set a new password for the admin account after logging in for the first time.
-
-On a new install the [setup wizard](../guides/getting_started.md#configuring-frigate) offers this as its first step, along with creating accounts for anyone else who needs access. You can also do both at any time under <NavPath path="Settings > Users" />.
+On startup, an admin user and password are generated and printed in the logs. It is recommended to set a new password for the admin account after logging in for the first time under Settings > Users.

 ## Resetting admin password

@@ -216,9 +214,9 @@ A default role can be provided. Any value in the mapped `role` header will overr

 Navigate to <NavPath path="Settings > System > Proxy" /> and set the default role.

-| Field            | Description                                                                                          |
-| ---------------- | ---------------------------------------------------------------------------------------------------- |
-| **Default role** | Fallback role when no role header is present (e.g., `viewer`), or `None (deny access)` to reject unmapped users |
+| Field            | Description                                                   |
+| ---------------- | ------------------------------------------------------------- |
+| **Default role** | Fallback role when no role header is present (e.g., `viewer`) |

 </TabItem>
 <TabItem value="yaml">
@@ -232,14 +230,6 @@ proxy:
 </TabItem>
 </ConfigTabs>

-Setting `default_role` to `none` denies access instead of falling back to a role. Any proxy-authenticated user whose headers do not match an explicit `role_map` entry receives a 403 response. This is useful when the upstream proxy authenticates a broader set of users than should reach Frigate, so that only mapped groups are allowed in.
-
-```yaml
-proxy:
-  ...
-  default_role: none
-```
-
 ## Role mapping

 In some environments, upstream identity providers (OIDC, SAML, LDAP, etc.) do not pass a Frigate-compatible role directly, but instead pass one or more group claims. To handle this, Frigate supports a `role_map` that translates upstream group names into Frigate's internal roles (`admin`, `viewer`, or custom). This is configurable via YAML in the configuration file:
@@ -265,7 +255,7 @@ In this example:
 - If the proxy passes a role header containing `sysadmins` or `access-level-security`, the user is assigned the `admin` role.
 - If the proxy passes a role header containing `camera-viewer`, the user is assigned the `viewer` role.
 - If the proxy passes a role header containing `operators`, the user is assigned the `operator` custom role.
- If no mapping matches, Frigate falls back to `default_role` if configured, or denies access if `default_role` is `none`.
+- If no mapping matches, Frigate falls back to `default_role` if configured.
 - If `role_map` is not defined, Frigate assumes the role header directly contains `admin`, `viewer`, or a custom role name.

 **Note on matching semantics:**
@@ -339,7 +329,7 @@ Frigate supports user roles to control access to certain features in the UI and

 - **admin**: Full access to all features, including user management and configuration.
 - **viewer**: Read-only access to the UI and API, including viewing cameras, review items, and historical footage. Configuration editor and settings in the UI are inaccessible.
- **Custom Roles**: Arbitrary role names (alphanumeric, dots/underscores) with specific camera permissions. These extend the system for granular access (e.g., "operator" for select cameras). The names `admin`, `viewer`, and `none` are reserved and cannot be used.
+- **Custom Roles**: Arbitrary role names (alphanumeric, dots/underscores) with specific camera permissions. These extend the system for granular access (e.g., "operator" for select cameras).

 ### Custom Roles and Camera Access

@@ -9,7 +9,7 @@ import NavPath from "@site/src/components/NavPath";

 ## Adding a camera with the Add Camera Wizard

-The Add Camera Wizard is the recommended way to add a camera. Click **Add Camera** in <NavPath path="Settings > Global configuration > Camera management" />, or use it from the [setup wizard](../guides/getting_started.md#configuring-frigate) on a new install. The wizard connects to your camera, tests each stream, and writes the camera's configuration for you, including the [go2rtc](go2rtc.md) restream and the live view stream mapping, so a standard setup needs no hand-written YAML.
+The Add Camera Wizard is the recommended way to add a camera. Click **Add Camera** in <NavPath path="Settings > Global configuration > Camera management" />. The wizard connects to your camera, tests each stream, and writes the camera's configuration for you, including the [go2rtc](go2rtc.md) restream and the live view stream mapping, so a standard setup needs no hand-written YAML.

 ### Step 1: Name and connection

@@ -517,6 +517,6 @@ objects:
 7. If descriptions are generated but the results are poor or inconsistent, look at the model and the context window.
   - Empty fields, missing `shortSummary` values, or `Failed to parse review description` errors usually mean the model is not following the requested JSON schema. Smaller models struggle with structured output. Try a larger parameter size or one of the [recommended models](#recommended-local-models).
   - Frigate calculates how many frames to send from the context size the provider reports. If your server reports a different value than it is actually running with, frames will be truncated or the request will fail. Pin the value by adding `context_size` under <NavPath path="Settings > Enrichments > Generative AI > Provider options" /> (`genai.<provider>.provider_options`), and for Ollama also confirm `options.num_ctx` there matches the context you have configured.
-   - Check **Review Description Speed** and **Object Description Speed** in <NavPath path="Health and Metrics > Enrichments" />. If inference takes tens of seconds, requests will queue behind each other and descriptions will appear to stop. For Ollama, review `OLLAMA_NUM_PARALLEL`, `OLLAMA_MAX_QUEUE`, and `OLLAMA_MAX_LOADED_MODELS` so that concurrent requests from Frigate are handled the way you expect.
+   - Check **Review Description Speed** and **Object Description Speed** in <NavPath path="System metrics > Enrichments" />. If inference takes tens of seconds, requests will queue behind each other and descriptions will appear to stop. For Ollama, review `OLLAMA_NUM_PARALLEL`, `OLLAMA_MAX_QUEUE`, and `OLLAMA_MAX_LOADED_MODELS` so that concurrent requests from Frigate are handled the way you expect.

 </FaqItem>
@@ -192,39 +192,6 @@ review:
 </TabItem>
 </ConfigTabs>

-### Response Style
-
-Different models respond to the built-in prompt with very different writing styles: some produce natural narration while others sound short and mechanical. The `response_style` option selects a writing style preset that rewords the prompt's instructions for the user-facing fields (the title, short summary, and scene description). Presets replace those instructions rather than adding extra ones, so the model never receives competing style directions.
-
-Available presets:
-
- `default`: The built-in prompt, unchanged. This already reads like a neutral security report.
- `natural`: Plain, everyday narration with flowing sentences and sentence-style headline titles. Useful when a model's output sounds robotic.
- `concise`: As brief as possible while still covering each significant action, with terse two-to-four word titles.
- `detailed`: Thorough descriptions and titles that include the most identifying specifics, like colors, clothing, and carried items.
-
-Style presets only adjust how the user-facing text reads; the model's step-by-step observations and threat level scoring guidance are unaffected. Results vary by model, so it is worth comparing presets against saved debug output using `testing-scripts/genai_review_tester.py` in the Frigate repository.
-
-<ConfigTabs>
-<TabItem value="ui">
-
-Navigate to <NavPath path="Settings > Global configuration > Review" />.
-
- Set **GenAI config > Response style** to the desired preset (e.g., `natural`)
-
-</TabItem>
-<TabItem value="yaml">
-
-```yaml {4}
-review:
-  genai:
-    enabled: true
-    response_style: natural
-```
-
-</TabItem>
-</ConfigTabs>
-
 ## Review Reports

 Along with individual review item summaries, Generative AI can also produce a single report of review items from all cameras marked "suspicious" over a specified time period (for example, a daily summary of suspicious activity while you're on vacation).
@@ -8,7 +8,7 @@ import TabItem from "@theme/TabItem";
 import NavPath from "@site/src/components/NavPath";
 import FaqItem from "@site/src/components/FaqItem";

-Frigate can recognize license plates on vehicles and automatically add the detected characters to the `recognized_license_plate` field or a [known](#matching) name as a `sub_label` to tracked objects of type `car`, `motorcycle`, `bus`, `truck`, `school_bus`, or `garbage_truck`, depending on which of those labels your model detects. A common use case may be to read the license plates of cars pulling into a driveway or cars passing by on a street.
+Frigate can recognize license plates on vehicles and automatically add the detected characters to the `recognized_license_plate` field or a [known](#matching) name as a `sub_label` to tracked objects of type `car` or `motorcycle`. A common use case may be to read the license plates of cars pulling into a driveway or cars passing by on a street.

 LPR works best when the license plate is clearly visible to the camera. For moving vehicles, Frigate continuously refines the recognition process, keeping the most confident result. When a vehicle becomes stationary, LPR continues to run for a short time after to attempt recognition.

@@ -24,7 +24,7 @@ When a plate is recognized, the details are:
 - Viewable in the Details pane in Review/History.
 - Viewable in the Tracked Object Details pane in Explore (sub labels and recognized license plates).
 - Filterable through the More Filters menu in Explore.
- Published via the `frigate/events` MQTT topic as a `sub_label` ([known](#matching)) or `recognized_license_plate` (unknown) for the vehicle tracked object.
+- Published via the `frigate/events` MQTT topic as a `sub_label` ([known](#matching)) or `recognized_license_plate` (unknown) for the `car` or `motorcycle` tracked object.
 - Published via the `frigate/tracked_object_update` MQTT topic with `name` (if [known](#matching)) and `plate`.

 ## Model Requirements
@@ -35,7 +35,7 @@ Users without a model that detects license plates can still run LPR. Frigate use

 :::note

-In the default mode, Frigate's LPR needs to first detect a vehicle before it can recognize a license plate. If you're using a dedicated LPR camera and have a zoomed-in view where a vehicle will not be detected, you can still run LPR, but the configuration parameters will differ from the default mode. See the [Dedicated LPR Cameras](#dedicated-lpr-cameras) section below.
+In the default mode, Frigate's LPR needs to first detect a `car` or `motorcycle` before it can recognize a license plate. If you're using a dedicated LPR camera and have a zoomed-in view where a `car` or `motorcycle` will not be detected, you can still run LPR, but the configuration parameters will differ from the default mode. See the [Dedicated LPR Cameras](#dedicated-lpr-cameras) section below.

 :::

@@ -86,7 +86,7 @@ cameras:
 </TabItem>
 </ConfigTabs>

-For non-dedicated LPR cameras, ensure that your camera is configured to detect vehicle objects, and that a vehicle is actually being detected by Frigate. Otherwise, LPR will not run. The object types that can carry a plate are defined by your model's `attributes_map`, so if your model detects other vehicle labels, you can add them there.
+For non-dedicated LPR cameras, ensure that your camera is configured to detect objects of type `car` or `motorcycle`, and that a car or motorcycle is actually being detected by Frigate. Otherwise, LPR will not run.

 Like the other real-time processors in Frigate, license plate recognition runs on the camera stream defined by the `detect` role in your config. To ensure optimal performance, select a suitable resolution for this stream in your camera's firmware that fits your specific scene and requirements.

@@ -158,7 +158,7 @@ lpr:

 Navigate to <NavPath path="Settings > Enrichments > License plate recognition" />.

- **Known plates**: Assign custom `sub_label` values to vehicle objects when a recognized plate matches a known value. These labels appear in the UI, filters, and notifications. Unknown plates are still saved but are added to the `recognized_license_plate` field rather than the `sub_label`.
+- **Known plates**: Assign custom `sub_label` values to `car` and `motorcycle` objects when a recognized plate matches a known value. These labels appear in the UI, filters, and notifications. Unknown plates are still saved but are added to the `recognized_license_plate` field rather than the `sub_label`.
 - **Match distance**: Allows for minor variations (missing/incorrect characters) when matching a detected plate to a known plate. For example, setting to `1` allows a plate `ABCDE` to match `ABCBE` or `ABCD`. This parameter will _not_ operate on known plates that are defined as regular expressions.

 </TabItem>
@@ -316,7 +316,7 @@ lpr:

 :::note

-If a camera is configured to detect vehicles but you don't want Frigate to run LPR for that camera, disable LPR at the camera level:
+If a camera is configured to detect `car` or `motorcycle` but you don't want Frigate to run LPR for that camera, disable LPR at the camera level:

 <ConfigTabs>
 <TabItem value="ui">
@@ -456,7 +456,7 @@ With this setup:
 - Snapshots will have license plate bounding boxes on them.
 - The `frigate/events` MQTT topic will publish tracked object updates.
 - Debug view will display `license_plate` bounding boxes.
- If you are using a Frigate+ model and want to submit images from your dedicated LPR camera for model training and fine-tuning, annotate both the vehicle and the `license_plate` in the snapshots on the Frigate+ website, even if the vehicle is barely visible.
+- If you are using a Frigate+ model and want to submit images from your dedicated LPR camera for model training and fine-tuning, annotate both the `car` / `motorcycle` and the `license_plate` in the snapshots on the Frigate+ website, even if the car is barely visible.

 ### Using the Secondary LPR Pipeline (Without Frigate+)

@@ -611,9 +611,9 @@ If you are still having issues detecting plates, start with a basic configuratio

 </FaqItem>

-<FaqItem id="can-i-run-lpr-without-detecting-car-or-motorcycle-objects" question={<>Can I run LPR without detecting vehicle objects?</>}>
+<FaqItem id="can-i-run-lpr-without-detecting-car-or-motorcycle-objects" question={<>Can I run LPR without detecting <code>car</code> or <code>motorcycle</code> objects?</>}>

-In normal LPR mode, Frigate requires a vehicle to be detected first before recognizing a license plate. If you have a dedicated LPR camera, you can change the camera `type` to `"lpr"` to use the Dedicated LPR Camera algorithm. This comes with important caveats, though. See the [Dedicated LPR Cameras](#dedicated-lpr-cameras) section above.
+In normal LPR mode, Frigate requires a `car` or `motorcycle` to be detected first before recognizing a license plate. If you have a dedicated LPR camera, you can change the camera `type` to `"lpr"` to use the Dedicated LPR Camera algorithm. This comes with important caveats, though. See the [Dedicated LPR Cameras](#dedicated-lpr-cameras) section above.

 </FaqItem>

@@ -697,9 +697,9 @@ lpr:
   - You may need to adjust your `detection_threshold` if your plates are not being detected.

 4. Ensure the characters on detected plates are being _recognized_.
-   - Check the **Plate recognition** inference time in Enrichment metrics (<NavPath path="Health and Metrics > Enrichments" />). High inference times (> 100ms) could lead to poor recognition results, especially for dedicated LPR cameras where the plate crosses the frame quickly.
+   - Check the **Plate recognition** inference time in Enrichment metrics (<NavPath path="System metrics > Enrichments" />). High inference times (> 100ms) could lead to poor recognition results, especially for dedicated LPR cameras where the plate crosses the frame quickly.
   - Enable `debug_save_plates` to save images of detected text on plates to the clips directory (`/media/frigate/clips/lpr`). Ensure these images are readable and the text is clear.
-   - Watch the debug view to see plates recognized in real-time. For non-dedicated LPR cameras, the vehicle's label will change to the recognized plate when LPR is enabled and working.
+   - Watch the debug view to see plates recognized in real-time. For non-dedicated LPR cameras, the `car` or `motorcycle` label will change to the recognized plate when LPR is enabled and working.
   - Adjust `recognition_threshold` settings per the suggestions [above](#advanced-configuration).

 </FaqItem>
@@ -714,13 +714,13 @@ LPR's performance impact depends on your hardware. Ensure you have at least 4GB

 The YOLOv9 license plate detector model will run (and the metric will appear) if you've enabled LPR but haven't defined `license_plate` as an object to track, either at the global or camera level.

-If you are detecting vehicles on cameras where you don't want to run LPR, make sure you disable LPR it at the camera level. And if you do want to run LPR on those cameras, make sure you define `license_plate` as an object to track.
+If you are detecting `car` or `motorcycle` on cameras where you don't want to run LPR, make sure you disable LPR it at the camera level. And if you do want to run LPR on those cameras, make sure you define `license_plate` as an object to track.

 </FaqItem>

 <FaqItem id="it-looks-like-frigate-picked-up-my-cameras-timestamp-or-overlay-text-as-the-license-plate-how-can-i-prevent-this" question="It looks like Frigate picked up my camera's timestamp or overlay text as the license plate. How can I prevent this?">

-This could happen if vehicles travel close to your camera's timestamp or overlay text. You could either move the text through your camera's firmware, or apply a mask to it in Frigate.
+This could happen if cars or motorcycles travel close to your camera's timestamp or overlay text. You could either move the text through your camera's firmware, or apply a mask to it in Frigate.

 If you are using a model that natively detects `license_plate`, add an _object mask_ of type `license_plate` and a _motion mask_ over your text.

@@ -1,387 +0,0 @@
---
-id: non_root
-title: Running as a non-root user
---
-
-# Running as a non-root user
-
-Frigate's services run as an unprivileged user inside the container. The main Frigate process and nginx run as `frigate`, and go2rtc runs as its own more restricted `go2rtc` user. Only the s6 init system and the certsync helper stay root.
-
-The runtime user is uid/gid `1000:1000` by default. You can change it with `PUID`/`PGID`, or bypass Frigate's user handling entirely with Docker's own `user:`.
-
-Most upgrades need nothing. Frigate aligns your volume ownership on the first boot and grants access to your hardware at startup. The sections below cover the cases that need attention: large storage volumes, network storage, and hardware the automatic grant can't reach.
-
-## Run modes
-
-| Mode                | How to enable                   | Ownership of `/config` and `/media/frigate`            | `read_only: true` |
-| ------------------- | ------------------------------- | ------------------------------------------------------ | ----------------- |
-| Default             | nothing, this is the default    | Aligned to `1000:1000` on first boot                   | Supported         |
-| `PUID`/`PGID`       | `PUID=1001`, `PGID=1001`        | Aligned to the values you set, on first boot           | Not supported     |
-| Docker-native user  | `user: "1001:1001"`             | You own it, Frigate never changes ownership            | Supported         |
-| Root (escape hatch) | `FRIGATE_RUN_AS_ROOT=true`      | Never touched                                          | Not supported     |
-| Granular root       | `FRIGATE_ROOT_SERVICES=frigate` | Aligned at boot; recordings and exports also at create | Not supported     |
-
-`PUID`/`PGID` remapping runs `usermod` at startup, which writes to `/etc/passwd`, so it can't work with a read-only root filesystem. That combination stops at startup with a message pointing here. `EXTRA_GROUPS` writes to `/etc/group` and stops the same way; use Docker's `group_add:` instead, which needs no writes inside the container. The default mode and Docker's `user:` mode both work with `read_only: true`; see [Hardened deployment](#hardened-deployment).
-
-`FRIGATE_RUN_AS_ROOT` is matched against the exact lowercase string `true`. `True`, `TRUE`, and `1` are all ignored. `FRIGATE_DEVICE_ACLS` works the same way: only the lowercase string `false` turns off the automatic device grants.
-
-### Keeping individual services root
-
-`FRIGATE_ROOT_SERVICES` takes a comma separated list of `frigate`, `go2rtc`, and `nginx`. A listed service keeps running as root, and everything else about non-root operation still applies: `PUID`/`PGID` remapping, the ownership sweep, and ownership of the files those services create.
-
-There are two reasons to use it:
-
- Your detector hardware won't work as an unprivileged user, even after reading [Hardware device access](#hardware-device-access). `FRIGATE_ROOT_SERVICES=frigate` keeps the main process and its detectors as root while nginx and go2rtc stay unprivileged.
- You want everything to run as root but still want your files owned by `PUID`/`PGID` instead of root. `FRIGATE_ROOT_SERVICES=frigate,go2rtc,nginx` does that.
-
-Try the device grants and `EXTRA_GROUPS` first. The `frigate` service runs the API and every ffmpeg process that decodes your camera streams, so listing it puts those back on root as well, not just your detectors.
-
-A listed service also stops honoring a [custom ffmpeg or go2rtc build](/configuration/advanced/system#custom-dependencies) kept in `/config`, since that directory stays owned by the unprivileged user and a binary there would run as root. `FRIGATE_RUN_AS_ROOT=true` has no such restriction.
-
-Recordings and exports are owned by `PUID`/`PGID` as soon as they're written, even by a root service. Snapshots, thumbnails, and other files under `clips/` are corrected on each restart, so they can show as root-owned from the host until then. A listed service also keeps root's home directory, so library caches go to the container layer instead of `/config`. The same applies to the [detector runtimes](/frigate/network_requirements#detector-runtimes) Frigate installs at first start (Hailo, MemryX, AXEngine): a root `frigate` service installs them into `/root/.local`, which is lost when the container is recreated, and never loads a copy left behind in `/config/.local`.
-
-Listing all three services is not the same as `FRIGATE_RUN_AS_ROOT=true`. The escape hatch never touches ownership; the list keeps the ownership handling active. A few more details:
-
- An unknown name in the list stops the container at startup, rather than silently leaving a service unprivileged.
- Changing the list runs the full ownership sweep once on the next boot.
- If both are set, `FRIGATE_RUN_AS_ROOT=true` wins and the list is ignored.
- With Docker's `user:`, the list does nothing, since the container never has root to keep.
-
-## Migrating an existing install
-
-Volumes from earlier versions of Frigate are owned by root, so ownership has to be aligned with the runtime user once. This happens automatically on the first boot after upgrading.
-
-On large recordings volumes, do it from the host beforehand instead. The boot sweep runs before any service starts, so a multi-terabyte `/media/frigate` can hold the container in startup long enough for Docker's healthcheck to mark it unhealthy, and orchestrators that watch health will restart it mid-sweep. If you'd rather not run the script, raise the healthcheck start period instead (`--start-period=1800s`, or `start_period: 1800s` under `healthcheck:` in compose).
-
-Grab [`fix-permissions.sh`](https://github.com/blakeblackshear/frigate/blob/dev/docker/migration/fix-permissions.sh) from the Frigate repo and dry run it first:
-
-```bash
-./fix-permissions.sh --dry-run /path/to/your/config /path/to/your/storage
-```
-
-That reports how many entries would change and touches nothing. When it looks right, run it without `--dry-run`:
-
-```bash
-./fix-permissions.sh /path/to/your/config /path/to/your/storage
-```
-
-Pass `PUID` and `PGID` as the third and fourth arguments if you're not using the default `1000:1000`. The script wraps the same helper the container uses, so the result is identical either way. Override the image it pulls with `FRIGATE_IMAGE=...` if you're not on `stable`.
-
-Both the script and the boot sweep report progress, so you can tell a slow sweep from a stuck one:
-
-```
-[INFO] fix-ownership: scanning /media/frigate for ownership mismatches; this may take a while on large filesystems
-[WARN] fix-ownership: adjusting ownership of 4823941 entries under /media/frigate
-[INFO] fix-ownership: /media/frigate 5% (241197/4823941 entries)
-[INFO] fix-ownership: /media/frigate 10% (482394/4823941 entries)
-[INFO] fix-ownership: finished /media/frigate in 12m 4s
-```
-
-The scan has no percentage because the total isn't known until it finishes. Watch the boot sweep with `docker logs -f frigate`.
-
-Once the volumes are aligned, start Frigate normally. A file at `/config/.permissions_version` records what was done, so later boots skip the sweep unless you change `PUID`/`PGID`.
-
-If something under your volumes can't be chowned, a read-only btrfs snapshot directory for example, the sweep warns and names the path and doesn't record the migration as finished. It retries on the next boot instead. Either move those paths outside `/media/frigate` or expect the scan to repeat.
-
-### Network storage
-
-Recordings on a NAS behave differently, so check what you have before migrating:
-
-```bash
-findmnt -T /path/to/your/storage -o TARGET,FSTYPE,OPTIONS
-```
-
-**SMB and CIFS** don't store per-file ownership at all. It's synthesized from the mount options, so a per-file `chown` fails and isn't needed. Mount the share as the uid and gid Frigate runs as, and every file already looks correct to the sweep:
-
-```
-//nas/frigate /media/frigate cifs credentials=/root/.smb,uid=1000,gid=1000,file_mode=0664,dir_mode=0775 0 0
-```
-
-**NFS** exports default to `root_squash` on most servers, which maps the container's root to `nobody`. The chown then fails, you get `[WARN] fix-ownership: some entries under /media/frigate could not be updated`, and since the sweep didn't finish it doesn't record the migration, so it retries on every boot.
-
-The best fix is to not chown over NFS at all. Do it on the server, where there's no squash and no network round trip per file:
-
-```bash
-# on the NAS itself, against the exported directory
-chown -R 1000:1000 /export/frigate
-```
-
-Frigate's sweep then finds nothing to change and records the migration normally. If you can't get a shell on the server, you can export temporarily with `no_root_squash`, migrate, and put it back, or leave ownership alone and set `PUID`/`PGID` to whichever uid already owns the files.
-
-Either way the uid has to mean the same thing on both machines. NFS sends numeric uids, so container uid 1000 is uid 1000 on the server no matter what the usernames are.
-
-Expect the first boot to be slow even when nothing needs changing, because checking ownership costs a round trip per file. That's a one-time cost. **If the sweep runs on every boot rather than once, ownership isn't actually being applied**, and the warning above will say so.
-
-Keep `/config` on local storage either way. Frigate's database is SQLite and network shares handle its locking poorly. That's a long-standing recommendation, not something running non-root introduces.
-
-## Rolling back
-
-Set `FRIGATE_RUN_AS_ROOT=true` and restart. Everything runs as root again, exactly as it did before. This is the fastest way to get a broken install running while you sort out a device permission problem.
-
-The escape hatch never changes ownership, and it clears the record of the last sweep on startup, so switching back to non-root later corrects whatever root created in the meantime. Toggling in either direction is safe.
-
-## Hardware device access
-
-Frigate grants the runtime user access to your devices at startup. Pass your hardware with `--device` (or `devices:` in compose) and detection and hardware acceleration work with no group or udev setup on the host.
-
-The grant covers the common accelerator and camera nodes: GPU render nodes, Intel/AMD NPUs (`/dev/accel`), Coral, Hailo, Rockchip, Jetson, `/dev/video*`, and the USB bus. For hardware it misses, add your own paths with `DEVICE_ACL_PATHS`, a comma separated list of globs:
-
-```yaml
-environment:
-  DEVICE_ACL_PATHS: "/dev/mydev*"
-```
-
-Set `FRIGATE_DEVICE_ACLS=false` if you manage device permissions yourself and want Frigate to leave them alone.
-
-Frigate grants access by adding an ACL entry for the runtime users. The device's owner and mode are unchanged, and nothing is made world accessible. One thing to know: `--device` nodes belong to the container, but a bind mounted `/dev/bus/usb` (the usual Coral USB setup) shares the host's device nodes, so the entry is visible on the host until udev recreates the node.
-
-### Manual setup
-
-You only need this for hardware the automatic grant can't reach, or for Docker's `user:` mode, where there's no root startup to do the granting.
-
-Your accelerator most likely worked in older versions because Frigate ran as root. Device nodes are usually owned by `root:root`, and root either matches the group or skips the check entirely. The runtime user does neither, so a device that worked before can become unreadable with no change to your Frigate config.
-
-#### Read what your device requires
-
-Find the node and look at its owner, group, and mode:
-
-```bash
-ls -ln /dev/dri/renderD128
-crw-rw---- 1 0 105 226, 128 Jul  5 10:12 /dev/dri/renderD128
-#          ^ ^  ^
-#          | |  group GID 105
-#          | owner UID 0 (root)
-#          mode: owner rw, group rw, other none
-```
-
-Then work out which of the three permission sets applies to the runtime user. It isn't the owner, since that's root, so it gets the group bits if it belongs to that GID and otherwise falls through to "other". In the example above "other" is empty, so without membership in group 105 the runtime user can't open the node.
-
-Watch for a node that looks permissive but isn't. A USB Coral defaults to this:
-
-```bash
-ls -ln /dev/bus/usb/004/003
-crw-rw-r-- 1 0 0 189, 386 Jul  5 10:12 /dev/bus/usb/004/003
-```
-
-The group is `0`, so "other" applies to the runtime user, and "other" here is read only. `libedgetpu` needs to write to the node, so detection fails with `No EdgeTPU was detected` as though no Coral were attached. Read access alone isn't enough for most accelerators.
-
-#### Grant access
-
-Give the runtime user the GID with `EXTRA_GROUPS`, a comma separated list of numeric host GIDs. They're added to both the `frigate` and `go2rtc` users, which matters because go2rtc needs its own render and video access for hardware accelerated restreams.
-
-```yaml
-environment:
-  EXTRA_GROUPS: "105,44" # host render and video GIDs
-```
-
-Use numeric GIDs from the host, not names. Group names don't have to match between the host and the container, and the kernel only checks the number. If the GID doesn't exist in the image, Frigate creates a placeholder group for it.
-
-Two things that look like they should work but don't:
-
- Docker's `group_add` has no effect in the default or `PUID` modes. Frigate rebuilds the supplementary group list from `/etc/group` when it drops privileges, which discards what Docker passed in. It is the right tool with Docker's `user:`, where no privilege drop happens and `EXTRA_GROUPS` does nothing.
- `privileged: true` doesn't help. It grants capabilities to root, and the runtime user isn't root, so the file permissions on the node still apply.
-
-If the node's group is `root` or the mode denies the group, no `EXTRA_GROUPS` value will help. You need a udev rule first.
-
-#### Verify access
-
-Check the group landed, then check the runtime user can open the node. Test for write, not just read:
-
-```bash
-docker exec frigate id frigate
-docker exec frigate /command/s6-setuidgid frigate sh -c 'test -w /dev/dri/renderD128 && echo ok'
-docker exec frigate /command/s6-setuidgid go2rtc  sh -c 'test -w /dev/dri/renderD128 && echo ok'
-```
-
-A permission check is only a proxy for the driver working. These exercise the real libraries as the runtime user:
-
-```bash
-docker exec frigate /command/s6-setuidgid frigate vainfo
-docker exec frigate /command/s6-setuidgid frigate python3 -c "import openvino as ov; print(ov.Core().available_devices)"
-```
-
-`vainfo` should reach `va_openDriver() returns 0` and list profiles. Complaints about `XDG_RUNTIME_DIR` or an X server above that are normal. OpenVINO should list `GPU`; if it returns only `CPU`, detection has fallen back and inference will be much slower without an error in the log.
-
-To tell a permissions problem from anything else, start the container once with `FRIGATE_RUN_AS_ROOT=true`. If the device works as root and not otherwise, it's node permissions and a udev rule is the fix. If it's missing either way, the problem is your device mapping or the host, and isn't related to running non-root.
-
-#### udev rules by device
-
-Rules go in `/etc/udev/rules.d/` on the host and take effect after:
-
-```bash
-sudo udevadm control --reload-rules && sudo udevadm trigger
-```
-
-A device that's already connected sometimes keeps its original ownership through a trigger. If `ls -ln` doesn't show the new group, replug it, or reboot for a built-in device.
-
-**Coral USB** needs two rules, because the device re-enumerates after loading firmware. It appears as Global Unichip `1a6e` before and Google `18d1` after, with a different node each time. A rule covering only `1a6e` gives you a Coral that starts up once and then disappears mid-run.
-
-```
-SUBSYSTEM=="usb", ATTRS{idVendor}=="1a6e", GROUP="plugdev", MODE="0664"
-SUBSYSTEM=="usb", ATTRS{idVendor}=="18d1", GROUP="plugdev", MODE="0664"
-```
-
-Map the whole `/dev/bus/usb` rather than a single node, for the same reason. Most hosts put `plugdev` at GID 46 and the image agrees, so a USB Coral often needs no `EXTRA_GROUPS` entry. Confirm with `getent group plugdev` and add the number if your host differs.
-
-**Coral PCIe** is often `crw------- root root`, which only root can open:
-
-```
-SUBSYSTEM=="apex", MODE="0660", GROUP="apex"
-```
-
-Create the group with `sudo groupadd -f apex`, then add its GID to `EXTRA_GROUPS`.
-
-**Hailo** works the same way. Grant `/dev/hailo0` a group and add that GID:
-
-```
-SUBSYSTEM=="hailo_chardev", MODE="0660", GROUP="hailo"
-```
-
-**Intel and AMD GPUs** usually need nothing beyond `EXTRA_GROUPS`, since most distributions ship a `render` group that owns `/dev/dri/renderD128`. The GID often differs between the host and the image, so pass the host's number rather than assuming the name resolves. Debian based images have no `render` group at all.
-
-#### Quick reference
-
-What each device needs when you're setting it up by hand. The automatic grant covers most of these already, so start here only if it didn't.
-
-| Hardware                  | Device(s)                                                   | What non-root needs                                                                                              |
-| ------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| Intel/AMD GPU (VAAPI/QSV) | `/dev/dri/renderD128`                                       | Host render GID in `EXTRA_GROUPS`, from `getent group render`                                                    |
-| Intel/AMD NPU             | `/dev/accel`                                                | udev rule granting a group, then that GID in `EXTRA_GROUPS`                                                      |
-| Coral USB                 | `/dev/bus/usb`                                              | udev rules for both `1a6e` and `18d1`; usually already covered by `plugdev` 46                                   |
-| Coral PCIe                | `/dev/apex_0`                                               | udev rule granting a group, then that GID in `EXTRA_GROUPS`                                                      |
-| Hailo                     | `/dev/hailo0`                                               | udev rule granting a group, then that GID in `EXTRA_GROUPS`                                                      |
-| NVIDIA                    | nvidia runtime                                              | Nothing, works with the nvidia-container-toolkit defaults                                                        |
-| AMD ROCm                  | `/dev/kfd`, `/dev/dri`                                      | Host `video` and `render` GIDs in `EXTRA_GROUPS`                                                                 |
-| Raspberry Pi              | `/dev/video11`                                              | Host `video` GID in `EXTRA_GROUPS`                                                                               |
-| Rockchip                  | `/dev/dri`, `/dev/dma_heap`, `/dev/rga`, `/dev/mpp_service` | Commonly `root:root` `0600`, so all four need udev rules. If you can't grant all four, use `FRIGATE_RUN_AS_ROOT` |
-| Axera (AXCL)              | `/dev/ax_*` per the AXCL driver docs                        | Unverified. Check node ownership on your hardware before assuming this works                                     |
-| Synaptics SL1680          | per the Synaptics docs                                      | Unverified                                                                                                       |
-| MemryX                    | per the MemryX docs                                         | Still requires `privileged: true`, which means root. Out of scope for non-root operation                         |
-| Nvidia Jetson             | nvidia runtime plus Jetson nodes                            | Unverified. The nvidia runtime handles mapping, but check `/dev/nvhost-*` ownership on your board                |
-| VeriSilicon NPU (Teflon)  | per the driver, commonly `/dev/galcore`                     | Unverified. Check node ownership on your hardware before assuming this works                                     |
-| CPU detector              | none                                                        | Nothing, no device is opened                                                                                     |
-| ZMQ detector              | none                                                        | Nothing, inference happens over a socket                                                                         |
-| Apple Silicon             | none                                                        | Nothing, the NPU client runs on the host and Frigate reaches it over the network                                 |
-
-## Hardened deployment
-
-A read-only root filesystem means the container can't modify itself, only the volumes you give it. It works in the default mode and under Docker's `user:`, but not with `PUID`/`PGID` or `EXTRA_GROUPS`, which both need to write to `/etc`.
-
-Start with the default mode. It keeps go2rtc on its own restricted user and still grants your hardware automatically, at the cost of a short root startup that finishes before any service runs.
-
-```yaml
-services:
-  frigate:
-    container_name: frigate
-    image: ghcr.io/blakeblackshear/frigate:stable
-    restart: unless-stopped
-    stop_grace_period: 30s
-    read_only: true
-    security_opt:
-      - no-new-privileges:true
-    shm_size: "512mb" # size for your cameras, see the shm-size calculation
-    devices:
-      - /dev/dri/renderD128:/dev/dri/renderD128 # your hardware, granted at startup
-    volumes:
-      - /etc/localtime:/etc/localtime:ro
-      - /path/to/your/config:/config
-      - /path/to/your/storage:/media/frigate
-    tmpfs:
-      - /tmp:size=256m
-      - /tmp/cache:size=1000000000 # recording segments, sized as before
-      - /run:exec,nosuid,nodev,mode=0755,size=16m
-    ports:
-      - "8971:8971"
-      - "8554:8554" # RTSP feeds
-      - "8555:8555/tcp" # WebRTC over tcp
-      - "8555:8555/udp" # WebRTC over udp
-```
-
-`/run` has to allow `exec`. With a read-only root filesystem s6 copies its service scripts into `/run` and runs them from there, and tmpfs mounts default to `noexec`. The equivalent for `docker run` is `--tmpfs /run:exec,nosuid,nodev,mode=0755`. Spelling out `nosuid` and `nodev` matters: passing any tmpfs options replaces Docker's defaults instead of adjusting them, so asking for `exec` alone would drop those two as well.
-
-Size `/tmp` deliberately. It now carries nginx's config copy and its five proxy temp directories as well as the recording cache. Keeping `/tmp/cache` as its own nested tmpfs, as above, leaves your existing [cache sizing](/frigate/installation#storage) untouched and adds a small allowance for nginx. If you'd rather use one tmpfs over all of `/tmp`, size it as your cache budget plus roughly 50MB, or recordings begin failing once the cache fills.
-
-The self signed certificate is written to `/config/tls`, which stays writable. Certificates you mount at `/etc/letsencrypt/live/frigate` work unchanged and still take precedence.
-
-[Detector runtimes](/frigate/network_requirements#detector-runtimes) that Frigate installs at first start (Hailo, MemryX, AXEngine) are staged in `/tmp` and installed into `/config/.local`, so they work with a read-only root filesystem in the default mode and under `user:`. A root `frigate` service installs into `/root/.local` instead, which a read-only root filesystem prevents; either leave `frigate` out of `FRIGATE_ROOT_SERVICES` or drop `read_only`.
-
-Soak a hardened deployment for 24 hours against real cameras before relying on it. A read-only root filesystem turns an occasional write into a failure that startup won't reveal.
-
-### Never starting as root
-
-To remove root from the container entirely, add Docker's `user:`:
-
-```yaml
-    user: "1000:1000" # NOT compatible with PUID/PGID, see the run modes table
-```
-
-Two things change, and the first one will break a working install if you skip it. The startup device grants can't run, because there is no root left to run them, so every device you pass stops working until you grant that uid access yourself with `group_add:` or a udev rule; see [Manual setup](#manual-setup). Expect this to surface as a driver error rather than a permission error, like `No VA display found` from VAAPI. And every service then runs as that one uid, so go2rtc no longer gets its own restricted user. `/config` and `/media/frigate` have to be owned by that uid already, since Frigate never adjusts ownership in this mode. Switching an existing install over also leaves `/config/go2rtc_homekit.yml` owned by the go2rtc user, which this mode can't write; `chown` it to your uid or HomeKit pairing changes stop persisting. Frigate warns and starts either way.
-
-This mode can also take `cap_drop: [ALL]`, which the default mode cannot: starting as root needs `CAP_CHOWN` for the ownership sweep, `CAP_SETUID` and `CAP_SETGID` to drop to the runtime user, and `CAP_FOWNER` for the device grants.
-
-### Per-variant exceptions
-
- **Rockchip** needs `- /sys/:/sys/:ro` alongside its device nodes, in addition to everything above.
- **MemryX** and **QNAP Container Station** still require `privileged: true` per their own documentation, which gives back most of what this layout removes. MemryX also downloads its models to `/memryx_models` on the root filesystem, so it can't run read-only regardless. Its SDK is installed into `/config/.local` like the other detector runtimes.
-
-## Network isolation
-
-Everything above limits what a compromised container can do to the host. It doesn't limit what your cameras can do to your network. Camera firmware is closed source, rarely patched, and not something you can audit, and none of it needs internet access for Frigate to work.
-
-Put the cameras on their own VLAN or subnet, give the Frigate host a route into it, and deny that VLAN any route out. Frigate reaches in to pull streams, the cameras reach nothing. A second NIC on the Frigate host is the simplest version of this, and a tagged VLAN on the NIC you already have works just as well.
-
-Here's the deny as nftables on the router, with cameras on `vlan20` and the Frigate host at `192.168.10.5`:
-
-```
-table inet cameras {
-  chain forward {
-    type filter hook forward priority filter; policy accept;
-
-    ct state established,related accept
-    iifname "vlan20" ip daddr 192.168.10.5 accept
-    iifname "vlan20" drop
-  }
-}
-```
-
-It's in its own table so it can sit alongside an existing ruleset without touching it. Streams keep working because Frigate opens those connections and the return traffic is `established`. Cameras can still reach each other on their own VLAN, since that traffic never reaches the router, so use client isolation on the switch if that matters to you.
-
-Two things break when you do this. The manufacturer's phone app stops working, which is the point, and camera clocks drift, because most of them set their time over NTP and are bad at it. Point them at an NTP server on your own network rather than opening the VLAN back up, or their timestamps and Frigate's will disagree.
-
-Frigate itself needs some outbound access, though nearly all of it is optional. The startup version check is the only piece that's on by default, and `telemetry.version_check: false` turns it off. Everything else (model downloads for the enrichment features, push notifications, Frigate+, and cloud GenAI providers) only reaches out once you enable that feature. See [Network Requirements](/frigate/network_requirements) for the full list and how to run fully offline.
-
-For containers that only talk to each other, an internal compose network gets you the same isolation without involving the router:
-
-```yaml
-services:
-  frigate:
-    networks: [default, iot]
-    # the rest of your frigate service
-  mosquitto:
-    image: eclipse-mosquitto
-    networks: [iot]
-
-networks:
-  iot:
-    internal: true
-```
-
-`internal: true` gives that network no route off the host, so the broker isn't reachable from anywhere else on your LAN. Frigate sits on both networks and keeps its normal outbound path.
-
-One Docker specific trap: published ports are inserted ahead of the host firewall, so `ufw deny 8971` doesn't do what it looks like it does. Bind the port to the interface you want instead, like `127.0.0.1:8971:8971` for a reverse proxy on the same host, or your LAN address for everything else.
-
-## Known limitations
-
-`telemetry.stats.network_bandwidth` uses nethogs, which needs `CAP_NET_ADMIN` and `CAP_NET_RAW` and therefore root. The stat is turned off automatically when Frigate isn't running as root, with one warning in the log. Use `FRIGATE_ROOT_SERVICES=frigate` (or `FRIGATE_RUN_AS_ROOT=true`) if you need it.
-
-go2rtc's ffmpeg processes no longer appear in Intel GPU stats. Frigate reads per-process GPU usage from `/proc/<pid>/fdinfo`, which the kernel won't let one user read for another user's processes, so anything go2rtc spawns is invisible to it. Overall GPU utilization is unaffected.
-
-If you mount your own TLS certificate at `/etc/letsencrypt/live/frigate`, the private key has to be readable by the runtime user, which runs nginx. Frigate hands the key to that user at startup if the mount is writable; on a read-only mount, make the key readable by uid 1000 (or your `PUID`) yourself.
-
-If you're debugging nginx, run the config check as the runtime user with stdout discarded:
-
-```bash
-docker exec frigate /command/s6-setuidgid frigate bash -c 'nginx -t -c /tmp/nginx/conf/nginx.conf >/dev/null'
-```
-
-Running `nginx -t` as root hands nginx's runtime directories to root as a side effect, which breaks the running workers until the service restarts, and the config's `/dev/stdout` logs can't be reopened through a root-owned `docker exec` pipe. The results print on stderr either way.
@@ -134,7 +134,7 @@ Along with picking a detector for your hardware, you will choose a model's **inp

 **Resolution (320x320 vs 640x640):** Frigate is optimized for `320x320` models, and `320x320` is the best choice for the vast majority of setups. Frigate is specifically designed to compensate for the smaller model by cropping a region of motion from the full frame and zooming into it before running detection, so a `320x320` model is actually _better_ at small and distant objects, not worse. A `640x640` model is slower and uses more resources, and its main benefit is fitting more objects into a single inference when many objects are spread across a large area. Recent versions of Frigate have improved support for `640x640` models, but `320x320` remains the recommended starting point for nearly all setups.

-**Variant size (tiny/small/medium):** Larger variants are gradually more accurate but slower. Whether the difference is noticeable depends on your specific cameras and scenes. A good rule of thumb is to use the largest model your hardware can run without skipping detections, which you can monitor on the <NavPath path="Health and Metrics > Cameras" /> page in the UI. Better accuracy only helps if your detector keeps up with the detection load across all cameras.
+**Variant size (tiny/small/medium):** Larger variants are gradually more accurate but slower. Whether the difference is noticeable depends on your specific cameras and scenes. A good rule of thumb is to use the largest model your hardware can run without skipping detections, which you can monitor on the <NavPath path="System > Metrics > Cameras" /> page in the UI. Better accuracy only helps if your detector keeps up with the detection load across all cameras.

 **Acceptable inference time depends on your hardware.** Inference time alone does not tell the whole story, because different hardware has different capacity. A GPU can run multiple instances of the same model concurrently, so an inference time around 30ms can still keep up with several cameras. A Google Coral runs only a single instance of the model, so it needs a much lower inference time (around 10ms) to keep up.

@@ -297,12 +297,6 @@ If no custom model is provided, the Hailo detector downloads a default model fro

 :::

-:::info
-
-The HailoRT runtime is not part of the Frigate image. It is downloaded and installed into `/config/.local` the first time a Hailo detector is configured, verified against pinned checksums, and updated automatically when a Frigate release pins a new version. If the container has no internet access, see [Detector runtimes](/frigate/network_requirements#detector-runtimes) for how to provide the files yourself.
-
-:::
-
 ### Configuration {#configuration-hailo}

 When configuring the Hailo detector, you have two options to specify the model: a local **path** or a **URL**.
@@ -344,8 +338,6 @@ models:

 ### Intel NPU host requirements {#intel-npu-requirements}

-The NPU device must be passed into the container by adding `/dev/accel:/dev/accel` to the `devices` section of your compose file. Frigate grants the runtime user access to the device automatically; see [hardware device access](/configuration/non_root#hardware-device-access) if you manage device permissions yourself.
-
 The NPU firmware is loaded by the host kernel and is not part of the Frigate image. Everything else the NPU needs is bundled in the container, so host NPU libraries should never be mounted in.

 Frigate bundles a specific version of Intel's [linux-npu-driver](https://github.com/intel/linux-npu-driver/releases), and the host firmware must come from that release or a newer one. Firmware older than the bundled driver may fail with `MAPPED_INFERENCE_VERSION is NOT compatible with the ELF`, where `Expected` is the version the firmware supports and `received` is the version the bundled compiler produced. Distributions often package older firmware than the driver Frigate ships, so check the build date on the host with `sudo dmesg | grep -i vpu` and update it there if needed.
@@ -574,12 +566,6 @@ See the [installation docs](../frigate/installation.md#memryx-mx3) for informati

 To configure a MemryX detector, simply set the `type` attribute to `memryx` and follow the configuration guide below.

-:::info
-
-The MemryX SDK is not part of the Frigate image. It is downloaded and installed into `/config/.local` the first time a MemryX detector is configured, verified against pinned checksums, and updated automatically when a Frigate release pins a new version. If the container has no internet access, see [Detector runtimes](/frigate/network_requirements#detector-runtimes) for how to provide the files yourself.
-
-:::
-
 ### Configuration {#configuration-memryx}

 <ModelConfigDropdown detectorTitle="MemryX" models={objectDetectorsModels.memryx.models} />
@@ -840,12 +826,6 @@ The AXEngine detector downloads its default model from HuggingFace on first star

 :::

-:::info
-
-The AXEngine python package is not part of the Frigate image. It is downloaded and installed into `/config/.local` the first time an AXEngine detector is configured, verified against a pinned checksum, and updated automatically when a Frigate release pins a new version. If the container has no internet access, see [Detector runtimes](/frigate/network_requirements#detector-runtimes) for how to provide the file yourself.
-
-:::
-
 ### Configuration {#configuration-axengine}

 When configuring the AXEngine detector, you have to specify the model name.
@@ -9,7 +9,7 @@ import NavPath from "@site/src/components/NavPath";

 Recordings can be enabled and are stored at `/media/frigate/recordings`. The folder structure for the recordings is `YYYY-MM-DD/HH/<camera_name>/MM.SS.mp4` in **UTC time**. These recordings are written directly from your camera stream without re-encoding. Each camera supports a configurable retention policy. Frigate chooses the largest matching retention value between the recording retention and the tracked object retention when determining if a recording should be removed.

-New recording segments are written from the camera stream to cache, they are only moved to disk if they pass a validation check and match the setup recording retention policy.
+New recording segments are written from the camera stream to cache, they are only moved to disk if they match the setup recording retention policy.

 :::tip

@@ -280,7 +280,6 @@ This configuration will retain recording segments that overlap with alerts and d
 In addition to the main recording stream, Frigate can record a second, lower quality stream for each camera. This serves two purposes:

 - **Quality selection during playback**: A quality selector (`Auto`, `Original`, or `Low`) appears in History view for cameras with sub stream recording enabled. `Original` and `Low` play only that stream's recordings. Time ranges where the selected stream has no footage are skipped during playback, and the selector notes when the selected stream has no recordings at all in the viewed time range. With `Auto` (the default), playback prefers the original quality and automatically falls back to the low quality stream when the connection cannot keep up, or for time ranges where the original recordings have expired. The selector shows each stream's video codec and audio details beneath the options; footage recorded by older Frigate versions shows no details.
- **Quality selection when exporting**: A `Quality` selector (`Auto`, `Original`, or `Low`) is available for cameras with sub stream recording enabled. See [exporting](#exporting-a-camera-that-records-two-streams) for details on each option.
 - **Extended retention**: Sub stream recordings have their own retention settings, fully independent of the main recordings. By giving the low quality recordings a longer retention period, you can keep weeks or months of low quality history using a fraction of the storage, and that history remains playable after the main recordings expire. Playback falls back to the low quality recordings automatically, and the timeline shows a muted treatment for time ranges where only low quality footage remains. Timeline previews are kept for as long as either stream still has recordings, so scrubbing works across the whole retained history.

 ### Configuring sub stream recording
@@ -417,8 +416,7 @@ As a general rule, features that read recordings prefer the main stream and fall
 | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
 | Recording playback (History and Review)                                                  | Both (main preferred with sub fallback by default), or exactly one stream when a quality is selected manually |
 | Tracking details and Explore clip playback                                               | Main, falling back to sub where the main recordings have expired                                              |
-| Exports                                                                                  | Both (main preferred with sub fallback by default), or exactly one stream when a quality is selected in the export dialog |
-| Clip downloads                                                                           | Main; sub is used when no main recordings remain in the range (streams are never mixed in one file)           |
+| Exports and clip downloads                                                               | Main; sub is used when no main recordings remain in the range (streams are never mixed in one file)           |
 | Frames grabbed from a recording in History (download snapshot, submit frame to Frigate+) | Main preferred, sub fallback                                                                                  |
 | Audio extraction (e.g., transcription)                                                   | Main preferred, sub fallback                                                                                  |
 | Motion search                                                                            | Main only                                                                                                     |
@@ -501,7 +499,7 @@ Media files (event snapshots, event thumbnails, review thumbnails, previews, exp

 Normal operation may leave small numbers of orphaned files until Frigate's scheduled cleanup, but crashes, configuration changes, or upgrades may cause more orphaned files that Frigate does not clean up. This feature checks the file system for media files and removes any that are not referenced in the database.

-The Maintenance pane in the Frigate UI or an API endpoint `POST /api/media/sync` can be used to trigger a media sync. When using the API, a job ID is returned and the operation continues on the server. Status can be checked with the `/api/media/sync/status/{job_id}` endpoint. Results include the disk space reclaimed, or with `dry_run: true`, the space that would be reclaimed.
+The Maintenance pane in the Frigate UI or an API endpoint `POST /api/media/sync` can be used to trigger a media sync. When using the API, a job ID is returned and the operation continues on the server. Status can be checked with the `/api/media/sync/status/{job_id}` endpoint.

 Setting `verbose: true` writes a detailed report of every orphaned file and database entry to `/config/media_sync/<job_id>.txt`. For recordings, the report separates orphaned database entries (DB records whose files are missing from disk) from orphaned files (files on disk with no corresponding database record).

@@ -517,7 +515,7 @@ The storage usage Frigate reports will not exactly match what the operating syst

 ### How Frigate measures recording usage

-The **Recordings** value on the Storage Metrics page (<NavPath path="Health and Metrics > Storage" />), and the per-camera **Camera Storage** breakdown, is the sum of the recording segment sizes Frigate has written, taken from Frigate's database. It is **not** computed by a scan of the disk. Frigate tracks usage this way by design: repeatedly walking the entire drive to total its size would keep hard drives spun up and add unnecessary I/O.
+The **Recordings** value on the Storage Metrics page (<NavPath path="System > Storage" />), and the per-camera **Camera Storage** breakdown, is the sum of the recording segment sizes Frigate has written, taken from Frigate's database. It is **not** computed by a scan of the disk. Frigate tracks usage this way by design: repeatedly walking the entire drive to total its size would keep hard drives spun up and add unnecessary I/O.

 The disk **total** shown beside it, and the free-space figure Frigate uses to decide when to delete recordings, instead come from the operating system's report for the whole filesystem mounted at `/media/frigate`. As a result, the **Unused** value on the page is _total disk capacity minus Frigate's recordings_, not the drive's real free space, which will be lower whenever anything else is stored on the disk.

@@ -9,7 +9,7 @@ import NavPath from "@site/src/components/NavPath";

 # TLS

-Frigate's integrated NGINX server supports TLS certificates. By default Frigate will generate a self signed certificate that will be used for port 8971, stored in `/config/tls` so it survives container recreation. Frigate is designed to make it easy to use whatever tool you prefer to manage certificates.
+Frigate's integrated NGINX server supports TLS certificates. By default Frigate will generate a self signed certificate that will be used for port 8971. Frigate is designed to make it easy to use whatever tool you prefer to manage certificates.

 Frigate is often running behind a reverse proxy that manages TLS certificates for multiple services. You will likely need to set your reverse proxy to allow self signed certificates or you can disable TLS in Frigate's config. However, if you are running on a dedicated device that's separate from your proxy or if you expose Frigate directly to the internet, you may want to configure TLS with valid certificates.

@@ -45,9 +45,7 @@ frigate:
  ...
 ```

-Within the folder, the private key is expected to be named `privkey.pem` and the certificate is expected to be named `fullchain.pem`. Mounted certificates take precedence over the self signed pair in `/config/tls`.
-
-`privkey.pem` must be readable by the runtime user that runs NGINX. Frigate hands it over at startup when the mount is writable; on a `:ro` mount, make it readable by uid 1000 (or your `PUID`) yourself. See [Running as a non-root user](/configuration/non_root).
+Within the folder, the private key is expected to be named `privkey.pem` and the certificate is expected to be named `fullchain.pem`.

 Note that certbot uses symlinks, and those can't be followed by the container unless it has access to the targets as well, so if using certbot you'll also have to mount the `archive` folder for your domain, e.g.:

@@ -61,7 +59,7 @@ frigate:

 ```

-Frigate automatically compares the fingerprint of the certificate it loaded, from either location, against the fingerprint of the TLS cert in NGINX every minute. If these differ, the NGINX config is reloaded to pick up the updated certificate.
+Frigate automatically compares the fingerprint of the certificate at `/etc/letsencrypt/live/frigate/fullchain.pem` against the fingerprint of the TLS cert in NGINX every minute. If these differ, the NGINX config is reloaded to pick up the updated certificate.

 If you issue Frigate valid certificates you will likely want to configure it to run on port 443 so you can access it without a port number like `https://your-frigate-domain.com` by mapping 8971 to 443.

@@ -75,4 +73,4 @@ frigate:

 ## ACME Challenge

-Frigate also supports hosting the acme challenge files for the HTTP challenge method if needed. The challenge files should be mounted at `/etc/letsencrypt/www`. With a read-only root filesystem this has to be a mounted volume, since Frigate cannot create the directory itself.
+Frigate also supports hosting the acme challenge files for the HTTP challenge method if needed. The challenge files should be mounted at `/etc/letsencrypt/www`.
@@ -124,8 +124,6 @@ Additionally, the USB Coral draws a considerable amount of power. If using any o

 The Hailo-8 and Hailo-8L AI accelerators are available in both M.2 and HAT form factors for the Raspberry Pi. The M.2 version typically connects to a carrier board for PCIe, which then interfaces with the Raspberry Pi 5 as part of the AI Kit. The HAT version can be mounted directly onto compatible Raspberry Pi models. Both form factors have been successfully tested on x86 platforms as well, making them versatile options for various computing environments.

-The HailoRT runtime is not part of the Frigate image; Frigate downloads and installs it at first start once a Hailo detector is configured. Containers without internet access can provide the files themselves, see [Detector runtimes](/frigate/network_requirements#detector-runtimes).
-
 #### Installation

 :::warning
@@ -317,8 +315,6 @@ The MemryX MX3 Accelerator is available in the M.2 2280 form factor (like an NVM

 To get started with MX3 hardware setup for your system, refer to the [Hardware Setup Guide](https://developer.memryx.com/2p1/get_started/install_hardware.html).

-The MemryX SDK used inside the container is not part of the Frigate image; Frigate downloads and installs it at first start once a MemryX detector is configured. Containers without internet access can provide the file themselves, see [Detector runtimes](/frigate/network_requirements#detector-runtimes). The host side driver still has to be installed as described below.
-
 Then follow these steps for installing the correct driver/runtime configuration:

 1. Copy or download [this script](https://github.com/blakeblackshear/frigate/blob/dev/docker/memryx/user_installation.sh).
@@ -483,8 +479,6 @@ Follow these steps for installation:

 To set up Frigate, follow the default installation instructions, for example: `ghcr.io/blakeblackshear/frigate:stable`

-The AXEngine python package is not part of the Frigate image; Frigate downloads and installs it at first start once an AXEngine detector is configured. Containers without internet access can provide the file themselves, see [Detector runtimes](/frigate/network_requirements#detector-runtimes).
-
 Next, grant Docker permissions to access your hardware by adding the following lines to your `docker-compose.yml` file:

 ```yaml
@@ -554,7 +548,9 @@ services:

 ### Recommended security options

-Frigate does not need elevated container privileges for most setups. The following hardens the container; add the `devices`/`group_add` entries your hardware requires (see the hardware acceleration docs):
+Frigate does not need elevated container privileges for most setups. The
+following hardens the container; add the `devices`/`group_add` entries your
+hardware requires (see the hardware acceleration docs):

 ```yaml
 services:
@@ -568,14 +564,15 @@ services:

 :::note

-`telemetry.stats.network_bandwidth` uses nethogs, which requires root with NET_ADMIN/NET_RAW capabilities. If you enable that stat, omit `cap_drop: [ALL]` or add `cap_add: [NET_ADMIN, NET_RAW]`.
+`telemetry.stats.network_bandwidth` uses nethogs, which requires root with
+NET_ADMIN/NET_RAW capabilities. If you enable that stat, omit `cap_drop: [ALL]`
+or add `cap_add: [NET_ADMIN, NET_RAW]`.

-Platforms that genuinely require `privileged: true` (MemryX, some QNAP setups) are called out in their own sections and are unaffected by this guidance.
+Platforms that genuinely require `privileged: true` (MemryX, some QNAP setups)
+are called out in their own sections and are unaffected by this guidance.

 :::

-Frigate's services run as an unprivileged user inside the container. See [Running as a non-root user](../configuration/non_root.md) for the run modes, the one time volume ownership migration, what each accelerator needs on the host, and the [hardened deployment](../configuration/non_root.md#hardened-deployment) layout with a read-only root filesystem.
-
 **Docker CLI**

 If you can't use Docker Compose, you can run the container with something similar to this:
@@ -56,24 +56,6 @@ The default CPU, EdgeTPU, and OpenVINO object detection models are bundled into

 :::

-### Detector Runtimes
-
-The SDKs for a few hardware detectors are not shipped in the Frigate image. They are downloaded the first time that detector is configured, verified against checksums pinned in the Frigate release, and installed into the Frigate user's home directory (`/config/.local` by default). Once installed they are not downloaded again until a Frigate release pins a new version.
-
-| Detector                                                       | Version | Files                                                                                                                                                                                                 | Source                                                                                     |
-| -------------------------------------------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
-| [Hailo 8 / 8L](/configuration/object_detectors#hailo-8)        | 4.21.0  | `hailort-debian12-amd64.tar.gz` and `hailort-4.21.0-cp311-cp311-linux_x86_64.whl` on x86, `hailort-debian12-arm64.tar.gz` and `hailort-4.21.0-cp311-cp311-linux_aarch64.whl` on arm64 | [GitHub release](https://github.com/frigate-nvr/hailort/releases/tag/v4.21.0)              |
-| [MemryX MX3](/configuration/object_detectors#memryx-mx3)       | 2.1.0   | `mx_accl_frigate-2.1.0.zip` (the release source archive, renamed)                                                                                                                                     | [GitHub archive](https://github.com/memryx/mx_accl_frigate/archive/refs/tags/v2.1.0.zip)   |
-| [AXERA AXEngine](/configuration/object_detectors#axera)        | 0.1.3   | `axengine-0.1.3-py3-none-any.whl`                                                                                                                                                                     | [GitHub release](https://github.com/AXERA-TECH/pyaxengine/releases/tag/0.1.3-frigate)      |
-
-If the container cannot reach GitHub, provide the files yourself:
-
-1. Download the files for your architecture on a machine with internet access.
-2. Place them, with exactly the file names listed above, in `/config/model_cache/runtimes/<detector>/`, where `<detector>` is the detector `type` from your config (`hailo8l`, `memryx`, or `axengine`).
-3. Start Frigate. Files whose checksum matches are installed without any download; a file with the wrong checksum is discarded and downloaded again, so a failed startup log names the file to replace.
-
-The `GITHUB_ENDPOINT` mirror variable below applies to these downloads as well.
-
 ### Preventing Model Downloads

 If you have already downloaded all required models and want to prevent Frigate from attempting any outbound connections to HuggingFace or the Transformers library, set the following environment variables on your Frigate container:
@@ -97,7 +79,7 @@ If your Frigate instance has restricted internet access, you can point model dow
 | Environment Variable                | Default                             | Used By                                       |
 | ----------------------------------- | ----------------------------------- | --------------------------------------------- |
 | `HF_ENDPOINT`                       | `https://huggingface.co`            | Semantic search, Sherpa-ONNX, AXEngine models |
-| `GITHUB_ENDPOINT`                   | `https://github.com`                | Face recognition, LPR, RKNN models, detector runtimes |
+| `GITHUB_ENDPOINT`                   | `https://github.com`                | Face recognition, LPR, RKNN models            |
 | `GITHUB_RAW_ENDPOINT`               | `https://raw.githubusercontent.com` | Bird classification                           |
 | `TF_KERAS_MOBILENET_V2_WEIGHTS_URL` | Unset (Keras uses its own default)  | Custom classification training                |

@@ -60,7 +60,7 @@ If you’re running Frigate via Docker (recommended method), follow these steps:
     ```bash
     docker logs frigate
     ```
-   - Visit the Frigate Web UI (default: `http://<your-ip>:5000`) to confirm the new version is running. The version number is displayed at the top of the Health and Metrics page.
+   - Visit the Frigate Web UI (default: `http://<your-ip>:5000`) to confirm the new version is running. The version number is displayed at the top of the System Metrics page.

 ### Notes

@@ -4,7 +4,6 @@ title: Getting started
 ---

 import ConfigTabs from "@site/src/components/ConfigTabs";
-import Tabs from "@theme/Tabs";
 import TabItem from "@theme/TabItem";
 import NavPath from "@site/src/components/NavPath";

@@ -133,68 +132,21 @@ services:
      - "8554:8554" # RTSP feeds
 ```

-Now you should be able to start Frigate by running `docker compose up -d` from within the folder containing `docker-compose.yml`. On startup, an admin user and password will be created and outputted in the logs. You can see this by running `docker logs frigate`. Frigate should now be accessible at `https://server_ip:8971` where you can login with the `admin` user. With no cameras configured yet, the setup wizard runs on first login and walks you through the rest.
+Now you should be able to start Frigate by running `docker compose up -d` from within the folder containing `docker-compose.yml`. On startup, an admin user and password will be created and outputted in the logs. You can see this by running `docker logs frigate`. Frigate should now be accessible at `https://server_ip:8971` where you can login with the `admin` user and finish configuration using the Settings UI.

 ## Configuring Frigate

 This section assumes that you already have an environment setup as described in [Installation](../frigate/installation.md). You should also configure your cameras according to the [camera setup guide](/frigate/camera_setup). Pay particular attention to the section on choosing a detect resolution.

-<Tabs
-groupId="setup-method"
-defaultValue="wizard"
-values={[
-{ label: "Setup wizard", value: "wizard" },
-{ label: "Manual", value: "manual" },
-]}
-
-> <TabItem value="wizard">
-
-The first time you open Frigate with no cameras configured, the setup wizard walks you through the basics. Every step can be skipped, everything it sets can be changed later in Settings, and once you finish or dismiss it, it doesn't come back.
-
-:::note
-
-Frigate only sees hardware that has been passed into the container. If you plan to use a GPU, a Coral, or another accelerator, add the device to your `docker-compose.yml` and restart before running the wizard, otherwise it won't appear in the detection or hardware acceleration steps. The Manual tab shows the device entries for an Intel or AMD GPU and for a Coral, and the [hardware acceleration](../configuration/hardware_acceleration_video.md) and [object detectors](../configuration/object_detectors.md) docs cover the rest.
-
-:::
-
-**Account**
-
-Set a password for the `admin` account to replace the generated one from the logs, and add accounts for anyone else who needs access. This step is hidden if you have turned authentication off.
-
-**Add a camera**
-
-Opens the [Add Camera Wizard](../configuration/cameras.md#adding-a-camera-with-the-add-camera-wizard), which connects to the camera, tests each stream, and writes its configuration for you. You can add more than one before moving on.
-
-**Object detection**
-
-Lists the detection hardware Frigate found on your system, such as a Coral, an Intel GPU or NPU, or a discrete GPU, and configures the one you pick. NVIDIA and AMD GPUs need a model before detection can start, so the wizard offers your Frigate+ models if you have them, or lets you finish setup and add one later under <NavPath path="Settings > System > Detection models" />.
-
-**Hardware acceleration**
-
-Offers only the decoding methods your hardware supports. Auto picks one based on that hardware and the codec your camera sends, so a mixed h264 and h265 setup gets the right preset per camera.
-
-**Recording**
-
-Choose whether to record only when something is detected or around the clock, and how long to keep it.
-
-The last screen summarizes what was set up. If a step changed something that needs a restart, the button restarts Frigate and returns you to the Live view once it is back.
-
-The wizard configures the essentials only. Motion masks are not included and should be set up afterward, once you can identify the areas of the frame that trigger unwanted motion. See the [masks documentation](../configuration/masks.md). Zones, tracked object types, notifications, and MQTT are also configured in Settings.
-
-</TabItem>
-<TabItem value="manual">
-
-On a new install the setup wizard opens first. Click **Skip setup and configure manually** on its welcome screen to dismiss it, and the steps below apply. The wizard won't come back once dismissed.
-
-**Step 1: Start Frigate**
+### Step 1: Start Frigate

 At this point you should be able to start Frigate and a basic config will be created automatically.

-**Step 2: Add a camera**
+### Step 2: Add a camera

 Click the **Add Camera** button in <NavPath path="Settings > Global configuration > Camera management" /> to use the camera setup wizard to get your first camera added into Frigate. See [Adding a camera with the Add Camera Wizard](../configuration/cameras.md#adding-a-camera-with-the-add-camera-wizard) for a walkthrough of each step.

-**Step 3: Configure hardware acceleration (recommended)**
+### Step 3: Configure hardware acceleration (recommended)

 Now that you have a working camera configuration, set up hardware acceleration to minimize the CPU required to decode your video streams. See the [hardware acceleration](../configuration/hardware_acceleration_video.md) docs for examples applicable to your hardware.

@@ -238,7 +190,7 @@ cameras:
 </TabItem>
 </ConfigTabs>

-**Step 4: Configure detectors**
+### Step 4: Configure detectors

 By default, Frigate will use a single OpenVINO detector running on the CPU.

@@ -347,7 +299,7 @@ More details on available detectors can be found [here](../configuration/object_

 Restart Frigate and you should start seeing detections for `person`. If you want to track other objects, they can be configured in <NavPath path="Settings > Global configuration > Objects" /> or via the [configuration file reference](../configuration/advanced/reference.md).

-**Step 5: Setup motion masks**
+### Step 5: Setup motion masks

 Now that you have optimized your configuration for decoding the video stream, you will want to check to see where to implement motion masks. Click on the camera from the main dashboard, then select the gear icon in the top right, enable the [Debug view](/usage/live#the-single-camera-view), and finally enable the switch for Motion Boxes. Watch for areas that continuously trigger unwanted motion to be detected. Common areas to mask include camera timestamps and trees that frequently blow in the wind. The goal is to avoid wasting object detection cycles looking at these areas.

@@ -384,7 +336,7 @@ cameras:
          coordinates: "0,461,3,0,1919,0,1919,843,1699,492,1344,458,1346,336,973,317,869,375,866,432"
 ```

-**Step 6: Enable recordings**
+### Step 6: Enable recordings

 In order to review activity in the Frigate UI, recordings need to be enabled.

@@ -433,10 +385,7 @@ If you only plan to use Frigate for recording, it is still recommended to define

 By default, Frigate will retain video of all tracked objects for 10 days. The full set of options for recording can be found [here](../configuration/advanced/reference.md).

-</TabItem>
-</Tabs>
-
-### Complete config
+### Step 7: Complete config

 At this point you have a complete config with basic functionality.

@@ -66,19 +66,17 @@ An FFmpeg message meaning it probed the stream but never saw enough decodable vi

 ## Recording

-<FaqItem id="no-new-recording-segments" question="No new recording segments were created (or: No new valid recording segments were created / No valid segments created since last invalid segment) for <camera> in the last 120s">
+<FaqItem id="no-new-recording-segments" question="No new recording segments were created for <camera> in the last 120s">

-Frigate's record watchdog is restarting the record FFmpeg process because the camera stopped producing usable recordings. The wording distinguishes the cases: `No new recording segments` means no new segment file reached the cache, so ffmpeg isn't getting video out of the record stream; the two `valid` variants mean recordings are arriving but keep failing validation. Either way the fault is on the camera or network side, and the restart is Frigate trying to recover.
+Frigate's record watchdog is restarting the record FFmpeg process because no valid segment has reached the cache. This means the record stream is not connecting or the segments are being rejected (see the audio-codec entry below).

-See [Recordings: no new recording segments were created](/troubleshooting/recordings#no-new-recording-segments-were-created).
+See [Recordings: the record stream isn't connecting](/troubleshooting/recordings#the-record-stream-isnt-connecting).

 </FaqItem>

-<FaqItem id="invalid-or-missing-video-stream-in-segment" question="Invalid or missing video stream in segment. Discarding. / Discarding a corrupt recording segment / Failed to probe corrupt segment / Invalid recording segment detected">
+<FaqItem id="invalid-or-missing-video-stream-in-segment" question="Invalid or missing video stream in segment. Discarding.">

-A cached recording segment failed validation and was deleted, either because it had no readable video stream or because its length was impossible. This nearly always means the camera stopped sending usable video partway through the segment: a camera that rebooted, dropped the connection, or ran out of simultaneous connections, or an unreliable link such as WiFi or a failing switch port. Broken camera timestamps (a "Smart Codec" / H.264+ mode) cause the corrupt-segment variants. The same stream failure trips the record watchdog, so the restarts above usually appear alongside these messages.
-
-See [Recordings: invalid or missing video stream in segment](/troubleshooting/recordings#invalid-or-missing-video-stream-in-segment).
+A cached recording segment failed validation (no readable video stream) and was deleted. The most common cause is a segment that was truncated because the record FFmpeg process was killed mid-write, so this often appears alongside, and as a consequence of, the record-stream restarts above. A segment containing only audio triggers it too.

 </FaqItem>

@@ -121,7 +121,7 @@ You can still configure Frigate to use UDP by using ffmpeg input args or the pre

 ### Frigate is slow to start up with a "probing detect stream" message in the logs

-When `detect.width` and `detect.height` are not set, Frigate probes each camera's detect stream on startup (and when saving the config) to auto-detect its resolution. For RTSP streams Frigate probes with ffprobe and automatically retries over TCP if UDP doesn't respond, with a 5 second timeout per attempt. A camera that cannot be reached over either transport will add up to ~10 seconds to startup before Frigate falls through with default dimensions, which may show up as width `0` and height `0` in Camera Probe Info under Health and Metrics.
+When `detect.width` and `detect.height` are not set, Frigate probes each camera's detect stream on startup (and when saving the config) to auto-detect its resolution. For RTSP streams Frigate probes with ffprobe and automatically retries over TCP if UDP doesn't respond, with a 5 second timeout per attempt. A camera that cannot be reached over either transport will add up to ~10 seconds to startup before Frigate falls through with default dimensions, which may show up as width `0` and height `0` in Camera Probe Info under System Metrics.

 To skip the probe entirely and make startup instant, set `detect.width` and `detect.height` explicitly in your camera config:

@@ -167,9 +167,3 @@ Frigate's object detection relies on a machine learning [model](../frigate/gloss
 - If the false positive is always in the same fixed spot (like a statue or mailbox that reads as a person), add an [object filter mask](../configuration/masks.md#object-filter-masks) over that location.

 Filters and masks only hide the incorrect result - they don't teach Frigate what the object actually is. For that, fine-tune your own model or use Frigate+.
-
-### Where do I see problems Frigate has detected?
-
-Open System > Health. The Notices list shows problems the backend has noticed on its own, such as a camera whose ffmpeg keeps crashing, a detector that had to be restarted, a model download that failed, or recordings being deleted before their retention period. Entries that describe a one-time event can be dismissed; entries that describe an ongoing condition clear themselves once it is fixed.
-
-The Hardware section below the notices shows whether the detection hardware, hardware acceleration, and enrichment devices in your config were found and are being used, so a GPU that silently fell back to the CPU shows up as a warning. Run stream checks to probe every camera's streams for the same problems the camera wizard reports.
@@ -15,7 +15,7 @@ When a stream won't play or behaves oddly, the most important first step is to f

 ### 1. Read the go2rtc logs

-Access the go2rtc logs in the Frigate UI under <NavPath path="Logs" /> in the sidebar (select the **go2rtc** tab). If go2rtc cannot connect to your camera you will usually see a clear error here: `401 Unauthorized` (bad or incorrectly encoded credentials), `Connection refused` / `timeout` (wrong IP, port, or the camera is at its connection limit), or `404 Not Found` (wrong RTSP path, or the referenced stream name does not exist).
+Access the go2rtc logs in the Frigate UI under <NavPath path="System Logs" /> in the sidebar (select the **go2rtc** tab). If go2rtc cannot connect to your camera you will usually see a clear error here: `401 Unauthorized` (bad or incorrectly encoded credentials), `Connection refused` / `timeout` (wrong IP, port, or the camera is at its connection limit), or `404 Not Found` (wrong RTSP path, or the referenced stream name does not exist).

 ### 2. Test the stream in the go2rtc web interface

@@ -209,50 +209,6 @@ If the record stream uses a "Smart Codec"/H.264+ mode or changes encoding parame

 </FaqItem>

-<FaqItem id="invalid-or-missing-video-stream-in-segment" question="I see the message: WARNING : Invalid or missing video stream in segment ... Discarding.">
-
-Every recording segment is validated before it leaves the cache. Frigate probes each finished `.mp4` in `/tmp/cache` and requires a readable video stream and a valid duration before moving to storage. A segment that fails is deleted, so those ~10 seconds of footage are lost. Three messages come from this check:
-
- `Invalid or missing video stream in segment <path>. Discarding.` The segment holds no video, or could not be read at all.
- `Failed to probe corrupt segment <path>` followed by `Discarding a corrupt recording segment: <path>`. The segment was read, but its length could not be determined.
- `Discarding a corrupt recording segment: <path>` on its own. The segment's length is impossible (empty, or longer than ten minutes), which points at broken timestamps coming from the camera.
-
-For each one, the camera watchdog also logs `Invalid recording segment detected for <camera> at <timestamp>`.
-
-:::warning
-
-This is almost always a **camera or network problem**, not a Frigate one. A segment is only complete once ffmpeg has finished writing it, so anything that interrupts the stream partway through leaves behind a file that cannot be saved. Frigate is reporting the interruption, not causing it.
-
-:::
-
-#### Start with the camera and the network
-
- **The camera dropped the connection.** Cameras reboot, reinitialize their stream when switching to night mode, and cut clients off when they are overloaded or out of simultaneous connections. Count everything pulling from the camera at once: Frigate's detect and record streams, go2rtc, a phone app, and any other NVR each use one. Routing all roles through a single [RTSP restream](/configuration/restream#reduce-connections-to-camera) so the camera only ever sees one connection often resolves this by itself.
- **The link to the camera is unreliable.** WiFi cameras, powerline adapters, a saturated uplink, a failing switch port, or a marginal cable all produce this pattern, and usually only on one camera at a time. WiFi cameras are [not recommended](https://ipcamtalk.com/threads/multiple-cameras-high-bandwidth.77100/#post-861110).
- **The camera cannot reliably send what it is being asked for.** A high bitrate 4K stream can be more than the camera's own hardware can encode and push out under load. Lower the bitrate, or record a lower-resolution profile.
- **The camera is using a "Smart Codec", H.264+, or H.265+ mode.** These change encoding parameters mid-stream and produce the broken timestamps behind the corrupt-segment variant. Turn the mode off and set the camera's keyframe interval equal to its frame rate. See [Segments are only ~1 second long](#segments-are-only-1-second-long).
-
-Read the rest of the Frigate and/or go2rtc log around the **first** occurrence. When the camera or the network is at fault, other messages show up with it, such as `No frames received from <camera> in 20 seconds`, `Non-monotonic DTS`, `RTP: PT=xx: bad cseq`, `error while decoding MB`, or a connection timeout. Each of those is explained in [Common error messages](/troubleshooting/common_errors). To confirm the camera is the source, open its stream in the [go2rtc web interface](/troubleshooting/go2rtc) on port `1984` or play the same URL in VLC, and leave it running long enough for the failures to happen again.
-
-#### If the camera and network check out
-
- **Audio the recording cannot store.** Some cameras send G.711 audio, which cannot be saved in an MP4 and stops segments from finalizing. See [Incompatible audio codec](#incompatible-audio-codec-recordings-silently-fail-to-save).
- **Frigate itself was stopped or restarted.** A single warning per camera around a restart is expected and needs no action.
- **The system ran out of room or memory.** A full `/tmp/cache`, or the host killing Frigate for using too much memory, cuts off the segment being written. Both leave other errors in the log alongside this one. See [No space left on device](#errno-28-no-space-left-on-device).
-
-</FaqItem>
-
-<FaqItem id="no-new-recording-segments-were-created" question="I see the message: ERROR : No new recording segments were created for <camera> in the last 120s. Restarting the ffmpeg record process...">
-
-When a camera stops producing usable recordings for two minutes, Frigate restarts that camera's record process to try to recover. The wording tells you how far the recordings got:
-
- **`No new recording segments were created`**: no new segment file showed up in the cache at all, so ffmpeg isn't getting video out of the record stream. The camera is unreachable or refusing the connection, the stream URL, path, or credentials are wrong, or the camera accepted the connection and then sent nothing. See [The record stream isn't connecting](#the-record-stream-isnt-connecting).
- **`No new valid recording segments were created`** and **`No valid segments created since last invalid segment`**: recordings are arriving, but they keep failing validation, so the camera is sending video that cannot be saved. See [Invalid or missing video stream in segment](#invalid-or-missing-video-stream-in-segment) above.
-
-The restart is Frigate recovering from a problem, not causing one. One of these after a camera reboot or a brief network drop is normal. Seeing them repeat every couple of minutes means the camera or the network is still failing, and the restarts can extend the damage, because each one cuts off the segment that was being written. Work from the earliest failure in that camera's log rather than from the restarts.
-
-</FaqItem>
-
 <FaqItem id="i-see-the-message-warning--unable-to-keep-up-with-recording-segments-in-cache-for-camera-keeping-the-5-most-recent-segments-out-of-6-and-discarding-the-rest" question="I see the message: WARNING : Unable to keep up with recording segments in cache for camera. Keeping the 5 most recent segments out of 6 and discarding the rest...">

 This warning means the recording maintainer cannot move recording segments from the RAM cache to disk fast enough. When the cache fills up, Frigate discards the oldest segments to avoid running out of memory and crashing, so you lose recorded footage. This is almost always a storage throughput or system resource problem. Work through the steps below to identify which.
@@ -374,7 +330,7 @@ If segments are only ~1 second instead of ~10 seconds, the camera is sending cor

 :::tip

-You don't have to run `ffprobe` by hand to catch this. Open a camera's **Camera Probe Info** dialog (the info icon on the Health and Metrics → Cameras page) and check the **Keyframe analysis** section. It probes the record stream and flags sparse or variable keyframes, which is what smart/"+" codecs (H.264+/H.265+) and long keyframe intervals produce.
+You don't have to run `ffprobe` by hand to catch this. Open a camera's **Camera Probe Info** dialog (the info icon on the System → Metrics → Cameras page) and check the **Keyframe analysis** section. It probes the record stream and flags sparse or variable keyframes, which is what smart/"+" codecs (H.264+/H.265+) and long keyframe intervals produce.

 :::

@@ -122,7 +122,6 @@ const sidebars: SidebarsConfig = {
          "configuration/ffmpeg_presets",
          "configuration/pwa",
          "configuration/tls",
-          "configuration/non_root",
        ],
      },
      {
@@ -62,9 +62,6 @@ paths:
                type: string
        '401':
          description: Authentication Failed
-        '403':
-          description: Access Denied (proxy user resolved to a default role of 
-            'none')
      security: []
      x-required-role: public
  /profile:
@@ -1479,10 +1476,12 @@ paths:
        - Classification
      summary: Get custom classification attributes
      description: |-
-        **Access:** Authenticated user with access to all cameras.
+        **Access:** Any authenticated user.

        Returns custom classification attributes for a given object type.
            Only includes models with classification_type set to 'attribute'.
+            Callers without access to every camera only receive values that have been
+            recorded on the cameras they can access.
            By default returns a flat sorted list of all attribute labels.
            If group_by_model is true, returns attributes grouped by model name.
      operationId: get_custom_attributes_classification_attributes_get
@@ -1514,7 +1513,7 @@ paths:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - frigateUserAuth: []
-      x-required-role: all_cameras
+      x-required-role: any
  /classification/{name}/train:
    get:
      tags:
@@ -2283,42 +2282,6 @@ paths:
        - frigateUserAuth: []
      x-required-role: camera
      description: '**Access:** Authenticated user with access to the referenced camera.'
-  /review/{review_id}/regenerate_description:
-    put:
-      tags:
-        - Review
-      summary: Generate a review item description
-      description: |-
-        **Access:** Admin role required.
-
-        Re-runs a review item through the GenAI descriptions process.
-            Frames are always taken from recordings, and both alerts and detections are
-            accepted regardless of the camera's GenAI alerts/detections toggles.
-      operationId: 
-        regenerate_review_description_review__review_id__regenerate_description_put
-      parameters:
-        - name: review_id
-          in: path
-          required: true
-          schema:
-            type: string
-            title: Review Id
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/GenericResponse'
-        '422':
-          description: Validation Error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
  /review/{review_id}/viewed:
    delete:
      tags:
@@ -2518,25 +2481,6 @@ paths:
      security:
        - frigateAdminAuth: []
      x-required-role: admin
-  /genai/roles:
-    get:
-      tags:
-        - App
-      summary: Get the model assigned to each GenAI role
-      description: |-
-        **Access:** Admin role required.
-
-        Returns the selected model and its context size for each configured GenAI role. Reads only what the client saved when it initialized, so the provider is not queried for its model list.
-      operationId: genai_roles_genai_roles_get
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema: {}
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
  /genai/probe:
    post:
      tags:
@@ -4111,148 +4055,6 @@ paths:
      security:
        - frigateAdminAuth: []
      x-required-role: admin
-  /hardware/hwaccel:
-    get:
-      tags:
-        - Hardware
-      summary: Hwaccel Recommendation
-      description: |-
-        **Access:** Admin role required.
-
-        Get the hardware decoding this system can do.
-
-        Args:
-            detector: Hardware key of the detection hardware in use, which biases
-                the recommendation toward that hardware's GPU
-            codecs: Comma separated codecs of the streams that will be decoded,
-                used to drop families that cannot decode one of them
-
-        Returns:
-            The recommended family (empty when none fits) and every usable family
-      operationId: hwaccel_recommendation_hardware_hwaccel_get
-      parameters:
-        - name: detector
-          in: query
-          required: false
-          schema:
-            anyOf:
-              - type: string
-              - type: 'null'
-            title: Detector
-        - name: codecs
-          in: query
-          required: false
-          schema:
-            anyOf:
-              - type: string
-              - type: 'null'
-            title: Codecs
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HwaccelRecommendation'
-        '422':
-          description: Validation Error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
-  /notices:
-    get:
-      tags:
-        - Notices
-      summary: Get Notices
-      description: |-
-        **Access:** Admin role required.
-
-        Get the active notices, most severe first.
-
-        Args:
-            include_dismissed: Also return event notices the user has dismissed
-
-        Returns:
-            The active notices
-      operationId: get_notices_notices_get
-      parameters:
-        - name: include_dismissed
-          in: query
-          required: false
-          schema:
-            type: boolean
-            default: false
-            title: Include Dismissed
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema: {}
-        '422':
-          description: Validation Error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
-  /notices/stats:
-    get:
-      tags:
-        - Notices
-      summary: Get Notice Stats
-      description: |-
-        **Access:** Admin role required.
-
-        Get lifetime occurrence counts per notice kind.
-      operationId: get_notice_stats_notices_stats_get
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema: {}
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
-  /notices/{notice_id}/dismiss:
-    post:
-      tags:
-        - Notices
-      summary: Dismiss Notice
-      description: |-
-        **Access:** Admin role required.
-
-        Hide an event notice until it is raised again.
-      operationId: dismiss_notice_notices__notice_id__dismiss_post
-      parameters:
-        - name: notice_id
-          in: path
-          required: true
-          schema:
-            type: string
-            title: Notice Id
-      responses:
-        '200':
-          description: Successful Response
-          content:
-            application/json:
-              schema: {}
-        '422':
-          description: Validation Error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/HTTPValidationError'
-      security:
-        - frigateAdminAuth: []
-      x-required-role: admin
  /events:
    get:
      tags:
@@ -7342,17 +7144,13 @@ paths:
          in: query
          required: false
          schema:
-            anyOf:
-              - type: number
-              - type: 'null'
+            type: number
            title: After
        - name: before
          in: query
          required: false
          schema:
-            anyOf:
-              - type: number
-              - type: 'null'
+            type: number
            title: Before
      responses:
        '200':
@@ -7726,14 +7524,6 @@ components:
            - type: 'null'
          title: New case description
          description: Optional description for a newly created export case
-        stream:
-          $ref: '#/components/schemas/ExportStreamEnum'
-          title: Recorded stream to export
-          description: Which recorded stream every item in the batch is exported
-            from. 'auto' uses the merged timeline, preferring the main stream 
-            and falling back to the sub stream where main has aged out. 'main' 
-            or 'sub' pins the exports to that stream.
-          default: auto
      type: object
      required:
        - items
@@ -7915,18 +7705,6 @@ components:
          description: Per-request thinking toggle. None means use the provider 
            default. Ignored by providers that do not expose a per-request 
            thinking switch.
-        tool_decisions:
-          additionalProperties:
-            type: string
-            enum:
-              - approve
-              - reject
-          type: object
-          title: Tool Decisions
-          description: Decisions for tool calls that paused for approval, keyed 
-            by tool call ID. Send these with the conversation chain returned 
-            alongside an approval request; rejected calls are reported to the 
-            model as declined instead of being executed.
      type: object
      required:
        - messages
@@ -8671,14 +8449,6 @@ components:
          title: Chapter mode
          description: Optional chapter metadata to embed in the export. When 
            omitted, the camera's configured export chapter mode is used.
-        stream:
-          $ref: '#/components/schemas/ExportStreamEnum'
-          title: Recorded stream to export
-          description: Which recorded stream to export. 'auto' uses the merged 
-            timeline, preferring the main stream and falling back to the sub 
-            stream where main has aged out. 'main' or 'sub' pins the export to 
-            that stream alone.
-          default: auto
      type: object
      title: ExportRecordingsBody
    ExportRecordingsCustomBody:
@@ -8733,20 +8503,6 @@ components:
      required:
        - name
      title: ExportRenameBody
-    ExportStreamEnum:
-      type: string
-      enum:
-        - auto
-        - main
-        - sub
-      title: ExportStreamEnum
-      description: |-
-        Which recorded stream an export should be built from.
-
-        ``auto`` keeps the merged timeline: main where it exists, sub filling
-        the gaps main has already aged out of. Pinning to one stream trades
-        that coverage for a uniform source, which is always a plain stream
-        copy since nothing hands off mid-export.
    Extension:
      type: string
      enum:
@@ -8916,43 +8672,6 @@ components:
        - label
      title: HardwareUnit
      description: One physical piece of hardware.
-    HwaccelFamily:
-      properties:
-        key:
-          type: string
-          title: Family key
-          description: Stable identifier for this kind of hardware decoding.
-        presets:
-          additionalProperties:
-            type: string
-          type: object
-          title: Presets
-          description: The ffmpeg preset for each codec this family decodes, or 
-            a single 'any' preset when it decodes every codec.
-      type: object
-      required:
-        - key
-        - presets
-      title: HwaccelFamily
-      description: A kind of hardware decoding, and the presets that drive it.
-    HwaccelRecommendation:
-      properties:
-        recommended:
-          type: string
-          title: Recommended family
-          description: Key of the family that fits this system best, or an empty
-            string when none does.
-        available:
-          items:
-            $ref: '#/components/schemas/HwaccelFamily'
-          type: array
-          title: Available families
-          description: Every family this system's hardware can use, best first.
-      type: object
-      required:
-        - recommended
-      title: HwaccelRecommendation
-      description: The hardware decoding this system can do.
    Last24HoursReview:
      properties:
        reviewed_alert:
@@ -190,20 +190,6 @@ def genai_models(request: Request):
    return JSONResponse(content=request.app.genai_manager.list_models())


-@router.get(
-    "/genai/roles",
-    dependencies=[Depends(allow_any_authenticated())],
-    summary="Get the model assigned to each GenAI role",
-    description=(
-        "Returns the selected model and its context size for each configured "
-        "GenAI role. Reads only what the client saved when it initialized, so "
-        "the provider is not queried for its model list."
-    ),
-)
-def genai_roles(request: Request):
-    return JSONResponse(content=request.app.genai_manager.role_info())
-
-
@router.post(
    "/genai/probe",
    dependencies=[Depends(require_role(["admin"]))],
@@ -497,7 +497,6 @@ def resolve_role(
                     Admin matches short-circuit to admin.
                 - If no role_map is configured, treat the header as role names directly.
      2. If no valid role is found, return proxy_config.default_role if it's valid in config_roles, else 'viewer'.
-         The literal value 'none' is a valid default and means access should be denied.

    Args:
        headers (dict): Incoming request headers (case-insensitive).
@@ -510,17 +509,10 @@ def resolve_role(
    default_role = proxy_config.default_role
    role_header = proxy_config.header_map.role

-    # Validate default_role against config; fallback to 'viewer' if invalid.
-    # "none" is a sentinel meaning "deny access when no mapping matches"; it is
-    # reserved in AuthConfig.validate_roles so it is never a configured role.
-    validated_default = (
-        default_role
-        if default_role in config_roles or default_role == "none"
-        else "viewer"
-    )
+    # Validate default_role against config; fallback to 'viewer' if invalid
+    validated_default = default_role if default_role in config_roles else "viewer"
    if not config_roles:
-        # Edge case: no roles defined
-        validated_default = "none" if default_role == "none" else "viewer"
+        validated_default = "viewer"  # Edge case: no roles defined

    if not role_header:
        logger.debug(
@@ -625,9 +617,6 @@ def resolve_role(
            },
        },
        401: {"description": "Authentication Failed"},
-        403: {
-            "description": "Access Denied (proxy user resolved to a default role of 'none')"
-        },
    },
 )
 def auth(request: Request):
@@ -677,10 +666,6 @@ def auth(request: Request):
        config_roles_set = set(auth_config.roles.keys())
        role = resolve_role(request.headers, proxy_config, config_roles_set)

-        if role == "none":
-            logger.debug("Resolved role is 'none', denying access")
-            return Response("", status_code=403)
-
        success_response.headers["remote-role"] = role

        deny_status = deny_response_for_media_uri(original_url, role, frigate_config)
@@ -302,9 +302,7 @@ def ffprobe(request: Request, paths: str = "", detailed: bool = False):
                    stderr_decoded = str(ffprobe.stderr)

            stderr_lines = [
-                clean_camera_user_pass(line.strip())
-                for line in stderr_decoded.split("\n")
-                if line.strip()
+                line.strip() for line in stderr_decoded.split("\n") if line.strip()
            ]

            result = {
@@ -1303,9 +1301,6 @@ async def delete_camera(
            if request.app.dispatcher is not None:
                request.app.dispatcher.clear_runtime_state_for_camera(camera_name)

-            if request.app.notice_registry is not None:
-                request.app.notice_registry.resolve_camera(camera_name)
-
            # Publish removal to stop ffmpeg processes and clean up runtime state
            request.app.config_publisher.publish_update(
                CameraConfigUpdateTopic(CameraConfigUpdateEnum.remove, camera_name),
@@ -10,7 +10,6 @@ from functools import reduce
 from typing import Any, Literal

 import cv2
-import numpy as np
 from fastapi import APIRouter, Body, Depends, HTTPException, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import BaseModel
@@ -24,7 +23,6 @@ from frigate.api.chat_util import (
    chunk_content,
    distance_to_score,
    format_events_with_local_time,
-    format_local_time,
    fuse_scores,
    hydrate_event,
    parse_iso_to_timestamp,
@@ -35,44 +33,29 @@ from frigate.api.defs.response.chat_response import (
    ChatCompletionResponse,
    ChatMessageResponse,
    ToolCall,
-    ToolCallInvocation,
 )
 from frigate.api.defs.tags import Tags
 from frigate.api.event import _build_attribute_filter_clause, events
-from frigate.api.export import _build_export_job, _validate_export_source
 from frigate.config import FrigateConfig
 from frigate.config.classification import SemanticSearchModelEnum
 from frigate.genai.prompts import (
    build_chat_system_prompt,
    get_attribute_classifications,
    get_tool_definitions,
-    get_write_tool_names,
-    strip_tool_access,
 )
-from frigate.genai.utils import (
-    build_assistant_message_for_conversation,
-    parse_tool_calls_from_message,
-)
-from frigate.jobs.export import ExportQueueFullError, start_export_job
+from frigate.genai.utils import build_assistant_message_for_conversation
 from frigate.jobs.vlm_watch import (
    get_vlm_watch_job,
    start_vlm_watch_job,
    stop_vlm_watch_job,
 )
-from frigate.models import Event, Export, ExportCase
-from frigate.record.export import PlaybackSourceEnum
-from frigate.util.file import get_event_thumbnail_bytes, load_event_snapshot_image
+from frigate.models import Event
 from frigate.util.object_names import get_categorized_object_names

 logger = logging.getLogger(__name__)

 router = APIRouter(tags=[Tags.chat])

-# Tool result recorded for a rejected write tool call. Providers require a
-# result for every requested call; the user's intent is conveyed in a
-# follow-up user message built by _rejection_message.
-TOOL_REJECTED_RESULT: dict[str, str] = {"error": "user_rejected"}
-

 class ToolExecuteRequest(BaseModel):
    """Request model for tool execution."""
@@ -683,39 +666,29 @@ async def _get_live_frame_image_url(
        frame = frame_processor.get_current_frame(camera, {})
        if frame is None:
            return None
-        return _encode_frame_data_url(frame)
+        height, width = frame.shape[:2]
+        target_height = 480
+        if height > target_height:
+            scale = target_height / height
+            frame = cv2.resize(
+                frame,
+                (int(width * scale), target_height),
+                interpolation=cv2.INTER_AREA,
+            )
+        _, img_encoded = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        b64 = base64.b64encode(img_encoded.tobytes()).decode("utf-8")
+        return f"data:image/jpeg;base64,{b64}"
    except Exception as e:
        logger.debug("Failed to get live frame for %s: %s", camera, e)
        return None


-def _encode_frame_data_url(frame: np.ndarray, target_height: int = 480) -> str:
-    """Downscale a BGR frame and encode it as a JPEG data URL for the model."""
-    height, width = frame.shape[:2]
-    if height > target_height:
-        scale = target_height / height
-        frame = cv2.resize(
-            frame,
-            (int(width * scale), target_height),
-            interpolation=cv2.INTER_AREA,
-        )
-    _, img_encoded = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
-    b64 = base64.b64encode(img_encoded.tobytes()).decode("utf-8")
-    return f"data:image/jpeg;base64,{b64}"
-
-
-def _request_roles(request: Request) -> list[str]:
-    """Roles from the auth proxy header, split on the configured separator."""
-    separator = request.app.frigate_config.proxy.separator
-    header = request.headers.get("remote-role", "")
-    return [r.strip() for r in header.split(separator) if r.strip()]
-
-
 async def _execute_set_camera_state(
    request: Request,
    arguments: dict[str, Any],
 ) -> dict[str, Any]:
-    if "admin" not in _request_roles(request):
+    role = request.headers.get("remote-role", "")
+    if "admin" not in [r.strip() for r in role.split(",")]:
        return {"error": "Admin privileges required to change camera settings."}

    camera = arguments.get("camera", "").strip()
@@ -765,189 +738,6 @@ def _execute_get_categorized_object_names(
    return {"names": names}


-def _execute_get_export_cases(allowed_cameras: list[str]) -> dict[str, Any]:
-    """List export cases with how many accessible exports each one holds."""
-    from peewee import fn
-
-    count_rows = (
-        Export.select(Export.export_case, fn.COUNT(Export.id))
-        .where(Export.camera << allowed_cameras, Export.export_case.is_null(False))
-        .group_by(Export.export_case)
-        .tuples()
-    )
-    counts = {case_id: count for case_id, count in count_rows}
-
-    cases: list[dict[str, Any]] = []
-    for case in ExportCase.select().order_by(ExportCase.created_at.desc()):
-        created_at = case.created_at
-        cases.append(
-            {
-                "id": case.id,
-                "name": case.name,
-                "description": case.description,
-                "created_at_local": format_local_time(created_at.timestamp())
-                if isinstance(created_at, datetime)
-                else str(created_at),
-                "export_count": counts.get(case.id, 0),
-            }
-        )
-
-    if not cases:
-        return {"cases": [], "message": "No export cases exist yet."}
-
-    return {"cases": cases}
-
-
-async def _execute_create_export(
-    request: Request,
-    arguments: dict[str, Any],
-    allowed_cameras: list[str],
-) -> dict[str, Any]:
-    """Queue a recording export, optionally attached to an existing case."""
-    config = request.app.frigate_config
-    camera = (arguments.get("camera") or "").strip()
-    start_time = parse_iso_to_timestamp(arguments.get("start_time"))
-    end_time = parse_iso_to_timestamp(arguments.get("end_time"))
-    name = (arguments.get("name") or "").strip() or None
-
-    if not camera or start_time is None or end_time is None:
-        return {"error": "camera, start_time, and end_time are all required."}
-
-    if camera not in config.cameras:
-        return {"error": f"Camera '{camera}' not found."}
-
-    if camera not in allowed_cameras:
-        return {"error": f"Camera '{camera}' not found or access denied"}
-
-    if end_time <= start_time:
-        return {"error": "end_time must be after start_time."}
-
-    try:
-        playback_source = PlaybackSourceEnum(arguments.get("source") or "recordings")
-    except ValueError:
-        return {"error": "source must be 'recordings' or 'preview'."}
-
-    # Mirror the export API: attaching to an existing case is admin-only
-    # until case-level ACLs exist.
-    export_case_id = (arguments.get("export_case_id") or "").strip() or None
-    if export_case_id is not None:
-        if "admin" not in _request_roles(request):
-            return {"error": "Only admins can attach exports to an existing case."}
-        try:
-            ExportCase.get(ExportCase.id == export_case_id)
-        except ExportCase.DoesNotExist:
-            return {"error": f"Export case '{export_case_id}' not found."}
-
-    source_error = _validate_export_source(
-        camera, start_time, end_time, playback_source
-    )
-    if source_error is not None:
-        return {"error": source_error}
-
-    export_job = _build_export_job(
-        camera,
-        start_time,
-        end_time,
-        name,
-        None,
-        playback_source,
-        export_case_id,
-        chapters=config.cameras[camera].record.export.chapters,
-    )
-    try:
-        start_export_job(config, export_job)
-    except ExportQueueFullError:
-        return {"error": "Export queue is full. Try again once current exports finish."}
-
-    return {
-        "success": True,
-        "export_id": export_job.id,
-        "status": "queued",
-        "camera": camera,
-        "name": name,
-        "source": playback_source.value,
-        "start_time_local": format_local_time(start_time),
-        "end_time_local": format_local_time(end_time),
-        "export_case_id": export_case_id,
-        "message": "Export queued. It will appear on the Export page when finished.",
-    }
-
-
-async def _execute_get_event_image(
-    request: Request,
-    arguments: dict[str, Any],
-    allowed_cameras: list[str],
-) -> dict[str, Any]:
-    """Attach an event's thumbnail or snapshot for a vision model to view."""
-    event_id = (arguments.get("event_id") or "").strip()
-    if not event_id:
-        return {"error": "event_id is required."}
-
-    image_type = arguments.get("image") or "thumbnail"
-    if image_type not in ("thumbnail", "snapshot"):
-        return {"error": "image must be 'thumbnail' or 'snapshot'."}
-
-    try:
-        event = Event.get(Event.id == event_id)
-    except Event.DoesNotExist:
-        return {"error": f"Could not find event {event_id}."}
-
-    if event.camera not in allowed_cameras:
-        return {"error": f"Event {event_id} not found or access denied"}
-
-    chat_client = request.app.genai_manager.chat_client
-    if chat_client is None or not chat_client.supports_vision:
-        return {
-            "error": (
-                "The configured chat model does not support vision, so images "
-                "cannot be viewed."
-            )
-        }
-
-    note = None
-    frame = None
-    if image_type == "snapshot":
-        if event.has_snapshot:
-            frame, _ = load_event_snapshot_image(event)
-        if frame is None:
-            note = "Snapshot not available; returning the thumbnail instead."
-            image_type = "thumbnail"
-
-    if frame is None:
-        thumbnail = get_event_thumbnail_bytes(event)
-        if thumbnail:
-            frame = cv2.imdecode(
-                np.frombuffer(thumbnail, dtype=np.uint8), cv2.IMREAD_COLOR
-            )
-
-    if frame is None:
-        return {"error": f"No image is available for event {event_id}."}
-
-    result: dict[str, Any] = {
-        "id": event.id,
-        "camera": event.camera,
-        "label": event.label,
-        "sub_label": event.sub_label,
-        "zones": event.zones,
-        "start_time_local": format_local_time(event.start_time),
-        "image": image_type,
-    }
-    if event.end_time is not None:
-        result["end_time_local"] = format_local_time(event.end_time)
-    description = (event.data or {}).get("description")
-    if description:
-        result["description"] = description
-    if note:
-        result["note"] = note
-
-    result["_image_url"] = _encode_frame_data_url(frame)
-    result["_image_text"] = (
-        f"Here is the {image_type} for event {event.id} "
-        f"({event.sub_label or event.label} on {event.camera})."
-    )
-    return result
-
-
 async def _execute_tool_internal(
    tool_name: str,
    arguments: dict[str, Any],
@@ -1003,18 +793,11 @@ async def _execute_tool_internal(
        return _execute_get_profile_status(request)
    elif tool_name == "get_recap":
        return _execute_get_recap(arguments, allowed_cameras)
-    elif tool_name == "get_export_cases":
-        return _execute_get_export_cases(allowed_cameras)
-    elif tool_name == "create_export":
-        return await _execute_create_export(request, arguments, allowed_cameras)
-    elif tool_name == "get_event_image":
-        return await _execute_get_event_image(request, arguments, allowed_cameras)
    else:
        logger.error(
            "Tool call failed: unknown tool %r. Expected one of: search_objects, find_similar_objects, "
            "get_categorized_object_names, get_live_context, start_camera_watch, stop_camera_watch, "
-            "get_profile_status, get_recap, get_export_cases, create_export, get_event_image. "
-            "Arguments received: %s",
+            "get_profile_status, get_recap. Arguments received: %s",
            tool_name,
            json.dumps(arguments),
        )
@@ -1243,74 +1026,14 @@ def _execute_get_recap(
        return {"error": "Failed to fetch recap data."}


-def _pending_tool_calls_from_tail(
-    conversation: list[dict[str, Any]],
-) -> list[dict[str, Any]] | None:
-    """Return the tool calls of a trailing assistant message, if any.
-
-    A conversation that ends with an assistant message requesting tools is a
-    resume after an approval pause: the client sends the chain back with its
-    decisions and the loop runs those calls before asking the model again.
-    """
-    if not conversation:
-        return None
-    tail = conversation[-1]
-    if tail.get("role") != "assistant" or not tail.get("tool_calls"):
-        return None
-    return parse_tool_calls_from_message(tail)
-
-
-def _tool_calls_awaiting_approval(
-    pending_tool_calls: list[dict[str, Any]],
-    body: ChatCompletionRequest,
-    write_tools: set[str],
-) -> list[dict[str, Any]]:
-    """Return the write tool calls the user still has to decide on."""
-    return [
-        {
-            "id": tc["id"],
-            "name": tc["name"],
-            "arguments": tc.get("arguments") or {},
-        }
-        for tc in pending_tool_calls
-        if tc["name"] in write_tools and tc["id"] not in body.tool_decisions
-    ]
-
-
-def _rejection_message(tool_names: list[str]) -> dict[str, Any]:
-    """User message telling the model a rejected call should not proceed.
-
-    Uses list-form content so the UI, which only renders string user
-    content, does not show it as something the user typed.
-    """
-    names = ", ".join(name.replace("_", " ") for name in tool_names)
-    return {
-        "role": "user",
-        "content": [
-            {
-                "type": "text",
-                "text": (
-                    f"I do not want to proceed with the {names} call. Ask me for "
-                    "clarification or suggest adjustments instead of running it."
-                ),
-            }
-        ],
-    }
-
-
 async def _execute_pending_tools(
    pending_tool_calls: list[dict[str, Any]],
    request: Request,
    allowed_cameras: list[str],
-    decisions: dict[str, str] | None = None,
 ) -> tuple[list[ToolCall], list[dict[str, Any]], list[dict[str, Any]]]:
    """
    Execute a list of tool calls.

-    Calls the user rejected (per `decisions`) are not executed; they get a
-    placeholder result and a user message saying not to proceed is appended
-    after the tool results.
-
    Returns:
        (ToolCall list for API response,
         tool result dicts for conversation,
@@ -1319,28 +1042,10 @@ async def _execute_pending_tools(
    tool_calls_out: list[ToolCall] = []
    tool_results: list[dict[str, Any]] = []
    extra_messages: list[dict[str, Any]] = []
-    rejected_tools: list[str] = []
    for tool_call in pending_tool_calls:
        tool_name = tool_call["name"]
        tool_args = tool_call.get("arguments") or {}
        tool_call_id = tool_call["id"]
-        if decisions and decisions.get(tool_call_id) == "reject":
-            logger.debug(
-                "Tool %s (id: %s) was rejected by the user", tool_name, tool_call_id
-            )
-            rejected_tools.append(tool_name)
-            rejected_content = json.dumps(TOOL_REJECTED_RESULT)
-            tool_calls_out.append(
-                ToolCall(name=tool_name, arguments=tool_args, response=rejected_content)
-            )
-            tool_results.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": tool_call_id,
-                    "content": rejected_content,
-                }
-            )
-            continue
        logger.debug(
            f"Executing tool: {tool_name} (id: {tool_call_id}) with arguments: {json.dumps(tool_args, indent=2)}"
        )
@@ -1374,21 +1079,17 @@ async def _execute_pending_tools(
                    if isinstance(evt, dict)
                ]

-            # Extract _image_url from tool results — images can only be sent
-            # in user messages, not tool results
+            # Extract _image_url from get_live_context results — images can
+            # only be sent in user messages, not tool results
            if isinstance(tool_result, dict) and "_image_url" in tool_result:
                image_url = tool_result.pop("_image_url")
-                image_text = tool_result.pop("_image_text", None) or (
-                    "Here is the current live image from camera "
-                    f"'{tool_result.get('camera', 'unknown')}'."
-                )
                extra_messages.append(
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
-                                "text": image_text,
+                                "text": f"Here is the current live image from camera '{tool_result.get('camera', 'unknown')}'.",
                            },
                            {
                                "type": "image_url",
@@ -1432,8 +1133,6 @@ async def _execute_pending_tools(
                    "content": error_content,
                }
            )
-    if rejected_tools:
-        extra_messages.append(_rejection_message(rejected_tools))
    return (tool_calls_out, tool_results, extra_messages)


@@ -1480,8 +1179,6 @@ async def chat_completion(
        attribute_classifications=attribute_classifications,
        embeddings_language=_embeddings_language(config),
    )
-    write_tools = get_write_tool_names(tools)
-    llm_tools = strip_tool_access(tools)
    conversation = []

    # Build the system message only when the client hasn't already pinned one.
@@ -1520,10 +1217,6 @@ async def chat_completion(
    tool_calls: list[ToolCall] = []
    max_iterations = body.max_tool_iterations

-    # Resume after an approval pause: run the tail's tool calls (honoring the
-    # client's decisions) before asking the model for anything new.
-    resume_pending = _pending_tool_calls_from_tail(conversation)
-
    logger.debug(
        f"Starting chat completion with {len(conversation)} message(s), "
        f"{len(tools)} tool(s) available, max_iterations={max_iterations}"
@@ -1535,64 +1228,93 @@ async def chat_completion(

        async def stream_body_llm():
            nonlocal conversation, stream_iterations
-            pending: list[dict[str, Any]] | None = resume_pending

-            def _emit(payload: dict[str, Any]) -> bytes:
-                return json.dumps(payload).encode("utf-8") + b"\n"
-
-            def _emit_chain(extra: list[dict[str, Any]] | None = None) -> bytes:
+            def _emit_chain(extra: list[dict[str, Any]] | None = None):
                # Return the full conversation (including the system message) so
                # the client persists and replays it verbatim next turn.
-                return _emit(
-                    {"type": "messages", "messages": conversation + (extra or [])}
+                chain = conversation + (extra or [])
+                return (
+                    json.dumps({"type": "messages", "messages": chain}).encode("utf-8")
+                    + b"\n"
                )

            while stream_iterations < max_iterations:
                if await request.is_disconnected():
                    logger.debug("Client disconnected, stopping chat stream")
                    return
-
-                if pending is None:
-                    logger.debug(
-                        f"Streaming LLM (iteration {stream_iterations + 1}/{max_iterations}) "
-                        f"with {len(conversation)} message(s)"
-                    )
-                    async for event in genai_client.chat_with_tools_stream(
-                        messages=conversation,
-                        tools=llm_tools if llm_tools else None,
-                        tool_choice="auto",
-                        enable_thinking=body.enable_thinking,
-                    ):
-                        if await request.is_disconnected():
-                            logger.debug("Client disconnected, stopping chat stream")
-                            return
-                        kind, value = event
-                        if kind == "content_delta":
-                            yield _emit({"type": "content", "delta": value})
-                        elif kind == "reasoning_delta":
-                            yield _emit({"type": "reasoning", "delta": value})
-                        elif kind == "stats":
-                            yield _emit({"type": "stats", **value})
-                        elif kind == "message":
-                            msg = value
-                            if msg.get("finish_reason") == "error":
-                                yield _emit(
+                logger.debug(
+                    f"Streaming LLM (iteration {stream_iterations + 1}/{max_iterations}) "
+                    f"with {len(conversation)} message(s)"
+                )
+                async for event in genai_client.chat_with_tools_stream(
+                    messages=conversation,
+                    tools=tools if tools else None,
+                    tool_choice="auto",
+                    enable_thinking=body.enable_thinking,
+                ):
+                    if await request.is_disconnected():
+                        logger.debug("Client disconnected, stopping chat stream")
+                        return
+                    kind, value = event
+                    if kind == "content_delta":
+                        yield (
+                            json.dumps({"type": "content", "delta": value}).encode(
+                                "utf-8"
+                            )
+                            + b"\n"
+                        )
+                    elif kind == "reasoning_delta":
+                        yield (
+                            json.dumps({"type": "reasoning", "delta": value}).encode(
+                                "utf-8"
+                            )
+                            + b"\n"
+                        )
+                    elif kind == "stats":
+                        yield (
+                            json.dumps({"type": "stats", **value}).encode("utf-8")
+                            + b"\n"
+                        )
+                    elif kind == "message":
+                        msg = value
+                        if msg.get("finish_reason") == "error":
+                            yield (
+                                json.dumps(
                                    {
                                        "type": "error",
                                        "error": "An error occurred while processing your request.",
                                    }
+                                ).encode("utf-8")
+                                + b"\n"
+                            )
+                            return
+                        pending = msg.get("tool_calls")
+                        if pending:
+                            stream_iterations += 1
+                            conversation.append(
+                                build_assistant_message_for_conversation(
+                                    msg.get("content"), pending
+                                )
+                            )
+                            if await request.is_disconnected():
+                                logger.debug(
+                                    "Client disconnected before tool execution"
                                )
                                return
-                            requested = msg.get("tool_calls")
-                            if requested:
-                                stream_iterations += 1
-                                conversation.append(
-                                    build_assistant_message_for_conversation(
-                                        msg.get("content"), requested
-                                    )
-                                )
-                                pending = requested
-                                break
+                            (
+                                _executed_calls,
+                                tool_results,
+                                extra_msgs,
+                            ) = await _execute_pending_tools(
+                                pending, request, allowed_cameras
+                            )
+                            conversation.extend(tool_results)
+                            conversation.extend(extra_msgs)
+                            # Emit the running chain so the client can render tool
+                            # calls live and replay them verbatim next turn.
+                            yield _emit_chain()
+                            break
+                        else:
                            # Streaming never appends the final assistant message
                            # to the conversation, so add it to the chain.
                            yield _emit_chain(
@@ -1603,41 +1325,11 @@ async def chat_completion(
                                    }
                                ]
                            )
-                            yield _emit({"type": "done"})
+                            yield (json.dumps({"type": "done"}).encode("utf-8") + b"\n")
                            return
-                    if pending is None:
-                        # The stream ended without a final message; nothing
-                        # more to run.
-                        break
-
-                awaiting = _tool_calls_awaiting_approval(pending, body, write_tools)
-                if awaiting:
-                    # Pause before running write tools. The client shows the
-                    # calls, collects decisions, and resends the chain.
-                    yield _emit_chain()
-                    yield _emit({"type": "approval_required", "tool_calls": awaiting})
-                    yield _emit({"type": "done"})
-                    return
-
-                if await request.is_disconnected():
-                    logger.debug("Client disconnected before tool execution")
-                    return
-                (
-                    _executed_calls,
-                    tool_results,
-                    extra_msgs,
-                ) = await _execute_pending_tools(
-                    pending, request, allowed_cameras, decisions=body.tool_decisions
-                )
-                conversation.extend(tool_results)
-                conversation.extend(extra_msgs)
-                pending = None
-                # Emit the running chain so the client can render tool
-                # calls live and replay them verbatim next turn.
+            else:
                yield _emit_chain()
-
-            yield _emit_chain()
-            yield _emit({"type": "done"})
+                yield json.dumps({"type": "done"}).encode("utf-8") + b"\n"

        return StreamingResponse(
            stream_body_llm(),
@@ -1646,129 +1338,102 @@ async def chat_completion(
        )

    try:
-        pending_tool_calls = resume_pending
        while tool_iterations < max_iterations:
-            if pending_tool_calls is None:
+            logger.debug(
+                f"Calling LLM (iteration {tool_iterations + 1}/{max_iterations}) "
+                f"with {len(conversation)} message(s) in conversation"
+            )
+            response = genai_client.chat_with_tools(
+                messages=conversation,
+                tools=tools if tools else None,
+                tool_choice="auto",
+                enable_thinking=body.enable_thinking,
+            )
+
+            if response.get("finish_reason") == "error":
+                logger.error("GenAI client returned an error")
+                return JSONResponse(
+                    content={
+                        "error": "An error occurred while processing your request.",
+                    },
+                    status_code=500,
+                )
+
+            conversation.append(
+                build_assistant_message_for_conversation(
+                    response.get("content"), response.get("tool_calls")
+                )
+            )
+
+            pending_tool_calls = response.get("tool_calls")
+            if not pending_tool_calls:
                logger.debug(
-                    f"Calling LLM (iteration {tool_iterations + 1}/{max_iterations}) "
-                    f"with {len(conversation)} message(s) in conversation"
-                )
-                response = genai_client.chat_with_tools(
-                    messages=conversation,
-                    tools=llm_tools if llm_tools else None,
-                    tool_choice="auto",
-                    enable_thinking=body.enable_thinking,
+                    f"Chat completion finished with final answer (iterations: {tool_iterations})"
                )
+                final_content = response.get("content") or ""

-                if response.get("finish_reason") == "error":
-                    logger.error("GenAI client returned an error")
-                    return JSONResponse(
-                        content={
-                            "error": "An error occurred while processing your request.",
-                        },
-                        status_code=500,
-                    )
+                if body.stream:
+                    final_reasoning = response.get("reasoning")

-                conversation.append(
-                    build_assistant_message_for_conversation(
-                        response.get("content"), response.get("tool_calls")
-                    )
-                )
+                    chain = list(conversation)

-                pending_tool_calls = response.get("tool_calls")
-                if not pending_tool_calls:
-                    logger.debug(
-                        f"Chat completion finished with final answer (iterations: {tool_iterations})"
-                    )
-                    final_content = response.get("content") or ""
-
-                    if body.stream:
-                        final_reasoning = response.get("reasoning")
-
-                        chain = list(conversation)
-
-                        async def stream_body() -> Any:
+                    async def stream_body() -> Any:
+                        yield (
+                            json.dumps({"type": "messages", "messages": chain}).encode(
+                                "utf-8"
+                            )
+                            + b"\n"
+                        )
+                        # Emit the full reasoning trace up front when the
+                        # underlying client did not stream it
+                        if final_reasoning:
                            yield (
                                json.dumps(
-                                    {"type": "messages", "messages": chain}
+                                    {"type": "reasoning", "delta": final_reasoning}
                                ).encode("utf-8")
                                + b"\n"
                            )
-                            # Emit the full reasoning trace up front when the
-                            # underlying client did not stream it
-                            if final_reasoning:
-                                yield (
-                                    json.dumps(
-                                        {"type": "reasoning", "delta": final_reasoning}
-                                    ).encode("utf-8")
-                                    + b"\n"
+                        # Stream content in word-sized chunks for smooth UX
+                        for part in chunk_content(final_content):
+                            yield (
+                                json.dumps({"type": "content", "delta": part}).encode(
+                                    "utf-8"
                                )
-                            # Stream content in word-sized chunks for smooth UX
-                            for part in chunk_content(final_content):
-                                yield (
-                                    json.dumps(
-                                        {"type": "content", "delta": part}
-                                    ).encode("utf-8")
-                                    + b"\n"
-                                )
-                            yield json.dumps({"type": "done"}).encode("utf-8") + b"\n"
+                                + b"\n"
+                            )
+                        yield json.dumps({"type": "done"}).encode("utf-8") + b"\n"

-                        return StreamingResponse(
-                            stream_body(),
-                            media_type="application/x-ndjson",
-                        )
-
-                    return JSONResponse(
-                        content=ChatCompletionResponse(
-                            message=ChatMessageResponse(
-                                role="assistant",
-                                content=final_content,
-                                reasoning=response.get("reasoning"),
-                                tool_calls=None,
-                            ),
-                            finish_reason=response.get("finish_reason", "stop"),
-                            tool_iterations=tool_iterations,
-                            tool_calls=tool_calls,
-                            messages=list(conversation),
-                        ).model_dump(),
+                    return StreamingResponse(
+                        stream_body(),
+                        media_type="application/x-ndjson",
                    )

-                tool_iterations += 1
-                logger.debug(
-                    f"Tool calls detected (iteration {tool_iterations}/{max_iterations}): "
-                    f"{len(pending_tool_calls)} tool(s) to execute"
-                )
-
-            awaiting = _tool_calls_awaiting_approval(
-                pending_tool_calls, body, write_tools
-            )
-            if awaiting:
-                # Pause before running write tools; the client resends the
-                # returned chain with its decisions to continue.
                return JSONResponse(
                    content=ChatCompletionResponse(
                        message=ChatMessageResponse(
                            role="assistant",
-                            content=None,
-                            tool_calls=[ToolCallInvocation(**tc) for tc in awaiting],
+                            content=final_content,
+                            reasoning=response.get("reasoning"),
+                            tool_calls=None,
                        ),
-                        finish_reason="approval_required",
+                        finish_reason=response.get("finish_reason", "stop"),
                        tool_iterations=tool_iterations,
                        tool_calls=tool_calls,
                        messages=list(conversation),
                    ).model_dump(),
                )

+            tool_iterations += 1
+            logger.debug(
+                f"Tool calls detected (iteration {tool_iterations}/{max_iterations}): "
+                f"{len(pending_tool_calls)} tool(s) to execute"
+            )
            executed_calls, tool_results, extra_msgs = await _execute_pending_tools(
-                pending_tool_calls,
-                request,
-                allowed_cameras,
-                decisions=body.tool_decisions,
+                pending_tool_calls, request, allowed_cameras
            )
            tool_calls.extend(executed_calls)
            conversation.extend(tool_results)
            conversation.extend(extra_msgs)
-            pending_tool_calls = None
            logger.debug(
                f"Added {len(tool_results)} tool result(s) to conversation. "
                f"Continuing with next LLM call..."
@@ -44,11 +44,6 @@ def chunk_content(content: str, chunk_size: int = 80) -> Generator[str, None, No
        yield " ".join(current)


-def format_local_time(timestamp: float) -> str:
-    """Format a unix timestamp as the server-local string quoted to users."""
-    return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %I:%M:%S %p")
-
-
 def format_events_with_local_time(
    events_list: list[dict[str, Any]],
 ) -> list[dict[str, Any]]:
@@ -63,9 +58,11 @@ def format_events_with_local_time(
            start_ts = evt.get("start_time")
            end_ts = evt.get("end_time")
            if start_ts is not None:
-                copy_evt["start_time_local"] = format_local_time(start_ts)
+                dt_start = datetime.fromtimestamp(start_ts)
+                copy_evt["start_time_local"] = dt_start.strftime("%Y-%m-%d %I:%M:%S %p")
            if end_ts is not None:
-                copy_evt["end_time_local"] = format_local_time(end_ts)
+                dt_end = datetime.fromtimestamp(end_ts)
+                copy_evt["end_time_local"] = dt_end.strftime("%Y-%m-%d %I:%M:%S %p")
        except (TypeError, ValueError, OSError):
            pass
        result.append(copy_evt)
@@ -11,10 +11,14 @@ from typing import Any
 import cv2
 from fastapi import APIRouter, Depends, Request, UploadFile
 from fastapi.responses import JSONResponse
-from peewee import DoesNotExist
+from peewee import DoesNotExist, fn
 from playhouse.shortcuts import model_to_dict

-from frigate.api.auth import require_full_camera_access, require_role
+from frigate.api.auth import (
+    allow_any_authenticated,
+    get_allowed_cameras_for_filter,
+    require_role,
+)
 from frigate.api.defs.request.classification_body import (
    AudioTranscriptionBody,
    DeleteFaceImagesBody,
@@ -739,19 +743,81 @@ def get_classification_dataset(name: str):
    )


+def get_observed_attributes(
+    model_attributes: dict[str, list[str]],
+    object_labels: set[str],
+    allowed_cameras: list[str],
+) -> dict[str, set[str]]:
+    """Get the attribute values recorded on the given cameras.
+
+    Args:
+        model_attributes: Labels each attribute model can emit, keyed by model name
+        object_labels: Object types those models run on
+        allowed_cameras: Cameras the caller has access to
+
+    Returns:
+        Values seen for each model, keyed by model name
+    """
+    if not model_attributes or not object_labels or not allowed_cameras:
+        return {}
+
+    model_names = list(model_attributes.keys())
+
+    query = (
+        Event.select(
+            *[
+                fn.json_extract(Event.data, f'$."{model_name}"')
+                for model_name in model_names
+            ]
+        )
+        .where(
+            (Event.camera << allowed_cameras) & (Event.label << sorted(object_labels))
+        )
+        .distinct()
+        .tuples()
+    )
+
+    targets = {
+        model_name: set(attributes)
+        for model_name, attributes in model_attributes.items()
+    }
+    observed: dict[str, set[str]] = {model_name: set() for model_name in model_names}
+
+    for row in query.iterator():
+        found = False
+
+        for model_name, value in zip(model_names, row):
+            if isinstance(value, str) and value not in observed[model_name]:
+                observed[model_name].add(value)
+                found = True
+
+        if found and all(
+            observed[model_name] >= targets[model_name] for model_name in model_names
+        ):
+            break
+
+    return observed
+
+
@router.get(
    "/classification/attributes",
-    dependencies=[Depends(require_full_camera_access)],
+    dependencies=[Depends(allow_any_authenticated())],
    summary="Get custom classification attributes",
    description="""Returns custom classification attributes for a given object type.
    Only includes models with classification_type set to 'attribute'.
+    Callers without access to every camera only receive values that have been
+    recorded on the cameras they can access.
    By default returns a flat sorted list of all attribute labels.
    If group_by_model is true, returns attributes grouped by model name.""",
 )
 def get_custom_attributes(
-    request: Request, object_type: str = None, group_by_model: bool = False
+    request: Request,
+    object_type: str = None,
+    group_by_model: bool = False,
+    allowed_cameras: list[str] = Depends(get_allowed_cameras_for_filter),
 ):
    models_with_attributes = {}
+    objects_by_model = {}

    for (
        model_key,
@@ -782,6 +848,32 @@ def get_custom_attributes(
        if attributes:
            model_name = model_config.name or model_key
            models_with_attributes[model_name] = sorted(attributes)
+            objects_by_model[model_name] = model_objects
+
+    # the dataset holds every label a model can emit, including ones never
+    # applied to an event, so callers without full camera access are limited to
+    # the values actually recorded on the cameras they can see
+    all_cameras = set(request.app.frigate_config.cameras.keys())
+
+    if models_with_attributes and not all_cameras.issubset(allowed_cameras):
+        observed = get_observed_attributes(
+            models_with_attributes,
+            set().union(*objects_by_model.values()),
+            allowed_cameras,
+        )
+        models_with_attributes = {
+            model_name: [
+                attribute
+                for attribute in attributes
+                if attribute in observed.get(model_name, set())
+            ]
+            for model_name, attributes in models_with_attributes.items()
+        }
+        models_with_attributes = {
+            model_name: attributes
+            for model_name, attributes in models_with_attributes.items()
+            if attributes
+        }

    if group_by_model:
        return JSONResponse(content=models_with_attributes)
@@ -1,7 +1,5 @@
 from pydantic import BaseModel, Field, model_validator

-from frigate.record.export import ExportStreamEnum
-
 MAX_BATCH_EXPORT_ITEMS = 50


@@ -55,16 +53,6 @@ class BatchExportBody(BaseModel):
        title="New case description",
        description="Optional description for a newly created export case",
    )
-    stream: ExportStreamEnum = Field(
-        default=ExportStreamEnum.auto,
-        title="Recorded stream to export",
-        description=(
-            "Which recorded stream every item in the batch is exported "
-            "from. 'auto' uses the merged timeline, preferring the main "
-            "stream and falling back to the sub stream where main has "
-            "aged out. 'main' or 'sub' pins the exports to that stream."
-        ),
-    )

    @model_validator(mode="after")
    def validate_case_target(self) -> "BatchExportBody":
@@ -1,6 +1,6 @@
 """Chat API request models."""

-from typing import Any, Literal
+from typing import Any

 from pydantic import BaseModel, Field

@@ -59,12 +59,3 @@ class ChatCompletionRequest(BaseModel):
            "Ignored by providers that do not expose a per-request thinking switch."
        ),
    )
-    tool_decisions: dict[str, Literal["approve", "reject"]] = Field(
-        default_factory=dict,
-        description=(
-            "Decisions for tool calls that paused for approval, keyed by tool "
-            "call ID. Send these with the conversation chain returned alongside "
-            "an approval request; rejected calls are reported to the model as "
-            "declined instead of being executed."
-        ),
-    )
@@ -3,7 +3,6 @@ from pydantic.json_schema import SkipJsonSchema

 from frigate.record.export import (
    ChaptersEnum,
-    ExportStreamEnum,
    PlaybackSourceEnum,
 )

@@ -28,16 +27,6 @@ class ExportRecordingsBody(BaseModel):
            "the camera's configured export chapter mode is used."
        ),
    )
-    stream: ExportStreamEnum = Field(
-        default=ExportStreamEnum.auto,
-        title="Recorded stream to export",
-        description=(
-            "Which recorded stream to export. 'auto' uses the merged "
-            "timeline, preferring the main stream and falling back to the "
-            "sub stream where main has aged out. 'main' or 'sub' pins the "
-            "export to that stream alone."
-        ),
-    )


 class ExportRecordingsCustomBody(BaseModel):
@@ -13,7 +13,6 @@ class Tags(Enum):
    logs = "Logs"
    media = "Media"
    motion_search = "Motion Search"
-    notices = "Notices"
    notifications = "Notifications"
    preview = "Preview"
    recordings = "Recordings"
@@ -386,9 +386,7 @@ def events_explore(
    limit: int = 10,
    allowed_cameras: list[str] = Depends(get_allowed_cameras_for_filter),
 ):
-    if not allowed_cameras:
-        return JSONResponse(content=[])
-
+    # get distinct labels for all events
    distinct_labels = (
        Event.select(Event.label)
        .where(Event.camera << allowed_cameras)
@@ -398,31 +396,13 @@ def events_explore(

    label_counts = {}

-    explore_columns = (
-        Event.id,
-        Event.camera,
-        Event.label,
-        Event.sub_label,
-        Event.zones,
-        Event.start_time,
-        Event.end_time,
-        Event.has_clip,
-        Event.has_snapshot,
-        Event.plus_id,
-        Event.retain_indefinitely,
-        Event.top_score,
-        Event.false_positive,
-        Event.box,
-        Event.data,
-    )
-
    def event_generator():
        for label_obj in distinct_labels.iterator():
            label = label_obj.label

            # get most recent events for this label
            label_events = (
-                Event.select(*explore_columns)
+                Event.select()
                .where((Event.label == label) & (Event.camera << allowed_cameras))
                .order_by(Event.start_time.desc())
                .limit(limit)
@@ -504,18 +484,22 @@ async def event_ids(ids: str, request: Request):
            status_code=400,
        )

+    for event_id in ids:
+        try:
+            event = Event.get(Event.id == event_id)
+            await require_camera_access(event.camera, request=request)
+        except DoesNotExist:
+            # we should not fail the entire request if an event is not found
+            continue
+
    try:
-        events = list(Event.select().where(Event.id << ids).dicts().iterator())
+        events = Event.select().where(Event.id << ids).dicts().iterator()
+        return JSONResponse(list(events))
    except Exception:
        return JSONResponse(
            content=({"success": False, "message": "Events not found"}), status_code=400
        )

-    for event in events:
-        await require_camera_access(event["camera"], request=request)
-
-    return JSONResponse(events)
-

@router.get(
    "/events/search",
@@ -1,9 +1,7 @@
 """Export apis."""

-import contextlib
 import datetime
 import logging
-import os
 import random
 import string
 import time
@@ -11,13 +9,12 @@ import zipfile
 from collections import deque
 from collections.abc import Iterator
 from pathlib import Path
-from urllib.parse import quote

 import psutil
 from fastapi import APIRouter, Depends, Query, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 from pathvalidate import sanitize_filename
-from peewee import DatabaseError, DoesNotExist, IntegrityError
+from peewee import DoesNotExist
 from playhouse.shortcuts import model_to_dict

 from frigate.api.auth import (
@@ -72,9 +69,7 @@ from frigate.models import Export, ExportCase, Previews, Recordings
 from frigate.record.export import (
    DEFAULT_TIME_LAPSE_FFMPEG_ARGS,
    ChaptersEnum,
-    ExportStreamEnum,
    PlaybackSourceEnum,
-    export_video_path,
    validate_ffmpeg_args,
 )
 from frigate.util.path import sanitize_contained_path
@@ -149,23 +144,16 @@ def _sanitize_existing_image(
    return existing_image, None


-def _no_recordings_message(stream: ExportStreamEnum) -> str:
-    if stream == ExportStreamEnum.auto:
-        return "No recordings found for time range"
-
-    return f"No {stream.value} stream recordings found for time range"
-
-
 def _validate_export_source(
    camera_name: str,
    start_time: float,
    end_time: float,
    playback_source: PlaybackSourceEnum,
-    stream: ExportStreamEnum = ExportStreamEnum.auto,
 ) -> str | None:
    if playback_source == PlaybackSourceEnum.recordings:
-        query = Recordings.select().where(
-            (
+        recordings_count = (
+            Recordings.select()
+            .where(
                Recordings.start_time.between(start_time, end_time)
                | Recordings.end_time.between(start_time, end_time)
                | (
@@ -173,16 +161,12 @@ def _validate_export_source(
                    & (end_time < Recordings.end_time)
                )
            )
-            & (Recordings.camera == camera_name)
+            .where(Recordings.camera == camera_name)
+            .count()
        )

-        # a pinned export reads only that stream, so the other stream's
-        # coverage must not make the range look exportable
-        if stream != ExportStreamEnum.auto:
-            query = query.where(Recordings.stream_type == stream.value)
-
-        if query.count() <= 0:
-            return _no_recordings_message(stream)
+        if recordings_count <= 0:
+            return "No recordings found for time range"

        return None

@@ -206,7 +190,6 @@ def _validate_export_source(
 def _get_item_recording_export_errors(
    request: Request,
    items: list[BatchExportItem],
-    stream: ExportStreamEnum = ExportStreamEnum.auto,
 ) -> dict[int, str]:
    """Return {item_index: error message} for items with invalid state.

@@ -236,20 +219,20 @@ def _get_item_recording_export_errors(
        min_start = min(r[1] for r in indexed_ranges)
        max_end = max(r[2] for r in indexed_ranges)

-        query = Recordings.select(Recordings.start_time, Recordings.end_time).where(
-            Recordings.camera == camera_name,
-            Recordings.start_time.between(min_start, max_end)
-            | Recordings.end_time.between(min_start, max_end)
-            | ((min_start > Recordings.start_time) & (max_end < Recordings.end_time)),
+        recording_ranges = list(
+            Recordings.select(Recordings.start_time, Recordings.end_time)
+            .where(
+                Recordings.camera == camera_name,
+                Recordings.start_time.between(min_start, max_end)
+                | Recordings.end_time.between(min_start, max_end)
+                | (
+                    (min_start > Recordings.start_time)
+                    & (max_end < Recordings.end_time)
+                ),
+            )
+            .iterator()
        )

-        # a pinned batch reads only that stream, so the other stream's
-        # coverage must not make an item look exportable
-        if stream != ExportStreamEnum.auto:
-            query = query.where(Recordings.stream_type == stream.value)
-
-        recording_ranges = list(query.iterator())
-
        for index, start_time, end_time in indexed_ranges:
            has_recording = any(
                (
@@ -260,7 +243,7 @@ def _get_item_recording_export_errors(
                for rec in recording_ranges
            )
            if not has_recording:
-                errors[index] = _no_recordings_message(stream)
+                errors[index] = "No recordings found for time range"

    return errors

@@ -277,7 +260,6 @@ def _build_export_job(
    ffmpeg_output_args: str | None = None,
    cpu_fallback: bool = False,
    chapters: ChaptersEnum | None = None,
-    stream: ExportStreamEnum = ExportStreamEnum.auto,
 ) -> ExportJob:
    return ExportJob(
        id=_generate_export_id(camera_name),
@@ -292,7 +274,6 @@ def _build_export_job(
        ffmpeg_output_args=ffmpeg_output_args,
        cpu_fallback=cpu_fallback,
        chapters=chapters,
-        stream=stream,
    )


@@ -422,17 +403,14 @@ class _StreamingZipBuffer:


 def _unique_archive_name(export: Export, used: set[str]) -> str:
-    """Zip entry name for an export, de-duplicated within the archive.
-
-    The on-disk name is the one the user sees either way: renaming an export
-    renames its file, so a zip entry and an individual download can't drift.
-    """
-    source = Path(export.video_path)
-    candidate = source.name
+    base = sanitize_filename(export.name) if export.name else None
+    if not base:
+        base = f"{export.camera}_{int(export.date)}"

+    candidate = f"{base}.mp4"
    counter = 1
    while candidate in used:
-        candidate = f"{source.stem}_{counter}{source.suffix}"
+        candidate = f"{base}_{counter}.mp4"
        counter += 1

    used.add(candidate)
@@ -475,22 +453,6 @@ def _stream_case_archive(exports: list[Export]) -> Iterator[bytes]:
    yield from buffer.drain()


-def _content_disposition(filename: str, ascii_fallback: str) -> str:
-    """Build an attachment Content-Disposition that survives non-ASCII names.
-
-    Header values are encoded as latin-1, so a name outside that range cannot
-    go in filename at all. RFC 6266 handles this with a pair: a plain ASCII
-    filename for old clients, plus a percent-encoded UTF-8 filename* that
-    every current browser prefers.
-    """
-    ascii_name = filename if filename.isascii() else ascii_fallback
-
-    return (
-        f'attachment; filename="{ascii_name}"; '
-        f"filename*=UTF-8''{quote(filename, safe='')}"
-    )
-
-
@router.get(
    "/cases/{case_id}/download",
    dependencies=[Depends(allow_any_authenticated())],
@@ -533,9 +495,7 @@ def download_export_case(
        _stream_case_archive(exports),
        media_type="application/zip",
        headers={
-            "Content-Disposition": _content_disposition(
-                f"{archive_base}.zip", f"{case_id}.zip"
-            ),
+            "Content-Disposition": f'attachment; filename="{archive_base}.zip"',
        },
    )

@@ -706,7 +666,7 @@ def export_recordings_batch(
            return image_validation_error
        sanitized_images.append(existing_image)

-    item_errors = _get_item_recording_export_errors(request, body.items, body.stream)
+    item_errors = _get_item_recording_export_errors(request, body.items)

    queueable_indexes = [
        index for index in range(len(body.items)) if index not in item_errors
@@ -775,7 +735,6 @@ def export_recordings_batch(
            chapters=request.app.frigate_config.cameras[
                item.camera
            ].record.export.chapters,
-            stream=body.stream,
        )
        try:
            start_export_job(request.app.frigate_config, export_job)
@@ -883,7 +842,6 @@ def export_recording(
        start_time,
        end_time,
        playback_source,
-        body.stream,
    )
    if source_error is not None:
        return JSONResponse(
@@ -900,7 +858,6 @@ def export_recording(
        playback_source,
        export_case_id,
        chapters=chapters,
-        stream=body.stream,
    )
    try:
        start_export_job(request.app.frigate_config, export_job)
@@ -951,59 +908,8 @@ async def export_rename(event_id: str, body: ExportRenameBody, request: Request)
            status_code=404,
        )

-    if export.in_progress:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "Export is still being written and can't be renamed yet.",
-            },
-            status_code=400,
-        )
-
-    new_path = export_video_path(body.name, export.id)
-    old_path = export.video_path
-    moved = new_path != old_path
-
-    # move the file first so a rename that can't happen leaves the row alone
-    if moved:
-        try:
-            os.rename(old_path, new_path)
-        except OSError:
-            logger.exception("Failed to rename export file for %s", event_id)
-            return JSONResponse(
-                content={"success": False, "message": "Failed to rename export."},
-                status_code=500,
-            )
-
    export.name = body.name
-    export.video_path = new_path
-
-    try:
-        export.save()
-    except DatabaseError as err:
-        # the queue database has no transactions, so undo the move by hand
-        if moved:
-            with contextlib.suppress(OSError):
-                os.rename(new_path, old_path)
-
-        if isinstance(err, IntegrityError):
-            logger.warning(
-                "Export %s cannot be renamed, %s is taken", event_id, new_path
-            )
-            return JSONResponse(
-                content={
-                    "success": False,
-                    "message": "Another export already uses that name.",
-                },
-                status_code=409,
-            )
-
-        logger.exception("Failed to save renamed export %s", event_id)
-        return JSONResponse(
-            content={"success": False, "message": "Failed to rename export."},
-            status_code=500,
-        )
-
+    export.save()
    return JSONResponse(
        content=(
            {
@@ -24,7 +24,6 @@ from frigate.api import (
    hardware,
    media,
    motion_search,
-    notices,
    notification,
    preview,
    record,
@@ -42,7 +41,6 @@ from frigate.config.profile_manager import ProfileManager
 from frigate.debug_replay import DebugReplayManager, debug_replay_auto_stop_watchdog
 from frigate.embeddings import EmbeddingsContext
 from frigate.genai import GenAIClientManager
-from frigate.notices.registry import NoticeRegistry
 from frigate.ptz.onvif import OnvifController
 from frigate.stats.emitter import StatsEmitter
 from frigate.storage import StorageMaintainer
@@ -79,7 +77,6 @@ def create_fastapi_app(
    profile_manager: ProfileManager | None = None,
    enforce_default_admin: bool = True,
    config_holder: ConfigHolder | None = None,
-    notice_registry: NoticeRegistry | None = None,
 ):
    logger.info("Starting FastAPI app")
    app = FastAPI(
@@ -150,7 +147,6 @@ def create_fastapi_app(
    app.include_router(notification.router)
    app.include_router(export.router)
    app.include_router(hardware.router)
-    app.include_router(notices.router)
    app.include_router(event.router)
    app.include_router(media.router)
    app.include_router(motion_search.router)
@@ -167,7 +163,6 @@ def create_fastapi_app(
    app.camera_error_image = None
    app.onvif = onvif
    app.stats_emitter = stats_emitter
-    app.notice_registry = notice_registry
    app.event_metadata_updater = event_metadata_updater
    app.config_publisher = config_publisher
    app.replay_manager = replay_manager
@@ -7,7 +7,6 @@ from fastapi import APIRouter, Depends
 from frigate.api.auth import require_role
 from frigate.api.defs.tags import Tags
 from frigate.detectors.hardware import DetectionHardware, hardware_prober
-from frigate.util.hwaccel import HwaccelRecommendation, hwaccel_options

 logger = logging.getLogger(__name__)

@@ -29,29 +28,3 @@ def probe_hardware(refresh: bool = False) -> list[DetectionHardware]:
        Every kind of detection hardware that was found
    """
    return hardware_prober.probe(refresh=refresh)
-
-
-@router.get(
-    "/hardware/hwaccel",
-    response_model=HwaccelRecommendation,
-    dependencies=[Depends(require_role(["admin"]))],
-)
-def hwaccel_recommendation(
-    detector: str | None = None, codecs: str | None = None
-) -> HwaccelRecommendation:
-    """Get the hardware decoding this system can do.
-
-    Args:
-        detector: Hardware key of the detection hardware in use, which biases
-            the recommendation toward that hardware's GPU
-        codecs: Comma separated codecs of the streams that will be decoded,
-            used to drop families that cannot decode one of them
-
-    Returns:
-        The recommended family (empty when none fits) and every usable family
-    """
-    wanted = {
-        codec.strip().lower() for codec in (codecs or "").split(",") if codec.strip()
-    }
-    recommended, available = hwaccel_options(detector, wanted)
-    return HwaccelRecommendation(recommended=recommended, available=available)
@@ -1060,7 +1060,7 @@ async def event_thumbnail(
    except DoesNotExist:
        thumbnail_bytes = None

-    if not thumbnail_bytes:
+    if thumbnail_bytes is None:
        # see if the object is currently being tracked
        try:
            camera_states = request.app.detected_frames_processor.get_camera_states()
@@ -1076,7 +1076,7 @@ async def event_thumbnail(
                status_code=404,
            )

-    if not thumbnail_bytes:
+    if thumbnail_bytes is None:
        return JSONResponse(
            content={"success": False, "message": "Event not found"},
            status_code=404,
@@ -1085,13 +1085,6 @@ async def event_thumbnail(
    img_as_np = np.frombuffer(thumbnail_bytes, dtype=np.uint8)
    img = cv2.imdecode(img_as_np, flags=1)

-    if img is None:
-        # thumbnail on disk is truncated or corrupt
-        return JSONResponse(
-            content={"success": False, "message": "Event not found"},
-            status_code=404,
-        )
-
    # android notifications prefer a 2:1 ratio
    if format == "android":
        img = cv2.copyMakeBorder(
@@ -1,60 +0,0 @@
-"""Notice APIs."""
-
-import logging
-
-from fastapi import APIRouter, Depends, Request
-from fastapi.responses import JSONResponse
-
-from frigate.api.auth import require_role
-from frigate.api.defs.tags import Tags
-from frigate.notices.registry import DismissResult
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(tags=[Tags.notices])
-
-
-@router.get("/notices", dependencies=[Depends(require_role(["admin"]))])
-def get_notices(request: Request, include_dismissed: bool = False) -> JSONResponse:
-    """Get the active notices, most severe first.
-
-    Args:
-        include_dismissed: Also return event notices the user has dismissed
-
-    Returns:
-        The active notices
-    """
-    return JSONResponse(
-        content=request.app.notice_registry.active(include_dismissed=include_dismissed)
-    )
-
-
-@router.get("/notices/stats", dependencies=[Depends(require_role(["admin"]))])
-def get_notice_stats(request: Request) -> JSONResponse:
-    """Get lifetime occurrence counts per notice kind."""
-    return JSONResponse(content=request.app.notice_registry.stats())
-
-
-@router.post(
-    "/notices/{notice_id}/dismiss", dependencies=[Depends(require_role(["admin"]))]
-)
-def dismiss_notice(request: Request, notice_id: str) -> JSONResponse:
-    """Hide an event notice until it is raised again."""
-    result = request.app.notice_registry.dismiss(notice_id)
-
-    if result == DismissResult.not_found:
-        return JSONResponse(
-            content={"success": False, "message": "Notice not found"},
-            status_code=404,
-        )
-
-    if result == DismissResult.not_dismissable:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "This notice clears itself when the problem is fixed",
-            },
-            status_code=400,
-        )
-
-    return JSONResponse(content={"success": True, "message": "Notice dismissed"})
@@ -358,13 +358,10 @@ async def recordings_coverage(
@router.get("/{camera_name}/recordings", dependencies=[Depends(require_camera_access)])
 async def recordings(
    camera_name: str,
-    after: float | None = None,
-    before: float | None = None,
+    after: float = (datetime.now() - timedelta(hours=1)).timestamp(),
+    before: float = datetime.now().timestamp(),
 ):
    """Return specific camera recordings between the given 'after'/'end' times. If not provided the last hour will be used"""
-    now = datetime.now()
-    after = after if after is not None else (now - timedelta(hours=1)).timestamp()
-    before = before if before is not None else now.timestamp()
    recordings = (
        Recordings.select(
            Recordings.id,
@@ -9,7 +9,7 @@ import pandas as pd
 from fastapi import APIRouter, Request
 from fastapi.params import Depends
 from fastapi.responses import JSONResponse
-from peewee import Case, DoesNotExist, fn, operator
+from peewee import Case, DoesNotExist, IntegrityError, fn, operator
 from playhouse.shortcuts import model_to_dict

 from frigate.api.auth import (
@@ -173,19 +173,11 @@ async def review_ids(request: Request, ids: str):
            status_code=400,
        )

-    try:
-        reviews = list(
-            ReviewSegment.select().where(ReviewSegment.id << ids).dicts().iterator()
-        )
-    except Exception:
-        return JSONResponse(
-            content=({"success": False, "message": "Review segments not found"}),
-            status_code=400,
-        )
-
-    found_ids = {r["id"] for r in reviews}
    for review_id in ids:
-        if review_id not in found_ids:
+        try:
+            review = ReviewSegment.get(ReviewSegment.id == review_id)
+            await require_camera_access(review.camera, request=request)
+        except DoesNotExist:
            return JSONResponse(
                content=(
                    {"success": False, "message": f"Review {review_id} not found"}
@@ -193,10 +185,16 @@ async def review_ids(request: Request, ids: str):
                status_code=404,
            )

-    for review in reviews:
-        await require_camera_access(review["camera"], request=request)
-
-    return JSONResponse(reviews)
+    try:
+        reviews = (
+            ReviewSegment.select().where(ReviewSegment.id << ids).dicts().iterator()
+        )
+        return JSONResponse(list(reviews))
+    except Exception:
+        return JSONResponse(
+            content=({"success": False, "message": "Review segments not found"}),
+            status_code=400,
+        )


@router.get(
@@ -493,52 +491,27 @@ async def set_multiple_reviewed(

    user_id = current_user["username"]

-    reviews = list(
-        ReviewSegment.select(ReviewSegment.id, ReviewSegment.camera).where(
-            ReviewSegment.id << body.ids
-        )
-    )
-
-    for review in reviews:
-        await require_camera_access(review.camera, request=request)
-
-    found_ids = [r.id for r in reviews]
-
-    if found_ids:
-        existing_statuses = list(
-            UserReviewStatus.select().where(
-                (UserReviewStatus.user_id == user_id)
-                & (UserReviewStatus.review_segment << found_ids)
+    for review_id in body.ids:
+        try:
+            review = ReviewSegment.get(ReviewSegment.id == review_id)
+            await require_camera_access(review.camera, request=request)
+            review_status = UserReviewStatus.get(
+                UserReviewStatus.user_id == user_id,
+                UserReviewStatus.review_segment == review_id,
            )
-        )
-
-        status_by_review = {s.review_segment_id: s for s in existing_statuses}
-
-        to_update = []
-        to_create = []
-
-        for review_id in found_ids:
-            if review_id in status_by_review:
-                status = status_by_review[review_id]
-                if status.has_been_reviewed != body.reviewed:
-                    status.has_been_reviewed = body.reviewed
-                    to_update.append(status)
-            else:
-                to_create.append(
-                    {
-                        "user_id": user_id,
-                        "review_segment_id": review_id,
-                        "has_been_reviewed": body.reviewed,
-                    }
+            # Update based on the reviewed parameter
+            if review_status.has_been_reviewed != body.reviewed:
+                review_status.has_been_reviewed = body.reviewed
+                review_status.save()
+        except DoesNotExist:
+            try:
+                UserReviewStatus.create(
+                    user_id=user_id,
+                    review_segment=ReviewSegment.get(id=review_id),
+                    has_been_reviewed=body.reviewed,
                )
-
-        if to_update:
-            UserReviewStatus.bulk_update(
-                to_update, fields=[UserReviewStatus.has_been_reviewed], batch_size=100
-            )
-
-        if to_create:
-            UserReviewStatus.insert_many(to_create).on_conflict_ignore().execute()
+            except (DoesNotExist, IntegrityError):
+                pass

    return JSONResponse(
        content=(
@@ -734,73 +707,6 @@ async def get_review(request: Request, review_id: str):
        )


-@router.put(
-    "/review/{review_id}/regenerate_description",
-    response_model=GenericResponse,
-    dependencies=[Depends(require_role(["admin"]))],
-    summary="Generate a review item description",
-    description="""Re-runs a review item through the GenAI descriptions process.
-    Frames are always taken from recordings, and both alerts and detections are
-    accepted regardless of the camera's GenAI alerts/detections toggles.
-    """,
-)
-async def regenerate_review_description(request: Request, review_id: str):
-    try:
-        review: ReviewSegment = ReviewSegment.get(ReviewSegment.id == review_id)
-    except DoesNotExist:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "Review " + review_id + " not found",
-            },
-            status_code=404,
-        )
-
-    await require_camera_access(review.camera, request=request)
-
-    if review.end_time is None:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "Review " + review_id + " has not ended yet",
-            },
-            status_code=400,
-        )
-
-    camera_config = request.app.frigate_config.cameras.get(review.camera)
-
-    if camera_config is None or not camera_config.review.genai.enabled:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "GenAI descriptions must be enabled for this camera",
-            },
-            status_code=400,
-        )
-
-    if request.app.genai_manager.description_client is None:
-        return JSONResponse(
-            content={
-                "success": False,
-                "message": "A GenAI provider with the descriptions role must be configured",
-            },
-            status_code=400,
-        )
-
-    context: EmbeddingsContext = request.app.embeddings
-    context.regenerate_review_description(review_id)
-
-    return JSONResponse(
-        content={
-            "success": True,
-            "message": "Review "
-            + review_id
-            + " description generation has been requested",
-        },
-        status_code=202,
-    )
-
-
@router.delete(
    "/review/{review_id}/viewed",
    response_model=GenericResponse,
@@ -50,7 +50,6 @@ from frigate.debug_replay import (
    cleanup_replay_cameras,
 )
 from frigate.detectors.detector_config import SceneEnum
-from frigate.detectors.detector_types import api_types
 from frigate.detectors.device import build_detector_config, runner_names
 from frigate.embeddings import EmbeddingProcess, EmbeddingsContext
 from frigate.events.audio import AudioProcessor
@@ -62,8 +61,6 @@ from frigate.log import _stop_logging
 from frigate.models import (
    Event,
    Export,
-    Notice,
-    NoticeStats,
    Previews,
    Recordings,
    RecordingsToDelete,
@@ -73,7 +70,6 @@ from frigate.models import (
    Trigger,
    User,
 )
-from frigate.notices.registry import NoticeRegistry
 from frigate.object_detection.base import ObjectDetectProcess
 from frigate.object_detection.util import detection_frame_size
 from frigate.output.output import OutputProcess
@@ -92,7 +88,6 @@ from frigate.util.builtin import empty_and_close_queue
 from frigate.util.image import UntrackedSharedMemory
 from frigate.util.ownership import chown_to_runtime
 from frigate.util.process import FrigateProcess
-from frigate.util.runtime_deps import RuntimeDependencyError
 from frigate.util.services import set_file_limit
 from frigate.version import VERSION
 from frigate.watchdog import FrigateWatchdog
@@ -236,17 +231,6 @@ class FrigateApp:

        migrate_db.close()

-        # a root frigate service creates these as root; wal and shm recreated
-        # later in the run are realigned by the per-boot /config sweep
-        for db_file in (
-            self.config.database.path,
-            f"{self.config.database.path}-wal",
-            f"{self.config.database.path}-shm",
-            self.config.database.path.replace("frigate.db", "backup.db"),
-        ):
-            if os.path.exists(db_file):
-                chown_to_runtime(db_file)
-
    def init_go2rtc(self) -> None:
        for proc in psutil.process_iter(["pid", "name"]):
            if proc.info["name"] == "go2rtc":
@@ -297,8 +281,6 @@ class FrigateApp:
        models = [
            Event,
            Export,
-            Notice,
-            NoticeStats,
            Previews,
            Recordings,
            RecordingsToDelete,
@@ -310,10 +292,6 @@ class FrigateApp:
        ]
        self.db.bind(models)

-        self.notice_registry = NoticeRegistry()
-        # producers confirm state notices again at startup if they still hold
-        self.notice_registry.mark_state_notices_unconfirmed()
-
    def check_db_data_migrations(self) -> None:
        # check if vacuum needs to be run
        if not os.path.exists(f"{CONFIG_DIR}/.exports"):
@@ -363,7 +341,6 @@ class FrigateApp:
            self.onvif_controller,
            self.ptz_metrics,
            comms,
-            notice_registry=self.notice_registry,
        )
        self.dispatcher.start_communicators()

@@ -373,26 +350,6 @@ class FrigateApp:
        )
        self.dispatcher.profile_manager = self.profile_manager

-    def ensure_detector_dependencies(self) -> None:
-        """Install runtimes for the configured detector types.
-
-        Runs before any detector process starts so one install serves them
-        all and the user site is on sys.path before the forkserver copies it.
-        A failure is logged and startup continues; the detector process then
-        fails on its own with a clear import error.
-        """
-        detector_types = {
-            spec.detector
-            for model in self.config.models
-            for spec in self.config.devices_for_model(model)
-        }
-
-        for detector_type in sorted(detector_types):
-            try:
-                api_types[detector_type].ensure_dependencies()
-            except RuntimeDependencyError as err:
-                logger.error("Unable to prepare the %s runtime: %s", detector_type, err)
-
    def start_detectors(self) -> None:
        model_cameras: dict[SceneEnum, list[str]] = {
            model.scene: [] for model in self.config.models
@@ -510,9 +467,7 @@ class FrigateApp:
        self.record_cleanup.start()

    def start_storage_maintainer(self) -> None:
-        self.storage_maintainer = StorageMaintainer(
-            self.config, self.stop_event, self.notice_registry
-        )
+        self.storage_maintainer = StorageMaintainer(self.config, self.stop_event)
        self.storage_maintainer.start()

    def start_stats_emitter(self) -> None:
@@ -526,14 +481,11 @@ class FrigateApp:
                self.processes,
            ),
            self.stop_event,
-            notice_registry=self.notice_registry,
        )
        self.stats_emitter.start()

    def start_watchdog(self) -> None:
-        self.frigate_watchdog = FrigateWatchdog(
-            self.detectors, self.stop_event, self.notice_registry
-        )
+        self.frigate_watchdog = FrigateWatchdog(self.detectors, self.stop_event)

        # (attribute on self, key in self.processes, factory)
        specs: list[tuple[str, str, Callable[[], FrigateProcess]]] = [
@@ -627,7 +579,6 @@ class FrigateApp:

        # Ensure global state.
        self.ensure_dirs()
-        self.ensure_detector_dependencies()

        # Set soft file limits.
        set_file_limit()
@@ -701,7 +652,6 @@ class FrigateApp:
                    self.dispatcher,
                    self.profile_manager,
                    config_holder=self.config_holder,
-                    notice_registry=self.notice_registry,
                ),
                host="127.0.0.1",
                port=5001,
@@ -61,11 +61,6 @@ class CameraState:
        # face/LPR pipelines when using a model without built-in detection.
        self.face_recognition_min_obj_area: int = 0
        self.lpr_min_obj_area: int = 0
-        self.lp_objects = {
-            label
-            for label, attributes in self.model.attributes_map.items()
-            if "license_plate" in attributes
-        }

        if (
            self.camera_config.face_recognition.enabled
@@ -452,7 +447,7 @@ class CameraState:
                and obj_area >= self.face_recognition_min_obj_area
                and updated_obj.obj_data.get("sub_label") is None
            ) or (
-                obj_label in self.lp_objects
+                obj_label in ("car", "motorcycle")
                and self.lpr_min_obj_area > 0
                and obj_area >= self.lpr_min_obj_area
                and updated_obj.obj_data.get("sub_label") is None
@@ -548,7 +543,7 @@ class CameraState:
                    current_best.thumbnail_data is not None
                    and obj.thumbnail_data is not None
                    and is_better_thumbnail(
-                        obj.thumbnail_attributes,
+                        object_type,
                        current_best.thumbnail_data,
                        obj.thumbnail_data,
                        self.camera_config.frame_shape,
@@ -11,7 +11,6 @@ from peewee import IntegrityError
 from frigate.camera import PTZMetrics
 from frigate.camera.activity_manager import AudioActivityManager, CameraActivityManager
 from frigate.comms.base_communicator import Communicator
-from frigate.comms.mqtt import MqttClient
 from frigate.comms.runtime_state import RuntimeStatePersistence
 from frigate.comms.webpush import WebPushClient
 from frigate.config import (
@@ -41,12 +40,10 @@ from frigate.const import (
    UPDATE_EVENT_DESCRIPTION,
    UPDATE_JOB_STATE,
    UPDATE_MODEL_STATE,
-    UPDATE_NOTICE,
    UPDATE_REVIEW_DESCRIPTION,
    UPSERT_REVIEW_SEGMENT,
 )
 from frigate.models import Event, Previews, Recordings, ReviewSegment
-from frigate.notices.registry import NoticeRegistry
 from frigate.ptz.onvif import OnvifCommandEnum, OnvifController
 from frigate.types import ModelStatusTypesEnum, TrackedObjectUpdateTypesEnum
 from frigate.util.object import get_camera_regions_grid
@@ -70,18 +67,12 @@ class Dispatcher:
        onvif: OnvifController,
        ptz_metrics: dict[str, PTZMetrics],
        communicators: list[Communicator],
-        notice_registry: NoticeRegistry | None = None,
    ) -> None:
        self.config = config
        self.config_updater = config_updater
        self.onvif = onvif
        self.ptz_metrics = ptz_metrics
        self.comms = communicators
-        self.notice_registry = notice_registry
-
-        if notice_registry is not None:
-            notice_registry.subscribe(self._publish_notices)
-
        self.camera_activity = CameraActivityManager(config, self.publish)
        self.audio_activity = AudioActivityManager(config, self.publish)
        self.model_state: dict[str, ModelStatusTypesEnum] = {}
@@ -221,10 +212,6 @@ class Dispatcher:
            False,
        )
        publish("birdseye_layout", json.dumps(self.birdseye_layout.copy()), False)
-
-        if self.notice_registry is not None:
-            publish("notices", json.dumps(self.notice_registry.active()), False)
-
        publish("audio_detections", json.dumps(audio_detections), False)
        publish(
            "profile/state",
@@ -352,29 +339,6 @@ class Dispatcher:
                self.model_state[model] = ModelStatusTypesEnum[state]
                self.publish("model_state", json.dumps(self.model_state))

-        def handle_update_notice() -> None:
-            if self.notice_registry is None or not isinstance(payload, dict):
-                return
-
-            try:
-                action = payload.get("action")
-                kind = payload.get("kind")
-                scope = payload.get("scope")
-
-                if not isinstance(kind, str):
-                    logger.warning("Ignoring notice update without a kind")
-                elif action == "raise":
-                    self.notice_registry.raise_notice(
-                        kind, scope=scope, params=payload.get("params") or {}
-                    )
-                elif action == "resolve":
-                    self.notice_registry.resolve(kind, scope)
-                else:
-                    logger.warning("Ignoring notice update with action %s", action)
-            except Exception:
-                # a raise here would kill the REP thread for every process
-                logger.exception("Failed to apply notice update")
-
        def handle_model_state() -> None:
            self.publish("model_state", json.dumps(self.model_state.copy()))

@@ -442,7 +406,6 @@ class Dispatcher:
            UPDATE_REVIEW_DESCRIPTION: handle_update_review_description,
            UPDATE_MODEL_STATE: handle_update_model_state,
            UPDATE_JOB_STATE: handle_update_job_state,
-            UPDATE_NOTICE: handle_update_notice,
            UPDATE_EMBEDDINGS_REINDEX_PROGRESS: handle_update_embeddings_reindex_progress,
            UPDATE_BIRDSEYE_LAYOUT: handle_update_birdseye_layout,
            UPDATE_AUDIO_TRANSCRIPTION_STATE: handle_update_audio_transcription_state,
@@ -501,23 +464,6 @@ class Dispatcher:
        for comm in self.comms:
            comm.publish(topic, payload, retain)

-    def publish_local(self, topic: str, payload: Any) -> None:
-        """Publish to every communicator except MQTT.
-
-        Used for topics whose external schema is not settled yet.
-        """
-        for comm in self.comms:
-            if isinstance(comm, MqttClient):
-                continue
-
-            comm.publish(topic, payload, False)
-
-    def _publish_notices(self) -> None:
-        if self.notice_registry is None:
-            return
-
-        self.publish_local("notices", json.dumps(self.notice_registry.active()))
-
    def stop(self) -> None:
        self.camera_activity.stop()

@@ -32,7 +32,6 @@ class EmbeddingsRequestEnum(Enum):
    reprocess_plate = "reprocess_plate"
    # Review Descriptions
    summarize_review = "summarize_review"
-    regenerate_review_description = "regenerate_review_description"


 class EmbeddingsResponder:
@@ -430,7 +430,6 @@ class WebPushClient(Communicator):
        # Don't notify if message is an update and important fields don't have an update
        if (
            state == "update"
-            and payload["before"]["severity"] == payload["after"]["severity"]
            and len(payload["before"]["data"]["objects"])
            == len(payload["after"]["data"]["objects"])
            and len(payload["before"]["data"]["zones"])
@@ -31,7 +31,6 @@ from frigate.const import (
    UPDATE_EMBEDDINGS_REINDEX_PROGRESS,
    UPDATE_EVENT_DESCRIPTION,
    UPDATE_MODEL_STATE,
-    UPDATE_NOTICE,
    UPDATE_REVIEW_DESCRIPTION,
    UPSERT_REVIEW_SEGMENT,
 )
@@ -57,7 +56,6 @@ _WS_BLOCKED_TOPICS = frozenset(
        UPDATE_EMBEDDINGS_REINDEX_PROGRESS,
        UPDATE_BIRDSEYE_LAYOUT,
        UPDATE_AUDIO_TRANSCRIPTION_STATE,
-        UPDATE_NOTICE,
    }
 )

@@ -160,16 +158,6 @@ _WS_UNRESTRICTED_ONLY_TOPICS = frozenset(
    }
 )

-# Topics only an admin connection may receive. unrestricted_only is not
-# enough: the built-in viewer role has an empty camera allow-list, which the
-# camera policy treats as full access, while the REST side of these topics
-# is admin-only.
-_WS_ADMIN_ONLY_TOPICS = frozenset(
-    {
-        "notices",
-    }
-)
-
 # Topics whose payload (parsed as JSON) names a single owning camera at the
 # given key path. Used to scope events, reviews, triggers, etc.
 _WS_PAYLOAD_CAMERA_TOPICS: dict[str, tuple[str, ...]] = {
@@ -292,7 +280,6 @@ def _classify_outbound(
      - "global"             : send to every authenticated client
      - "drop"               : send to nobody (fail-closed for unknowns)
      - "unrestricted_only"  : send only to admin/full-access roles
-      - "admin_only"         : send only to connections with the admin role
      - "camera"             : extra is the owning camera name
      - "payload_camera"     : extra is the JSON key path to the camera name
      - "reshape_by_camera_key"
@@ -301,8 +288,6 @@ def _classify_outbound(
    """
    if topic in _WS_GLOBAL_OUTBOUND_TOPICS:
        return ("global", None)
-    if topic in _WS_ADMIN_ONLY_TOPICS:
-        return ("admin_only", None)
    if topic in _WS_UNRESTRICTED_ONLY_TOPICS:
        return ("unrestricted_only", None)
    if topic in _WS_RESHAPE_BY_CAMERA_KEY_TOPICS:
@@ -406,9 +391,6 @@ def _materialize_for_ws(
    if kind == "unrestricted_only":
        return full_message if _ws_is_unrestricted(ws, config) else None

-    if kind == "admin_only":
-        return full_message if "admin" in _ws_valid_roles(ws, config) else None
-
    if kind == "camera":
        return full_message if ws_has_camera_access(ws, extra, config) else None

@@ -78,14 +78,11 @@ class AuthConfig(FrigateBaseModel):
                    f"Invalid role name '{role}'. Must be alphanumeric with underscores."
                )

-        # 'none' is the deny sentinel for proxy.default_role, where it is matched
-        # case-insensitively, so every casing of it has to be reserved here
-        used_reserved = sorted(
-            r for r in v if r in ("admin", "viewer") or r.lower() == "none"
-        )
-        if used_reserved:
+        # Ensure 'admin' and 'viewer' are not used as custom role names
+        reserved_roles = {"admin", "viewer"}
+        if v.keys() & reserved_roles:
            raise ValueError(
-                f"Reserved role name(s) {', '.join(used_reserved)} cannot be used as custom roles."
+                f"Reserved roles {reserved_roles} cannot be used as custom roles."
            )

        # Ensure no role has an empty camera list
@@ -4,13 +4,7 @@ from pydantic import Field, field_validator

 from ..base import FrigateBaseModel

-__all__ = [
-    "ReviewConfig",
-    "DetectionsConfig",
-    "AlertsConfig",
-    "ImageSourceEnum",
-    "ReviewResponseStyleEnum",
-]
+__all__ = ["ReviewConfig", "DetectionsConfig", "AlertsConfig", "ImageSourceEnum"]


 class ImageSourceEnum(str, Enum):
@@ -20,15 +14,6 @@ class ImageSourceEnum(str, Enum):
    recordings = "recordings"


-class ReviewResponseStyleEnum(str, Enum):
-    """Writing style presets for GenAI review descriptions."""
-
-    default = "default"
-    natural = "natural"
-    concise = "concise"
-    detailed = "detailed"
-
-
 DEFAULT_ALERT_OBJECTS = ["person", "car"]


@@ -153,11 +138,6 @@ class GenAIReviewConfig(FrigateBaseModel):
        description="Preferred language to request from the GenAI provider for generated responses.",
        default=None,
    )
-    response_style: ReviewResponseStyleEnum = Field(
-        default=ReviewResponseStyleEnum.default,
-        title="Response style",
-        description="Writing style preset for generated review descriptions. Presets adjust the tone and level of detail of the user-facing title, summary, and scene description; 'default' leaves the built-in prompt unchanged.",
-    )
    activity_context_prompt: str = Field(
        default="""### Normal Activity Indicators (Level 0)
 - Known/verified people in any zone at any time
@@ -43,7 +43,7 @@ class ProxyConfig(FrigateBaseModel):
    default_role: str | None = Field(
        default="viewer",
        title="Default role",
-        description="Default role assigned to proxy-authenticated users when no role mapping applies. Set to 'none' to deny access to unmapped users.",
+        description="Default role assigned to proxy-authenticated users when no role mapping applies.",
    )
    separator: str | None = Field(
        default=",",
@@ -51,16 +51,6 @@ class ProxyConfig(FrigateBaseModel):
        description="Character used to split multiple values provided in proxy headers.",
    )

-    @field_validator("default_role", mode="before")
-    @classmethod
-    def normalize_deny_sentinel(cls, v):
-        # Fail closed on capitalization: an unnormalized "None" would miss the
-        # sentinel and fall back to viewer, granting the access it was meant to
-        # deny. Other role names stay case-sensitive.
-        if isinstance(v, str) and v.strip().lower() == "none":
-            return "none"
-        return v
-
    @field_validator("separator", mode="before")
    @classmethod
    def validate_separator_length(cls, v):
@@ -53,11 +53,7 @@ DEFAULT_ATTRIBUTE_LABEL_MAP = {
        "ups",
        "usps",
    ],
-    "truck": ["license_plate"],
-    "garbage_truck": ["license_plate"],
    "motorcycle": ["license_plate"],
-    "bus": ["license_plate"],
-    "school_bus": ["license_plate"],
 }
 ATTRIBUTE_LABEL_DISPLAY_MAP = {
    "amazon": "Amazon",
@@ -155,7 +151,6 @@ UPDATE_MODEL_STATE = "update_model_state"
 UPDATE_EMBEDDINGS_REINDEX_PROGRESS = "handle_embeddings_reindex_progress"
 UPDATE_BIRDSEYE_LAYOUT = "update_birdseye_layout"
 UPDATE_JOB_STATE = "update_job_state"
-UPDATE_NOTICE = "update_notice"
 NOTIFICATION_TEST = "notification_test"

 # IO Nice Values
@@ -1290,7 +1290,7 @@ class LicensePlateProcessingMixin:
                and obj_data.get("label") != "license_plate"
            ):
                logger.debug(
-                    f"{camera}: Not a processing license plate for {obj_data.get('label', 'unknown')}."
+                    f"{camera}: Not a processing license plate for non car/motorcycle object."
                )
                return

@@ -1367,7 +1367,7 @@ class LicensePlateProcessingMixin:

                if not license_plate:
                    logger.debug(
-                        f"{camera}: Detected no license plates for {obj_data.get('label', 'unknown')} object."
+                        f"{camera}: Detected no license plates for car/motorcycle object."
                    )
                    return

@@ -12,7 +12,6 @@ from typing import Any

 import cv2
 from peewee import DoesNotExist
-from playhouse.shortcuts import model_to_dict
 from titlecase import titlecase

 from frigate.comms.embeddings_updater import EmbeddingsRequestEnum
@@ -168,9 +167,17 @@ class ReviewDescriptionProcessor(PostProcessorApi):
            image_source = camera_config.review.genai.image_source

            if image_source == ImageSourceEnum.recordings:
-                buffer_extension = get_recording_buffer_extension(
-                    final_data["end_time"] - final_data["start_time"]
-                )
+                duration = final_data["end_time"] - final_data["start_time"]
+                buffer_extension = min(5, duration * RECORDING_BUFFER_EXTENSION_PERCENT)
+
+                # Ensure minimum total duration for short review items
+                # This provides better context for brief events
+                total_duration = duration + (2 * buffer_extension)
+                if total_duration < MIN_RECORDING_DURATION:
+                    # Expand buffer to reach minimum duration, still respecting max of 5s per side
+                    additional_buffer_per_side = (MIN_RECORDING_DURATION - duration) / 2
+                    buffer_extension = min(5, additional_buffer_per_side)
+
                final_data["start_time"] -= buffer_extension
                final_data["end_time"] += buffer_extension

@@ -195,7 +202,16 @@ class ReviewDescriptionProcessor(PostProcessorApi):
                        camera_config.review.genai.debug_save_thumbnails,
                    )
                elif camera_config.review.genai.debug_save_thumbnails:
-                    self.save_debug_recording_frames(id, thumbs)
+                    # Save debug thumbnails for recordings
+                    Path(os.path.join(CLIPS_DIR, "genai-requests", id)).mkdir(
+                        parents=True, exist_ok=True
+                    )
+                    for idx, frame_bytes in enumerate(thumbs):
+                        with open(
+                            os.path.join(CLIPS_DIR, f"genai-requests/{id}/{idx}.jpg"),
+                            "wb",
+                        ) as f:
+                            f.write(frame_bytes)
            else:
                # Use preview frames
                thumbs = self.get_preview_frames_as_bytes(
@@ -207,23 +223,25 @@ class ReviewDescriptionProcessor(PostProcessorApi):
                    camera_config.review.genai.debug_save_thumbnails,
                )

-            self.start_analysis(camera_config, final_data, thumbs)
+            # kickoff analysis
+            self.review_desc_dps.update()
+            threading.Thread(
+                target=run_analysis,
+                args=(
+                    self.requestor,
+                    self.genai_manager.description_client,
+                    self.review_desc_speed,
+                    camera_config,
+                    final_data,
+                    thumbs,
+                    camera_config.review.genai,
+                    sorted(self.config.all_labels),
+                    self.config.all_attributes,
+                ),
+            ).start()

    def handle_request(self, topic: str, request_data: dict[str, Any]) -> str | None:
-        if topic == EmbeddingsRequestEnum.regenerate_review_description.value:
-            review_id = request_data["review_id"]
-            logger.debug("Found GenAI Review description request for %s", review_id)
-
-            # frame extraction shells out to ffmpeg once per frame, so run the
-            # whole thing off the maintainer loop and answer the caller now
-            threading.Thread(
-                target=self.regenerate_description,
-                name=f"regenerate_review_description_{review_id}",
-                daemon=True,
-                args=(review_id,),
-            ).start()
-            return "started"
-        elif topic == EmbeddingsRequestEnum.summarize_review.value:
+        if topic == EmbeddingsRequestEnum.summarize_review.value:
            start_ts = request_data["start_ts"]
            end_ts = request_data["end_ts"]
            logger.debug(
@@ -342,104 +360,6 @@ class ReviewDescriptionProcessor(PostProcessorApi):
        else:
            return None

-    def regenerate_description(self, review_id: str) -> None:
-        """Re-run a finished review item through the description process.
-
-        Frames always come from recordings: preview frames only live in the
-        cache briefly and are much harder to sample from once they have been
-        compressed into a preview clip. Alerts and detections are both accepted
-        regardless of the per-camera alerts/detections toggles, since the run
-        was asked for explicitly.
-        """
-        client = self.genai_manager.description_client
-
-        if client is None:
-            logger.error("No GenAI provider is assigned the descriptions role")
-            return
-
-        try:
-            review: ReviewSegment = ReviewSegment.get(ReviewSegment.id == review_id)
-        except DoesNotExist:
-            logger.error(
-                "Review item %s not found for description generation", review_id
-            )
-            return
-
-        camera_config = self.config.cameras.get(str(review.camera))
-
-        if camera_config is None:
-            logger.error("Camera %s no longer exists", review.camera)
-            return
-
-        if not camera_config.review.genai.enabled:
-            logger.error(
-                "GenAI review descriptions are not enabled for %s", review.camera
-            )
-            return
-
-        final_data = model_to_dict(review)
-
-        if final_data["end_time"] is None:
-            logger.error("Review item %s has not ended yet", review_id)
-            return
-
-        buffer_extension = get_recording_buffer_extension(
-            final_data["end_time"] - final_data["start_time"]
-        )
-        thumbs = self.get_recording_frames(
-            str(review.camera),
-            final_data["start_time"] - buffer_extension,
-            final_data["end_time"] + buffer_extension,
-            height=480,
-        )
-
-        if not thumbs:
-            logger.error(
-                "No recording frames are available for review item %s", review_id
-            )
-            return
-
-        if camera_config.review.genai.debug_save_thumbnails:
-            self.save_debug_recording_frames(review_id, thumbs)
-
-        self.start_analysis(camera_config, final_data, thumbs)
-
-    def start_analysis(
-        self,
-        camera_config: CameraConfig,
-        final_data: dict[str, Any],
-        thumbs: list[bytes],
-    ) -> None:
-        """Kick off description generation for a review item in the background."""
-        self.review_desc_dps.update()
-        threading.Thread(
-            target=run_analysis,
-            args=(
-                self.requestor,
-                self.genai_manager.description_client,
-                self.review_desc_speed,
-                camera_config,
-                final_data,
-                thumbs,
-                camera_config.review.genai,
-                sorted(self.config.all_labels),
-                self.config.all_attributes,
-            ),
-        ).start()
-
-    def save_debug_recording_frames(self, review_id: str, thumbs: list[bytes]) -> None:
-        """Write the recording frames sent to the provider out for debugging."""
-        Path(os.path.join(CLIPS_DIR, "genai-requests", review_id)).mkdir(
-            parents=True, exist_ok=True
-        )
-
-        for idx, frame_bytes in enumerate(thumbs):
-            with open(
-                os.path.join(CLIPS_DIR, f"genai-requests/{review_id}/{idx}.jpg"),
-                "wb",
-            ) as f:
-                f.write(frame_bytes)
-
    def get_cache_frames(
        self,
        camera: str,
@@ -619,20 +539,6 @@ class ReviewDescriptionProcessor(PostProcessorApi):
        return thumbs


-def get_recording_buffer_extension(duration: float) -> float:
-    """Seconds of padding to add to each side of a review item when pulling
-    recording frames, so brief items still carry enough context."""
-    buffer_extension = min(5, duration * RECORDING_BUFFER_EXTENSION_PERCENT)
-
-    # Ensure minimum total duration for short review items
-    # This provides better context for brief events
-    if duration + (2 * buffer_extension) < MIN_RECORDING_DURATION:
-        # Expand buffer to reach minimum duration, still respecting max of 5s per side
-        buffer_extension = min(5, (MIN_RECORDING_DURATION - duration) / 2)
-
-    return buffer_extension
-
-
 def run_analysis(
    requestor: InterProcessRequestor,
    genai_client: GenAIClient,
@@ -695,7 +601,6 @@ def run_analysis(
        genai_config.preferred_language,
        genai_config.debug_save_thumbnails,
        genai_config.activity_context_prompt,
-        genai_config.response_style,
    )
    review_inference_speed.update(datetime.datetime.now().timestamp() - start)

@@ -28,7 +28,6 @@ class DataProcessorMetrics:
    object_desc_dps: ValueProxy[float]
    classification_speeds: DictProxy[str, ValueProxy[float]]
    classification_cps: DictProxy[str, ValueProxy[float]]
-    runtime_devices: DictProxy[str, str]

    def __init__(self, manager: SyncManager, custom_classification_models: list[str]):
        self.image_embeddings_speed = manager.Value("d", 0.0)
@@ -47,7 +46,6 @@ class DataProcessorMetrics:
        self.object_desc_dps = manager.Value("d", 0.0)
        self.classification_speeds = manager.dict()
        self.classification_cps = manager.dict()
-        self.runtime_devices = manager.dict()

        if custom_classification_models:
            for key in custom_classification_models:
@@ -1,11 +1,9 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import ClassVar

 import numpy as np

 from frigate.detectors.detector_config import BaseDetectorConfig, ModelTypeEnum
-from frigate.util.runtime_deps import RuntimeManifest, activate, ensure_installed

 logger = logging.getLogger(__name__)

@@ -14,10 +12,6 @@ class DetectionApi(ABC):
    type_key: str
    supported_models: list[ModelTypeEnum]

-    # pinned SDK artifacts that are installed at runtime instead of being
-    # shipped in the image; None when the runtime is already available
-    runtime_manifest: ClassVar[RuntimeManifest | None] = None
-
    @abstractmethod
    def __init__(self, detector_config: BaseDetectorConfig):
        self.detector_config = detector_config
@@ -29,23 +23,6 @@ class DetectionApi(ABC):
    def detect_raw(self, tensor_input):
        pass

-    @classmethod
-    def ensure_dependencies(cls) -> None:
-        """Download and install this detector's runtime if it is not present.
-
-        Runs once in the main process before detector processes start, so a
-        single install serves every process and the user site is on sys.path
-        before it is inherited.
-        """
-        if cls.runtime_manifest is not None:
-            ensure_installed(cls.runtime_manifest)
-
-    @classmethod
-    def activate_dependencies(cls) -> None:
-        """Make the installed runtime importable in the current process."""
-        if cls.runtime_manifest is not None:
-            activate(cls.runtime_manifest)
-
    def calculate_grids_strides(self, expanded=True) -> None:
        grids = []
        expanded_strides = []
@@ -18,36 +18,6 @@ logger = logging.getLogger(__name__)
 # Process-wide lock serializing all OpenVINO compile/inference calls
 _OPENVINO_LOCK = threading.Lock()

-# model file path -> (model type, device the runner actually loaded on); the
-# embeddings maintainer folds this per enrichment for the stats endpoint.
-# Models load on several threads (reindex, lazy first use), so writes and
-# snapshots go through the lock.
-loaded_devices: dict[str, tuple[str, str]] = {}
-_loaded_devices_lock = threading.Lock()
-
-
-def record_loaded_device(model_path: str, model_type: str, device: str) -> None:
-    """Record the device a model loaded on, for the enrichment stats."""
-    with _loaded_devices_lock:
-        loaded_devices[model_path] = (model_type, device)
-
-    logger.info("Loaded %s model on %s", model_type, device)
-
-
-def snapshot_loaded_devices() -> dict[str, tuple[str, str]]:
-    """A copy that is safe to iterate while other threads load models."""
-    with _loaded_devices_lock:
-        return dict(loaded_devices)
-
-
-_PROVIDER_LABELS = {
-    "CUDAExecutionProvider": "CUDA",
-    "TensorrtExecutionProvider": "TensorRT",
-    "MIGraphXExecutionProvider": "MIGraphX",
-    "OpenVINOExecutionProvider": "OpenVINO",
-    "CPUExecutionProvider": "CPU",
-}
-

 def is_arm64_platform() -> bool:
    """Check if we're running on an ARM platform."""
@@ -55,31 +25,25 @@ def is_arm64_platform() -> bool:
    return machine in ("aarch64", "arm64", "armv8", "armv7l")


-def get_ort_session_options(model_type: str | None = None) -> ort.SessionOptions | None:
+def get_ort_session_options(
+    is_complex_model: bool = False,
+) -> ort.SessionOptions | None:
    """Get ONNX Runtime session options with appropriate settings.

    Args:
-        model_type: Model being loaded, used to pin its graph optimization level.
+        is_complex_model: Whether the model needs basic optimization to avoid graph fusion issues.

    Returns:
-        SessionOptions with a pinned optimization level, or None for default settings.
+        SessionOptions with appropriate optimization level, or None for default settings.
    """
-    # Import here to avoid circular imports
-    from frigate.embeddings.types import EnrichmentModelTypeEnum
+    if is_complex_model:
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = (
+            ort.GraphOptimizationLevel.ORT_ENABLE_BASIC
+        )
+        return sess_options

-    if model_type == EnrichmentModelTypeEnum.jina_v2.value:
-        # below EXTENDED the CUDA EP returns an identical vector for every image,
-        # and ORT_ENABLE_ALL fails to build on CPU with a SimplifiedLayerNormFusion error
-        level = ort.GraphOptimizationLevel.ORT_ENABLE_EXTENDED
-    elif model_type == EnrichmentModelTypeEnum.jina_v1.value:
-        # aggressive optimizations create or expect nodes that don't exist
-        level = ort.GraphOptimizationLevel.ORT_ENABLE_BASIC
-    else:
-        return None
-
-    sess_options = ort.SessionOptions()
-    sess_options.graph_optimization_level = level
-    return sess_options
+    return None


 # Import OpenVINO only when needed to avoid circular dependencies
@@ -147,16 +111,25 @@ class BaseModelRunner(ABC):
        """Run inference with the model."""
        pass

-    @property
-    @abstractmethod
-    def device_name(self) -> str:
-        """Short label of the device the model actually loaded on."""
-        pass
-

 class ONNXModelRunner(BaseModelRunner):
    """Run ONNX models using ONNX Runtime."""

+    @staticmethod
+    def is_cpu_complex_model(model_type: str) -> bool:
+        """Check if model needs basic optimization level to avoid graph fusion issues.
+
+        Some models (like Jina-CLIP) have issues with aggressive optimizations like
+        SimplifiedLayerNormFusion that create or expect nodes that don't exist.
+        """
+        # Import here to avoid circular imports
+        from frigate.embeddings.types import EnrichmentModelTypeEnum
+
+        return model_type in [
+            EnrichmentModelTypeEnum.jina_v1.value,
+            EnrichmentModelTypeEnum.jina_v2.value,
+        ]
+
    @staticmethod
    def is_migraphx_complex_model(model_type: str) -> bool:
        # Import here to avoid circular imports
@@ -210,18 +183,6 @@ class ONNXModelRunner(BaseModelRunner):

        return self.ort.run(None, input)

-    @property
-    def device_name(self) -> str:
-        providers = self.ort.get_providers()
-
-        if not providers:
-            return "CPU"
-
-        provider = providers[0]
-        return _PROVIDER_LABELS.get(
-            provider, provider.removesuffix("ExecutionProvider")
-        )
-

 class CudaGraphRunner(BaseModelRunner):
    """Encapsulates CUDA Graph capture and replay using ONNX Runtime IOBinding.
@@ -298,10 +259,6 @@ class CudaGraphRunner(BaseModelRunner):
        self._session.run_with_iobinding(self._io_binding, ro)
        return self._io_binding.copy_outputs_to_cpu()

-    @property
-    def device_name(self) -> str:
-        return "CUDA"
-

 class OpenVINOModelRunner(BaseModelRunner):
    """OpenVINO model runner that handles inference efficiently."""
@@ -366,36 +323,17 @@ class OpenVINOModelRunner(BaseModelRunner):
        if device in ["GPU", "AUTO", "NPU"]:
            self.ov_core.set_property(device, {"PERFORMANCE_HINT": "LATENCY"})

-        if device in ["GPU", "AUTO"]:
-            try:
-                self.ov_core.set_property("GPU", {"GPU_QUEUE_THROTTLE": "LOW"})
-            except Exception as e:
-                logger.debug(f"GPU_QUEUE_THROTTLE not supported: {e}")
-
-        # Some keys must be passed as compile-time config so that it can be caught
-        compile_config = {}
-
        if device == "NPU" and OpenVINOModelRunner.is_detection_model(model_type):
-            compile_config["NPU_TURBO"] = "YES"
-
-        self.compiled_device = device
+            try:
+                self.ov_core.set_property(device, {"NPU_TURBO": "YES"})
+            except Exception as e:
+                logger.debug(f"NPU_TURBO not supported by driver: {e}")

        # Compile model under the shared lock
        with _OPENVINO_LOCK:
-            try:
-                self.compiled_model = self.ov_core.compile_model(
-                    model=model_path, device_name=device, config=compile_config
-                )
-            except RuntimeError as e:
-                if not compile_config:
-                    raise
-
-                logger.debug(
-                    f"Failed to compile with {compile_config}, retrying without: {e}"
-                )
-                self.compiled_model = self.ov_core.compile_model(
-                    model=model_path, device_name=device
-                )
+            self.compiled_model = self.ov_core.compile_model(
+                model=model_path, device_name=device
+            )

            # Create reusable inference request
            self.infer_request = self.compiled_model.create_infer_request()
@@ -411,22 +349,6 @@ class OpenVINOModelRunner(BaseModelRunner):
                # model is complex and has dynamic shape
                pass

-    @property
-    def device_name(self) -> str:
-        device = self.compiled_device
-
-        if device == "AUTO":
-            try:
-                resolved = self.compiled_model.get_property("EXECUTION_DEVICES")
-
-                if resolved:
-                    device = ",".join(str(d) for d in resolved)
-            except Exception:
-                # older OpenVINO builds do not expose the property
-                pass
-
-        return f"OpenVINO {device}"
-
    def get_input_names(self) -> list[str]:
        """Get input names for the model."""
        return [input.get_any_name() for input in self.compiled_model.inputs]
@@ -574,10 +496,6 @@ class RKNNModelRunner(BaseModelRunner):
            logger.error(f"Error loading RKNN model: {e}")
            raise

-    @property
-    def device_name(self) -> str:
-        return "RKNN"
-
    def get_input_names(self) -> list[str]:
        """Get input names for the model."""
        # For detection models, we typically use "input" as the default input name
@@ -658,14 +576,6 @@ class RKNNModelRunner(BaseModelRunner):
                pass


-def _record_runner(
-    model_path: str, model_type: str, runner: BaseModelRunner
-) -> BaseModelRunner:
-    """Record the device a freshly loaded runner ended up on."""
-    record_loaded_device(model_path, model_type, runner.device_name)
-    return runner
-
-
 def get_optimized_runner(
    model_path: str, device: str | None, model_type: str, **kwargs
 ) -> BaseModelRunner:
@@ -676,7 +586,7 @@ def get_optimized_runner(
        rknn_path = auto_convert_model(model_path)

        if rknn_path:
-            return _record_runner(model_path, model_type, RKNNModelRunner(rknn_path))
+            return RKNNModelRunner(rknn_path)

    providers, options = get_ort_providers(device == "CPU", device, **kwargs)

@@ -685,11 +595,7 @@ def get_optimized_runner(
        # In other images we will get CUDA / ROCm which are preferred over OpenVINO
        # There is currently no way to prioritize OpenVINO over CUDA / ROCm in these images
        if device != "CPU" and is_openvino_gpu_npu_available():
-            return _record_runner(
-                model_path,
-                model_type,
-                OpenVINOModelRunner(model_path, device, model_type, **kwargs),
-            )
+            return OpenVINOModelRunner(model_path, device, model_type, **kwargs)

    if (
        CudaGraphRunner.is_model_supported(model_type)
@@ -699,17 +605,13 @@ def get_optimized_runner(
            **options[0],
            "enable_cuda_graph": True,
        }
-        return _record_runner(
-            model_path,
-            model_type,
-            CudaGraphRunner(
-                ort.InferenceSession(
-                    model_path,
-                    providers=providers,
-                    provider_options=options,
-                ),
-                options[0]["device_id"],
+        return CudaGraphRunner(
+            ort.InferenceSession(
+                model_path,
+                providers=providers,
+                provider_options=options,
            ),
+            options[0]["device_id"],
        )

    if (
@@ -721,16 +623,14 @@ def get_optimized_runner(
        providers.pop(0)
        options.pop(0)

-    return _record_runner(
-        model_path,
-        model_type,
-        ONNXModelRunner(
-            ort.InferenceSession(
-                model_path,
-                sess_options=get_ort_session_options(model_type),
-                providers=providers,
-                provider_options=options,
+    return ONNXModelRunner(
+        ort.InferenceSession(
+            model_path,
+            sess_options=get_ort_session_options(
+                ONNXModelRunner.is_cpu_complex_model(model_type)
            ),
-            model_type=model_type,
+            providers=providers,
+            provider_options=options,
        ),
+        model_type=model_type,
    )
@@ -10,28 +10,11 @@ from frigate.const import MODEL_CACHE_DIR
 from frigate.detectors.detection_api import DetectionApi
 from frigate.detectors.detector_config import BaseDetectorConfig, ModelTypeEnum
 from frigate.util.model import post_process_yolo
-from frigate.util.runtime_deps import Artifact, ArtifactKind, RuntimeManifest

 logger = logging.getLogger(__name__)

 DETECTOR_KEY = "axengine"

-# The AXEngine python package is installed at first start rather than shipped
-# in the image; its native libraries are bind mounted from the host.
-AXENGINE_VERSION = "0.1.3"
-AXENGINE_MANIFEST = RuntimeManifest(
-    name=DETECTOR_KEY,
-    version=AXENGINE_VERSION,
-    artifacts=(
-        Artifact(
-            url=f"https://github.com/AXERA-TECH/pyaxengine/releases/download/{AXENGINE_VERSION}-frigate/axengine-{AXENGINE_VERSION}-py3-none-any.whl",
-            sha256="e995b8a887b067dc3456512aae2fa9c84f70e708c28b11caf184efdc254c64ae",
-            kind=ArtifactKind.wheel,
-        ),
-    ),
-    import_check="axengine",
-)
-
 supported_models = {
    ModelTypeEnum.yologeneric: "frigate-yolov9-.*$",
 }
@@ -51,18 +34,12 @@ class AxengineDetectorConfig(BaseDetectorConfig):

 class Axengine(DetectionApi):
    type_key = DETECTOR_KEY
-    runtime_manifest = AXENGINE_MANIFEST

    def __init__(self, config: AxengineDetectorConfig):
-        self.activate_dependencies()
-
        try:
            import axengine as axe
        except ModuleNotFoundError:
-            raise ImportError(
-                "AXEngine is not installed. Frigate installs it at startup when an "
-                "axengine detector is configured; check the startup log for errors."
-            ) from None
+            raise ImportError("AXEngine is not installed.") from None

        logger.info("__init__ axengine")
        super().__init__(config)
@@ -16,14 +16,6 @@ from frigate.detectors.detector_config import (
    BaseDetectorConfig,
 )
 from frigate.object_detection.util import RequestStore, ResponseStore
-from frigate.util.runtime_deps import (
-    ArchiveDest,
-    ArchiveMapping,
-    Artifact,
-    ArtifactKind,
-    RuntimeManifest,
-    find_tool,
-)

 logger = logging.getLogger(__name__)

@@ -60,58 +52,11 @@ H8L_DEFAULT_MODEL = "yolov6n.hef"
 H8_DEFAULT_URL = "https://hailo-model-zoo.s3.eu-west-2.amazonaws.com/ModelZoo/Compiled/v2.14.0/hailo8/yolov6n.hef"
 H8L_DEFAULT_URL = "https://hailo-model-zoo.s3.eu-west-2.amazonaws.com/ModelZoo/Compiled/v2.14.0/hailo8l/yolov6n.hef"

-# HailoRT is installed at first start rather than shipped in the image. The
-# tarball carries libhailort and hailortcli, the wheel the python bindings.
-HAILORT_VERSION = "4.21.0"
-HAILORT_RELEASE = (
-    f"https://github.com/frigate-nvr/hailort/releases/download/v{HAILORT_VERSION}"
-)
-HAILORT_MAPPINGS = (
-    ArchiveMapping("rootfs/usr/local/lib/", ArchiveDest.lib),
-    ArchiveMapping("rootfs/usr/local/bin/", ArchiveDest.bin),
-)
-HAILORT_MANIFEST = RuntimeManifest(
-    name=DETECTOR_KEY,
-    version=HAILORT_VERSION,
-    artifacts=(
-        Artifact(
-            url=f"{HAILORT_RELEASE}/hailort-debian12-amd64.tar.gz",
-            sha256="0a57ac5f7cc8c2c3668133189d9285b55f498e8cb219797e203f6f5015fec4b3",
-            kind=ArtifactKind.archive,
-            mappings=HAILORT_MAPPINGS,
-            machines=("x86_64",),
-        ),
-        Artifact(
-            url=f"{HAILORT_RELEASE}/hailort-debian12-arm64.tar.gz",
-            sha256="dd840548eb5d0d147c99aee2cb013d39d64be09c5bc63061171fcfacf4547b3f",
-            kind=ArtifactKind.archive,
-            mappings=HAILORT_MAPPINGS,
-            machines=("aarch64",),
-        ),
-        Artifact(
-            url=f"{HAILORT_RELEASE}/hailort-{HAILORT_VERSION}-cp311-cp311-linux_x86_64.whl",
-            sha256="8112a973ab48095399b29d883f31987828df5861b8553f614c89f098a67b3fb6",
-            kind=ArtifactKind.wheel,
-            machines=("x86_64",),
-        ),
-        Artifact(
-            url=f"{HAILORT_RELEASE}/hailort-{HAILORT_VERSION}-cp311-cp311-linux_aarch64.whl",
-            sha256="658432a43573280d472f6402d7934669effe7f163ba3dffa31c50bbeeaa7c01d",
-            kind=ArtifactKind.wheel,
-            machines=("aarch64",),
-        ),
-    ),
-    preload=(f"libhailort.so.{HAILORT_VERSION}",),
-    import_check="hailo_platform",
-)
-

 def detect_hailo_arch():
    try:
        result = subprocess.run(
-            [find_tool("hailortcli"), "fw-control", "identify"],
-            capture_output=True,
-            text=True,
+            ["hailortcli", "fw-control", "identify"], capture_output=True, text=True
        )
        if result.returncode != 0:
            logger.error(f"Inference error: {result.stderr}")
@@ -151,10 +96,7 @@ class HailoAsyncInference:
                VDevice,
            )
        except ModuleNotFoundError:
-            raise ImportError(
-                "HailoRT is not installed. Frigate installs it at startup when a "
-                "Hailo detector is configured; check the startup log for errors."
-            ) from None
+            pass

        self.input_store = input_store
        self.output_store = output_store
@@ -260,11 +202,9 @@ class HailoAsyncInference:
 # ----------------- HailoDetector Class ----------------- #
 class HailoDetector(DetectionApi):
    type_key = DETECTOR_KEY
-    runtime_manifest = HAILORT_MANIFEST

    def __init__(self, detector_config: "HailoDetectorConfig"):
        global ARCH
-        self.activate_dependencies()
        ARCH = detect_hailo_arch()
        self.cache_dir = MODEL_CACHE_DIR
        self.device_type = detector_config.device
@@ -18,58 +18,11 @@ from frigate.detectors.detector_config import (
 )
 from frigate.util.file import FileLock
 from frigate.util.model import xyxy_to_xywh_for_nms
-from frigate.util.runtime_deps import (
-    ArchiveDest,
-    ArchiveMapping,
-    Artifact,
-    ArtifactKind,
-    RuntimeManifest,
-)

 logger = logging.getLogger(__name__)

 DETECTOR_KEY = "memryx"

-# The MemryX SDK is installed at first start rather than shipped in the image.
-# The release archive holds the python package with its compiled extensions
-# and, per architecture, the shared libraries they link against. libmemx has
-# no SONAME, so the libraries are resolved through LD_LIBRARY_PATH.
-MEMRYX_VERSION = "2.1.0"
-MEMRYX_ARCHIVE_ROOT = f"mx_accl_frigate-{MEMRYX_VERSION}/memryx/"
-MEMRYX_LIBS = ("libmemx.so*", "libmx_accl.so*")
-MEMRYX_MANIFEST = RuntimeManifest(
-    name=DETECTOR_KEY,
-    version=MEMRYX_VERSION,
-    artifacts=(
-        Artifact(
-            url=f"https://github.com/memryx/mx_accl_frigate/archive/refs/tags/v{MEMRYX_VERSION}.zip",
-            sha256="54d1971dee54688541561b7bd9136342be51707b68c11a2a5e575fa19e69bc51",
-            kind=ArtifactKind.archive,
-            filename=f"mx_accl_frigate-{MEMRYX_VERSION}.zip",
-            mappings=(
-                ArchiveMapping(
-                    MEMRYX_ARCHIVE_ROOT, ArchiveDest.site_packages, subdir="memryx"
-                ),
-                ArchiveMapping(
-                    f"{MEMRYX_ARCHIVE_ROOT}x86/",
-                    ArchiveDest.lib,
-                    include=MEMRYX_LIBS,
-                    machines=("x86_64",),
-                ),
-                ArchiveMapping(
-                    f"{MEMRYX_ARCHIVE_ROOT}arm/",
-                    ArchiveDest.lib,
-                    include=MEMRYX_LIBS,
-                    machines=("aarch64",),
-                ),
-            ),
-        ),
-    ),
-    preload=("libmemx.so", "libmx_accl.so.2"),
-    import_check="memryx",
-    needs_ld_library_path=True,
-)
-

 # Configuration class for model settings
 class ModelConfig(BaseModel):
@@ -103,20 +56,17 @@ class MemryXDetector(DetectionApi):
        ModelTypeEnum.yologeneric,  # Treated as yolov9 in MemryX implementation
        ModelTypeEnum.yolox,
    ]
-    runtime_manifest = MEMRYX_MANIFEST

    def __init__(self, detector_config):
        """Initialize MemryX detector with the provided configuration."""
-        self.activate_dependencies()
-
        try:
            # Import MemryX SDK
            from memryx import AsyncAccl
        except ModuleNotFoundError:
            raise ImportError(
-                "MemryX SDK is not installed. Frigate installs it at startup when "
-                "a MemryX detector is configured; check the startup log for errors."
+                "MemryX SDK is not installed. Install it and set up MIX environment."
            ) from None
+            return

        # Initialize stop_event as None, will be set later by set_stop_event()
        self.stop_event = None
@@ -128,7 +78,7 @@ class MemryXDetector(DetectionApi):
            detector_config.model.model_type = model_cfg.model_type
        else:
            logger.info(
-                "model_type not set in config, defaulting to yolonas for MemryX"
+                "model_type not set in config — defaulting to yolonas for MemryX."
            )
            detector_config.model.model_type = ModelTypeEnum.yolonas

@@ -334,9 +334,3 @@ class EmbeddingsContext:
            EmbeddingsRequestEnum.summarize_review.value,
            {"start_ts": start_ts, "end_ts": end_ts},
        )
-
-    def regenerate_review_description(self, review_id: str) -> None:
-        self.requestor.send_data(
-            EmbeddingsRequestEnum.regenerate_review_description.value,
-            {"review_id": review_id},
-        )
@@ -60,8 +60,6 @@ from frigate.data_processing.real_time.license_plate import (
 )
 from frigate.data_processing.types import DataProcessorMetrics, PostProcessDataEnum
 from frigate.db.sqlitevecq import SqliteVecQueueDatabase
-from frigate.detectors.detection_runners import snapshot_loaded_devices
-from frigate.embeddings.types import fold_runtime_devices
 from frigate.events.types import (
    EventStateEnum,
    EventTypeEnum,
@@ -103,7 +101,6 @@ class EmbeddingMaintainer(threading.Thread):
        super().__init__(name="embeddings_maintainer")
        self.config = config
        self.metrics = metrics
-        self._published_devices: dict[str, str] = {}
        self.embeddings = None
        self.config_updater = CameraConfigUpdateSubscriber(
            self.config,
@@ -340,7 +337,6 @@ class EmbeddingMaintainer(threading.Thread):
            self._expire_dedicated_lpr()
            self._process_finalized()
            self._process_event_metadata()
-            self._publish_runtime_devices()

        # Shutdown deferred processors
        for processor in self.realtime_processors:
@@ -742,19 +738,6 @@ class EmbeddingMaintainer(threading.Thread):
                if isinstance(processor, ReviewDescriptionProcessor):
                    processor.process_data(review_updates, PostProcessDataEnum.review)

-    def _publish_runtime_devices(self) -> None:
-        """Push each enrichment's loaded device to the shared metrics dict.
-
-        Runs every loop iteration, so only changed entries cross the manager
-        boundary.
-        """
-        for enrichment, device in fold_runtime_devices(
-            snapshot_loaded_devices()
-        ).items():
-            if self._published_devices.get(enrichment) != device:
-                self.metrics.runtime_devices[enrichment] = device
-                self._published_devices[enrichment] = device
-
    def _process_event_metadata(self):
        # Check for regenerate description requests
        (topic, payload) = self.event_metadata_subscriber.check_for_update()
@@ -6,10 +6,7 @@ import os
 import numpy as np

 from frigate.const import MODEL_CACHE_DIR
-from frigate.detectors.detection_runners import (
-    get_optimized_runner,
-    record_loaded_device,
-)
+from frigate.detectors.detection_runners import get_optimized_runner
 from frigate.embeddings.types import EnrichmentModelTypeEnum
 from frigate.log import suppress_stderr_during
 from frigate.util.downloader import ModelDownloader
@@ -65,18 +62,13 @@ class FaceNetEmbedding(BaseEmbedding):
            if self.downloader:
                self.downloader.wait_for_download()

-            model_path = os.path.join(MODEL_CACHE_DIR, "facedet/facenet.tflite")
-
            # Suppress TFLite delegate creation messages that bypass Python logging
            with suppress_stderr_during("tflite_interpreter_init"):
-                self.runner = Interpreter(model_path=model_path, num_threads=2)
+                self.runner = Interpreter(
+                    model_path=os.path.join(MODEL_CACHE_DIR, "facedet/facenet.tflite"),
+                    num_threads=2,
+                )
                self.runner.allocate_tensors()
-
-            # tflite never goes through get_optimized_runner, so the small face
-            # model would otherwise never report a device
-            record_loaded_device(
-                model_path, EnrichmentModelTypeEnum.facenet.value, "CPU"
-            )
            self.tensor_input_details = self.runner.get_input_details()
            self.tensor_output_details = self.runner.get_output_details()

@@ -13,37 +13,3 @@ class EnrichmentModelTypeEnum(str, Enum):
    jina_v2 = "jina_v2"
    paddleocr = "paddleocr"
    yolov9_license_plate = "yolov9_license_plate"
-
-
-# which enrichment each model type belongs to; the single place this lives
-ENRICHMENT_FOR_MODEL_TYPE: dict[str, str] = {
-    EnrichmentModelTypeEnum.arcface.value: "face_recognition",
-    EnrichmentModelTypeEnum.facenet.value: "face_recognition",
-    EnrichmentModelTypeEnum.jina_v1.value: "semantic_search",
-    EnrichmentModelTypeEnum.jina_v2.value: "semantic_search",
-    EnrichmentModelTypeEnum.paddleocr.value: "lpr",
-    EnrichmentModelTypeEnum.yolov9_license_plate.value: "lpr",
-}
-
-
-def fold_runtime_devices(loaded: dict[str, tuple[str, str]]) -> dict[str, str]:
-    """One device per enrichment from the per model registry.
-
-    A non CPU device wins so a model pinned to the CPU on purpose (the Jina V1
-    text model) does not hide the accelerator its sibling loaded on, while an
-    enrichment whose models all fell back to the CPU still reports CPU.
-    """
-    folded: dict[str, str] = {}
-
-    for model_type, device in loaded.values():
-        enrichment = ENRICHMENT_FOR_MODEL_TYPE.get(model_type)
-
-        if enrichment is None:
-            continue
-
-        current = folded.get(enrichment)
-
-        if current is None or ("CPU" in current and "CPU" not in device):
-            folded[enrichment] = device
-
-    return folded
@@ -104,7 +104,6 @@ class GenAIClient:
        preferred_language: str | None,
        debug_save: bool,
        activity_context_prompt: str,
-        response_style: str = "default",
    ) -> ReviewMetadata | None:
        """Generate a description for the review item activity."""
        context_prompt = build_review_description_prompt(
@@ -113,7 +112,6 @@ class GenAIClient:
            concerns,
            preferred_language,
            activity_context_prompt,
-            response_style,
        )

        logger.debug(
@@ -110,28 +110,6 @@ class GenAIClientManager:
        name = self._role_map.get(GenAIRoleEnum.embeddings)
        return self._get_client(name) if name else None

-    def role_info(self) -> dict[str, dict[str, Any]]:
-        """Return the model selected for each configured role and its context size.
-
-        Only reads state the client saved when it initialized, so unlike
-        list_models() this does not ask the provider for its catalog.
-        """
-        result: dict[str, dict[str, Any]] = {}
-
-        for role, name in self._role_map.items():
-            client = self._get_client(name)
-
-            if not client:
-                continue
-
-            result[role.value] = {
-                "name": name,
-                "model": self._configs[name].model,
-                "context_size": client.get_context_size(),
-            }
-
-        return result
-
    def list_models(self) -> dict[str, dict[str, Any]]:
        """Return per-entry model lists and capabilities, keyed by config entry name."""
        result: dict[str, dict[str, Any]] = {}
@@ -16,48 +16,6 @@ from frigate.config.ui import UnitSystemEnum
 from frigate.data_processing.post.types import ReviewMetadata
 from frigate.models import Event

-# Base guidance per response field. `observations` is a reasoning scaffold,
-# not user-facing, so style presets never override it.
-REVIEW_DESCRIPTION_FIELD_GUIDELINES: dict[str, str] = {
-    "observations": "Include the very start of the activity — for example, a vehicle entering the frame or pulling into the driveway — even if it lasts only a few frames and the rest of the clip is dominated by a longer activity. Include each arrival, departure, object handled, and notable change in position or state. Each item is a single concrete fact written as a complete sentence.",
-    "scene": 'Describe how the sequence begins, then the progression of events — all significant movements and actions in order. For example, if a vehicle arrives and then a person exits, describe both sequentially. For named subjects (those with a `←` separator in "Objects in Scene"), always use their name — do not replace them with generic terms. For unnamed objects (e.g., "person", "car"), refer to them naturally with articles (e.g., "a person", "the car"). Your description should align with and support the threat level you assign.',
-    "title": "Name the primary activity across the observations, together with the location. An activity is what is being done with objects, tools, or surfaces; locomotion through the scene qualifies as the activity only when no other interaction is observed. For named subjects, always use their name. For unnamed objects, refer to them naturally with articles.",
-    "shortSummary": "Briefly summarize the primary activity across the observations.",
-    "potential_threat_level": "Must be consistent with your scene description and the activity patterns above.",
-}
-
-# Style presets keyed by ReviewResponseStyleEnum value. Presets replace the
-# base guidance rather than append to it, so the prompt never carries
-# competing style instructions.
-REVIEW_RESPONSE_STYLES: dict[str, dict[str, str]] = {
-    "natural": {
-        "scene": 'Recount what happened the way a person would describe it to a neighbor, in plain everyday language: how the sequence begins, then each significant movement and action in the order it happens. Use flowing sentences that connect related actions, written the way people actually talk rather than like a surveillance report. For named subjects (those with a `←` separator in "Objects in Scene"), always use their name rather than a generic term. Refer to unnamed objects naturally with articles. Stay factual, and keep the description consistent with the threat level you assign.',
-        "title": 'Write the title as a short, sentence-case headline in present tense: the subject, then what they do, phrased the way you would text it to the homeowner. Describe only the action you see; do not assign the person a role or purpose that is not visibly indicated by a uniform, a marked vehicle, or a "(delivery/service)" tag in Objects in Scene. Name the main thing done, not just movement through the scene, unless movement is all that happens. For named subjects, always use their name.',
-        "shortSummary": "Sum up the primary activity in one short, natural sentence, as if mentioning it to someone in passing.",
-    },
-    "concise": {
-        "scene": 'Cover each significant movement and action in order using as few short, direct sentences as possible, omitting environmental and cosmetic detail unless it affects the assessment. For named subjects (those with a `←` separator in "Objects in Scene"), always use their name. For unnamed objects, refer to them naturally with articles. Your description should align with and support the threat level you assign.',
-        "title": 'Write the title as a terse label of two to four words naming the specific activity observed and where it happened. Do not assign a role or purpose that is not visibly indicated by a uniform, a marked vehicle, or a "(delivery/service)" tag in Objects in Scene. For named subjects, always use their name.',
-        "shortSummary": "Summarize the primary activity in one short sentence.",
-    },
-    "detailed": {
-        "scene": 'Describe how the sequence begins, then the progression of events — all significant movements and actions in order, including the specifics that best identify the subjects: colors, clothing, carried items, positions, and paths of movement, plus environmental details like lighting changes when they stand out. Favor the most identifying details over exhaustive coverage, and keep every added detail observational rather than speculative. For named subjects (those with a `←` separator in "Objects in Scene"), always use their name rather than a generic term. For unnamed objects, refer to them naturally with articles. Your description should align with and support the threat level you assign.',
-        "title": 'Write the title as a specific description of who did what and where, in under roughly twelve words, including the most distinguishing visible detail of the subject, such as clothing or vehicle color. Do not assign a role or purpose that is not visibly indicated by a uniform, a marked vehicle, or a "(delivery/service)" tag in Objects in Scene. Name the main thing done, not just movement through the scene, unless movement is all that happens. For named subjects, always use their name.',
-        "shortSummary": "Briefly summarize the primary activity across the observations, including the most identifying visible detail, such as vehicle color or clothing.",
-    },
-}
-
-
-def get_review_field_guidelines(response_style: str = "default") -> dict[str, str]:
-    """Return per-field response guidance with the style preset applied.
-
-    "default" (or an unknown value) applies no overrides.
-    """
-    return {
-        **REVIEW_DESCRIPTION_FIELD_GUIDELINES,
-        **REVIEW_RESPONSE_STYLES.get(response_style, {}),
-    }
-

 def build_review_description_prompt(
    review_data: dict[str, Any],
@@ -65,7 +23,6 @@ def build_review_description_prompt(
    concerns: list[str],
    preferred_language: str | None,
    activity_context_prompt: str,
-    response_style: str = "default",
 ) -> str:
    """Build the prompt for review activity description generation."""

@@ -92,8 +49,6 @@ def build_review_description_prompt(
        else:
            return "\n- (No objects detected)"

-    fields = get_review_field_guidelines(response_style)
-
    return f"""
 Your task is to analyze a sequence of images taken in chronological order from a security camera.

@@ -120,11 +75,11 @@ When forming your description:
 ## Response Field Guidelines

 Respond with a JSON object matching the provided schema. Field-specific guidance:
- `observations`: {fields["observations"]}
- `scene`: {fields["scene"]}
- `title`: {fields["title"]}
- `shortSummary`: {fields["shortSummary"]}
- `potential_threat_level`: {fields["potential_threat_level"]}
+- `observations`: Include the very start of the activity — for example, a vehicle entering the frame or pulling into the driveway — even if it lasts only a few frames and the rest of the clip is dominated by a longer activity. Include each arrival, departure, object handled, and notable change in position or state. Each item is a single concrete fact written as a complete sentence.
+- `scene`: Describe how the sequence begins, then the progression of events — all significant movements and actions in order. For example, if a vehicle arrives and then a person exits, describe both sequentially. For named subjects (those with a `←` separator in "Objects in Scene"), always use their name — do not replace them with generic terms. For unnamed objects (e.g., "person", "car"), refer to them naturally with articles (e.g., "a person", "the car"). Your description should align with and support the threat level you assign.
+- `title`: Name the primary activity across the observations, together with the location. An activity is what is being done with objects, tools, or surfaces; locomotion through the scene qualifies as the activity only when no other interaction is observed. For named subjects, always use their name. For unnamed objects, refer to them naturally with articles.
+- `shortSummary`: Briefly summarize the primary activity across the observations.
+- `potential_threat_level`: Must be consistent with your scene description and the activity patterns above.
 {get_concern_prompt()}

 ## Sequence Details
@@ -311,10 +266,6 @@ def get_tool_definitions(
    Descriptions here stay mechanical: which tool to reach for, and how the
    filters relate to each other, is stated once in the system prompt so the
    guidance is not paid for twice on every request.
-
-    Each definition carries a Frigate-only `access` field ("read" or "write");
-    write tools pause for user approval in the chat loop. Strip it with
-    `strip_tool_access` before sending the list to a provider.
    """
    search_objects_properties: dict[str, Any] = {
        "camera": {
@@ -386,7 +337,6 @@ def get_tool_definitions(
    return [
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "search_objects",
                "description": search_objects_description,
@@ -399,7 +349,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "get_categorized_object_names",
                "description": (
@@ -417,7 +366,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "find_similar_objects",
                "description": (
@@ -481,7 +429,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "write",
            "function": {
                "name": "set_camera_state",
                "description": (
@@ -537,7 +484,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "get_live_context",
                "description": (
@@ -562,7 +508,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "write",
            "function": {
                "name": "start_camera_watch",
                "description": (
@@ -606,7 +551,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "write",
            "function": {
                "name": "stop_camera_watch",
                "description": "Cancel the currently running watch job.",
@@ -619,7 +563,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "get_profile_status",
                "description": (
@@ -636,7 +579,6 @@ def get_tool_definitions(
        },
        {
            "type": "function",
-            "access": "read",
            "function": {
                "name": "get_recap",
                "description": (
@@ -669,120 +611,9 @@ def get_tool_definitions(
                },
            },
        },
-        {
-            "type": "function",
-            "access": "read",
-            "function": {
-                "name": "get_export_cases",
-                "description": (
-                    "List the export cases (named groups of exported clips) with "
-                    "their IDs, descriptions, and how many exports each holds. "
-                    "Call this before create_export when the user wants a clip "
-                    "added to an existing case."
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {},
-                    "required": [],
-                },
-            },
-        },
-        {
-            "type": "function",
-            "access": "write",
-            "function": {
-                "name": "create_export",
-                "description": (
-                    "Export a camera's recording for a time range to a "
-                    "downloadable file, optionally attached to an existing export "
-                    "case. Only call this when the user explicitly asks to export "
-                    "or save a clip."
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "camera": {
-                            "type": "string",
-                            "description": "Camera ID to export from.",
-                        },
-                        "start_time": {
-                            "type": "string",
-                            "description": "Start of the clip in ISO 8601 format (e.g. '2025-03-15T08:00:00').",
-                        },
-                        "end_time": {
-                            "type": "string",
-                            "description": "End of the clip in ISO 8601 format (e.g. '2025-03-15T08:05:00').",
-                        },
-                        "name": {
-                            "type": "string",
-                            "description": "Friendly name for the export (optional).",
-                        },
-                        "source": {
-                            "type": "string",
-                            "enum": ["recordings", "preview"],
-                            "description": (
-                                "'recordings' (default) exports full-quality footage; "
-                                "'preview' builds a low-resolution timelapse."
-                            ),
-                            "default": "recordings",
-                        },
-                        "export_case_id": {
-                            "type": "string",
-                            "description": (
-                                "ID of an existing export case to attach the export "
-                                "to. Use get_export_cases to find it."
-                            ),
-                        },
-                    },
-                    "required": ["camera", "start_time", "end_time"],
-                },
-            },
-        },
-        {
-            "type": "function",
-            "access": "read",
-            "function": {
-                "name": "get_event_image",
-                "description": (
-                    "View the thumbnail or snapshot image of a specific tracked "
-                    "object so you can describe what it shows. Use the event id "
-                    "from search_objects, find_similar_objects, or an attached "
-                    "event."
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "event_id": {
-                            "type": "string",
-                            "description": "ID of the tracked object to view.",
-                        },
-                        "image": {
-                            "type": "string",
-                            "enum": ["thumbnail", "snapshot"],
-                            "description": (
-                                "'thumbnail' (default) is a small crop of the object; "
-                                "'snapshot' is the full camera frame."
-                            ),
-                            "default": "thumbnail",
-                        },
-                    },
-                    "required": ["event_id"],
-                },
-            },
-        },
    ]


-def get_write_tool_names(tools: list[dict[str, Any]]) -> set[str]:
-    """Names of the tools whose `access` is "write" (they change state)."""
-    return {tool["function"]["name"] for tool in tools if tool.get("access") == "write"}
-
-
-def strip_tool_access(tools: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Drop the Frigate-only `access` field before handing tools to a provider."""
-    return [{k: v for k, v in tool.items() if k != "access"} for tool in tools]
-
-
 def build_chat_system_prompt(
    config: FrigateConfig,
    allowed_cameras: list[str],
@@ -18,11 +18,7 @@ from frigate.config.camera.record import ChaptersEnum
 from frigate.const import UPDATE_JOB_STATE
 from frigate.jobs.job import Job
 from frigate.models import Export
-from frigate.record.export import (
-    ExportStreamEnum,
-    PlaybackSourceEnum,
-    RecordingExporter,
-)
+from frigate.record.export import PlaybackSourceEnum, RecordingExporter
 from frigate.types import JobStatusTypesEnum

 logger = logging.getLogger(__name__)
@@ -62,7 +58,6 @@ class ExportJob(Job):
    ffmpeg_output_args: str | None = None
    cpu_fallback: bool = False
    chapters: ChaptersEnum | None = None
-    stream: ExportStreamEnum = ExportStreamEnum.auto
    current_step: str = "queued"
    progress_percent: float = 0.0

@@ -352,7 +347,6 @@ class ExportJobManager:
            job.ffmpeg_output_args,
            job.cpu_fallback,
            job.chapters,
-            job.stream,
            on_progress=self._make_progress_callback(job),
        )

@@ -183,25 +183,3 @@ class Trigger(Model):

    class Meta:
        primary_key = CompositeKey("camera", "name")
-
-
-class Notice(Model):
-    id = CharField(null=False, primary_key=True, max_length=150)
-    kind = CharField(index=True, max_length=50)
-    scope = CharField(max_length=100, null=True)
-    params = JSONField()
-    first_seen = DateTimeField()
-    last_seen = DateTimeField()
-    count = IntegerField(default=1)
-    dismissed_at = DateTimeField(null=True)
-
-
-class NoticeStats(Model):
-    kind = CharField(null=False, primary_key=True, max_length=50)
-    occurrences = IntegerField(default=0)
-    dismissals = IntegerField(default=0)
-    first_seen = DateTimeField()
-    last_seen = DateTimeField()
-    # watermarks for a future analytics reporter; unused until then
-    reported_occurrences = IntegerField(default=0)
-    reported_dismissals = IntegerField(default=0)
@@ -1,263 +0,0 @@
-"""Registry of active notices and per-kind occurrence counts."""
-
-import logging
-import threading
-from collections.abc import Callable
-from datetime import datetime
-from enum import Enum
-from typing import Any
-
-from frigate.const import REPLAY_CAMERA_PREFIX
-from frigate.models import Notice, NoticeStats
-from frigate.notices.types import (
-    NOTICE_KINDS,
-    SEVERITY_ORDER,
-    NoticeMode,
-    notice_id,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class DismissResult(str, Enum):
-    ok = "ok"
-    not_found = "not_found"
-    not_dismissable = "not_dismissable"
-
-
-# last_seen value of a state notice that has not been raised since startup
-UNCONFIRMED = 0
-
-
-class NoticeRegistry:
-    """Owns the notice tables. Lives in the main process only.
-
-    Producers in the main process call it directly. Other processes send an
-    update_notice request that the dispatcher forwards here. The FastAPI app
-    runs inside the main process too, so the API's dismiss shares this exact
-    object, its lock, and its listeners.
-    """
-
-    def __init__(self) -> None:
-        self._lock = threading.Lock()
-        self._listeners: list[Callable[[], None]] = []
-
-    def subscribe(self, listener: Callable[[], None]) -> None:
-        """Call listener after every change to the active list."""
-        self._listeners.append(listener)
-
-    def _notify(self) -> None:
-        for listener in self._listeners:
-            try:
-                listener()
-            except Exception:
-                logger.exception("Notice listener failed")
-
-    def raise_notice(
-        self,
-        kind: str,
-        *,
-        scope: str | None = None,
-        params: dict[str, Any] | None = None,
-    ) -> None:
-        """Insert or update a notice. See the counting rule in the spec."""
-        definition = NOTICE_KINDS.get(kind)
-
-        if definition is None:
-            logger.warning("Ignoring notice of unknown kind %s", kind)
-            return
-
-        if (
-            definition.category == "camera"
-            and scope
-            and scope.startswith(REPLAY_CAMERA_PREFIX)
-        ):
-            return
-
-        now = datetime.now().timestamp()
-        row_id = notice_id(kind, scope)
-        params = params or {}
-
-        with self._lock:
-            existing = Notice.get_or_none(Notice.id == row_id)
-
-            if existing is None:
-                Notice.create(
-                    id=row_id,
-                    kind=kind,
-                    scope=scope,
-                    params=params,
-                    first_seen=now,
-                    last_seen=now,
-                    count=1,
-                    dismissed_at=None,
-                )
-                self._bump_occurrences(kind, now)
-            elif definition.mode == NoticeMode.event:
-                Notice.update(
-                    count=Notice.count + 1,
-                    last_seen=now,
-                    params=params,
-                    dismissed_at=None,
-                ).where(Notice.id == row_id).execute()
-                self._bump_occurrences(kind, now)
-            else:
-                # one episode counts once; a repeat with nothing new is free
-                confirmed = existing.last_seen != UNCONFIRMED
-
-                if confirmed and existing.params == params:
-                    return
-
-                Notice.update(last_seen=now, params=params).where(
-                    Notice.id == row_id
-                ).execute()
-
-        self._notify()
-
-    def resolve(self, kind: str, scope: str | None = None) -> None:
-        """Delete a notice if present. Safe to call when it is absent."""
-        with self._lock:
-            deleted = (
-                Notice.delete().where(Notice.id == notice_id(kind, scope)).execute()
-            )
-
-        if deleted:
-            self._notify()
-
-    def resolve_camera(self, camera: str) -> None:
-        """Drop every camera-category notice scoped to a camera being deleted."""
-        camera_kinds = [
-            key
-            for key, definition in NOTICE_KINDS.items()
-            if definition.category == "camera"
-        ]
-
-        with self._lock:
-            deleted = (
-                Notice.delete()
-                .where(
-                    Notice.kind.in_(camera_kinds),  # type: ignore[call-arg, arg-type, misc]
-                    Notice.scope == camera,
-                )
-                .execute()
-            )
-
-        if deleted:
-            self._notify()
-
-    def dismiss(self, row_id: str) -> DismissResult:
-        """Hide an event notice until it is raised again."""
-        with self._lock:
-            existing = Notice.get_or_none(Notice.id == row_id)
-
-            if existing is None:
-                return DismissResult.not_found
-
-            definition = NOTICE_KINDS.get(existing.kind)
-
-            if definition is None or definition.mode == NoticeMode.state:
-                return DismissResult.not_dismissable
-
-            now = datetime.now().timestamp()
-            Notice.update(dismissed_at=now).where(Notice.id == row_id).execute()
-            NoticeStats.update(dismissals=NoticeStats.dismissals + 1).where(
-                NoticeStats.kind == existing.kind
-            ).execute()
-
-        self._notify()
-        return DismissResult.ok
-
-    def active(self, include_dismissed: bool = False) -> list[dict[str, Any]]:
-        """The active notices, most severe first, then most recent first."""
-        rows = []
-
-        for row in Notice.select():
-            definition = NOTICE_KINDS.get(row.kind)
-
-            if definition is None:
-                continue
-
-            if row.dismissed_at is not None and not include_dismissed:
-                continue
-
-            if definition.mode == NoticeMode.state and row.last_seen == UNCONFIRMED:
-                continue
-
-            rows.append(
-                {
-                    "id": row.id,
-                    "kind": row.kind,
-                    "mode": definition.mode.value,
-                    "severity": definition.severity.value,
-                    "category": definition.category,
-                    "scope": row.scope,
-                    "params": row.params,
-                    "first_seen": row.first_seen,
-                    "last_seen": row.last_seen,
-                    "count": row.count,
-                    "dismissed_at": row.dismissed_at,
-                }
-            )
-
-        rows.sort(
-            key=lambda n: (
-                SEVERITY_ORDER[NOTICE_KINDS[n["kind"]].severity],
-                -n["last_seen"],
-            )
-        )
-        return rows
-
-    def stats(self) -> list[dict[str, Any]]:
-        """Lifetime counts per kind, for the UI meta line and later analytics."""
-        return [
-            {
-                "kind": row.kind,
-                "occurrences": row.occurrences,
-                "dismissals": row.dismissals,
-                "first_seen": row.first_seen,
-                "last_seen": row.last_seen,
-                "reported_occurrences": row.reported_occurrences,
-                "reported_dismissals": row.reported_dismissals,
-            }
-            for row in NoticeStats.select()
-            if row.kind in NOTICE_KINDS
-        ]
-
-    def mark_state_notices_unconfirmed(self) -> None:
-        """Hide state notices until their producer raises them again.
-
-        Rows already unconfirmed from the previous run are deleted. Hiding
-        rather than deleting keeps one episode that spans a restart at one
-        occurrence.
-        """
-        state_kinds = [
-            key
-            for key, definition in NOTICE_KINDS.items()
-            if definition.mode == NoticeMode.state
-        ]
-
-        with self._lock:
-            Notice.delete().where(
-                Notice.kind.in_(state_kinds),  # type: ignore[call-arg, arg-type, misc]
-                Notice.last_seen == UNCONFIRMED,
-            ).execute()
-            Notice.update(last_seen=UNCONFIRMED).where(
-                Notice.kind.in_(state_kinds)  # type: ignore[call-arg, arg-type, misc]
-            ).execute()
-
-    def _bump_occurrences(self, kind: str, now: float) -> None:
-        # called with the lock held
-        stats = NoticeStats.get_or_none(NoticeStats.kind == kind)
-
-        if stats is None:
-            NoticeStats.create(
-                kind=kind,
-                occurrences=1,
-                dismissals=0,
-                first_seen=now,
-                last_seen=now,
-            )
-        else:
-            NoticeStats.update(
-                occurrences=NoticeStats.occurrences + 1, last_seen=now
-            ).where(NoticeStats.kind == kind).execute()
@@ -1,63 +0,0 @@
-"""Notice kinds and the definitions that fix their mode, severity, and category."""
-
-from dataclasses import dataclass
-from enum import Enum
-
-
-class NoticeMode(str, Enum):
-    """Whether a producer resolves the notice itself or the user dismisses it."""
-
-    state = "state"
-    event = "event"
-
-
-class NoticeSeverity(str, Enum):
-    error = "error"
-    warning = "warning"
-    info = "info"
-
-
-SEVERITY_ORDER: dict[NoticeSeverity, int] = {
-    NoticeSeverity.error: 0,
-    NoticeSeverity.warning: 1,
-    NoticeSeverity.info: 2,
-}
-
-
-@dataclass(frozen=True)
-class NoticeKind:
-    """One kind of notice. Producers pass the key; everything else comes from here.
-
-    Attributes:
-        key: Stable machine-readable name, also the translation key suffix
-        mode: state notices are resolved by their producer, event notices by the user
-        severity: error, warning, or info
-        category: what the scope names: camera, detector, and model kinds carry a scope
-        reportable: whether a future analytics reporter may send this kind's counts
-    """
-
-    key: str
-    mode: NoticeMode
-    severity: NoticeSeverity
-    category: str
-    reportable: bool = True
-
-
-SCOPED_CATEGORIES = frozenset({"camera", "detector", "model"})
-
-_KINDS = (
-    NoticeKind("ffmpeg_crash_loop", NoticeMode.state, NoticeSeverity.error, "camera"),
-    NoticeKind("detector_stuck", NoticeMode.event, NoticeSeverity.warning, "detector"),
-    NoticeKind(
-        "model_download_failed", NoticeMode.event, NoticeSeverity.error, "model"
-    ),
-    NoticeKind("retention_unmet", NoticeMode.state, NoticeSeverity.error, "storage"),
-    NoticeKind("update_available", NoticeMode.state, NoticeSeverity.info, "system"),
-)
-
-NOTICE_KINDS: dict[str, NoticeKind] = {kind.key: kind for kind in _KINDS}
-
-
-def notice_id(kind: str, scope: str | None) -> str:
-    """The row id for a kind and optional scope."""
-    return f"{kind}:{scope}" if scope else kind
@@ -353,23 +353,9 @@ class ObjectDetectProcess:
        logging.info("Detection process has exited...")

    def start_or_restart(self) -> None:
-        if (self.detect_process is not None) and self.detect_process.is_alive():
-            logging.info("Waiting for detection process to exit gracefully...")
-            self.detect_process.join(timeout=30)
-            if self.detect_process.exitcode is None:
-                # detection_start is set only after detection_queue.get()
-                # returns. If it was reset during the grace period, the process
-                # recovered and may be waiting on the shared queue again.
-                if self.detection_start.value == 0.0:  # type: ignore[attr-defined]
-                    logging.info("Detection process recovered before restart")
-                    return
-
-                logging.info("Detection process didn't exit. Force killing...")
-                self.detect_process.kill()
-                self.detect_process.join()
-            logging.info("Detection process has exited...")
-
        self.detection_start.value = 0.0  # type: ignore[attr-defined]
+        if (self.detect_process is not None) and self.detect_process.is_alive():
+            self.stop()

        # Async path for MemryX
        if self.detector_config.type == "memryx":
@@ -23,7 +23,6 @@ from frigate.ffmpeg_presets import (
 )
 from frigate.models import Previews
 from frigate.util.image import copy_yuv_to_position, get_blank_yuv_frame, get_yuv_crop
-from frigate.util.ownership import chown_to_runtime

 logger = logging.getLogger(__name__)

@@ -186,7 +185,6 @@ class FFMpegConverter(threading.Thread):

        if p.returncode == 0:
            logger.debug("successfully saved preview")
-            chown_to_runtime(self.path)
            self.requestor.send_data(
                INSERT_PREVIEW,
                {