Merge remote-tracking branch 'origin/main' into telemetry/grafana_dashboards_optimizations

# Conflicts:
#	telemtry/analysis/database/dashboards/orion/retrospect/chassis_suspension.json
#	telemtry/analysis/database/dashboards/orion/retrospect/driver_inputs.json

Author: cyberneel

.github/workflows/postsubmit.yml

@@ -50,6 +50,7 @@ jobs:
           docker network create telemetry_network || true
           docker volume create grafana_storage || true
           docker volume create telemetry_db || true
+          docker volume create kafka_data || true
 
       - name: Create .env file for Docker
         run: |

.github/workflows/presubmit.yml

@@ -37,6 +37,7 @@ jobs:
           docker network create telemetry_network || true
           docker volume create grafana_storage || true
           docker volume create telemetry_db || true
+          docker volume create kafka_data || true
 
       - name: Create .env file for Docker
         run: |

.github/workflows/schema-drift.yml

@@ -0,0 +1,108 @@
+name: schema-drift
+run-name: Schema codegen drift check (${{ github.actor }})
+
+# Regenerates every schema/CAN artifact from its source (can_packets.csv +
+# can_packets.proto) and fails if the committed artifacts are out of sync.
+# This makes schema / telemetry-signal updates dead-easy: change the source,
+# run the generators, commit — and CI guarantees nothing drifts.
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+    paths:
+      - 'drivers/longhorn-lib/config/**'
+      - 'drivers/longhorn-lib/protobuf/**'
+      - 'drivers/longhorn-lib/scripts/**'
+      - 'telemtry/scripts/**'
+      - 'telemtry/stack/ingest/**'
+      - 'telemtry/stack/kafka/proto/**'
+      - 'telemtry/analysis/database/viewer_tool/prisma/**'
+      - 'telemtry/analysis/database/viewer_tool/protobuf/**'
+      - 'telemtry/analysis/sql_utils/models.py'
+      - 'BEVO/nonhermetic/assets/**'
+      - 'BEVO/codegen.py'
+      - 'BEVO/generated_mapping.rs'
+      - 'BEVO/loggerd/**'
+      - 'BEVO/config.rs'
+      - '.github/workflows/schema-drift.yml'
+  workflow_dispatch:
+
+jobs:
+  schema-drift:
+    name: Schema codegen drift check
+    runs-on: ubuntu-latest
+    env:
+      PYTHONDONTWRITEBYTECODE: "1"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install protoc + python deps
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y protobuf-compiler
+          python -m pip install --upgrade pip
+          python -m pip install "protobuf>=6,<7"
+
+      - name: Regenerate all schema artifacts from source
+        env:
+          BUILD_WORKSPACE_DIRECTORY: ${{ github.workspace }}
+        run: |
+          set -euxo pipefail
+          # CSV -> proto (assigns/back-annotates stable proto field ids)
+          python3 drivers/longhorn-lib/scripts/update_can_proto.py
+          # CSV -> can.json + descriptor + Rust mapping
+          bash BEVO/nonhermetic/sync_assets.sh
+          # proto -> SQL / Prisma / SQLAlchemy models / dataclasses / sensor.proto
+          bash telemtry/scripts/sync_schema.sh Orion
+
+      - name: Fail if regenerated artifacts differ from committed
+        run: |
+          # sensor_data.desc is a binary protoc intermediate whose bytes vary by
+          # protoc version; exclude it and gate only on the deterministic text
+          # artifacts (proto, can.json, mapping.rs, SQL, prisma, models, ...).
+          if ! git diff --exit-code -- . ':(exclude)BEVO/sensor_data.desc'; then
+            {
+              echo "### ❌ Schema artifacts are out of sync with their sources"
+              echo ""
+              echo "A source (\`can_packets.csv\` / \`can_packets.proto\`) changed but the"
+              echo "generated artifacts weren't regenerated. Run locally and commit the result:"
+              echo ""
+              echo '```bash'
+              echo 'export BUILD_WORKSPACE_DIRECTORY="$PWD"'
+              echo 'python3 drivers/longhorn-lib/scripts/update_can_proto.py'
+              echo 'bash BEVO/nonhermetic/sync_assets.sh'
+              echo 'bash telemtry/scripts/sync_schema.sh Orion'
+              echo '```'
+            } >> "$GITHUB_STEP_SUMMARY"
+            echo "::error::Generated schema artifacts are out of sync with their sources. See job summary."
+            exit 1
+          fi
+
+  loggerd-tests:
+    name: BEVO loggerd unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install protoc
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y protobuf-compiler
+
+      - name: Test loggerd (schema-driven CSV header behavior)
+        working-directory: BEVO
+        env:
+          PROTOC: /usr/bin/protoc
+        run: cargo test --bin loggerd

