docs: fix stale documentation across sandbox, comms, and installer guides

- sandbox docs (README/QUICKSTART) and installer README still described the
  old Cohere-based code generator; code now uses MiniMax via an
  Anthropic-compatible SDK (ANTHROPIC_API_KEY/BASE_URL/MODEL). Also fixed a
  wrong service name (postgresdb3 -> timescaledb), wrong sandbox timeout
  (30s -> 120s), a personal local path, and a fabricated TimescaleDB docs URL.
- comms-setup.md: fixed docker-compose.jitsi.yml path and the car-side
  client instructions, which referenced a compose profile/service that
  doesn't exist — the car client is actually a standalone CI-published image.
- LOCAL_STACK.md described a docker-compose.local.yml that has never existed
  in this repo; rewrote it to use the real docker-compose.yml with explicit
  service selection, and corrected the TimescaleDB port, a nonexistent admin
  token file, and a nonexistent GRAFANA_DASHBOARDS_PATH env var.
- data-downloader/README.md: pointed at a .env.example that was removed when
  env vars were consolidated into server/installer/.env.example.
- kvaser-bridge/README.md: corrected the WS URL field description (it's the
  bridge's own server address, not the dashboard's).
- universal-telemetry-software/README.md: documented the can_uplink and
  telemetry_heartbeat Redis channels added by the uplink and heartbeat
  liveness-probe features.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01JqNzH7QyRpyXVfmvDFksiH

Author: claude

kvaser-bridge/README.md

@@ -33,7 +33,7 @@ python src/main.py
 A small window appears with:
 - **Channel** - select which Kvaser CAN channel to use
 - **Bitrate** - CAN bus bitrate (default 500k)
-- **WS URL** - WebSocket URL of the dashboard (default `ws://localhost:9080`)
+- **WS URL** - the bridge's own WebSocket server address, which the dashboard connects to (default `wss://127.0.0.1:9081`)
 - **Start/Stop Bridge** - toggle the connection
 
 Click **Start Bridge** to begin streaming CAN frames to the dashboard.

server/docs/comms-setup.md

@@ -24,20 +24,21 @@ Base Station RPI                    Car RPI
 ### Base Station
 
 ```bash
-cd universal-telemetry-software
+cd universal-telemetry-software/deploy
 docker compose -f docker-compose.jitsi.yml up -d
 ```
 
 Access: `http://<base-ip>:8000`
 
 ### Car RPI
 
+The car client is a standalone headless-browser image published by CI (`ghcr.io/western-formula-racing/data-acquisition/car-jitsi-client`) — it is not part of `docker-compose.jitsi.yml`.
+
 ```bash
 # Set base station IP first
-export JITSI_URL=http://192.168.1.1:8000
-
-cd universal-telemetry-software
-docker compose -f docker-compose.jitsi.yml --profile car up -d car-jitsi-client
+docker run -d --name car-jitsi-client \
+  -e JITSI_URL=http://192.168.1.1:8000 \
+  ghcr.io/western-formula-racing/data-acquisition/car-jitsi-client:latest
 ```
 
 The client will:
@@ -76,7 +77,7 @@ The client will:
 **Car can't connect?**
 - Check Ubiquiti link status
 - Verify base station IP in `JITSI_URL`
-- Check `docker logs daq-car-jitsi`
+- Check `docker logs car-jitsi-client`
 
 **No audio on car?**
 - Verify PulseAudio: `pactl info`

server/installer/LOCAL_STACK.md

@@ -2,32 +2,33 @@
 
 Minimal stack for testing without internet: TimescaleDB, Grafana, and file-uploader only.
 
+> There is no separate `docker-compose.local.yml` in this repo — use `docker-compose.yml` (in `server/installer/`) with an explicit service list to start only the three services below.
+
 ## First-time setup (requires internet)
 
 ### 1. Pull pre-built images
 
 ```bash
-cd installer
-docker compose -f docker-compose.local.yml pull
+cd server/installer
+docker compose pull timescaledb grafana
 ```
 
-This fetches `timescale/timescaledb:2.17.1-pg16` and `grafana/grafana:latest` from Docker Hub.
+This fetches `timescale/timescaledb:latest-pg16` and `grafana/grafana` from Docker Hub.
 Only needs to be done once, or when you want to update to newer images.
 
 ### 2. Build the file-uploader image
 
 ```bash
-docker compose -f docker-compose.local.yml build file-uploader
+docker compose build file-uploader
 ```
 
 This compiles the local `file-uploader/` source into an image.
 Re-run this if you change code in `file-uploader/`.
 
 ### 3. Prepare required files
 