.gitignore

@@ -96,3 +96,7 @@ MODULE.bazel.lock
 rust-project.json
 
 BEVO/vpn_creds.txt.claude/
+
+# Python bytecode (schema-gen scripts)
+__pycache__/
+*.pyc

BEVO/dashd/MQTT_CONTRACT.md

@@ -17,6 +17,50 @@ its data shown on the driver's dashboard in real time.
 | `lhre/dash/lapDelta`       | JSON number    | seconds           | `-0.45`  |
 | `lhre/dash/energyDelta`    | JSON number    | Wh                | `3.2`    |
 | `lhre/dash/lapsRemaining`  | JSON number    | laps (fractional) | `15.3`   |
+| `lhre/dash/targetPower`    | JSON number    | kW                | `32`     |
+| `lhre/dash/lapTrigger`     | JSON number    | monotonic counter | `7`      |
+| `lhre/dash/sfGate`         | JSON `[f64;4]` | `[lat1,lon1,lat2,lon2]` | `[30.39,-97.72,30.39,-97.73]` |
+
+### Endurance pacing signals
+
+`targetPower` and `lapTrigger` are published by the **Dash** tab on the
+trackside-live page (`telemtry/analysis/database/viewer_tool`) over the broker's
+websockets listener (port `8080`). They drive on-dash endurance pacing — the
+dash integrates CAN power locally and compares it to the budget, so only these
+two control values come off-car:
+
+- **`targetPower`** — the live power budget (kW) the strategist dials in. The
+  dash integrates real power against `targetPower * elapsed` per lap; the
+  top energy bar runs green while under budget and red while over. It's a
+  set-point, so the sender **republishes it ~1 Hz**. Unlike the other fields it
+  is **held last-known on the dash across a dropout** (not nulled): instead the
+  dash emits `targetPowerStale: true` to the frontend, which dims the bar and
+  shows a "STALE" badge — a held budget beats a blank one for the driver.
+- **`lapTrigger`** — a monotonically increasing lap counter. On each **increase**
+  the dash pops a full-screen lap card (lap time + energy used that lap) and
+  resets the per-lap energy integrator, so pacing error can't accumulate across
+  laps. The dash keys off the rising edge, not the absolute value. This is now a
+  **fallback/override**: when an `sfGate` is loaded the car counts its own laps.
+**Reverse channel (dash → trackside).** dashd also *publishes* so the strategist
+can confirm the uplink and mirror the driver's screen:
+
+- **`lhre/dash/state`** — JSON snapshot at ~2 Hz of what the driver sees (speed,
+  power, soc, temperature, lap count, and the on-car pacing: `lapEnergyWh`,
+  `budgetDeltaWh`, `lapNumber`, last-lap time/energy). The Dash tab renders this
+  as a live mirror; if it goes silent for >3 s the panel flags the uplink down.
+- **`lhre/dash/ack/{targetPower,lapTrigger,sfGate}`** — retained echoes published
+  the moment dashd ingests each control, so trackside sees "the car heard 32 kW
+  2 s ago" rather than just "I sent it." Energy integration is authoritative
+  on-car (survives a chromium reload), so these are the same numbers, not a
+  re-derivation.
+
+- **`sfGate`** — the start/finish line as `[lat1, lon1, lat2, lon2]`, published
+  **retained, QoS 1** from the Dash tab's "Push S/F to car" button (sourced from
+  the Track Builder gate). Once loaded, dashd watches `dynamics.gps` and bumps
+  the lap counter when the car's path crosses the line — so **the per-lap reset
+  no longer depends on the link at all.** The gate is cached to disk
+  (`DASHD_SFGATE_PATH`, default `/tmp/BEVO_dash_sfgate.json`) so it also survives
+  a reboot if the broker drops its retained copy.
 
 ## Payload format
 
@@ -56,4 +100,8 @@ mosquitto_pub -h 18.191.225.118 -t "lhre/dash/lapDelta" -m "-0.45"
 mosquitto_pub -h 18.191.225.118 -t "lhre/dash/lapDelta" -m "-0.45"
 mosquitto_pub -h 18.191.225.118 -t "lhre/dash/energyDelta" -m "3.2"
 mosquitto_pub -h 18.191.225.118 -t "lhre/dash/lapsRemaining" -m "15.3"
+
+# Endurance pacing: set a 32 kW budget, then trigger a lap card:
+mosquitto_pub -h 18.191.225.118 -t "lhre/dash/targetPower" -m "32"
+mosquitto_pub -h 18.191.225.118 -t "lhre/dash/lapTrigger" -m "1"
 ```

BEVO/dashd/deploy/launch_kiosk.sh

@@ -37,23 +37,38 @@ done
 #                          so this can be omitted there, but launching by
 #                          hand from SSH (where DISPLAY/WAYLAND_DISPLAY
 #                          weren't set up the same way) needs it explicit.
+CHROMIUM_BIN=""
 for bin in chromium-browser chromium; do
     if command -v "$bin" >/dev/null 2>&1; then
-        exec "$bin" \
-            --kiosk \
-            --incognito \
-            --ozone-platform=wayland \
-            --noerrdialogs \
-            --disable-restore-session-state \
-            --disable-infobars \
-            --disable-translate \
-            --disable-features=TranslateUI \
-            --check-for-update-interval=604800 \
-            --overscroll-history-navigation=0 \
-            --password-store=basic \
-            "$URL"
+        CHROMIUM_BIN="$bin"
+        break
     fi
 done
 
-echo "[BEVO] No chromium binary found (tried: chromium-browser, chromium)" >&2
-exit 1
+if [[ -z "$CHROMIUM_BIN" ]]; then
+    echo "[BEVO] No chromium binary found (tried: chromium-browser, chromium)" >&2
+    exit 1
+fi
+
+# Supervise the kiosk: a renderer/GPU crash or OOM kill must NOT leave a blank
+# dash for the rest of an endurance run. dashd and the static server already
+# auto-restart via systemd, but the browser did not until this loop — XDG
+# autostart launches it once and never again. Relaunch on exit with a short
+# backoff. `|| true` keeps `set -e` from aborting the loop on a nonzero exit.
+while true; do
+    "$CHROMIUM_BIN" \
+        --kiosk \
+        --incognito \
+        --ozone-platform=wayland \
+        --noerrdialogs \
+        --disable-restore-session-state \
+        --disable-infobars \
+        --disable-translate \
+        --disable-features=TranslateUI \
+        --check-for-update-interval=604800 \
+        --overscroll-history-navigation=0 \
+        --password-store=basic \
+        "$URL" || true
+    echo "[BEVO] Chromium kiosk exited; relaunching in 2s" >&2
+    sleep 2
+done

BEVO/dashd/frontend/src/hooks/useDemoData.ts

@@ -36,6 +36,15 @@ export function useDemoData(enabled: boolean): DashMessage | null {
         lastLap: 78.45,
         currentLapStart: Date.now(),
         lapTarget: 75 + Math.random() * 8,
+
+        // Endurance pacing demo state. Mirrors what dashd computes on-car so the
+        // bar + lap card render in demo mode. lapTrigger is bumped each lap.
+        lapTrigger: 0,
+        lapEnergyWh: 0,
+        lapBudgetWh: 0,
+        lastLapNum: null as number | null,
+        lastLapTimeS: null as number | null,
+        lastLapEnergyWh: null as number | null,
     });
 
     useEffect(() => {
@@ -85,6 +94,14 @@ export function useDemoData(enabled: boolean): DashMessage | null {
             s.speed = Math.max(0, Math.min(s.speed, 99));
             const clampedPower = Math.min(Math.max(newPower, -80), 80);
 
+            // Endurance power budget for the energy-bar demo (kW). The bar
+            // drifts green/red as the simulated power runs under/over this.
+            const targetPower = 32;
+            // Integrate per-lap energy + budget at the 100 ms tick (Wh = kW*dt/3.6),
+            // mirroring dashd's on-car integration.
+            a.lapEnergyWh += (clampedPower * 0.1) / 3.6;
+            a.lapBudgetWh += (targetPower * 0.1) / 3.6;
+
             // Accumulate derived values
             a.charge = Math.max(0, a.charge - (newPower > 0 ? 0.005 : -0.001));
 
@@ -131,6 +148,13 @@ export function useDemoData(enabled: boolean): DashMessage | null {
             if (elapsed >= a.lapTarget) {
                 a.lastLap = elapsed;
                 if (elapsed < a.bestLap) a.bestLap = elapsed;
+                a.lapTrigger += 1; // fire the on-dash lap card + per-lap reset
+                // Snapshot the just-finished lap, then reset the integrators.
+                a.lastLapNum = a.lapTrigger;
+                a.lastLapTimeS = elapsed;
+                a.lastLapEnergyWh = a.lapEnergyWh;
+                a.lapEnergyWh = 0;
+                a.lapBudgetWh = 0;
                 a.currentLapStart = Date.now();
                 a.lapTarget = 75 + Math.random() * 8;
                 elapsed = 0;
@@ -235,6 +259,18 @@ export function useDemoData(enabled: boolean): DashMessage | null {
                     lastLapTime: a.lastLap,
                     currentLapTime,
                     lapDeltaRate,
+                    targetPower,
+                    targetPowerStale: false,
+                    lapTrigger: a.lapTrigger,
+                },
+                pacing: {
+                    lapEnergyWh: a.lapEnergyWh,
+                    budgetDeltaWh: a.lapEnergyWh - a.lapBudgetWh,
+                    lapElapsedS: currentLapTime,
+                    lapNumber: a.lapTrigger + 1,
+                    lastLapNumber: a.lastLapNum,
+                    lastLapTimeS: a.lastLapTimeS,
+                    lastLapEnergyWh: a.lastLapEnergyWh,
                 },
             });
         }, 100);

BEVO/dashd/frontend/src/hooks/useEnergyPacing.ts

@@ -0,0 +1,74 @@
+import { useEffect, useRef, useState } from 'react';
+import { DashMessage } from '../types/DashData';
+
+// Endurance energy pacing. The integration + lap detection now live on-car in
+// dashd (BEVO/dashd/main.rs), so this hook is a thin consumer: it reads the
+// authoritative pacing snapshot and only owns the transient full-screen lap
+// card (show on each newly-completed lap, auto-clear after a few seconds).
+//
+// Why on-car: a chromium reload mid-endurance would otherwise zero the lap
+// integrator, and the trackside mirror reads the exact same numbers dashd
+// publishes to `lhre/dash/state`.
+
+// How long the full-screen lap card stays up after a lap completes.
+export const LAP_CARD_MS = 5000;
+
+export interface LapSummary {
+    lapNumber: number;   // the lap that just finished
+    timeS: number;       // its duration in seconds
+    energyWh: number;    // net energy used over the lap
+}
+
+export interface EnergyPacing {
+    lapEnergyWh: number;
+    lapElapsedS: number;
+    budgetDeltaWh: number | null;  // >0 over budget (red), <0 under (green), null until a target is set
+    targetPowerKw: number | null;
+    lapNumber: number;             // 1-based lap in progress
+    lapCard: LapSummary | null;    // the most recent completed lap, shown briefly
+}
+
+export function useEnergyPacing(data: DashMessage | null): EnergyPacing {
+    const [lapCard, setLapCard] = useState<LapSummary | null>(null);
+    // Highest completed-lap number we've already reacted to. Seeded on first
+    // sight so a reload mid-session doesn't pop a card for an old lap.
+    const lastShownLap = useRef<number | null>(null);
+
+    const pacing = data?.pacing;
+    const lastLapNumber = pacing?.lastLapNumber ?? null;
+    const lastLapTimeS = pacing?.lastLapTimeS ?? null;
+    const lastLapEnergyWh = pacing?.lastLapEnergyWh ?? null;
+
+    useEffect(() => {
+        if (lastLapNumber === null) return;
+        // First observation just sets the baseline (no card).
+        if (lastShownLap.current === null) {
+            lastShownLap.current = lastLapNumber;
+            return;
+        }
+        if (lastLapNumber > lastShownLap.current) {
+            lastShownLap.current = lastLapNumber;
+            setLapCard({
+                lapNumber: lastLapNumber,
+                timeS: lastLapTimeS ?? 0,
+                energyWh: lastLapEnergyWh ?? 0,
+            });
+        }
+    }, [lastLapNumber, lastLapTimeS, lastLapEnergyWh]);
+
+    // Auto-clear the card after LAP_CARD_MS.
+    useEffect(() => {
+        if (!lapCard) return;
+        const id = window.setTimeout(() => setLapCard(null), LAP_CARD_MS);
+        return () => window.clearTimeout(id);
+    }, [lapCard]);
+
+    return {
+        lapEnergyWh: pacing?.lapEnergyWh ?? 0,
+        lapElapsedS: pacing?.lapElapsedS ?? 0,
+        budgetDeltaWh: pacing?.budgetDeltaWh ?? null,
+        targetPowerKw: data?.mqtt.targetPower ?? null,
+        lapNumber: pacing?.lapNumber ?? 1,
+        lapCard,
+    };
+}