-Make sure these exist in `installer/`:
+Make sure this exists in `server/installer/`:
 
-- `timescaledb-admin-token.json` — TimescaleDB admin token file
 - A `.dbc` file (default: `example.dbc`, or set `DBC_FILE_PATH` in `.env`)
 
 The DBC file is the fallback used when no custom DBC is uploaded via the UI.
@@ -45,14 +46,14 @@ python installer/backup-dashboards.py \
     --git-push
 ```
 
-Then point the local stack at that directory:
+Then copy (or symlink) that directory over the provisioned one before starting the stack:
 
 ```bash
-export GRAFANA_DASHBOARDS_PATH=~/daq-internal/grafana-dashboards
-docker compose -f docker-compose.local.yml up
+cp -r ~/daq-internal/grafana-dashboards/* server/installer/grafana/dashboards/
+docker compose -f server/installer/docker-compose.yml up timescaledb grafana file-uploader
 ```
 
-If `GRAFANA_DASHBOARDS_PATH` is not set, the stack falls back to `./grafana/dashboards` (the provisioned dashboards checked into this repo).
+Grafana provisions dashboards from `./grafana/dashboards` (the path baked into `docker-compose.yml`) — there is no `GRAFANA_DASHBOARDS_PATH` env var to point it elsewhere.
 
 **Authentication** — the script reads from `.env` automatically:
 - `GRAFANA_API_TOKEN` (preferred — service account token)
@@ -70,15 +71,15 @@ crontab -e
 ## Starting the stack (offline)
 
 ```bash
-cd installer
-docker compose -f docker-compose.local.yml up
+cd server/installer
+docker compose up timescaledb grafana file-uploader
 ```
 
-| Service       | URL                        |
-|---------------|----------------------------|
-| Grafana       | http://localhost:8087       |
-| File Uploader | http://localhost:8084       |
-| TimescaleDB      | http://localhost:9000       |
+| Service       | URL                          |
+|---------------|-------------------------------|
+| Grafana       | http://localhost:8087        |
+| File Uploader | http://localhost:8084        |
+| TimescaleDB   | postgresql://localhost:5432  |
 
 Grafana credentials: `admin` / `password` (or `GRAFANA_ADMIN_PASSWORD` from `.env`)
 
@@ -98,21 +99,22 @@ Grafana credentials: `admin` / `password` (or `GRAFANA_ADMIN_PASSWORD` from `.en
 
 Before going offline, verify:
 
-- [ ] `docker images | grep timescaledb` shows `timescale/timescaledb:2.17.1-pg16`
+- [ ] `docker images | grep timescaledb` shows `timescale/timescaledb:latest-pg16`
 - [ ] `docker images | grep grafana` shows `grafana/grafana`
 - [ ] `docker images | grep file-uploader` shows the local build
-- [ ] `timescaledb-admin-token.json` exists
 - [ ] A `.dbc` file is present (or you plan to upload one per-session via the UI)
 
 ---
 
 ## Grafana has no plugins offline
 
-The main `docker-compose.yml` installs `grafana-clock-panel` and `grafana-simple-json-datasource`
-at container startup — this requires internet. The local compose omits `GF_INSTALL_PLUGINS`
-so Grafana starts cleanly offline with only its built-in panels.
+`docker-compose.yml` sets `GF_INSTALL_PLUGINS: grafana-clock-panel,grafana-simple-json-datasource`
+on the `grafana` service, which Grafana fetches from its plugin catalog at container startup —
+this requires internet. There is no offline-only compose variant that omits it, so to start Grafana
+fully offline, comment out `GF_INSTALL_PLUGINS` in `docker-compose.yml` before going offline (revert
+before going back online so plugin-dependent dashboards keep working).
 
-Dashboards that use those plugins will show "panel plugin not found" errors.
+Dashboards that use those plugins will show "panel plugin not found" errors while it's commented out.
 Use built-in panel types (Time series, Stat, Table, etc.) for offline-compatible dashboards.
 
 ---
@@ -122,6 +124,6 @@ Use built-in panel types (Time series, Stat, Table, etc.) for offline-compatible
 To pull the latest versions:
 
 ```bash
-docker compose -f docker-compose.local.yml pull
-docker compose -f docker-compose.local.yml build file-uploader
+docker compose pull timescaledb grafana
+docker compose build file-uploader
 ```

server/installer/README.md

@@ -54,8 +54,9 @@ All secrets and tokens are defined in `.env`. The defaults provided in `.env.exa
 | `SLACK_WEBHOOK_URL` | Incoming webhook for notifications (optional) | empty |
 | `SLACK_DEFAULT_CHANNEL` | Default Slack channel ID for outbound messages | `C0123456789` |
 | `FILE_UPLOADER_WEBHOOK_URL` | Webhook invoked after uploads complete | inherits `SLACK_WEBHOOK_URL` |
-| `COHERE_API_KEY` | Cohere API key for AI-powered code generation | empty |
-| `COHERE_MODEL` | Cohere model to use | `command-a-03-2025` |
+| `ANTHROPIC_API_KEY` | MiniMax API key for AI-powered code generation (Anthropic-compatible SDK) | empty |
+| `ANTHROPIC_BASE_URL` | MiniMax API base URL | `https://api.minimaxi.com/anthropic` |
+| `ANTHROPIC_MODEL` | MiniMax model to use | `MiniMax-M3` |
 | `MAX_RETRIES` | Maximum retries for failed code execution | `2` |
 | `DEFAULT_SEASON_TABLE` | Default season table for telemetry queries | `wfr26` |
 | `DEBUG` | Enables verbose logging for selected services | `0` |
@@ -74,7 +75,7 @@ All secrets and tokens are defined in `.env`. The defaults provided in `.env.exa
 | `file-uploader` | `8084` | Web UI for uploading CAN CSV archives and streaming them into TimescaleDB. |
 | `slackbot` | n/a | Socket-mode Slack bot for notifications and automation (optional). Integrates with code-generator for AI queries. |
 | `sandbox` | n/a | Custom Python execution environment for running AI-generated code and TimescaleDB queries. |
-| `code-generator` | `3030` (internal) | AI-powered code generation service using Cohere. Generates Python code from natural language. |
+| `code-generator` | `3030` (internal) | AI-powered code generation service using MiniMax. Generates Python code from natural language. |
 | `health-monitor` | n/a | Monitors container health and scanner status. |
 | `lap-detector` | `8050` | Dash-based lap analysis web application, tabled until GPS hardware is available. |
 | `startup-data-loader` | n/a | Seeds TimescaleDB with sample CAN frames on first boot. |
@@ -93,7 +94,7 @@ All secrets and tokens are defined in `.env`. The defaults provided in `.env.exa
 - **Service fails to connect to TimescaleDB** – Confirm `POSTGRES_DSN`, `POSTGRES_USER`, and `POSTGRES_PASSWORD` in `.env` are correct. Regenerate the volumes with `docker compose down -v` if you rotate credentials.
 - **Re-import sample data** – Run `docker compose down -v` and restart the stack to re-trigger the data loader.
 - **Slack services are optional** – Leave Slack variables empty or set `ENABLE_SLACK=false` to skip starting the bot during development.
-- **AI code generation not working** – Ensure `COHERE_API_KEY` is set in `.env`. Check logs with `docker compose logs code-generator`.
+- **AI code generation not working** – Ensure `ANTHROPIC_API_KEY` is set in `.env`. Check logs with `docker compose logs code-generator`.
 - **Sandbox execution fails** – Verify sandbox container is running with `docker ps | grep sandbox`. Check logs with `docker compose logs sandbox`.
 
 ## AI-Powered Code Generation
@@ -108,15 +109,15 @@ The stack includes an AI-powered code generation service that allows natural lan
 ```
 
 **Features:**
-- Automatic code generation from natural language using Cohere AI
+- Automatic code generation from natural language using MiniMax
 - Self-correcting retry mechanism (up to 2 retries on failure)
 - Secure sandboxed execution environment
 - Auto-generation of plots and visualizations
 - Direct TimescaleDB access for telemetry queries
 
 **Setup:**
-1. Add `COHERE_API_KEY` to your `.env` file
-2. Optional: Configure `COHERE_MODEL` and `MAX_RETRIES`
+1. Add `ANTHROPIC_API_KEY` to your `.env` file
+2. Optional: Configure `ANTHROPIC_MODEL` and `MAX_RETRIES`
 3. Services start automatically with the stack
 
 See `sandbox/README.md` for detailed documentation.

server/installer/data-downloader/README.md

@@ -10,9 +10,18 @@ Both JSON files are shared through the `./data` directory so every service (fron
 
 ## Getting started
 
-1. Duplicate the sample env file and fill in the TimescaleDB credentials:
+1. This stack's `docker-compose.yml` reads `env_file: .env`, but there is no `.env.example` in this
+   directory anymore — the sample vars now live in `server/installer/.env.example`. Create `.env` here
+   with at least `POSTGRES_DSN` and `DEFAULT_SEASON_TABLE` (copy the matching lines from
+   `server/installer/.env.example`, or write your own):
    ```bash
-   cp .env.example .env
+   cat > .env <<'EOF'
+   POSTGRES_DSN=postgresql://wfr:wfr_password@timescaledb:5432/wfr
+   DEFAULT_SEASON_TABLE=wfr26
+   SCAN_INTERVAL_SECONDS=3600
+   VITE_API_BASE_URL=http://localhost:8000
+   ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173
+   EOF
    ```
 2. Build + launch everything:
    ```bash

server/installer/sandbox/QUICKSTART.md

@@ -5,7 +5,7 @@ This guide helps you set up and test the AI-powered code generation feature for
 ## Prerequisites
 
 - Docker and Docker Compose installed
-- Cohere API key (get one at https://cohere.com)
+- MiniMax API key (get one at https://www.minimaxi.com), used via an Anthropic-compatible SDK
 - TimescaleDB with telemetry data (or use the sample data)
 
 ## Setup Steps
@@ -22,8 +22,9 @@ SLACK_APP_TOKEN=xapp-your-token
 SLACK_DEFAULT_CHANNEL=C0123456789
 
 # AI Code Generation (required)
-COHERE_API_KEY=your-cohere-api-key-here
-COHERE_MODEL=command-r-plus
+ANTHROPIC_API_KEY=your-minimax-api-key-here
+ANTHROPIC_BASE_URL=https://api.minimaxi.com/anthropic
+ANTHROPIC_MODEL=MiniMax-M3
 MAX_RETRIES=2
 DEFAULT_SEASON_TABLE=telemetry
 ```
@@ -47,7 +48,7 @@ From the `installer/` directory:
 docker compose up -d
 
 # Or start only the AI/sandbox services for testing
-docker compose up -d postgresdb3 sandbox code-generator
+docker compose up -d timescaledb sandbox code-generator
 ```
 
 ### 3. Verify Services are Running
@@ -127,7 +128,7 @@ Once you have telemetry data in TimescaleDB, try these prompts:
 2. **Code Generator**:
    - Receives prompt
    - Loads system prompt with TimescaleDB connection details
-   - Calls Cohere AI to generate Python code
+   - Calls MiniMax AI to generate Python code
 3. **Custom Sandbox**:
    - Receives generated code
    - Executes in isolated Python subprocess
@@ -138,7 +139,7 @@ Once you have telemetry data in TimescaleDB, try these prompts:
    - Slackbot uploads images to Slack
 5. **On Failure**:
    - Error message appended to original prompt
-   - Cohere generates corrected code
+   - MiniMax generates corrected code
    - Retries up to MAX_RETRIES times
 
 ## Monitoring and Debugging
@@ -161,8 +162,8 @@ docker compose exec code-generator cat generated_sandbox_code.py
 
 ### Common Issues
 
-**"COHERE_API_KEY not found"**
-- Make sure `.env` has `COHERE_API_KEY=your-key`
+**"ANTHROPIC_API_KEY not found"**
+- Make sure `.env` has `ANTHROPIC_API_KEY=your-key`
 - Restart services: `docker compose up -d --force-recreate code-generator`
 
 **"Connection refused to sandbox"**
@@ -194,7 +195,7 @@ docker compose exec code-generator cat generated_sandbox_code.py
          ▼
 ┌───────────────────────┐
 │  Code Generator       │
-│  (Cohere AI)          │ ← System Prompt + User Prompt
+│  (MiniMax AI)         │ ← System Prompt + User Prompt
 └──────────┬────────────┘
            │ Generated Python Code
            ▼
@@ -225,17 +226,17 @@ docker compose exec code-generator cat generated_sandbox_code.py
 
 - Code executes in isolated Python subprocess with configurable timeout
 - **Has internet access** for TimescaleDB queries via `slicks` and API calls
-- Maximum runtime: 30 seconds (configurable via SANDBOX_TIMEOUT)
+- Maximum runtime: 120 seconds (configurable via SANDBOX_TIMEOUT)
 - Maximum file size: 5 MB per file (configurable via SANDBOX_MAX_FILE_MB)
 - Maximum files: 10 files (configurable via SANDBOX_MAX_FILES)
 - TimescaleDB credentials passed via environment only (consumed by `slicks` automatically)
 - Generated code is logged for audit purposes
 
 ## Resources
 
-- Cohere Documentation: https://docs.cohere.com
-- Custom Sandbox Source: /Users/hz/GitHub/sandbox
-- TimescaleDB Docs: https://docs.postgresdata.com/postgresdb/
+- MiniMax API: https://api.minimaxi.com/anthropic
+- Custom Sandbox Source: server/installer/sandbox/
+- TimescaleDB Docs: https://docs.timescale.com/
 - Slack API: https://api.slack.com
 
 ## Support