Arbeitskopie liegt jetzt unter Projekte\audi-app - die alte ist stillgelegt

Vollstaendige Kopie, kein frischer Klon: companion-app/.env.local, die echten
Belege unter tests/belegparser/belege/ und beide node_modules sind mitgekommen,
es ist also nichts nachzuinstallieren. 10.924 Dateien, fsck ohne Beanstandung.

Die alte Kopie unter .claude\sessions\Audi_app_TG bleibt vorerst liegen, darf
aber nicht mehr pushen: ein pre-push-Hook lehnt jeden Push ab und nennt den
neuen Ort. Zwei Arbeitskopien, die beide pushen duerfen, laufen auseinander -
bei DM180 einmal geschehen. Der Hook liegt in .git/hooks und ist bewusst nicht
versioniert; er gehoert zu jenem einen Verzeichnis, nicht zum Projekt.

Nebenwirkung zum Guten: /stand und die uebrigen Projektbefehle greifen jetzt
ohne den unversionierten Zeiger, weil das Repository direkt geoeffnet wird.
stand.md und die Dateikarte in SPECIFICATION.md entsprechend nachgezogen.

AGENTS.md Abschnitt DK.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.claude/commands/stand.md

@@ -0,0 +1,79 @@
+---
+description: Zeigt den aktuellen Stand von DM360 - was zu tun ist, und ob Repo, Versionen und ausgelieferte App zusammenpassen.
+---
+
+> **Wo dieser Befehl greift.** Claude Code sucht Projektbefehle ausschliesslich
+> in `<Arbeitsverzeichnis>/.claude/commands/`. Seit dem Umzug der Arbeitskopie
+> nach `C:\Users\tobia\Projekte\audi-app` (10.09.2026) wird das Repository direkt
+> geoeffnet - `/stand` steht damit ohne Zutun zur Verfuegung. Der frueher noetige
+> Zeiger unter `.claude\sessions\.claude\commands\stand.md` entfaellt; er war
+> unversioniert und ging mit jeder verlorenen Arbeitsumgebung mit. Wird doch
+> einmal eine Ebene darueber gearbeitet, greift dieselbe Regel wie zuvor: dort
+> findet Claude Code diese Datei nicht.
+
+Zeige den aktuellen Stand dieses Projekts. Zwei Teile: den **gemessenen**
+(unten selbst nachrechnen, nie aus dem Gedächtnis) und den **gepflegten** (aus
+`OFFEN.md`).
+
+## 1. Messen
+
+Führe genau diesen Block aus:
+
+```bash
+R=$(git rev-parse --show-toplevel) && cd "$R"
+echo "== Repository =="
+echo "  Zweig $(git branch --show-current) | HEAD $(git rev-parse --short HEAD) | origin $(git rev-parse --short @{u} 2>/dev/null || echo '?')"
+printf "  Arbeitsbaum: "; [ -z "$(git status --porcelain)" ] && echo sauber || git status --short
+echo "== Versionen =="
+python - <<'PY'
+import json, hashlib, pathlib, zipfile, plistlib, re
+b = "custom_components/audi_dashboard/"
+m = json.load(open(b + "manifest.json"))["version"]
+print(f"  Integration   {m}")
+try:
+    j = json.load(open(b + "frontend/app/bundle.json"))
+    z = pathlib.Path(b + "frontend/app/bundle.zip").read_bytes()
+    ok = j["version"] == m and hashlib.sha256(z).hexdigest() == j["sha256"] and len(z) == j["bytes"]
+    print(f"  OTA-Buendel   {j['version']}   {'passt' if ok else 'PASST NICHT - npm run ota faellig'}")
+except Exception as e:
+    print("  OTA-Buendel   nicht lesbar:", e)
+try:
+    zf = zipfile.ZipFile("companion-app/auslieferung/App.ipa")
+    n = zf.namelist()
+    p = plistlib.loads(zf.read([x for x in n if re.match(r"Payload/[^/]+\.app/Info\.plist$", x)][0]))
+    print(f"  .ipa auf dem Telefon  {p.get('CFBundleShortVersionString')}")
+    c = [x for x in n if re.match(r"Payload/[^/]+\.app/capacitor\.config\.json$", x)]
+    if c:
+        L = json.loads(zf.read(c[0])).get("packageClassList", [])
+        fehlt = [k for k in ("BelegZwischenablagePlugin", "KalenderTerminPlugin") if k not in L]
+        print("  eigene Plugins registriert:", "ja" if not fehlt else "NEIN - " + ", ".join(fehlt))
+except Exception as e:
+    print("  .ipa nicht lesbar:", e)
+PY
+echo "== Wartet auf einen Xcode-Lauf =="
+B=$(git log --format=%H -1 -- companion-app/auslieferung/App.ipa)
+N=$(git log --oneline "$B..HEAD" -- companion-app/native/ companion-app/scripts/ios-*.sh companion-app/scripts/ios-*.mjs companion-app/capacitor.config.ts)
+[ -z "$N" ] && echo "  keine nativen Aenderungen seit der ausgelieferten .ipa" || echo "$N" | sed 's/^/  /'
+```
+
+## 2. Lesen
+
+Lies danach `OFFEN.md`. Steht dort etwas unter „Wartet auf einen Xcode-Lauf",
+oder meldet die Messung nicht registrierte Plugins, lies zusaetzlich
+`APPLE_DEV_BACKLOG.md`.
+
+## 3. Berichten
+
+Kurz und in dieser Reihenfolge:
+
+1. **Stimmt der mechanische Stand?** Nur melden, was *nicht* passt - Repo nicht
+   synchron, Buendel-Version abweichend, Pluginliste unvollstaendig, native
+   Aenderungen aufgelaufen. Passt alles, genuegt ein Satz.
+2. **Was wartet auf den Eigentuemer** (Abschnitt 1 und 2 von `OFFEN.md`).
+3. **Was eine Sitzung bauen koennte** (Abschnitt 3), mit einer Empfehlung.
+
+Nenne die Punkte aus `OFFEN.md`, statt sie neu herzuleiten - und wenn dir beim
+Messen etwas auffaellt, das dort fehlt, sag es und trage es nach.
+
+**Starte nichts von selbst.** Ein Xcode-Lauf ist immer die Handlung des
+Eigentuemers (Apple-Regel in `AGENTS.md`).

.claude/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "companion-app",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["run", "dev", "--prefix", "companion-app"],
+      "port": 5173
+    }
+  ]
+}

.gitignore

@@ -18,3 +18,10 @@ Thumbs.db
 
 # Protokolle
 *.log
+
+# Arbeitsdateien dieser Werkzeugkette (Patch-Skripte, Zwischenstaende)
+.tmp-*
+
+# Python-Bytecode, entsteht beim Kompilieren und gehoert nicht ins Repo
+__pycache__/
+*.pyc

APPLE_DEV_BACKLOG.md

@@ -0,0 +1,216 @@
+# Apple Dev Backlog (DM360)
+
+Alles, was einen **Xcode-Lauf** oder das **Apple Developer Portal** braucht,
+wird hier gesammelt - und nur hier.
+
+**Warum:** ein Xcode-Lauf lohnt sich nicht für eine einzelne native Änderung.
+Er wird erst gestartet, wenn eine nennenswerte Menge zusammengekommen ist; die
+Entscheidung darüber trifft der Eigentümer, nicht eine Sitzung.
+
+## Arbeitsregel (verbindlich)
+
+* Jede Aufgabe, die Xcode oder das Apple-Portal braucht, kommt **in diese
+  Datei**, in derselben Sitzung, in der sie auffällt - nicht in eine Notiz im
+  Bericht und nicht nur in `AGENTS.md`.
+* **Nichts davon wird von sich aus gestartet.** Ein Xcode-Lauf ist eine
+  Handlung des Eigentümers am Mac; eine Sitzung bereitet ihn vor und meldet,
+  wenn sich genug angesammelt hat.
+* Was **ohne** Xcode geht, gehört nicht hierher: Änderungen an der Oberfläche
+  der App reisen im OTA-Bündel (`@capgo/capacitor-updater`), Änderungen am Panel
+  und am Backend über die Selbstaktualisierung der Integration. Nur nativer
+  Code, Plugins, Berechtigungen, Signatur und Auslieferungsweg brauchen einen
+  Lauf.
+* Erledigtes wird **nicht gelöscht**, sondern nach unten unter „Erledigt"
+  verschoben - mit der Fassung, in der es ausgeliefert wurde. Sonst wird
+  dieselbe Frage in einem halben Jahr wieder aufgemacht.
+
+---
+
+## Stand der ausgelieferten App
+
+Gemessen am Artefakt `companion-app/auslieferung/App.ipa`, nicht aus dem
+Gedächtnis (06.09.2026):
+
+| | |
+|---|---|
+| Fassung | **2026.9.4.17** (Build 1), App und Erweiterung gleich |
+| Bundle-ID | `app.datametric360`, Erweiterung `app.datametric360.teilen` |
+| Profile | beide Ad Hoc, **2 Geräte**, gültig bis **2027-08-29** |
+| Berechtigungen | Standort, Kalender (beide Schlüssel), Kamera - alle vorhanden |
+| `packageClassList` | **6 Klassen - beide eigenen Plugins fehlen** |
+
+Zum Vergleich: das Repository steht auf `2026.9.6.5`. Der Abstand ist **kein**
+Rückstand - alles dazwischen war Oberfläche und Backend und reist über OTA. Was
+wirklich auf einen Lauf wartet, steht unten.
+
+---
+
+## Wie ein Lauf abläuft
+
+**Diese Datei ist die Übergabe.** Wer am Mac sitzt - mit oder ohne Claude am
+Xcode - braucht keine weitere: hier steht der Stand, der eine Befehl, und was
+danach zu prüfen ist. `AGENTS.md` ist nur für das *Warum* nötig.
+
+### Vorher
+
+**Nichts vorzubereiten** - auch kein `git pull`. Das Skript holt `origin/main`
+selbst und bringt den Klon darauf, solange das nachweislich verlustfrei ist:
+ein reiner Rückstand wird vorgespult, und Commits, die zwar nur lokal liegen,
+gegenüber dem gemeinsamen Vorfahren aber **keine einzige Datei ändern**, werden
+verworfen. Beides sagt es an; das Reflog hält Verworfenes noch 90 Tage.
+
+> **Warum kein `git pull`:** am 07.09.2026 sind drei Commits am Ende von `main`
+> entfernt und der Branch per Force-Push zurückgesetzt worden. Ein Klon von davor
+> steht damit **vor** `origin/main` - dort wäre `git pull` genau das Falsche: der
+> Merge hängt die entfernten Commits wieder in die Historie, und der nächste Push
+> stellte sie auf dem Server wieder her (er ginge sogar ohne `--force` durch).
+> Genau diese Lage räumt das Skript von sich aus auf.
+
+Ab **hier** entscheidet es nichts mehr allein: liegen lokale Commits, die **auch
+den Inhalt** ändern, bricht es ab und legt dir beide Wege vor (pushen oder
+verwerfen) - ungepushte Arbeit wirft es nie weg.
+Ein nicht sauberer Arbeitsbaum bricht den Lauf ebenfalls ab - er ist die
+Voraussetzung dafür, dass Zurechtrücken oben gefahrlos ist. Und ebenso bricht er
+ab, wenn das Zielgerät nicht im Team eingetragen ist („Your team has no
+devices"); das ist dann eine Portal-Sache, kein Projektfehler.
+
+### Der Lauf
+
+```bash
+bash companion-app/scripts/ios-signieren.sh
+```
+
+Ein Befehl, von jedem Verzeichnis im Repository aus. Er wechselt selbst nach
+`companion-app/` und erledigt der Reihe nach: Git-Stand prüfen, Webbündel bauen,
+native Hülle synchronisieren, Standort-/Kalender-/Kamera-Berechtigung eintragen,
+Share-Erweiterung einrichten, App-Symbol einspielen, Versionsnummern setzen,
+Archiv bauen und signieren, `.ipa` exportieren, **die fertige `.ipa` gegenlesen**
+und die Auslieferung über die Luft vorbereiten.
+
+**Die Fassung kommt aus `custom_components/audi_dashboard/manifest.json`** - es
+gibt nichts von Hand hochzuzählen. Beim Schreiben dieser Zeilen wäre das
+`2026.9.6.5`.
+
+**Einmalig beim ersten Signieren:** der Schlüsselbund fragt, ob `codesign` den
+Schlüssel benutzen darf. **„Immer erlauben"** wählen, nicht „Erlauben" - ein
+Archiv signiert über 25 Programmteile und fragte sonst jedes Mal erneut. Bleibt
+der Lauf minutenlang beim Signieren stehen, wartet er auf genau diesen Dialog.
+
+### Danach
+
+```bash
+git add companion-app/auslieferung && git commit && git push
+```
+
+Das Telefon lädt die `.ipa` aus dem Repository - ohne diesen Push ändert sich
+dort nichts. Danach in **Safari** auf dem Telefon öffnen (andere Browser reichen
+`itms-services://` nicht an das System weiter):
+
+```
+itms-services://?action=download-manifest&url=https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung/manifest.plist
+```
+
+Die Adresse trägt **kein** `?v=` - ein zweites Fragezeichen zerlegt den
+Parameter, und weil iOS die Rückfrage erst aus dem geladenen Manifest baut,
+passiert dann sichtbar gar nichts (Abschnitt CK).
+
+Zum Schluss die eine Prüfung, die kein Skript abnehmen kann - siehe Abschnitt C
+unten.
+
+---
+
+## A. Wartet auf einen Xcode-Lauf
+
+### A1. Zwei eigene Plugins sind auf dem Telefon tot
+
+**Auswirkung: Zwischenablage und Kalendereintrag funktionieren nicht.** Das ist
+die einzige Position mit sichtbarem Ausfall.
+
+Capacitor 8 registriert ausschließlich, was in `packageClassList` der
+`capacitor.config.json` im Bündel steht (`CapacitorBridge.swift`,
+`registerPlugins()`). Diese Liste erzeugt `cap sync` aus den installierten
+npm-Paketen - app-eigene Plugins sind keine. Beide Klassen liegen nachweislich
+im Programm der ausgelieferten `.ipa` und werden trotzdem nie registriert.
+
+*Korrektur liegt im Repo* (`a99ae43`): `ios-teilen-einrichten.mjs` trägt die
+Klassen nach jedem `cap sync` nach und liest ihre Namen aus den Swift-Dateien
+selbst, damit sie nicht an zwei Stellen gepflegt werden. `ios-signieren.sh`
+**bricht ab**, wenn eine davon im fertigen Bündel fehlt.
+
+Hintergrund vollständig: `AGENTS.md`, Abschnitt DH und CM.
+
+### A2. Installationslink ohne zweites Fragezeichen
+
+`ios-luftweg.sh` hängte den Cache-Brecher `?v=` auch an die Manifest-Adresse
+**innerhalb** des `itms-services`-Links - damit steht dort ein zweites `?`, der
+Abruf scheitert, und weil iOS die Rückfrage erst aus dem geladenen Manifest
+baut, passiert sichtbar gar nichts.
+
+*Korrektur liegt im Repo* (`6365136`). Die bereits ausgelieferte
+`auslieferung/index.html` wurde von Hand nachgezogen; das Skript zieht beim
+nächsten Lauf nach. Hintergrund: `AGENTS.md`, Abschnitt CK.
+
+---
+
+## B. Wartet auf das Apple Developer Portal
+
+Derzeit **nichts offen.** App-Gruppe, beide App-IDs und die Gerätefreigabe sind
+eingerichtet (Abschnitt AK), die Profile laufen bis 2027-08-29.
+
+Vorzumerken, aber noch lange hin:
+
+* **2027-07-17** - das Entwicklerzertifikat läuft ab.
+* **2027-08-29** - beide Bereitstellungsprofile laufen ab.
+* Ein **neues Gerät** braucht eine Registrierung im Portal *und* frisch
+  ausgestellte Profile. Ein bereits ausgestelltes Profil erfährt von einem neuen
+  Gerät nichts - deshalb räumt `ios-signieren.sh` die zwischengespeicherten
+  Profile vor dem Bauen weg (Abschnitt AI).
+
+---
+
+## C. Nach dem Lauf zu prüfen
+
+Am **fertigen Bündel**, nicht am Projekt. Die Begründung steht in Abschnitt AK:
+von fünf Fehlern der nativen Hülle haben vier einen erfolgreichen Archivlauf
+erzeugt und sind erst am entpackten `.ipa` aufgefallen.
+
+Das Skript prüft selbst und bricht ab, wenn etwas fehlt:
+
+1. Die Erweiterung hat ein echtes Programm.
+2. App und Erweiterung tragen dieselbe `CFBundleShortVersionString` **und** eine
+   brauchbare `CFBundleVersion` (ohne die lehnt iOS die Installation der ganzen
+   App ab - Abschnitt CD).
+3. Die App-Gruppe steht in den Entitlements **beider** Ziele.
+4. Beide eigenen Plugin-Klassen stehen in `packageClassList`.
+
+**Von Hand bleibt genau eine Prüfung** - auf dem Gerät: einen Beleg über das
+Teilen-Blatt schicken, ein PDF aus der Zwischenablage einfügen, einen
+Kalendereintrag anlegen. Ob die Plugins *registriert* sind, sagt Punkt 4; ob sie
+*tun*, was sie sollen, sagt nur das Telefon.
+
+---
+
+## Was der Lauf von selbst erledigt
+
+Damit es niemand ein zweites Mal von Hand macht: `ios-signieren.sh` trägt bei
+jedem Lauf Standort-, Kalender- und Kamera-Berechtigung ein, richtet die
+Share-Erweiterung ein, spielt das App-Symbol ein und setzt die Versionsnummern
+in beide Ziele. Das muss sein, weil `companion-app/ios/` gitignored ist und von
+`npx cap add ios` jederzeit neu erzeugt wird - alles, was man in Xcode
+anklickt, wäre danach weg (Abschnitt AI).
+
+Unvermeidlich von Hand bleiben: die einmalige Portal-Einrichtung, das
+Schlüsselbund-„Immer erlauben" beim ersten Signieren, und `git push` der
+fertigen `.ipa`, weil das Telefon sie aus dem Repository lädt.
+
+---
+
+## Erledigt
+
+| Fassung | Was |
+|---|---|
+| 2026.9.4.17 | Kamera-Berechtigung für den QR-Scanner |
+| 2026.9.4.7 | `CFBundleVersion` in beiden Bündeln - die App war vorher nicht installierbar |
+| 2026.9.4.5 | Versionsnummern von App und Erweiterung angeglichen |
+| 2026.9.2.7 | Share-Erweiterung, Zwischenablage- und Kalender-Plugin gebaut und signiert |
+| 2026.8.30.8 | Erste signierte `.ipa`, Luftweg über Gitea eingerichtet |

AUDI_CI_ARCHIV_2026-08-13.md

@@ -0,0 +1,89 @@
+# Audi-CI-Design — Archiv (Stand 2026-08-13, vor der iOS-Offizialisierung)
+
+**Warum diese Datei existiert:** `SPECIFICATION.md` §2 „Concept & Design System" beschrieb bis
+2026-08-13 das ursprüngliche, reine Audi-CI-Design des Panels — Nacht-Canvas `#161b23`, 20-px-
+Kachelradius, Rot nur als Akzent, keine Schatten. Mit der Entscheidung, die iOS-Auflage
+(`audi-dashboard-ios.css`) offiziell zur verbindlichen Optik zu machen (siehe
+`DESIGN_REVIEW_2026-08-13.md` §A, Option 1, und der entsprechende `AGENTS.md`-Eintrag), wurde §2
+umgeschrieben, um die iOS-Werte zu beschreiben. Diese Datei bewahrt den vorherigen Wortlaut
+**wortgleich**, falls die Entscheidung später zurückgenommen wird.
+
+**Wichtig — das ist nicht die einzige Absicherung:** Der Code selbst macht die Rückkehr trivial,
+unabhängig von dieser Datei. `audi-dashboard-ios.css` ist eine rein additive **Auflage**
+(`homeassistant/www/audi-dashboard-app.js`, Zeile ~3990–4000 lädt zuerst `audi-dashboard.css`, dann
+zusätzlich `audi-dashboard-ios.css`) — die Basisdatei `audi-dashboard.css` enthält die Audi-CI-Werte
+weiterhin vollständig und unverändert. Um zur reinen Audi-CI zurückzukehren, genügt es, das Laden
+von `audi-dashboard-ios.css` in `_aufbauen()` zu entfernen bzw. bedingt zu machen — kein Restore
+aus einem Backup nötig. Diese Datei dokumentiert die **Spezifikationstexte**, nicht den Code (der
+bleibt ohnehin vorhanden).
+
+Bekannter Nebenpunkt aus dem Design-Review: die korrigierte `--fg3`-Kontrastfarbe (`#8a94a3`, siehe
+unten) ist in `bauauftrag.md` §8 **nicht** nachgezogen — dort steht noch der ursprüngliche,
+kontrastschwache Wert `#657081`. Diese Archivdatei hier gibt daher den zuletzt tatsächlich gültigen
+Stand wieder, nicht `bauauftrag.md`.
+
+---
+
+## Ursprünglicher Wortlaut von `SPECIFICATION.md` §2 (vor 2026-08-13)
+
+### Visual language
+Dark ("Nacht") is the default and primary theme; a light ("Tag") theme exists as a toggle. No
+shadows, no gradients anywhere except the fade under the vehicle photo (`.szene`). Flat tiles,
+pill-shaped controls, hairline dividers.
+
+### Colors (CSS custom properties, defined per-theme via `:root` / `[data-theme="tag"]`)
+
+| Role | Nacht (default) | Tag |
+|---|---|---|
+| `--canvas` (page background) | `#161b23` | `#FFFFFF` |
+| `--tile` | `#1f2733` | `#f2f2f2` |
+| `--tile-2` (inputs, hover) | `#2a3341` | `#e5e5e5` |
+| `--line` | `rgba(255,255,255,.10)` | `rgba(0,0,0,.10)` |
+| `--line-strong` | `rgba(255,255,255,.20)` | `rgba(0,0,0,.22)` |
+| `--fg` | `#FFFFFF` | `#000000` |
+| `--fg2` (secondary text) | `#9aa1ad` | `#4c4c4c` |
+| `--fg3` (labels/eyebrows) | `#8a94a3` | `#666666` |
+| `--ok` | `#15da15` | `#0DA20D` |
+| `--warn` | `#ffaa00` | `#ffaa00` |
+| `--shade` | `rgba(255,255,255,.05)` | `rgba(0,0,0,.04)` |
+| `--bad` | `#fd2c4e` | `#eb0d3f` |
+| `--red` (accent, theme-independent) | `#F50537` | `#F50537` |
+
+`--red` is used sparingly (accents, active states, destructive actions), not as a background fill.
+
+### Radii
+- `--r-tile: 20px` — tiles, the vehicle-photo "scene" container.
+- `--r-pill: 999px` — buttons, switches, segmented controls, progress bars.
+- Small functional elements (form inputs, placeholder/mini image boxes, popups) use **hardcoded
+  literal pixel values** (6px / 12px / 14px respectively) rather than a shared token.
+
+### Typography
+Three font-family names in play, all under the trademarked "Audi Type" family, embedded inline as
+base64 `woff2` directly in `audi-dashboard.css` (private-install only):
+- `"Audi Type"` — body/UI text, weight 400.
+- `"Audi Type Wide"`, weight 300 — `.fig` class, used for large numeric figures (odometer, range,
+  tank %, prices, service countdowns).
+- `"Audi Type Extended"`, italic — `.sport` class and the vehicle-title badge suffix
+  (`.badge .zusatz`).
+
+Only weights 300 and 400 are shipped — never use `font-weight: 600` or higher; the browser would
+synthetically bold. Numbers are formatted via `de-DE` locale (thousands separator, comma decimals)
+through the `de()`/`eur()` helpers.
+
+### Licensing constraint (hard rule)
+The Audi Type font, the four-rings SVG, and the model badge SVGs (`www/badges/*.svg`) are
+**licensed/trademarked assets, cleared only for this one private, non-published installation**
+(bauauftrag §8, §12). Never extract, republish, or reuse them anywhere outside this specific Home
+Assistant instance.
+
+---
+
+## So kommst du zurück
+
+1. In `homeassistant/www/audi-dashboard-app.js`, `_aufbauen()`: die vier Zeilen, die `linkIos`
+   erzeugen und an `ROOT` anhängen, entfernen (oder hinter eine Bedingung stellen).
+2. `SPECIFICATION.md` §2 durch den obigen Wortlaut ersetzen (oder auf diese Datei verweisen und den
+   iOS-Absatz als „überholt" markieren, symmetrisch zur jetzigen Umkehrung).
+3. `AGENTS.md` entsprechend nachziehen (die Design-Review-Entscheidung als zurückgenommen
+   vermerken).
+4. `audi-dashboard-ios.css` selbst muss nicht gelöscht werden — ungeladen hat sie keine Wirkung.

CLAUDE.md

@@ -2,10 +2,16 @@
 
 ## Claude Code
 
-- `AGENTS.md` above is the single source of truth for project state, rules, and open items —
-  edit it there, keep this file as a thin shim.
+- **`OFFEN.md` says what is to be done right now** — start there, not in AGENTS.md's 12,000
+  lines. `/stand` measures the mechanical half itself (repo, versions, shipped `.ipa`) and reads
+  `OFFEN.md` alongside it. Keep `OFFEN.md` current in the same session something changes.
+- `AGENTS.md` above is the single source of truth for **why** things are as they are — history,
+  rules, and the record of decisions including rejected ones. Edit it there, keep this file a
+  thin shim.
 - Remember the AGENTS.md maintenance rule: update it (in English) in the same session whenever
   your changes affect anything it records.
+- Anything needing **Xcode or the Apple Developer Portal** goes in `APPLE_DEV_BACKLOG.md`, and
+  runs are batched — never start one; that call is the owner's (Apple rule in AGENTS.md).
 
 <!-- Claude Code does not read AGENTS.md natively; this import is the officially recommended
      pattern (code.claude.com/docs/en/memory, "AGENTS.md" section). -->

COMPANION_APP_ARCHITECTURE.md

@@ -1,7 +1,7 @@
 # DataMetric360 — Companion App Architecture (design decided, not yet built)
 
 **App name: `DataMetric360`** (decided 2026-08-10). Public hostname: a subdomain of
-**`datametric360.app`**,
+**`datametric360.de`**,
 a dedicated domain registered at all-inkl solely for this purpose (see §5.4 for why it must be a
 separate domain). Both the app name and the domain are deliberately neutral — they don't advertise
 "Audi", "car", or "GPS tracker" to anyone who sees the hostname or the app icon, which is a small but
@@ -130,10 +130,46 @@ Entschlüsseln des binären Codec8-Protokolls. Das Gerät liefert die Daten dann
 - **Der zugehörige Transportweg ist MQTT**, nicht ein HTTP-Webhook: *GPRS Server Settings → MQTT*.
   Das war die wichtigste Überraschung — die erste Vermutung „JSON heißt HTTP-POST an einen
   HA-Webhook" ist falsch.
-- **Ein eigener Broker ist vorgesehen:** in den MQTT-Einstellungen werden schlicht IP und Port des
-  Brokers eingetragen; Login und Passwort werden verwendet, wenn der Broker Anmeldung verlangt.
+- **Ein eigener Broker ist vorgesehen und bestätigt möglich:** *GPRS Server Settings → MQTT Settings →
+  MQTT Client Type* bietet laut der Hilfe im Configurator (Screenshot vom Besitzer, 2026-08-11) vier
+  Werte: `0 = AWS IoT Shadow`, `1 = AWS IoT Custom`, `2 = Azure IoT`, **`3 = Custom server`**. Die
+  öffentliche Teltonika-Doku (Wiki, PDF-Guides) kennt nur die ersten drei — „Custom server" ist offenbar
+  erst mit einer späteren Firmware/Configurator-Version dazugekommen und deshalb dort nicht beschrieben.
+  Für „Custom server" werden IP/Domain und Port des eigenen Brokers (unter *Server Settings*, nicht im
+  MQTT-Block selbst) eingetragen; Login und Passwort kommen zum Einsatz, wenn der Broker das verlangt.
+  - **Praktisch bestätigt, mit einem offenen Warnsignal:** ein Teltonika-Community-Thread
+    ([FMC003 - Custom MQTT Broker?](https://community.teltonika.lt/t/fmc003-custom-mqtt-broker/14784),
+    Juli 2025) zeigt einen Nutzer, der genau unser Setup (eigener Mosquitto auf einem VPS, eigene CA,
+    Client-Zertifikat vom Gerät) über den Modus „AWS IoT Custom" nachgebaut hat — 24 Stunden stabil
+    getestet, damals gab es „Custom server" noch nicht als eigene Option. Zwei Monate später berichtet
+    ein anderer Nutzer **speziell für den FMM003**, dass bei ihm über MQTT keine Pakete am Server
+    ankamen — nach Rückwechsel auf TCP lief es wieder. Keine Auflösung im Thread sichtbar.
+  - **Konsequenz:** die MQTT-Anbindung gilt als grundsätzlich machbar, aber **nicht als sicher
+    funktionierend, bevor sie mit dem echten Gerät getestet wurde** — TCP/Codec8 (der bisherige,
+    bekannt funktionierende Weg über Traccar) bleibt der Rückfallplan, falls MQTT am FMM003 in der
+    Praxis Probleme macht.
+  - **„Custom server" beim Besitzer nicht auswählbar (2026-08-11):** im eigenen Configurator lässt
+    sich Wert 3 nicht anklicken. Ein zweiter, unabhängiger Praxisbericht
+    ([mdworld.nl, FMC003 + eigener OpenRemote-Server](https://mdworld.nl/asset-tracking), Aug. 2025)
+    bestätigt den gleichen Umweg wie der Community-Thread: **„AWS IoT Custom" wählen und dort auf den
+    eigenen Server zeigen** — funktioniert nachweislich, unabhängig davon ob „Custom server" gerade
+    wählbar ist oder nicht. Das ist damit der empfohlene Standardweg, nicht nur ein Fallback.
+  - **Zertifikatsketten-Reihenfolge ist umgekehrt zur Konvention (wichtiger Stolperstein, aus
+    demselben Praxisbericht):** Teltonika-Geräte erwarten die hochgeladene Zertifikatskette in
+    **umgekehrter Reihenfolge** (Wurzelzertifikat zuerst, nicht zuletzt) — anders als das übliche
+    `fullchain.pem`-Format (Server-Cert zuerst). Wird das ignoriert, schlägt der TLS-Handshake mit
+    einem kryptischen Fehler fehl (`SSL routines::tlsv1 alert unknown ca`), der nicht offensichtlich
+    auf die Reihenfolge hindeutet. **Vor dem Hochladen im Security-Tab die Kette umdrehen.**
+  - **Topic-Namensschema (aus demselben Praxisbericht, als Orientierung):** z. B.
+    `<name>/teltonika/%imei%/data` und `.../commands` — `%imei%` wird vom Gerät automatisch ersetzt.
+    Exakte eigene Werte erst bei der Inbetriebnahme festlegen.
 - **TLS ist Pflicht, nicht optional:** ohne hochgeladene Zertifikate arbeitet MQTT nicht. Zertifikat,
   privater Schlüssel und Wurzelzertifikat werden im Configurator unter *Security* hinterlegt.
+  - **Dateinamen-Endung ist strikt geprüft (2026-08-11, live am Configurator beobachtet):** hochgeladene
+    Dateien müssen auf `.pem`, `.pem.crt` oder `.pem.key` enden, sonst Fehler „File format is not valid
+    or not supported". Reiner Inhalt (PEM-Format) reicht nicht, die Endung muss stimmen. Schema folgt
+    offenbar der AWS-IoT-Download-Konvention: Root-Zertifikat `*.pem`, Geräte-Zertifikat `*.pem.crt`,
+    privater Schlüssel `*.pem.key`. Eigene CA-Dateien entsprechend umbenennen, nicht nur `.crt`/`.key`.
 - **Firmware-Abhängigkeit:** Codec JSON ist nicht in jeder Firmware enthalten (bei mehreren
   Modellen erst ab 03.28.00 dokumentiert). Der Besitzer bestätigt, dass es auf diesem Gerät
   verfügbar ist — vor der Inbetriebnahme trotzdem die Firmware-Version notieren.
@@ -266,12 +302,13 @@ never reachable from the public internet. Only a narrow, purpose-built slice of
    tunnel from the HAOS host (the OptiPlex) to Cloudflare's edge; no router port ever opens. Confirmed
    capable of routing **multiple public hostnames to multiple local ports/services** — so it points at
    the reverse-proxy add-on's port below, not at HA's own port 8123.
-2. **Nginx Proxy Manager or Traefik add-on** — a path-scoped reverse proxy sitting between the tunnel
-   and HA's internal API, on the Supervisor's internal Docker network. Configured with an **allowlist**
-   of only the specific paths the companion app needs (e.g. `/api/states/sensor.audi_*`,
-   `/api/services/pyscript/audi_dashboard_*` — exact path list still TBD, depends on the final entity/
-   service names once the FMM003 mapping is built). Everything else — `/lovelace`, `/config`, `/auth`,
-   the HA frontend itself — is blocked at this layer, never reaching the tunnel at all.
+2. **Nginx Proxy Manager add-on** (decided, 2026-08-28 — see §5 item 3) — a path-scoped reverse proxy
+   sitting between the tunnel and HA's internal API, on the Supervisor's internal Docker network.
+   Configured with an **allowlist** of only the specific paths the companion app needs (`/api/states/
+   sensor.audi_dashboard_*`, `/api/services/audi_dashboard/*`, plus a handful more — the exact,
+   current list lives in `homeassistant/REVERSE_PROXY.md`, not duplicated here since entity/service
+   names can change and this doc would only go stale again). Everything else — `/lovelace`, `/config`,
+   `/auth`, the HA frontend itself — is blocked at this layer, never reaching the tunnel at all.
 3. **Auth stays a second, independent layer:** every proxied call still requires the same Bearer LLAT
    HA's REST API already demands. Even a path that slipped through the allowlist would be useless
    without that token, and any individual LLAT can be revoked from the HA profile if the phone is ever
@@ -297,28 +334,87 @@ surface *is* now internet-facing (even though HA itself never is) — accepted a
 Deliberately deferred until hardware arrives / the next architecture review — not blocking anything
 else in this document:
 
-1. **Exact reverse-proxy path allowlist** — depends on the final pyscript entity/service names once the
-   FMM003 combined-entity mapping is implemented; write these down here once decided.
+1. ✅ **ERLEDIGT (2026-08-28): reverse-proxy path allowlist defined and current.** Lives in
+   `homeassistant/REVERSE_PROXY.md`, kept in sync with the real entity/service names
+   (`sensor.audi_dashboard_*` / `audi_dashboard.<name>` since the native-integration conversion,
+   `AGENTS.md` §H) rather than duplicated here. The step-by-step setup runbook that applies it in
+   Nginx Proxy Manager is `homeassistant/INTERNET_ZUGRIFF_EINRICHTEN.md`. One correction worth
+   recording: the allowlist originally (2026-08-11 planning) assumed the app itself would be served as
+   a web build under `/local/dm360/` — that was never built. Distribution stayed **native/sideload
+   only** (§1), so the allowlist instead needed the app's own OTA surface
+   (`/audi_dashboard_static/app/*`, the `@capgo/capacitor-updater` bundle) rather than a served
+   web app.
 2. **No-hardcoding mapping system** for the FMM003 combined entity — discussed in an earlier session,
    not yet written to a file or finalized in detail. **Kann erst nach der ersten echten
    MQTT-Nachricht fertig werden** (§2b): die Feldnamen im Codec-JSON sind noch unbekannt und werden
    mitgeschnitten, nicht geraten.
-2a. **Erreichbarkeit des MQTT-Brokers für das Fahrzeug** — Portfreigabe 8883 gegen VPS-Broker mit
-   Mosquitto-Bridge, siehe §2b. Betrifft nur den Weg Fahrzeug→Zuhause und ist unabhängig von der
-   Anbindung der App (§4, dort bleibt es bei Cloudflare Tunnel).
-2b. **TLS-Zertifikate für Mosquitto und das Gerät** — bei der Inbetriebnahme zu erzeugen; ohne sie
-   verweigert der FMM003 die MQTT-Verbindung.
-3. **Reverse-proxy add-on: Nginx Proxy Manager vs. Traefik** — both viable (§4), pick deferred to the
-   next audit pass. Doesn't depend on the FMM003 — could be set up and tested against HA's existing API
-   before the hardware arrives, if worth doing ahead of time.
-4. **Cloudflare Tunnel domain** — ✅ **ERLEDIGT: `datametric360.app` ist bei all-inkl registriert**
-   (Stand 2026-08-11). Eigens dafür angelegt, ohne Webseite und ohne Postfach darauf — genau so, wie
-   es die unten stehende Einschränkung verlangt. Vorgesehene Adresse der App später:
-   `https://datametric360.app`.
+2a. ✅ **ERLEDIGT (Entscheidung, 2026-08-11): Portfreigabe 8883**, nicht VPS-Bridge. Begründung: ein
+   Broker mit TLS-Zwang und Pflicht-Client-Zertifikat lässt vor dem eigentlichen Login niemanden
+   auch nur ansetzen — der Mehraufwand einer dauerhaften VPS-Miete plus zweitem Mosquitto plus
+   Bridge-Verbindung stand in keinem Verhältnis zum zusätzlichen Schutz für ein einzelnes
+   Privatfahrzeug. Betrifft nur den Weg Fahrzeug→Zuhause und ist unabhängig von der Anbindung der
+   App (§4, dort bleibt es bei Cloudflare Tunnel — kein Widerspruch, siehe dort die Begründung, warum
+   ein eng begrenzter, zertifikatsgesicherter Port etwas anderes ist als HA selbst offenzulegen).
+   **Umsetzungsstand (2026-08-11):** DuckDNS-Hostname `datametric360.duckdns.org` angelegt und als
+   Add-on in HA eingerichtet, aktualisiert zuverlässig die öffentliche IP — das ist der für den
+   FMM003-Pfad tatsächlich entscheidende Teil. Router bestätigt **Dual-Stack** (kein DS-Lite), die
+   Portfreigabe 8883 am Speedport Smart 4 Plus ist eingerichtet, FMM003 sendet bestätigt Daten.
 
-   `.app` steht auf der HSTS-Preload-Liste: Browser erzwingen dort HTTPS bedingungslos. Das passt zum
-   Cloudflare Tunnel (immer HTTPS) und schließt eine versehentliche Klartextverbindung von vornherein
-   aus.
+   **Let's-Encrypt-Zertifikat für die HA-Oberfläche selbst — ✅ ERLEDIGT (2026-08-11), nach
+   ausführlicher Fehlersuche.** Der `deploy_challenge`-Hook (DNS-01, TXT-Eintrag via DuckDNS-API)
+   scheiterte zunächst wiederholt mit `timeout 120s` beim Warten auf den eigenen TXT-Eintrag, obwohl
+   DuckDNS den Eintrag nachweislich korrekt setzte (bestätigt per `nslookup` gegen `8.8.8.8` vom PC
+   *und* per `dig` aus der HA-eigenen SSH-Konsole gegen den internen Supervisor-Resolver). Der DNS-
+   Server selbst war am Ende kein Faktor (Erfolg trat auch mit dem Speedport als DNS-Server ein) —
+   **tatsächliche Ursache war ein fehlerhafter `aliases`-Eintrag** in der DuckDNS-Add-on-Konfiguration
+   (`alias: datametric360` ohne `.duckdns.org`, überflüssig und falsch, da keine externe Domain per
+   CNAME verwendet wird — `aliases` ist nur für diesen Fall gedacht) zusammen mit `accept_terms:
+   false`. Nach Entfernen von `aliases` und Setzen von `accept_terms: true` lief die Zertifikatsanfrage
+   beim nächsten Versuch sofort erfolgreich durch (`Challenge is valid! ... Creating fullchain.pem...
+   Done!`), Zertifikat gültig bis 2026-11-09.
+
+   Anschließend `configuration.yaml`'s alter `http:`-Block (der HA-Start blockiert hatte, solange die
+   Zertifikatsdateien nicht existierten) entfernt — HA migriert SSL-Zertifikatspfad/-Schlüssel und die
+   interne/externe URL inzwischen in die Oberfläche (Einstellungen → System → Netzwerk). **Eigenheit
+   dabei:** eine geänderte Netzwerkkonfiguration muss innerhalb von 5 Minuten über einen Dialog in der
+   Oberfläche bestätigt werden, sonst macht HA sie automatisch rückgängig und startet mit dem vorigen
+   Stand neu (`Pending HTTP config was not confirmed within 0:05:00` im Log) — beim ersten Versuch
+   deshalb ungewollt zurückgerollt, beim zweiten Versuch bewusst sofort bestätigt, seitdem stabil.
+   Externe URL bewusst leer gelassen (Port 8123 ist nicht freigegeben, HA bleibt nicht öffentlich
+   erreichbar); interne URL auf `https://192.168.2.216:8123` gesetzt — das Zertifikat ist auf den
+   Hostnamen ausgestellt, nicht auf die IP, der Browser zeigt deshalb bei IP-Zugriff weiterhin eine
+   Namensabgleich-Warnung (Verbindung bleibt trotzdem verschlüsselt); ein lokaler DNS-Eintrag, der
+   `datametric360.duckdns.org` intern auf die lokale IP auflöst, wäre die sauberere, aber optionale
+   Nachbesserung.
+
+   Nebenbei geklärt: ein Vorschlag, stattdessen komplett auf Cloudflare zu setzen, wurde geprüft und
+   **ist keine Alternative** — Cloudflare Tunnel kann kein rohes MQTT/TCP transportieren (nur HTTP),
+   der FMM003 kennt außerdem kein Tunnel-Konzept, nur IP/Domain+Port. Bleibt bei der klaren Trennung:
+   Cloudflare Tunnel für die App (§4), Portfreigabe+DuckDNS nur für die Fahrzeug-MQTT-Verbindung.
+2b. **TLS-Zertifikate für Mosquitto und das Gerät** — ✅ **ERLEDIGT (2026-08-11):** eigene private CA
+   (10 Jahre gültig) erzeugt, Server-Zertifikat (CN `datametric360.duckdns.org`) und Client-Zertifikat
+   für das Gerät signiert, beide gegen die CA verifiziert. Mosquitto ist mit `certfile`/`keyfile`/
+   `cafile`/`require_certificate: true` konfiguriert. **Noch offen:** die drei Geräte-Dateien (Root,
+   Client-Zertifikat, privater Schlüssel) müssen noch in den FMM003-Configurator hochgeladen werden —
+   dabei auf die Dateinamen-Endung achten (siehe Anmerkung oben bei „Dateinamen-Endung ist strikt
+   geprüft").
+3. ✅ **ERLEDIGT (2026-08-28): Nginx Proxy Manager**, not Traefik. Both remained viable per §4; NPM was
+   picked and is what `homeassistant/REVERSE_PROXY.md` and `INTERNET_ZUGRIFF_EINRICHTEN.md` are written
+   against. Setup itself (Cloudflare account, nameserver switch, add-on installation) is still the
+   owner's own action to perform — see the runbook for the exact steps.
+4. **Cloudflare Tunnel domain** — ✅ **ERLEDIGT: `datametric360.de` ist bei all-inkl registriert**
+   (ursprünglich `.app`, seither auf `.de` umgestellt — Stand 2026-08-28). Eigens dafür angelegt, ohne
+   Webseite und ohne Postfach darauf — genau so, wie es die unten stehende Einschränkung verlangt.
+   Vorgesehene Adresse der App später: `https://datametric360.de`.
+
+   **Korrektur 2026-08-28:** die ursprüngliche `.app`-Wahl hatte einen zusätzlichen Vorteil, der mit dem
+   Wechsel auf `.de` entfällt — `.app` steht auf Chromes HSTS-Preload-Liste, `.de` nicht, der Browser
+   erzwingt dort also nicht von sich aus HTTPS ohne vorherigen Kontakt zur Domain. Das ändert nichts an
+   der Sicherheit dieses Aufbaus: Cloudflare Tunnel liefert ohnehin ausschließlich HTTPS aus, und Nginx
+   Proxy Manager kann zusätzlich "Force SSL" erzwingen (siehe `INTERNET_ZUGRIFF_EINRICHTEN.md` Schritt
+   4) - nur der zusätzliche, browserseitig *vorab* erzwungene Schutz vor dem allerersten Verbindungs-
+   aufbau (bevor die App überhaupt einmal erfolgreich verbunden war) entfällt. Für ein sideload-only
+   installiertes, nicht öffentlich beworbenes Gerät eine vernachlässigbare Einbuße.
 
    **Noch offen, und der eigentliche Knackpunkt:** die Nameserver der Domain müssen bei all-inkl auf
    Cloudflare umgestellt werden („Full setup") — erst dann kann der Tunnel einen Hostnamen darunter
@@ -326,10 +422,12 @@ else in this document:
    setup"), gibt es nur im Business-Tarif für 200 $/Monat. Weil auf dieser Domain nichts liegt außer
    diesem Vorhaben, ist die Umstellung folgenlos.
 
-   Noch zu entscheiden (Kleinigkeit, erst bei der Einrichtung): ob die App unter der Domain selbst
-   liegt und die abgesicherte Schnittstelle unter einer Unteradresse (etwa `api.datametric360.app`),
-   oder umgekehrt. Beides funktioniert; ein getrennter Hostname für die Schnittstelle macht die
-   Pfad-Freigabeliste im Reverse Proxy übersichtlicher.
+   ✅ **ERLEDIGT (2026-08-28): ein einziger Hostname genügt**, kein Split nötig. Der ursprüngliche
+   Gedanke (App-Domain vs. API-Subdomain) setzte voraus, dass die App selbst als Web-Build unter einer
+   eigenen Adresse ausgeliefert würde — das wurde nie gebaut (Distribution blieb nativ/sideload, §1).
+   Es gibt nur eine Adresse, die überhaupt gebraucht wird: `https://datametric360.de`, die die App
+   sowohl für API-Aufrufe als auch für ihr eigenes OTA-Bündel verwendet (siehe §5 Punkt 1 oben,
+   `homeassistant/REVERSE_PROXY.md`).
 
    Die Einschränkung, die zur eigenen Domain geführt hat:
 
@@ -340,7 +438,7 @@ else in this document:
    ($200/month)**, i.e. not realistic here.
 
    **Therefore: never point this at an existing all-inkl domain carrying live websites or email** —
-   hence the dedicated `datametric360.app`. Nothing about the owner's existing domains/mail is touched.
+   hence the dedicated `datametric360.de`. Nothing about the owner's existing domains/mail is touched.
 
    Note the all-inkl "Neue Domain anlegen" dialog asks for a target (Webspace / Redirect /
    Webbaukasten) — that choice is irrelevant here, since DNS gets delegated to Cloudflare afterwards

DESIGN_AUDIT_2026-08-13.md

@@ -0,0 +1,191 @@
+# Design Audit — 2026-08-13 (Grossbildschirm-Layout)
+
+Auslöser: zwei konkrete User-Reports ("Einstellungen-Knopf sitzt am Bildschirmrand, obwohl
+die App-Spalte schon vorher endet" und "die Ringe als Einstellungen-Knopf sind zu klein").
+Beide sind bestätigt, behoben und live im `audi_ha_test`-Container verifiziert (Desktop
+1920px + Mobil 375px, Chrome-Konsole fehlerfrei bis auf die vorbestehenden, unbezogenen
+Service-Worker-/Platzhalterbild-404-Meldungen). Im Zuge der Fehlersuche wurde ein dritter,
+verwandter Fehler im selben Muster gefunden und mitbehoben.
+
+Geprüft wurden Übersicht, Mein Audi, Fahrten, Statistik, Tanken und Einstellungen (inkl.
+Setup-Popup) bei 375px und 1920px. Die drei unten dokumentierten Befunde sind die einzigen
+gefundenen Abweichungen; der Rest folgt konsistent den bestehenden Tokens (`--r-tile`,
+Farbrollen aus dem iOS-Overlay, `.aktion`/`.switch`-Semantik).
+
+## Befund 1 — Zahnrad/Kopfzeile sass bei breiten Fenstern am Fensterrand statt am Inhaltsrand
+
+**Root Cause:** `.topbar` (enthält den Einstellungen-Knopf `.profilbtn`) liegt im
+Grossbildschirm-Raster (`@container (min-width:860px)` in `audi-dashboard-ios.css`) in
+Spalte 2 (`grid-column:2`), derselben Spalte wie `main#view`. `main#view` hat dort ein
+`max-width:860px`, `.topbar` hatte keins - die Spalte selbst ist aber `minmax(0,1fr)`, füllt
+also die volle restliche Fensterbreite. `.head{flex:1}` in der Kopfzeile hat den Rest der
+Zeile aufgefüllt und `.profilbtn` bis an den rechten Rand der vollen Spalte geschoben, weit
+hinter das Ende des sichtbaren Inhalts.
+
+**Beleg (1920px Fenster):** `main#view` endete bei `x=1380`, `.topbar` ging bis `x=1920`,
+`.profilbtn` sass bei `x=1832-1876` - eine Lücke von über 450px zwischen Inhaltsende und
+Knopf.
+
+**Fix:** `.topbar`, `.phone:has(.back.on) .topbar` und `.ptr` bekommen im
+860px-Container-Query dasselbe `max-width:860px` wie `main#view`. Nach dem Fix enden
+`.topbar` und `main#view` an derselben Kante (`x=1380`), der Knopf sitzt bei `x=1292-1336`,
+sichtbar über dem Inhalt.
+
+**Datei:** `homeassistant/www/audi-dashboard-ios.css`
+
+## Befund 2 — Audi-Ringe als einziger Einstellungen-Zugang in Telefonbreite zu klein
+
+**Root Cause:** In Telefonbreite blendet die iOS-Auflage das Zahnrad-Icon (`.profilbtn`) aus
+- die Audi-Ringe (`#marke`/`.rings`) sind dort laut eigenem Code-Kommentar "der einzige
+Zugang zu den Einstellungen" und seit einer früheren Session bewusst ein echter,
+tastaturbedienbarer Knopf. Die Knopfgrösse war mit 42×24px aber deutlich kleiner als jeder
+andere Symbol-Knopf in derselben Kopfzeile (`.themebtn`/`.profilbtn`/`.back` sind alle
+44×44px) und lag unter der üblichen 44px-Mindestgrösse für Tippflächen.
+
+**Fix:** `.rings` von 42×24px auf 58×32px vergrössert (Seitenverhältnis beibehalten,
+`.rings svg{width:58px}`). Funktion (Klick navigiert zu Einstellungen) unverändert getestet.
+
+**Datei:** `homeassistant/www/audi-dashboard.css`
+
+## Befund 3 — Popups/Sheets auf breiten Bildschirmen fast bildschirmbreit (gleiches Muster wie Befund 1)
+
+Beim Nachprüfen von Befund 1 fiel derselbe Fehler bei vier weiteren Elementen auf: sie sind
+`position:absolute` mit `left`/`right` relativ zu `.phone` (der vollen Rasterbreite,
+Seitenspalte inklusive) statt zur schmaleren Inhaltsspalte, ohne eigenes `max-width` für
+grosse Bildschirme:
+
+- `.setup-popup` (Sensor-Zuordnung) - **bestätigt live:** 1644px breit bei 1920px Fenster
+  (nur 10px Rand auf jeder Seite), praktisch bildschirmfüllend statt eines ruhigen Dialogs.
+- `.sdpopup` (SmartDeal-Aktivierung)
+- `.sheet` (Action-Sheet, ersetzt confirm()/alert() beim Löschen)
+- `.standortmenu` (Standort-Bottom-Sheet auf der Kartenansicht)
+
+**Fix:** Im selben 860px-Container-Query `max-width:560px` (Popups/Sheet) bzw. `max-width:
+640px` (Standortmenü, mehr Inhalt) plus `margin-left/right:auto` ergänzt - zentriert die
+Elemente innerhalb ihres bestehenden `left`/`right`-Abstands, ohne die
+Transform-basierte Einblend-Animation dieser Elemente anzufassen (eine
+`transform:translateX(-50%)`-Zentrierung hätte mit der `sheet-rein`-Keyframe-Animation
+kollidiert, die am Ende selbst `transform:none` setzt). `border-radius` bleibt jeweils
+unverändert (`.standortmenu` behält oben abgerundete/unten eckige Kanten, passend zur
+weiterhin am unteren Fensterrand andockenden Bauweise).
+
+**Beleg nach Fix (Setup-Popup, 1920px Fenster):** 560px breit, zentriert bei `x=808-1368`.
+
+**Datei:** `homeassistant/www/audi-dashboard-ios.css`
+
+## Nicht verändert (bewusst ausserhalb dieses Audits)
+
+- `.bildmenu` (Kontextmenü bei Fahrzeugbildern) ist bereits `min-width:160px` und wächst
+  nicht mit der Fensterbreite - kein Fehler.
+- Zentrierung der Popups erfolgt relativ zur vollen `.phone`-Breite (Seitenspalte
+  inklusive), nicht exakt zur Mitte der 860px-Inhaltsspalte - bei 1920px ein Versatz von
+  ca. 138px nach rechts gegenüber echter Inhaltsmitte. Sichtbar besser als der vorige
+  Zustand (praktisch volle Fensterbreite), aber für pixelgenaue Zentrierung müssten die
+  Popups im Markup in die Grid-Spalte 2 verschoben werden statt als Geschwister von
+  `main#view` direkt in `.phone` zu liegen - eine grössere strukturelle Änderung, hier
+  bewusst zurückgestellt.
+
+## Runde 2 — sechs weitere User-Findings
+
+Vier bestätigt, ursächlich geklärt und behoben; zwei trotz gezielter Suche (Computed-Style-
+Vergleich, 2.5x-Zoom per temporärem `transform:scale()` auf das Live-DOM, Tag- und
+Nacht-Theme) nicht reproduzierbar - siehe unten.
+
+### Befund 4 — Kopfzeile (Übersicht/Fahrten/...) auf breiten Bildschirmen 30px zu weit rechts
+
+**Root Cause:** `.back` (Zurück-Pfeil) ist auch inaktiv (`opacity:0`, kein `.on`) weiterhin
+ein 44px breites Flex-Element in `.topbar` plus `gap`. Auf Wurzelseiten ohne Zurück-Pfeil
+(Übersicht, Fahrten, ...) schiebt dieser unsichtbare Platzhalter `.head`/`.title` sichtbar
+weiter nach rechts als `main#view` darunter beginnt.
+
+**Beleg:** `.title` links bei `x=594`, die erste Kachel in `main#view` links bei `x=564` -
+30px Versatz.
+
+**Fix:** `.back:not(.on){width:0;min-width:0;margin:0;overflow:hidden}` im
+860px-Container-Query. Nur für Wurzelseiten relevant; auf Detailseiten (`.back.on`, z. B.
+Einzelfahrt) bleibt der Knopf unverändert 44px breit und funktionsfähig - live getestet
+(Klick navigiert zurück zur Liste).
+
+**Beleg nach Fix:** Versatz auf 4px reduziert (der verbleibende `gap` zum nächsten
+Flex-Element, nicht mehr wahrnehmbar).
+
+**Datei:** `homeassistant/www/audi-dashboard-ios.css`
+
+### Befund 5 — Graue Pfeile auf "Mein Audi" (Fahrzeug/Service/Versicherung/Reifen) überlappen Text
+
+**Root Cause:** `.tilebtn .go{top:50%;margin-top:-5px}` zentriert den Kachel-Chevron
+vertikal auf die **gesamte** Kachelhöhe. Diese fünf Kacheln sind aber keine Einzeiler,
+sondern `<span class="label">Titel</span>` + Chevron + eine ganze `dl.rows`-Liste darunter -
+die 50%-Mitte der gesamten Kachel liegt damit mitten in der Zeilenliste statt neben dem
+Titel, und überlappt besonders bei mehrzeilig umgebrochenen Werten (z. B. "2.9 TFSI quattro
+· 331 kW · 450 PS") sichtbar den Text.
+
+**Fix:** `top:50%;margin-top:-5px` aus der iOS-Auflage entfernt - fällt zurück auf
+`top:var(--sp-5)` aus der Basis, die den Chevron wieder neben den Titel oben in der Kachel
+setzt (dafür existiert dort bereits extra Padding: `.tile:has(> .go) > .label:first-child
+{padding-right:44px}`).
+
+**Betroffen:** alle 5 `.go`-Kacheln (Fahrzeug, Service, Versicherung/Steuer, Reifen,
+Schutzbrief Mobilität) - identisches Markup-Muster überall.
+
+**Datei:** `homeassistant/www/audi-dashboard-ios.css`
+
+### Befund 6 — "10.000 km" / "1 Jahr" (Ölwechsel-Intervall) sehen nicht editierbar aus
+
+**Root Cause:** Beide Werte sind echte `<select>`-Dropdowns, aber die iOS-Auflage entfernt
+Rahmen und Fläche komplett (`background:transparent;border:0`) und färbt den Wert in
+`--fg2` - demselben gedämpften Grau wie jeder andere Fliesstext. Kombiniert mit
+`appearance:none` (entfernt zusätzlich den nativen Auswahlpfeil des Browsers, base-CSS) gibt
+es keinerlei visuellen Hinweis, dass hier eine Auswahl möglich ist.
+
+**Fix:** `.feld select{color:var(--ios-tint)}` ergänzt - der Wert erscheint jetzt in der
+Marken-Akzentfarbe (Rot), dem iOS-üblichen Signal "hier gibt es eine Auswahl" bei
+Picker-artigen Feldern (anders als bei freien Texteingaben, die bewusst unverändert bleiben).
+
+**Datei:** `homeassistant/www/audi-dashboard-ios.css`
+
+### Befund 7 — Auf/Zu-Pfeile bei Gruppenkopfzeilen (z. B. "2026", "August" in Fahrten) sehen wie Häkchen aus
+
+**Root Cause:** `.mark` baut den Chevron aus der klassischen "zwei Kanten + 45°-Drehung"-
+CSS-Technik (`border-right`+`border-bottom`, `transform:rotate(-45deg/45deg)`). Diese
+Technik braucht zwingend ein **Quadrat** für eine saubere Pfeilform - `.mark` war aber
+6×10px (für die SVG-Chevrons `.chev`/`.go` gedacht, die eine eigene, absichtlich
+nicht-quadratische Pfad-Form nutzen). Die ungleich langen Kantenabschnitte (10px vs. 6px)
+ergeben verdreht eine Form, die eher wie ein Häkchen als ein Pfeil aussieht - besonders im
+per Default aufgeklappten Zustand (`rotate(45deg)`), in dem "2026"/"August" standardmässig
+starten.
+
+**Fix:** `.mark` auf 8×8px quadratisch gesetzt.
+
+**Datei:** `homeassistant/www/audi-dashboard.css`
+
+### Nicht reproduziert — Befund A: "Alle Menü-Icons haben eine graue Box"
+
+Programmatisch geprüft (`.tab`, `.tabpille`, `.tab svg`: `background`, `border`,
+`box-shadow`, `outline` für alle 5 Tabs sowohl im Seitenmenü (Desktop) als auch in der
+Tableiste unten (375px)): nur der **aktive** Tab hat eine (sehr dezente, 7% Deckkraft)
+graue Füllung - `.tab.on .tabpille{background:var(--tile-2)}`/`.tab.on{background:
+var(--ios-fill)}`, exakt wie beabsichtigt. Die vier inaktiven Tabs sind computed
+`rgba(0,0,0,0)` (vollständig transparent) auf allen geprüften Ebenen. Falls auf dem
+tatsächlichen Gerät etwas anderes zu sehen ist (z. B. alle 5 Icons mit sichtbarer Box),
+bräuchte es einen Screenshot vom echten Gerät/Browser, um die Abweichung von diesem
+Testcontainer einzugrenzen.
+
+### Nicht reproduziert — Befund B: "Roter Teilrahmen rechts an jeder Zeile" (Fahrten/Tanken)
+
+Geprüft: `.swipe-content{background:var(--tile-deckend)}` (deckend, #171B21 Nacht /
+#FFFFFF Tag) deckt den dahinterliegenden roten Löschen-Button (`.swipe-delete`,
+`rgb(255,69,58)`) vollständig ab - beide Boxen exakt deckungsgleich (`x`/`width`/`right`
+identisch bis auf Subpixel), kein CSS-seitiger Spalt gefunden. Bei 2.5x-Zoom (temporärer
+`transform:scale()` auf das Live-DOM, nicht deploybar, nur zur Inspektion) war am rechten
+Rand in Tag- und Nacht-Theme kein Rot sichtbar. Möglich, dass dies nur unter bestimmten
+Bedingungen auftritt (Swipe-Geste mitten in der Transition, ein bestimmter Zoom-/DPI-Stand
+auf dem echten Gerät) - ein Screenshot oder eine genauere Beschreibung, wann genau es
+auftritt (beim Laden, nach einer Wischgeste, permanent?), würde helfen.
+
+## Deployment
+
+Alle sieben Fixes deployed und verifiziert im `audi_ha_test`-Docker-Container
+(`audi-dashboard-version.json` → `1786744000`), nach `homeassistant/installationspaket/`
+synchronisiert. Konsole fehlerfrei bis auf die vorbestehenden, unbezogenen
+Service-Worker-/Platzhalterbild-404-Meldungen.

DESIGN_BRIEF_DATAMETRIC360.md

@@ -11,6 +11,16 @@ system attached. Then iterate screen by screen. See the step-by-step in the chat
 Entwirf eine App namens "DataMetric360" — eine private Fahrzeug-App für ein einzelnes Auto.
 Nutze ausschließlich die Komponenten aus dem angehängten Design-System (Audi Dashboard UI).
 
+WICHTIG — Marken-Assets:
+Anders als das angehängte Design-System (das bewusst neutral gehalten ist) darf diese App echte
+Audi-Marken-Assets verwenden: die vier Ringe, die Audi-Type-Schrift, die Modell-Typenschilder
+(RS 4 Avant competition). Kein generischer Ersatz nötig.
+
+WICHTIG — kein Fernsteuerungs-Charakter:
+Diese App ist eine reine Anzeige- und Erfassungs-App. Keine Bedienelemente zum Verriegeln,
+Entriegeln, Starten oder sonstigen Fernsteuern des Fahrzeugs entwerfen — auch nicht als Mockup
+oder Platzhalter, der das suggeriert.
+
 WICHTIG — Grundlagen:
 - Dunkles Theme ("Nacht") ist Standard, helles Theme ("Tag") existiert als Umschaltung.
 - Keine Schatten, keine Verläufe. Flache Kacheln, Pill-Buttons, Haarlinien als Trenner.

DESIGN_REVIEW_2026-08-13.md

@@ -0,0 +1,258 @@
+# Design-Review des `main`-Branch — Abgleich gegen die Audi-CI-Vorgaben des Repos
+
+**Datum:** 2026-08-13 · **Gegenstand:** `origin/main` @ `2a3c4f2` („Zugangswege zum privaten
+Repository dokumentieren und trennen") · **Nur Befunde, keine Änderungen.**
+
+> Hinweis vorab: Das **lokale** `main` hängt 28 Commits hinter `origin/main`. Dieses Review
+> basiert auf `origin/main` — der Stand mit FMM003-Umstellung, Setup-Menü, Standort-Feature und
+> der scharf geschalteten iOS-/Großbildschirm-Auflage.
+
+## Methode
+
+1. **Vorgaben-Checkliste** aus den Repo-Dokumenten destilliert (`bauauftrag.md`,
+   `SPECIFICATION.md`, `AUDIT_2026-08-10.md`, `DESIGN_BRIEF_DATAMETRIC360.md`, `AGENTS.md`,
+   `design-system/`-Tokens) — Farben, Typografie, Layout, Marke, Formate, Interaktion, A11y.
+2. **Code-Review** aller UI-Schichten auf `main` gegen diese Checkliste:
+   `homeassistant/www/` (Panel-JS + beide CSS), `design/`-Export, `design-system/`,
+   `companion-app/`.
+3. **Browser-Test mit Screenshots:** Das Panel wurde in einem Harness mit Mock-`hass`-Objekt
+   und realistischen Beispieldaten (Beispielprofil, 5 Fahrten, 3 Tankvorgänge, Fahrzeugstatus,
+   Setup-Katalog) headless in Chromium gerendert — iPhone-Viewport (390×844, hell + dunkel) und
+   Desktop (1440×900, Großbildlayout ≥860 px), alle 5 Tabs plus 10 Unterseiten, Einstellungen,
+   Einrichten-Formular und Setup-Popup. ~40 Screenshots, Pfade im Annex.
+
+**Grenzen:** Kein echtes Home Assistant, kein echtes iOS-Gerät. Native Steuerelemente
+(`<input type="date">`) und Leaflet-Verhalten können im Harness abweichen — solche Befunde sind
+unten ausdrücklich als „am Gerät verifizieren" markiert.
+
+---
+
+## Kernaussagen (TL;DR)
+
+1. **Die iOS-Auflage (`audi-dashboard-ios.css`) ist der größte offene CI-Konflikt.** Sie ersetzt
+   die dokumentierte Audi-Palette durch iOS-Systemfarben, führt Schatten und Blur ein, ändert den
+   Kachelradius auf 16 px und macht Rot zur Flächenfüllung — alles Verstöße gegen in mehreren
+   Dokumenten wiederholte, bindende Regeln, und **nirgends als Entscheidung dokumentiert**
+   (`design/README.md` sagt selbst, das sei „noch zu klären", faktisch ist es seit 2026-08-11
+   produktiv).
+2. **Die Rot-Semantik ist dadurch invertiert.** `ios.css` füllt jeden `.aktion`-Knopf rot. Sichtbare
+   Folge (Screenshots): im Setup-Popup ist **„Abbrechen" rot gefüllt und „Speichern" schwarz**;
+   „Einrichten", „Setup — Sensoren zuordnen", „In den Kalender übernehmen" und die
+   Notruf-/Telefonnummern sind großflächig rote Balken. Der Audit-Befund A7 („Rot bleibt Akzent
+   und Destruktiv") ist damit rückgebaut.
+3. **`design-system/` (Basis für DataMetric360) trägt den Vor-Audit-Stand:** kontrastschwaches
+   `--fg3 #657081` (WCAG-AA-Fail, im Panel längst korrigiert), Versalien-Sperrschrift in 6+
+   Komponenten, **kein einziger Fokus-Stil in der ganzen Bibliothek**, Formularfelder 13,5 px
+   (iOS-Zoom-Falle), IconButton 34 px. Wer die App darauf aufbaut, erbt behobene Fehler zurück.
+4. **Vier echte Darstellungs-/Zustandsfehler im Panel, im Browser nachgewiesen** (unten F1–F4),
+   darunter gestreckte Schalter mit widersprüchlicher Zustandsanzeige (Ursache identifiziert:
+   `.feld label { flex: 1 1 auto }` trifft auch `label.switch`).
+5. **Positiv:** Schriftgewichts-Regel (nur 300/400) wird zu 100 % gehalten, de-DE-Formate sind
+   praktisch lückenlos, `design-system/` ist nachweislich **marken-frei** (Lizenzregel bestanden),
+   die Marke steht auf jedem Layout genau einmal, und die neuen main-Features sind bei
+   aria-Attributen überdurchschnittlich sorgfältig.
+
+---
+
+## A. Grundsatzkonflikt: iOS-Auflage vs. Audi-CI (hoch)
+
+Verbindlich laut `bauauftrag.md` §Design, `SPECIFICATION.md` §Design und Audit: Palette als
+Rollen (Nacht `#161b23`/`#1f2733`, Tag `#FFFFFF`/`#f2f2f2`), Signalfarben `#15da15/#ffaa00/#fd2c4e`,
+Kachelradius 20 px, **keine Schatten, keine Verläufe** (einzige Ausnahme Fahrbahn/`.szene`),
+Rot `#F50537` nur als Akzent. Die seit 2026-08-11 aktive `audi-dashboard-ios.css` bricht das
+systematisch:
+
+| Regel | ios.css-Ist | Fundstelle |
+|---|---|---|
+| Nacht-Canvas `#161b23` | `#0C1014` | `audi-dashboard-ios.css:21-41` |
+| Tag: Canvas weiß, Kachel `#f2f2f2` | **invertiert**: Canvas `#F2F2F7`, Kachel `#FFFFFF` | ebd. |
+| Audi-Signalfarben | iOS-Systemfarben `#30D158/#FFD60A/#FF453A` bzw. `#34C759/#FF9F0A/#FF3B30` | ebd. |
+| Kachelradius 20 px (`--r-tile`) | `--r-tile: 16px` | `audi-dashboard-ios.css:16` |
+| Keine Schatten/Blur | `box-shadow` auf Segmented Control, Switch-Knopf, Popups; `backdrop-filter: blur()` auf Tabbar/Popups | `:116, :135, :156-166` |
+| Rot nie als Fläche | `.aktion{background:var(--ios-tint)}`, roter Schalter, `.tab.on` rot hinterlegt | `:118-136, :221` |
+| Safe-Area-Insets (Audit B1) | ersetzt durch Festwerte `padding:56px` / `26px` | `:65, :163` |
+| Trefferfläche ≥44 px (Audit B6) | `.back` auf **34×34 px** gedrückt | `:69` |
+
+Dazu kommt: `.setup-popup` und `.standortmenu` schreiben `border-radius: 20px` als **Literal**
+fest (`audi-dashboard.css:895, :744`) — mit dem ios-Token 16 px sind Popups sichtbar runder als
+alle Kacheln daneben.
+
+**Empfehlungscharakter (keine Umsetzung hier):** Entweder die iOS-Optik als neue verbindliche
+Linie dokumentieren (und `bauauftrag.md`-/`SPECIFICATION.md`-Regeln als ÜBERHOLT markieren, wie
+es die Projektkonvention für Entscheidungen vorsieht) — oder die Auflage auf das zurückschneiden,
+was mit der CI vereinbar ist. Der jetzige Zustand ist ein unbeschlossener Bruch.
+
+## B. Rot-Semantik invertiert (hoch, visuell belegt)
+
+- **Setup-Popup: „Abbrechen" rot gefüllt, „Speichern" schwarz** (Screenshot
+  `iphone-hell-15e-setup-popup.png`). Nach der eigenen Systematik (`.aktion` =
+  Umriss-Sekundäraktion, `.primaer` = gefüllt, Rot = destruktiv) liegt die Signalfarbe auf der
+  falschen Aktion.
+- Gleiche Ursache (`ios.css .aktion`-Füllung) auf: „Einrichten" (Einstellungen), „Setup —
+  Sensoren zuordnen" + schwarzes „Fertig" daneben (Einrichten-Formular), „In den Kalender
+  übernehmen" (Service, Reifen), beide Notrufnummern (Versicherung — drei rote Großflächen
+  untereinander auf einer Seite, `iphone-hell-07-versicherung.png`).
+- Ebenfalls rot gefüllt: alle Schalter im Ein-Zustand (A7-Rückbau), aktive Navigation
+  (`.tab.on` rosa hinterlegt, Desktop-Sidebar).
+- Kleinere Fälle: `--red` als Balkensegment für die neutrale Kategorie „Arbeitsweg"
+  (`audi-dashboard-app.js:2423`) und im Versicherungs-Beitragsbalken (`:1628`).
+
+## C. `design-system/` — Vor-Audit-Stand als DataMetric360-Basis (hoch)
+
+| Befund | Fundstelle | Schwere |
+|---|---|---|
+| `--fg3: #657081` — der im Audit als kontrastschwach identifizierte Wert (3,0:1 auf `--tile`), im Panel seit 2026-08-10 auf `#8a94a3` korrigiert; Bibliothek **und** `design/_ds`-Bundle tragen ihn weiter | `design-system/src/tokens/tokens.css:33`, `design/_ds/.../_ds_bundle.css:20` | hoch |
+| **Kein einziger Fokus-Stil** in Tokens + allen 20 Komponenten (Audit fordert `:focus-visible` 2 px `#F50537`; das Panel hat ihn) | gesamtes Paket, grep-verifiziert | hoch |
+| Formularfelder **13,5 px** → iOS-Auto-Zoom (Audit-Regel ≥16 px); propagiert bis in den `design/`-Entwurf (Bundle-Regel gewinnt gegen `.dm-in`) | `Feld/Feld.css:24-33`; `DM360.dc.html:24/41/44/422-428` | hoch |
+| Versalien-Sperrschrift in 6 Komponenten über die bekannten `.ads-label`/`.ads-eyebrow` hinaus; StatGrid/TabBar mit nur **9 px** | `ActionButton.css:7`, `Pill.css:6`, `Seg.css:14`, `SwipeRow.css:16`, `StatGrid.css:15`, `TabBar.css:39` | mittel |
+| TabBar: aktiver Tab = **roter Oberkantenstrich** statt gefüllter Pille — exakt das Muster, das der Audit (B5) im Panel abgeschafft hat | `TabBar.css:22-24` | mittel |
+| Trefferflächen: IconButton 34×34, Switch 46×27, Popup-Items ≈34 px, Seg ≈35 px | jeweilige Komponenten-CSS | mittel |
+| Literalfarben (`#fff` auf Switch-Knopf und SwipeRow) | `Switch.css:35`, `SwipeRow.css:11` | niedrig |
+| Englischer Default-UI-Text `deleteLabel = "Delete"` | `SwipeRow.tsx:27` | niedrig |
+| **Positiv: Markenreinheit bestanden** — keine Fonts/Ringe/Typenschilder im Paket (Lizenzregel eingehalten); keine Gewichte ≥500, keine Schatten, Radius über Token | — | ✓ |
+
+## D. `design/`-Export (mittel)
+
+- **Der RS-6-Fehler reicht bis in die Fachdaten**, nicht nur Badge/Name: „V8 biturbo · 600 PS",
+  441 kW, 3.996 cm³, 2.150 kg, Tank **73 l** (RS 4: 58 l), Reifen **285/30 R22**, FIN-Baureihe
+  „4G" statt „8W" (`DM360.dc.html:116-628` diverse). Die korrekten RS-4-Schilder liegen bereits
+  unter `design/uploads/RS-S Badges/` — nur `assets/` enthält die RS-6-Kopien.
+- **`design/datametric360-ios.css` und `homeassistant/www/audi-dashboard-ios.css` sind divergente
+  Geschwister**, keine Kopien: der `.ads`-Variante fehlen Fokusring, gefüllte Tab-Pille (sie färbt
+  stattdessen das Icon rot) und das komplette ≥860-px-Layout; die Panel-Variante hat dafür die
+  Schatten. Zwei Wahrheiten für dieselbe Optik → Drift vorprogrammiert.
+- **Einstellungen-Einstieg widersprüchlich:** Entwurf + `DESIGN_BRIEF` sagen Zahnrad oben rechts,
+  Panel/`SPECIFICATION` sagen Audi-Ringe (Zahnrad erst ≥860 px). Vor der App-Umsetzung entscheiden.
+- IconButton-Hints 36 px (`DM360.dc.html:78, 90`); variable Audi Type mit `font-weight: 100 900`
+  registriert (lädt zur Verletzung der 300/400-Regel ein, genutzt werden nur 300/400);
+  Literalfarben/Schatten im Präsentationsrahmen (nur Board, nicht App-UI).
+- `companion-app/` auf `main` ist nur die Datenschicht; der dort noch offene Feldnamen-Defekt
+  (`tank_prozent`/`sicher_abgestellt`/`sicherheit` vs. Backend) ist auf dem Arbeitsbranch behoben
+  und löst sich beim Merge — bis dahin auf `main` latent.
+
+## E. Panel-Frontend: weitere Verstöße gegen die Vorgaben (Auswahl)
+
+**Farben nur als Tokens:**
+- **iOS-Systemblau `#0A84FF`** als palettenfremde Farbe für den Nutzer-Pin
+  (`audi-dashboard.css:702, :707`) — Blau existiert in der Palette nicht. (hoch)
+- Kartensteuerung komplett aus Literalen (`rgba(16,20,26,.84)`, `#fff`, `#101418`;
+  `audi-dashboard.css:722-734`), Leaflet-Startmarker `#fff`/`#000`
+  (`audi-dashboard-app.js:459`), Scrims 2× `rgba(0,0,0,.45)` ohne Token. (mittel/niedrig)
+
+**Typografie:**
+- **Zweite und dritte Versalien-Stelle** neben `.eyebrow`: `.setup-gruppe-titel` (uppercase,
+  .1em — im Setup-Popup sichtbar) und `.marke-logo .ph` (`audi-dashboard.css:913, :481`). (mittel)
+- Die selbst gesetzte Regel „`--fg3` nie unter 12 px" wird an ≥7 Stellen gebrochen
+  (`.sync` 10,5 px, `.quad .l` 11 px, `row dd small` 11,5 px, mehrere Inline-11-px;
+  Kontrast 4,6:1 ist unter der WCAG-Großtext-Schwelle für so kleine Schrift). (mittel)
+
+**Layout/A11y:**
+- Schatten/Blur auch im **Haupt-CSS** (nicht nur ios.css): Pins, Kartensteuerung
+  (+`backdrop-filter`), Standortmenü, Setup-Entitätenliste (`audi-dashboard.css:697-745, :950`). (mittel)
+- Trefferflächen <44 px bei neuen Elementen: Standortmenü-Schließen 32 px,
+  Setup-Reset 26 px, Fahrtart-Pille ≈31 px, `.rings` im Basis-CSS nur 42×24 px (erst ios.css
+  hebt an — ohne geladene Auflage ist der einzige Einstellungszugang zu klein). (mittel)
+- Bei ausgeschalteter Tab-Beschriftung sind **alle fünf Tabs namenlos** (Text per
+  `display:none`, SVG `aria-hidden`, kein `aria-label`; `audi-dashboard-app.js:3072-3074`,
+  `audi-dashboard.css:266`). (mittel)
+- Escape schließt Sheet und Setup, aber nicht Bildmenü/SmartDeal-Popup/Standortmenü. (niedrig)
+- Koordinaten als einzige nicht-de-DE-Zahl im UI (`toFixed(4)` mit Punkt,
+  `audi-dashboard-app.js:786-789`). (niedrig)
+
+**Auf `main` bereits behoben** (bekannte Befunde, die nicht mehr gelten): die Ringe sind
+inzwischen ein echter `<button aria-label="Einstellungen">`, und das Setup-Popup **hat** Fokusfalle
++ Escape (`audi-dashboard-app.js:3054-3070`) — die Einträge in `REVIEW_main_2026-08-13.md` §7.10/6.13
+sind insoweit überholt (Rest: Trefferfläche).
+
+## F. Im Browser nachgewiesene Darstellungs-/Zustandsfehler
+
+**F1 — Schalter werden gestreckt und zeigen widersprüchlichen Zustand (Ursache identifiziert).**
+`audi-dashboard.css:493` `.feld label { flex: 1 1 auto }` trifft auch `label.switch` — der Schalter
+in einer `.feld`-Zeile wächst mit dem freien Platz (gemessen: **277–319 px statt 51 px** im
+Desktop-Einrichten-Formular; auch am iPhone auf der Reifen-Seite sichtbar verbreitert). Da der
+Knopf fix um `translateX(20px)` wandert, steht er auf der gestreckten Bahn optisch **links
+(= „Aus"), obwohl die Bahn rot (= „Ein") ist**. Screenshots `desktop-hell-14-einstellungen.png`,
+`iphone-hell-08-reifen.png`. (hoch — Zustandsanzeige mehrdeutig)
+
+**F2 — Offene Fahrten zeigen zweimal „offen" untereinander.** In der Fahrtenliste rendert der
+Wert-Slot `"offen"` und das `<small>` darunter `t.status` = „offen"
+(`audi-dashboard-app.js:2275`). Screenshot `iphone-hell-09-trips.png`. (niedrig)
+
+**F3 — Ölwechsel-Kachel der Übersicht bleibt komplett leer** bei leerem Servicebuch: `termine()`
+baut nur auf Servicebuch-Einträgen auf (`audi-dashboard-app.js:1522-1534`); ohne Eintrag sind
+`km`/`datum`/`kmDatum` null und die Kachel zeigt **nur das Label ohne jeden Wert** — kein
+Leerzustand nach der eigenen D5-Regel („Ursache und nächste Handlung nennen"), und die vom
+Fahrzeug gemeldeten Fälligkeiten (`oelwechsel_faellig_ts/km` waren im Test gesetzt) werden auf
+der Übersicht nicht herangezogen. Auch die Service-Seite zeigt daneben nur „kein Eintrag im
+Servicebuch". Screenshots `iphone-hell-01-home.png`, `iphone-hell-06-service.png`. (mittel)
+
+**F4 — Alle drei Leaflet-Karten rendern im Harness nur fragmentarisch** (Übersichts-Kachel,
+Standort-Vollbild, Einzelfahrt/Beleg): Kacheln erscheinen nur in Teilbereichen, der Rest bleibt
+canvas-farbig — unverändert auch nach 4 s Wartezeit, also kein Ladeproblem, sondern
+Initialisierungs-/`invalidateSize`-Timing (Karte wird aufgebaut, bevor der Container seine
+endgültige Größe hat). **Am echten HA/Gerät verifizieren** — falls dort reproduzierbar, ist es
+der sichtbarste Fehler der neuen Standort-Features. Screenshots `iphone-hell-02b-standort-lang.png`,
+`desktop-hell-01-home.png`, `iphone-hell-10-trip-detail.png`. (verifizieren)
+
+**Weitere Beobachtungen (verifizieren, evtl. Harness-Artefakte):**
+- Native Datumsfelder zeigten `mm/dd/yyyy` (Werkstatttermin, Reifenwechsel) — `<input type=date>`
+  formatiert nach System-Locale; am deutschen iPhone vermutlich korrekt, auf Desktop-Browsern mit
+  englischer UI nicht. Kein Codefehler, aber ein bekannter Plattform-Seiteneffekt.
+- FIN-Wert im Einrichten-Formular rechts abgeschnitten ohne Ellipse
+  (`iphone-hell-15-setup.png`).
+- Im Desktop-Layout wirkte der Fahrzeugbild-Platzhalter der Übersicht gestaucht
+  (Beschriftung ragt an die Kachelkante, `desktop-hell-01-home.png`).
+
+## G. Was konsequent eingehalten wird (positiv)
+
+- **Schriftgewichte:** kein einziges `font-weight` ≥500 in ~5.300 Zeilen Panel-Code; alle
+  `<strong>`-Kontexte bewusst auf 400 neutralisiert; `tabular-nums` global. Auch design-system
+  und Entwurf nutzen nur 300/400.
+- **de-DE-Disziplin:** zentrales `de()/eur()/dedat()`-Trio, jeder Locale-Aufruf explizit
+  `"de-DE"`, ISO nur wo die Plattform es verlangt; im Entwurf durchgehend deutsche Texte und
+  Formate. Einzige Grauzone: Koordinaten (E, niedrig).
+- **Marke:** Typenschild exakt 18 px mit CSS-Theme-Wechsel (positive/negative-SVG); Marke steht
+  in jedem Layout genau einmal (Ringe mobil, `.navmarke` in der Desktop-Sidebar + Zahnrad);
+  `design-system/` nachweislich asset-frei — die harte Lizenzregel wird eingehalten.
+- **A11y der neuen Features:** Kartensteuerung mit präzisen `aria-label` + `aria-pressed`,
+  Standortmenü-Griff mit `aria-expanded/-controls` und 88×44-px-Trefferfläche, Setup-Dialog mit
+  `role="dialog"`, Fokusfalle und Escape; 16-px-Formularregel im Panel konsequent (inkl. neuem
+  Combo-Input).
+- Ehrliche Leerzustände („kein Eintrag im Servicebuch", „Fahrt ohne Ortsangabe", Startort
+  „unbekannt") statt erfundener Werte — mit Ausnahme F3.
+
+## H. Widersprüche in den Vorgaben selbst (fürs Aufräumen der Dokumente)
+
+1. `--fg3` hat **drei Werte im Repo**: `#657081` (bauauftrag, design-system, \_ds-Bundle) vs.
+   `#8a94a3` (SPECIFICATION, Panel) — der Audit hat nur SPEC nachgezogen.
+2. Kontrastangabe inkonsistent: CSS-Kommentar sagt „4,6:1", der Audit rechnet 5,6:1/4,9:1.
+3. `SPECIFICATION.md` ist bei Platzhaltern (nennt noch „exact expected filename", vom Audit
+   abgeschafft) und bei `confirm()`/Action-Sheet (B4) veraltet; §7.8 behauptet, `--sp-*`/`--r-func`
+   existierten nicht — sie existieren, werden aber (das stimmt) teils nicht genutzt.
+4. `DESIGN_BRIEF` (Zahnrad, Live-Telemetrie) widerspricht `bauauftrag.md`/`SPECIFICATION.md`
+   (Ringe, „keine Live-Telemetrie"); Auflösung über FMM003 ist nirgends explizit festgehalten.
+5. Bildmaße: `bauauftrag.md` nennt 206/165/78 px, der Code nutzt aspect-ratio + 96 px — Absicht
+   erfüllt, Zahlen nie als überschrieben dokumentiert.
+
+## Zählung (konsolidiert, ohne Doppelzählung der Sammelthemen)
+
+| Bereich | hoch | mittel | niedrig | verifizieren |
+|---|---|---|---|---|
+| A/B iOS-Auflage + Rot-Semantik | 2 Themenkomplexe (≥10 Einzelstellen) | — | — | — |
+| C design-system | 3 | 3 | 2 | — |
+| D design/-Export | — | 4 | 3 | — |
+| E Panel-Einzelbefunde | 1 | 8 | 6 | — |
+| F Browser-Nachweise | 1 | 1 | 1 | 4 |
+
+## Annex: Screenshots
+
+Liegen (sitzungsgebunden, nicht im Repo) unter
+`/private/tmp/claude-501/-Users-paul-Development-audi-app/a6c2c477-dbf4-43ec-9a25-88d762b653bf/scratchpad/harness/shots/`.
+Benennung: `iphone-hell-*` (390×844 hell), `iphone-dunkel-*`, `desktop-hell-*` (1440×900).
+Harness: `…/scratchpad/harness/` (`index.html` = Mock-`hass`, `shots*.mjs` = Playwright-Läufe,
+`profil.json` = Beispielprofil) — reproduzierbar gegen jeden Stand von `homeassistant/www/`.
+
+Aussagekräftigste Belege: `15e-setup-popup` (Abbrechen rot/Speichern schwarz),
+`14-einstellungen` + `desktop-14` (rote Flächen, gestreckte Schalter), `07-versicherung`
+(3 rote Großflächen), `08-reifen` (Schalter-Zustand mehrdeutig), `09-trips` (doppeltes „offen"),
+`01-home` (leere Ölwechsel-Kachel, Kartenfragment), `02b-standort-lang` (Kartenfragment nach 4 s).

OFFEN.md

@@ -0,0 +1,149 @@
+# Was jetzt zu tun ist (DM360)
+
+**Die eine Datei, die den aktuellen Stand nennt.** Wer wissen will, was ansteht,
+liest hier - nicht in 12.000 Zeilen `AGENTS.md`.
+
+Die drei Dateien teilen sich die Arbeit so:
+
+| Datei | beantwortet |
+|---|---|
+| **`OFFEN.md`** (hier) | **Was ist zu tun?** |
+| `APPLE_DEV_BACKLOG.md` | Was davon braucht Xcode oder das Apple-Portal? |
+| `AGENTS.md` | **Warum** ist etwas so, wie es ist - die Geschichte, nicht der Zustand |
+
+**Arbeitsregel (verbindlich):** diese Datei wird in **derselben Sitzung**
+nachgeführt, in der sich etwas ändert - erledigt, dazugekommen, entschieden.
+Eine Liste, die man erst am Monatsende pflegt, ist keine.
+Aufruf: **`/stand`** prüft den mechanischen Teil selbst nach und liest diese
+Datei dazu.
+
+---
+
+## 1. Wartet auf Sie
+
+### 1.1 Ein Xcode-Lauf - **zwei Funktionen sind auf dem Telefon tot**
+
+Zwischenablage und Kalendereintrag sind in der installierten App wirkungslos.
+Beide Korrekturen liegen im Repository und warten nur auf einen Lauf.
+
+*Was zu tun ist:* am Mac nur
+`bash companion-app/scripts/ios-signieren.sh`, danach die fertige `.ipa` pushen
+(das Telefon lädt sie aus dem Repository). Ein Befehl - das Skript prüft sich
+selbst und bricht ab, wenn etwas fehlt; von Hand bleiben das
+Schlüsselbund-„Immer erlauben" beim ersten Signieren und die Probe auf dem
+Gerät.
+
+**Die Datei, die man dafür in die Hand nimmt, ist
+[`APPLE_DEV_BACKLOG.md`](APPLE_DEV_BACKLOG.md)** - sie trägt den Ablauf, den
+Stand und die Prüfliste; Abschnitt „Wie ein Lauf abläuft", dann A1 und A2.
+
+### 1.2 Gitea-Token für den Laborzweig DM180
+
+Nicht dieses Repository - der Laborzweig (`tobias/Data-Metric-180`, privat).
+Seine Selbstaktualisierung zeigt seit dem 06.09.2026 auf das eigene Repository,
+ihr fehlt nur noch der Zugang.
+
+*Was zu tun ist:* in der Laborinstanz unter Einstellungen -> Geräte & Dienste ->
+Audi Dashboard -> Konfigurieren einen Gitea-Token mit Lesezugriff eintragen.
+
+### 1.3 `steuer.faellig` ist leer
+
+Betriebsdaten, kein Code - die Kfz-Steuer hat kein Fälligkeitsdatum.
+
+*Was zu tun ist:* in der App unter Mein Audi -> Versicherung/Steuer eintragen.
+
+---
+
+## 2. Wartet auf eine Entscheidung von Ihnen
+
+### 2.1 Die Übersicht-Box „Versicherung/Steuer" neu gestalten
+
+Seit dem 19.08.2026 vorgemerkt und **bewusst nicht begonnen**: Sie hatten
+gesagt, Sie wüssten noch nicht, was Sie dort sehen wollen. Ein Entwurf ohne
+diese Antwort wäre geraten.
+
+*Was zu tun ist:* ein kurzes Gespräch darüber, was auf einen Blick sichtbar sein
+soll und was auf die Detailseiten gehört. Danach wie üblich erst ein Muster,
+dann Code.
+
+---
+
+## 3. Wartet auf eine Sitzung
+
+Buildbar, ohne Rückfrage, in dieser Reihenfolge sinnvoll:
+
+### 3.1 Versicherung: PDF der Vertragsdetails ablegen
+
+Die Police als PDF an den Vertrag hängen und später wieder ansehen können.
+
+*Was zu tun ist:* zuerst den Ablageort entscheiden - spiegelt es die vorhandene
+Fotoablage unter `/config/audi_dashboard/`, oder wird es ein eigenes
+Anhang-Konzept? Danach Dienst, Ablage und beide Oberflächen (Paritätsregel).
+
+### 3.2 Versicherung: freies Notizfeld
+
+Eine eigene Zusammenfassung zur Versicherung, aus keinem strukturierten Feld
+abgeleitet.
+
+*Was zu tun ist:* Profilfeld, Textfeld in beiden Oberflächen. Das Panel hat mit
+`.feld--breit` bereits das Muster für ein Feld über die volle Breite.
+
+### 3.3 Restliche Dokumentendrift
+
+`SPECIFICATION.md`, `homeassistant/README.md` und die Profilvorlage nennen noch
+den WLAN-Sensor, der am 12.08.2026 entfallen ist; dazu eine falsche Aussage über
+Beispielzahlen in der Statistik und ein überholter TODO-Kommentar.
+
+*Was zu tun ist:* reine Textkorrekturen, kein Code.
+
+---
+
+## 3b. Optisch noch nicht gesehen
+
+**Erledigt am 07.09.2026.** Die Markierung überschrittener Servicetermine
+(Abschnitt DJ) ist jetzt auch im **Panel** live gesehen und gemessen -
+Übersicht und „Mein Audi", Tagmodus, Fassung 2026.9.6.9.
+
+Das Erstzulassungsdatum im Testcontainer war dafür vorübergehend auf
+01.03.2020 zurückdatiert und ist am 07.09.2026 auf **01.03.2025**
+zurückgestellt; die Sicherung `fahrzeugprofil.json.ansicht` ist entfernt.
+
+*Offen bleibt allein:* der **Nachtmodus** ist nur gerechnet, nicht gesehen.
+
+Die Beschreibung zum Nachziehen in einem Spin-off steht in
+`PORTIERUNG_UEBERSCHRITTEN.md`; als teilbare Seite unter
+<https://claude.ai/code/artifact/8f2eb15e-1107-45bc-bd04-78b19fa06a4b>.
+
+## 4. Gemeldet, aber nicht reproduzierbar
+
+Beide mehrfach gesucht und **nicht gefunden**. Sie bleiben stehen, bis sie
+wieder auftreten - raten hilft hier nicht.
+
+* **Das Kartenebenen-Symbol im Standort-Blatt** wirkt fehlerhaft. Dreimal
+  geprüft (Markup, Funktion, gerechnete Farbwerte), jedes Mal deckungsgleich mit
+  dem Panel. *Was hilft:* ein Bildschirmfoto vom Gerät.
+* **Die Batteriespannungs-Zeile lässt sich am Rechner nicht antippen.** Mit
+  Trefferpunkt-Prüfung, synthetischen und echten Klicks getestet - navigiert
+  jedes Mal korrekt. *Was hilft:* die Fensterbreite und ein Blick in die
+  Browser-Konsole im Moment des Fehlversuchs.
+
+---
+
+## 5. Bekannte Grenzen - bewusst so, nicht offen
+
+Damit sie nicht als Fehler wiederkommen:
+
+* **Der Fahrtbeginn liegt bis zu neun Minuten zu spät.** Der Dongle wacht erst
+  über den Beschleunigungssensor auf; die verschlafenen Kilometer holt die App
+  seit `2026.9.6.2` aus dem Kilometerstand zurück, den *Zeitpunkt*
+  zurückzurechnen haben Sie abgelehnt, solange es eine gerechnete statt
+  gemeldeten Zahl wäre.
+* **Werkbank und Fahrzeug lassen sich nicht automatisch trennen.** Ein
+  Werkbank-Schalter wurde am 06.09.2026 angeboten und abgelehnt - Sie
+  entscheiden selbst, welche Messwerte bleiben, über das Wischen in der
+  Messwertliste. **Nicht erneut vorschlagen.**
+* **Das Panel wird nicht gelöscht, sondern archiviert** - aber erst, wenn die App
+  es wirklich abgelöst hat. Heute nicht.
+* **HACS ist ein Sackgassenweg**, dauerhaft: es lehnt private Repositories
+  kategorisch ab. `install.ps1` ist der einzige Installationsweg, die
+  Selbstaktualisierung der einzige Aktualisierungsweg.

PORTIERUNG_UEBERSCHRITTEN.md

@@ -0,0 +1,246 @@
+# Überschrittene Servicetermine — Beschreibung zum Nachziehen
+
+Stand 07.09.2026, Fassung `2026.9.6.9`, Commit `33c2ffa` (und Vorläufer).
+Gedacht für ein Spin-off dieser App: alles, was gebraucht wird, um dieselbe
+Markierung dort noch einmal zu bauen — einschließlich der Gründe, damit die
+Entscheidungen nicht neu erraten werden müssen.
+
+**Teilbare Fassung:** dieselbe Beschreibung als Seite, mit echt gerenderten
+Farbmustern für Tag und Nacht -
+<https://claude.ai/code/artifact/8f2eb15e-1107-45bc-bd04-78b19fa06a4b>
+(standardmäßig privat; teilbar über das Teilen-Menü auf der Seite). Sie ist
+markenfrei gehalten: keine lizenzierten Schriften, Embleme oder Modellzeichen.
+Änderungen an dieser Datei dort nachziehen, sonst laufen die beiden Fassungen
+auseinander.
+
+Betroffen sind **zwei Codebasen**, die nach der Paritätsregel immer denselben
+funktionalen Stand haben: das Home-Assistant-Panel
+(`custom_components/audi_dashboard/frontend/`) und die Companion-App
+(`companion-app/src/`). Wer nur eine davon nachzieht, hat einen latenten Fehler.
+
+---
+
+## 1. Was die Markierung leistet
+
+Ein Servicetermin, dessen Fälligkeitstag erreicht oder überschritten ist, wird
+an drei Stellen hervorgehoben:
+
+| Ort | Darstellung |
+|---|---|
+| Service-Blatt | die betroffene Termingruppe blass gelb hinterlegt, Marke „überschritten" im Kopf |
+| „Mein Audi", Service-Kachel | **nur die betroffene Zeile** blass gelb, Marke links vom Wert |
+| Übersicht, Kachel „Nächster Service" | Kennzahl in kräftigem Orange, Marke rechts daneben |
+
+Zwei Randbedingungen, die der Eigentümer ausdrücklich gesetzt hat:
+
+* Auf der Übersicht darf die Marke die Kachel **nicht höher machen** — sie steht
+  deshalb in derselben Zeile wie die Kennzahl, nicht darunter.
+* In „Mein Audi" wird **nicht die ganze Kachel** hinterlegt, sondern nur das
+  überschrittene Feld. Eine Zwischenfassung hatte die Kachel als Ganzes getönt;
+  das wurde zurückgewiesen.
+
+---
+
+## 2. Die Fachregel: entschieden wird am Datum
+
+`terminUeberschritten(...kandidaten)` — im Panel in `audi-dashboard-app.js`, in
+der App exportiert aus `src/daten/service.ts`.
+
+**Regel:** Nimm das **erste lesbare Datum** der übergebenen Kandidaten und melde
+`true`, sobald es nicht mehr in der Zukunft liegt. Der Fälligkeitstag selbst
+zählt mit.
+
+Drei Punkte, die beim Nachbau leicht falsch gemacht werden:
+
+1. **Nicht an den Restkilometern entscheiden.** Die Kilometerseite trägt je nach
+   Quelle ein anderes Vorzeichen: die Fahrzeugsensoren melden negativ, solange
+   noch Strecke bleibt (gemessen: `oil_change_distance` = −28600 bei Fälligkeit
+   2028), und die Prognosefunktion klemmt ihre Restkilometer mit
+   `Math.max(0, …)`. Welches Vorzeichen ein überschrittener Fahrzeugwert trägt,
+   ist an den vorliegenden Daten **nicht beobachtbar**. Der km-Fall fällt ohnehin
+   unter die Datumsregel, weil die Prognose das Datum auf heute setzt, sobald die
+   Restkilometer auf 0 laufen.
+2. **Das erste lesbare Datum nehmen, nicht das früheste.** Es ist genau das
+   Datum, das an der Stelle auch angezeigt wird — so kann die Markierung nicht
+   von dem abweichen, was daneben steht.
+3. **Volle ISO-Zeitstempel mitlesen.** Die Fahrzeugmeldung liefert
+   `"2027-10-21T00:00:00+00:00"`, und sie ist bei Ölwechsel und Inspektion die
+   Hauptquelle. Der verankerte Textparser lehnt Zeitstempel ab; ohne einen
+   eigenen Zweig dafür gälte die Hauptquelle stillschweigend **nie** als
+   überschritten. Im Panel macht das `zeitstempelAlsDatum()` mit einem auf
+   `JJJJ-MM-TT` plus `T` verankerten Ausdruck; in der App kann `alsZeitpunkt()`
+   das bereits. Der Fehler wurde vom Test gefangen, nicht im Betrieb — er wäre
+   still geblieben.
+
+Bewusst eng gefasst statt einem allgemeinen `new Date()`: sonst deutete der
+Rückfall auch Zeichenketten, die der Textparser gerade abgelehnt hat.
+
+---
+
+## 3. Die Farben: jedes Element an seiner eigenen WCAG-Schwelle
+
+Das ist der Teil, der zwei Anläufe gebraucht hat, und der Grund dafür ist
+übertragbar: **kräftiges Orange ist bei 4,5:1 nicht zu haben.** Apples
+systemOrange `#FF9500` kommt auf Weiß auf 2,20:1; jedes Orange, das 4,5:1
+schafft, ist so dunkel, dass es als Braun gelesen wird. Zwei Anläufe mit einer
+einzigen Textfarbe (`#A15800`, dann Apples `#C55300`) wurden beide als „braun
+statt gelb" zurückgewiesen — zu Recht.
+
+Die Lösung ist nicht ein besserer Kompromisston, sondern **die Trennung der
+Rollen**, jede an ihrer eigenen Schwelle:
+
+| Rolle | Größe | Schwelle | Tag | Nacht |
+|---|---|---|---|---|
+| `--warn` (Fläche, 12 % hinterlegt) | — | — | `#FF9F0A` | `#FFD60A` |
+| `--warn-fig` (Kennzahl) | 32 px = Großtext | 3:1 | `#DD6000` | `#FF9F0A` |
+| `--warn-marke-grund` (Pille) | — | — | `#C55300` | `#FFA056` |
+| `--warn-marke-schrift` | 10,5 px = Kleintext | 4,5:1 | `#FFFFFF` | `#171B21` |
+| `--warn-text` (Schrift auf hellem Grund) | klein | 4,5:1 | `#C55300` | `#FFA056` |
+
+Gemessen (WCAG 2.1, Hülle = 12 % `--warn` auf dem jeweiligen Kachelgrund):
+
+* `#DD6000` → 3,65:1 auf Weiß, 3,34:1 auf der Hülle (Schwelle 3:1) ✔
+* Weiß auf `#C55300` → 4,55:1 (Schwelle 4,5:1) ✔
+* `#FF9F0A` auf `#171B21` → 8,41:1 ✔
+* `#171B21` auf `#FFA056` → 8,57:1 ✔
+
+**Der entscheidende Kniff bei der Marke:** keine dünne Schrift, sondern eine
+**gefüllte Pille**. Derselbe Ton liest sich als Fläche eindeutig als Orange,
+während er als 1 px starker Buchstabenstrich bräunlich wirkt. Weiße Schrift auf
+`#C55300` erfüllt die 4,5:1 exakt so, wie es umgekehrt nicht ginge.
+
+Tokens liegen in `frontend/audi-dashboard-ios.css` (Panel) und
+`design-system/src/tokens/tokens.css` (App) — beide Sätze müssen gleich sein.
+
+**Zur Frage HIG oder Audi CI:** die Fläche ist Apple (iOS-Palette, 2026-08-13
+übernommen); das Audi-CI-Gelb `#ffaa00` wurde damals abgelöst und liefert als
+Schrift nur 1,91:1. Die Schriftwerte sind **gerechnet, nicht übernommen** —
+Apples eigener Kontrastwert `#A16A00` liefert auf der 12 %-Hülle nur 4,19:1.
+Nebenbefund: Apples HIG-Seite führt inzwischen die neue („unified") Palette;
+einen einzelnen Wert daraus zu übernehmen wäre inkonsistent gewesen.
+
+---
+
+## 4. CSS
+
+Gleiche Regeln in beiden Codebasen, nur andere Klassennamen
+(Panel `audi-dashboard.css` / App `src/stile/screens.css`):
+
+| Panel | App |
+|---|---|
+| `.termingruppe.ueberschritten` | `.dm-termingruppe--ueberschritten` |
+| `.row.ueberschritten` | `.dm-wertzeile--ueberschritten` |
+| `.ueberschritten-marke` | `.dm-ueberschritten-marke` |
+| `.serviceblock.ueberschritten .fig` | `.dm-serviceblock--ueberschritten .ads-fig` |
+| `.fig-zeile` | `.dm-servicefig` |
+
+Die Tönung:
+
+```css
+background: color-mix(in srgb, var(--warn) 12%, transparent);
+border-radius: var(--r-tile);
+padding-left: 12px;  padding-right: 12px;
+margin-left: -12px;  margin-right: -12px;
+```
+
+Die negativen Außenabstände sind der Punkt: sie lassen die Tönung bis an den
+Kachelrand laufen, obwohl die Zeile selbst im Innenabstand der Kachel sitzt.
+Prüfbar am gemessenen Breitenunterschied — getönte Zeile 752 px gegenüber 728 px
+der übrigen, also genau 2 × 12 px.
+
+Die Pille:
+
+```css
+font-size: 10.5px; font-weight: 600;
+color: var(--warn-marke-schrift); background: var(--warn-marke-grund);
+border-radius: var(--r-pill); padding: 3px 8px;
+white-space: nowrap; flex: 0 0 auto;
+display: inline-block; vertical-align: middle;
+```
+
+Platzierung: `.fig-zeile .ueberschritten-marke { margin-left: 10px }` (Übersicht,
+rechts der Kennzahl in derselben Zeile) und
+`.row .ueberschritten-marke { margin-right: 8px }` („Mein Audi", links des Werts).
+
+Dazu `.termingruppe.ueberschritten, .termingruppe.ueberschritten + .termingruppe
+{ border-top: 0 }` — sonst schneidet die Trennlinie durch die getönte Fläche.
+
+---
+
+## 5. Markup
+
+**Übersicht** — die Marke muss in dieselbe Zeile wie die Kennzahl, sonst wächst
+die Kachel. Die Zeile wird deshalb **immer** gebaut, auch ohne Marke:
+
+```js
+const figMarkup = `<div class="fig-zeile">${artIcon ? ciSVG(artIcon, 31) : ""}`
+  + `<div class="fig" style="font-size:${zahlGroesse}px">${hauptwert}</div>`
+  + `${ueber ? UEBERSCHRITTEN_MARKE : ""}</div>`;
+```
+
+Die Kennzahl steht auf **32 px** (vorher 40 px, auf Rückmeldung „wirkt sehr groß"
+reduziert). 32 px liegt über der 24-px-Grenze für Großtext — das ist die
+Voraussetzung dafür, dass `--warn-fig` mit 3:1 auskommen darf.
+
+**„Mein Audi"** — Marke **vor** dem Wert, Klasse an der Zeile, **nicht** an der
+Kachel:
+
+```js
+return `<div class="row${ueber ? " ueberschritten" : ""}" ${letzte}>
+  <dt>…</dt>
+  <dd>${ueber ? UEBERSCHRITTEN_MARKE : ""}${haupt}…</dd></div>`;
+```
+
+In der App reicht `Wertzeile` dafür eine Eigenschaft `ueberschritten?: boolean`
+durch, die die Klasse am Zeilen-`div` setzt.
+
+---
+
+## 6. Tests
+
+* `service.test.ts` — Fälle für `terminUeberschritten()` (Grenztag, Zukunft,
+  Vergangenheit, leere und unlesbare Kandidaten, Zeitstempel).
+* `paritaet_ueberschritten.test.ts` — 14 Fälle, die die Panel-Funktion **aus dem
+  Quelltext herausschneiden** und gegen die App-Funktion laufen lassen. Das ist
+  der Mechanismus, der die Paritätsregel überhaupt durchsetzt; ohne ihn driften
+  die beiden Fassungen auseinander, ohne dass es auffällt.
+* `screens.test.tsx` — Render-Tests gegen ein überschrittenes Profil.
+* `buendelversion.test.ts` — hält `manifest.json`-Version, `bundle.json` und die
+  tatsächliche `bundle.zip` zusammen. Nach jeder UI-Änderung Version heben und
+  Bündel neu bauen, sonst schlägt dieser Test fehl.
+
+---
+
+## 7. Fallen, die Zeit gekostet haben
+
+1. **Stylesheets im Panel greifen asynchron.** Direkt nach dem Neuladen liefert
+   eine Messung die UA-Vorgabe — die Pille erbt dann `13,3333px` schwarz aus dem
+   umgebenden `<button>`. Das sieht exakt so aus, als würde die Regel nicht
+   greifen, und hat hier eine lange Fehlersuche ausgelöst (bis hin zum Einspielen
+   einer Testregel zur Laufzeit, die aus demselben Grund ebenfalls „nicht
+   griff"). **Vor dem Messen warten und auf den Zielwert pollen**, nicht einmal
+   messen und daraus schließen.
+2. **Ein Testfall, der den Fall gar nicht auslöst.** Der erste Render-Test war
+   mit einem Wartungsplan-Datum bestückt, das noch in der Zukunft lag — grün,
+   aber wertlos. Ebenso: synchrone Zusicherungen gegen asynchron geladene Daten
+   brauchen `waitFor`.
+3. **Der Fall muss erst erzeugt werden.** Zum Ansehen wurde die Erstzulassung im
+   Testcontainer vorübergehend auf `01.03.2020` zurückdatiert (Sicherung daneben,
+   hinterher zurückgestellt). Ohne das ist nichts überschritten und es gibt
+   nichts zu sehen.
+4. **Der Nachtmodus ist hier nur gerechnet, nicht gesehen.** Wer ihn im Spin-off
+   nutzt, sollte ihn einmal ansehen.
+
+---
+
+## 8. Reihenfolge zum Nachziehen
+
+1. `terminUeberschritten()` in beiden Codebasen, mit dem Zeitstempel-Zweig.
+2. Tokens `--warn-fig`, `--warn-marke-grund`, `--warn-marke-schrift` in beide
+   Token-Dateien.
+3. CSS-Blöcke in beiden Stildateien.
+4. Markup: Übersicht (Zeile immer bauen, 32 px), „Mein Audi" (Klasse an der
+   Zeile), Service-Blatt (Termingruppe).
+5. Tests, **einschließlich** des Paritätstests.
+6. Version heben, Design-System bauen, OTA-Bündel bauen.
+7. Live ansehen — mit zurückdatiertem Datum, und mit Wartezeit vor der Messung.

README.md

@@ -0,0 +1,108 @@
+# Audi Dashboard — „Mein Audi" für Home Assistant
+
+Fahrtenbuch, Tankstatistik, Reifen- und Servicebuch für ein einzelnes
+Fahrzeug — als eigener Sidebar-Eintrag in Home Assistant und als iOS-App, die
+dieselben Daten zeigt.
+
+Die App wertet aus, was Home Assistant ohnehin über das Fahrzeug weiß
+(Zündung, Kilometerstand, Tankfüllstand, Bordspannung, GPS — etwa über einen
+Teltonika FMM003 oder eine EU-Data-Act-Integration des Herstellers), und macht
+daraus einen dauerhaften Bestand: erkannte Fahrten, erkannte Tankvorgänge,
+Belegdaten aus hochgeladenen Tank-PDFs, ein Spannungsverlauf über Jahre.
+
+> Privates Projekt für ein bestimmtes Fahrzeug. Es ist nicht als allgemein
+> nutzbare Integration gedacht und steht in keinem Verhältnis zur AUDI AG.
+
+---
+
+## Installation
+
+HACS scheidet aus, und zwar endgültig: laut eigener Dokumentation
+(hacs.xyz/docs/faq/private_repositories) kann HACS **grundsätzlich nicht**
+mit privaten GitHub-Repositories arbeiten — „HACS can only get publicly
+available information", ohne Ausnahme für Tokens oder verbundene Konten. Und
+öffentlich machen ist keine Option: das Repository enthält die
+Audi-Hausschrift und die Typenschilder, die nur für diese eine private
+Installation lizenziert sind.
+
+Der Installer unten ist deshalb nicht die zweite Wahl, sondern der einzige
+Weg für die **Erstinstallation** — die Integration muss laufen, bevor sie
+sich selbst aktualisieren kann.
+
+Für **Updates danach** gibt es seit 2026-08-24 einen zweiten, bevorzugten
+Weg: die Integration lädt ihre neueste Fassung direkt von Gitea und ersetzt
+sich selbst (Einstellungen → Geräte & Dienste → Audi Dashboard →
+Konfigurieren, dort ein Gitea-Zugriffstoken eintragen; danach in der App
+unter Einstellungen → Integration-Update). Grund: Windows Smart App Control
+blockiert die Ausführung von `install.ps1` zuverlässig und lässt sich —
+anders als der SmartScreen davor — nicht per „trotzdem ausführen" umgehen.
+Der Installer unten bleibt der Weg für die Erstinstallation und für den
+seltenen Fall, dass das Selbst-Update selbst nicht mehr erreichbar ist.
+
+Von einem Windows-Rechner aus, der das `config`-Verzeichnis der HA-Instanz
+erreicht (Samba-Add-on oder gemounteter Pfad):
+
+```
+homeassistant\installationspaket\Installieren.cmd
+```
+
+Das Skript kopiert `custom_components\audi_dashboard\` in die Instanz und
+fasst sonst nichts an — keine `configuration.yaml`, keine Fahrzeugdaten. Mit
+`-Pruefen` zeigt es vorher, was es tun würde. Details und die
+Sicherheitszusagen stehen im Kopf von
+[`install.ps1`](homeassistant/installationspaket/install.ps1).
+
+Danach ebenfalls: neu starten, Integration hinzufügen.
+
+## Nach der Installation
+
+**Sensoren zuordnen** — **Einstellungen → Fahrzeug einrichten → Setup** in der
+App. Im Auslieferstand ist bewusst *kein* Sensor vorbelegt: welche Entity-IDs
+richtig sind, hängt an der Instanz, und eine gesetzte, aber falsche ID ist
+schlechter als eine leere. Zwingend ist allein der Zündungs-/ACC-Sensor — er
+trägt die Fahrterkennung. Änderungen wirken sofort, ohne Neustart.
+
+**Datenaufbewahrung verlängern** — Home Assistant löscht Sensor-Verläufe nach
+10 Tagen. Das begrenzt, wie weit „Daten importieren aus Home Assistant"
+zurückreichen kann, und was einmal gelöscht ist, kommt nicht wieder. Der Block
+aus [`recorder_snippet.yaml`](homeassistant/recorder_snippet.yaml) hebt das
+auf ein Jahr an; dort steht auch der gemessene Platzbedarf. Bewusst nicht
+automatisch eingefügt: das ist eine Entscheidung über den Plattenplatz der
+Instanz.
+
+**Vergangenes nachholen** — **Einstellungen → Einrichten → Daten importieren
+aus Home Assistant** leitet Fahrten, Tankvorgänge und Spannungswerte
+rückwirkend aus dem bereits aufgezeichneten Verlauf ab.
+
+## Was die Integration mitbringt
+
+| | |
+|---|---|
+| Panel | Sidebar-Eintrag „Mein Audi", von der Integration selbst angemeldet |
+| Entitäten | `sensor.audi_dashboard_*` — Profil, Fahrten, Tankvorgänge, Fahrzeugstatus, Batterieverlauf, Reifenzähler |
+| Dienste | `audi_dashboard.*` — 18 Stück, in Entwicklerwerkzeuge → Aktionen dokumentiert |
+| Daten | `/config/audi_dashboard/` — JSON und JSON Lines, dauerhaft, nie von einem Update angefasst |
+| Abhängigkeit | `pypdf` (für Tankbelege), von Home Assistant automatisch nachinstalliert |
+
+Die Nutzlast der Entitäten steckt im Attribut `daten` und ist ausdrücklich von
+der Aufzeichnung ausgenommen — das Fahrtenarchiv wächst über Jahre auf
+Hunderte Kilobyte und hat in der Recorder-Datenbank nichts verloren.
+
+## Companion-App (iOS)
+
+`companion-app/` ist dieselbe Oberfläche als eigenständige App (React +
+Capacitor), die über die HA-API auf dieselben Entitäten und Dienste zugreift.
+Sie trägt ihre Version fest einkompiliert und meldet selbst, wenn sie älter
+ist als die installierte Integration — siehe
+[`VERSIONIERUNG.md`](VERSIONIERUNG.md).
+
+## Ordner in diesem Repository
+
+| Ordner | Inhalt |
+|---|---|
+| `custom_components/audi_dashboard/` | die Integration — Backend und Panel-Dateien |
+| `companion-app/` | die iOS-App |
+| `design-system/` | gemeinsame UI-Bausteine (`@audi-dash/ui`) |
+| `homeassistant/` | Installationspaket, Konfigurationsschnipsel, Anleitungen |
+| `testumgebung/` | Wegwerf-Home-Assistant in Docker für Entwicklung und Tests |
+| `tests/belegparser/` | Regressionstest des Tankbeleg-Lesers |

REVIEW_main_2026-08-13.md

@@ -0,0 +1,419 @@
+# Review: Branch `main`, Commits `c66ed82..d5562c7`
+
+**Datum:** 2026-08-13 · **Umfang:** 18 Commits, 24 Dateien, +2752/−259 Zeilen
+**Gegenstand:** Setup-Menü zur Sensor-Zuordnung, Umstellung von WLAN/VAG auf FMM003,
+Standort-Kachel mit Live-Position, iOS-/Großbildschirm-Optikauflage, DuckDNS und Zertifikate.
+
+Geprüft wurde gegen eine Arbeitskopie von `origin/main`. Die mit **[belegt]** markierten Befunde
+sind am Code nachvollzogen oder nachgestellt; **[plausibel]** heißt: aus dem Code abgeleitet, aber
+nicht im Browser reproduziert.
+
+---
+
+> ## ✅ Umgesetzt am 2026-08-13
+>
+> Alle Befunde dieses Dokuments sind behoben — siehe die fünf Commits von
+> `Setup-Zuordnung: Zuruecksetzen wirkt…` bis `Kleinere Befunde und Dokumentation…`.
+> Das Dokument bleibt als Befundprotokoll stehen: es begründet, warum die
+> Änderungen so aussehen, wie sie aussehen.
+>
+> **Zwei Punkte wurden bewusst anders gelöst als hier vorgeschlagen:**
+>
+> 1. *Karte nur bei echtem Ansichtswechsel neu aufbauen* — nicht umgesetzt. `render()` ersetzt den
+>    Inhalt per `innerHTML`; eine überlebende Leaflet-Instanz zeigte danach auf ein abgehängtes
+>    Element und bliebe leer. Der Neuaufbau hängt am 20-Sekunden-Takt des Backends und ließe sich
+>    nur durch einen Umbau der Render-Architektur ändern. Die Begründung steht im Code.
+>    Behoben ist dagegen die Standortabfrage, die tatsächlich ungedrosselt lief.
+> 2. *`SPECIFICATION.md`* wurde nicht in Teilen umgeschrieben, sondern hat einen datierten
+>    Statushinweis am Anfang bekommen. Ein Umschreiben der §4/§5-Tabellen hätte neue
+>    Ungenauigkeiten riskiert.
+>
+> **Drei Fehler kamen beim Umsetzen dazu**, sichtbar erst im laufenden Panel: ein unlesbares Datum
+> ergab „NaN/N" statt eines Strichs, ein fehlender Tanksensor „0 %" statt „unbekannt", und neben dem
+> Typenschild stand die Ausführung doppelt. Alle drei sind mit behoben.
+>
+> Und ein pyscript-Fallstrick ist dabei aufgefallen und im Code vermerkt: **Generatorausdrücke sind
+> nicht implementiert** (`not implemented ast ast_generatorexp`), Mengen-, Listen- und
+> Dict-Comprehensions dagegen schon.
+
+---
+
+## Gesamteindruck
+
+Handwerklich stark. Das Setup-Menü ersetzt „vor der Installation `einstellungen.py` editieren"
+durch eine Oberfläche mit Live-Wertvorschau, Unavailable-Warnung, Duplikat-Prüfung und einem
+ehrlichen Neustart-Hinweis für die drei triggergebundenen Felder. Der Kniff dahinter — `setattr`
+auf dem laufenden Modul-Objekt, weil alle Leser `einstellungen.KM_SENSOR` als lebenden
+Attributzugriff machen — ist elegant und im Kopfkommentar sauber begründet.
+
+Positiv außerdem: Escaping ist im neuen Code durchgängig (kein XSS gefunden), Karten-Ebenen werden
+vor dem Neuaufbau entfernt, die Haversine-Distanz ist mathematisch korrekt, Listenfelder sind gegen
+zu kurze Arrays abgesichert, und die Python-Syntax aller acht geänderten pyscript-Dateien ist in
+Ordnung.
+
+Die Fehler unten liegen fast alle im selben Bereich — dem neuen Setup-Menü — und **drei davon
+werden erst nach einem Neustart sichtbar**, also mit maximalem zeitlichem Abstand zur Ursache.
+
+## Übersicht
+
+| # | Befund | Wirkung | Ort |
+|---|---|---|---|
+| 1 | Speichern bei fehlendem Katalog löscht alle Zuordnungen | Datenverlust | `audi-dashboard-app.js:1773, 2031` |
+| 2 | „Zurücksetzen" wirkt bei 15 von 17 Feldern nicht | falscher Zustand | `entitaeten.py:188` |
+| 3 | Alle vier Listenpositionen bekommen denselben Sensor | falsche Sicherheitsaussage | `audi-dashboard-app.js:1976` |
+| 4 | Vorschlagsschwelle akzeptiert beliebige Sensoren | falscher Fahrt-Trigger | `audi-dashboard-app.js:1980` |
+| 5 | Geleerte Listen setzen `["","","",""]` | Status dauerhaft „unbekannt" | `entitaeten.py:188` |
+| 6 | Zuordnung wird nirgends gesichert | Verlust bei Wiederherstellung | `backup.py:32` |
+| 7 | Kaputte `entitaeten.json` legt das Panel lahm | Totalausfall | `entitaeten.py:159` |
+| 8 | Standortabfrage im Dauerfeuer bei abgelehnter Freigabe | Akku, Netz | `audi-dashboard-app.js:553/557` |
+| 9 | Kein Tastaturweg in die Einstellungen unter 860 px | Bedienbarkeit | `audi-dashboard-app.js:3849` |
+| 10 | `.navmarke` nur in der iOS-Auflage versteckt | Tab-Leiste zerfällt | `audi-dashboard-ios.css:194` |
+
+---
+
+# Schwerwiegend
+
+## 1. Speichern bei fehlendem Katalog löscht die gesamte Zuordnung [belegt]
+
+**Kette:**
+
+1. `ENTITAETEN` wird an genau einer Stelle gefüllt (`audi-dashboard-app.js:3723`), aus `hass.states`.
+2. Der Nachlade-Pfad nach einem HA-Neustart (`:3699-3703`) holt Profil, Fahrten, Tankvorgänge,
+   Status und Batterieverlauf nach — **nicht** aber `pyscript.audi_dashboard_entitaeten`.
+3. `DATEN_GELADEN` hängt allein am Profil. Die App gilt also als geladen, während der Katalog fehlt.
+4. Der Knopf „Setup — Sensoren zuordnen" (`:1773`) ist nur an `einrichtenOffen` gekoppelt, nicht an
+   den Katalog. `setupKatalog()` liefert `[]`, das Popup öffnet **ohne eine Zeile und ohne
+   Fehlermeldung**, `setupZuordnung` bleibt `{}`.
+5. „Speichern" schickt `"{}"` (`:2031`). `overrides_schreiben()` ersetzt die Datei vollständig,
+   ohne Zusammenführen (`entitaeten.py:166-173`).
+
+**Auswirkung:** `data/entitaeten.json` enthält danach `{}`. Weil die `setattr`-Werte im laufenden
+Prozess bestehen bleiben, fällt der Verlust **erst beim nächsten Neustart** auf. Zusammen mit
+Befund 6 (keine Sicherung) gibt es dann nichts zurückzuholen.
+
+**Vorschlag:** Setup-Knopf sperren, solange `ENTITAETEN` null ist, und in
+`setupSpeichernAusfuehren()` abbrechen, wenn `setupZuordnung` leer ist. Zusätzlich die Entität in
+den Nachlade-Pfad aufnehmen.
+
+## 2. „Zurücksetzen" wirkt bei 15 von 17 Feldern nicht [belegt, nachgestellt]
+
+`entitaeten.py:188` überspringt leere Werte:
+
+```python
+if wert in (None, "", []):
+    continue
+```
+
+Der Kopfkommentar derselben Datei beschreibt das Problem exakt richtig — `setattr` verändert das
+Modul dauerhaft, „Zurücksetzen" muss den Standardwert *aktiv* zurückschreiben. Das Frontend tut das
+auch (`setupStandardwert`). Nur ist der Standardwert bei 15 der 17 Katalogfelder `""` oder `[]` —
+und genau die werden übersprungen.
+
+Nachgestellt:
+
+```
+nach Zuordnung:     KM_SENSOR = 'sensor.alt_vag_mileage'
+nach Zurücksetzen:  KM_SENSOR = 'sensor.alt_vag_mileage'   ← erwartet: ''
+```
+
+**Auswirkung:** Für den Nutzer sieht es aus, als hätte das Speichern versagt — `aktueller_stand()`
+liest aus dem laufenden Modul, das Feld zeigt beim nächsten Zeichnen wieder den alten Wert.
+Funktioniert nur bei `ZUENDUNG_SENSOR`, `BATTERIE_SENSOR` und `STANDORT_TRACKER`, den drei Feldern
+mit nicht-leerem Standard.
+
+## 3. Alle vier Listenpositionen bekommen denselben Sensor [belegt]
+
+`audi-dashboard-app.js:1976-1981`:
+
+```js
+zuordnung[feld.key] = feld.positionen.map((_, i) => {
+  const vorhanden = (werte[feld.key] || [])[i];
+  if (vorhanden) return vorhanden;
+  const vorschlag = entitaetKandidaten(feld.key, "", "")[0];   // i geht nicht ein
+  return vorschlag && entitaetScore(feld, vorschlag, "") >= 3 ? vorschlag.id : "";
+});
+```
+
+`entitaetKandidaten()` hängt nicht vom Index ab und schließt bereits vergebene IDs nicht aus —
+alle vier Positionen bekommen dieselbe Entität. Betrifft `TUER_SENSOREN`, `FENSTER_SENSOREN`,
+`TUERSCHLOSS_SENSOREN`.
+
+**Auswirkung:** Bei einer Frischinstallation (genau der Fall, für den das Menü gebaut wurde) prüft
+`_sicherheitscheck()` danach viermal dieselbe Tür. **„Sicher abgestellt" meldet gesichert, obwohl
+drei Türen nie geprüft wurden.** Die Duplikat-Warnung fängt das beim Speichern ab, ist aber mit
+„Trotzdem speichern" wegklickbar.
+
+## 4. Die Vorschlagsschwelle akzeptiert beliebige Sensoren [belegt]
+
+`entitaetScore()` (`:1936`) vergibt: Stichwort +5, Domain +3, device_class +3, Einheit +2. Die
+Schwelle ist `>= 3` — **ein Domain-Treffer allein genügt**, ohne dass ein einziges Stichwort passt.
+Verschärfend: `setupNurPassend` wird zwei Zeilen vorher auf `true` gesetzt (`:1971`), wodurch
+`entitaetKandidaten()` ohnehin hart auf die Domain filtert. Die Schwelle ist damit *immer* erfüllt.
+Die Reihenfolge kommt aus `Object.keys(HASS.states)`, ist also faktisch willkürlich.
+
+**Auswirkung:** Ohne passenden Zündungssensor wird `ZUENDUNG_SENSOR` stumm mit dem erstbesten
+`binary_sensor.*` vorbelegt — Bewegungsmelder, Fensterkontakt, was zuerst kommt. Das Feld sieht
+ausgefüllt aus, wird mitgespeichert, und **die gesamte Fahrterkennung hängt an einem
+Zufallssensor**. Bei Einzelfeldern greift keine Duplikat-Warnung. Dasselbe für `TANK_SENSOR` (jeder
+%-Sensor, etwa Luftfeuchte) und `REFRESH_BUTTON` (jedes `button.*`).
+
+**Vorschlag:** Schwelle auf `>= 5` — also mindestens ein Stichworttreffer.
+
+## 5. Geleerte Listenfelder setzen `["","","",""]` [belegt]
+
+Die Skip-Regel aus Befund 2 prüft auf `[]`. Ein Array aus vier leeren Zeichenketten ist das nicht:
+
+```python
+["","","",""] in (None, "", [])   # False -> wird per setattr gesetzt
+```
+
+`_sicherheitscheck()` zippt dann über vier leere Entity-IDs und erzeugt vier „unbekannt"-Zeilen —
+mal drei Listen sind das zwölf.
+
+**Auswirkung:** Weil die Gesamtaussage bewusst `None` wird, sobald *eine* Prüfung unbekannt ist,
+steht die Übersicht danach **dauerhaft auf „Zustand unbekannt"** statt auf grün.
+
+Kurios ist die Kombination mit Befund 2: Bei Einzelfeldern wirkt „Zurücksetzen" gar nicht, bei
+Listenfeldern zu stark. Beides verschwindet mit demselben Fix — statt leere Werte zu überspringen,
+immer den Standardwert aus `_STANDARDWERTE` zurückschreiben:
+
+```python
+def overrides_anwenden():
+    overrides = overrides_lesen()
+    for key in _SCHLUESSEL:
+        wert = overrides.get(key)
+        leer = wert in (None, "", []) or (isinstance(wert, list) and not any(wert))
+        setattr(einstellungen, key, _STANDARDWERTE[key] if leer else wert)
+```
+
+## 6. Die Sensor-Zuordnung wird nirgends gesichert [belegt]
+
+`backup.py:32` sichert `fahrzeugprofil.json`, `fahrten.jsonl`, `tankvorgaenge.jsonl` —
+`entitaeten.json` fehlt. Auch `audi_dashboard_backup_wiederherstellen` kennt es nicht, `update.ps1`
+fasst `data/` bewusst nicht an, und in `homeassistant/.gitignore` steht es nicht neben den anderen
+Laufzeitdateien.
+
+**Auswirkung:** Nach einer Wiederherstellung ist die komplette Sensor-Zuordnung still weg. In
+Verbindung mit Befund 1 gibt es keinen Rückweg.
+
+## 7. Eine beschädigte `entitaeten.json` legt das Panel lahm [belegt]
+
+`overrides_lesen()` (`entitaeten.py:159`) ruft `json.loads` ohne Absicherung. Der Aufruf steht in
+`beim_start()` **vor** `alles_veroeffentlichen()` — wirft er, wird gar nichts veröffentlicht, das
+Panel bleibt komplett leer.
+
+Geschrieben wird zwar atomar über `.tmp` + `os.replace`, das Risiko ist also gering — der Ausfall
+wäre aber total. Dieselbe Fehlerklasse, die im Branch `umsetzung-datametric360` bei `profil_lesen()`
+bereits abgefangen wurde.
+
+---
+
+# Mittel
+
+## 8. Standortabfrage im Dauerfeuer, Karte bei jedem Render neu [belegt]
+
+`USER_POS_TS` wird nur im Erfolgs-Callback gesetzt (`:553`), nicht im Fehlerfall (`:557`). Die
+30-Sekunden-Drossel in `standortErfassenFallsNoetig()` (`:560`) greift damit nie, wenn der Nutzer
+die Standortfreigabe ablehnt oder kein Fix zustande kommt.
+
+Parallel dazu zerstört `render()` die Vorschaukarte und baut sie neu (`:2879-2880`), sobald die
+Route `home` ist — bei **jedem** Backend-Update.
+
+**Auswirkung:** Mit einem GPS-Tracker als Quelle (genau der FMM003-Fall) sind das dutzende
+`getCurrentPosition({enableHighAccuracy:true})`-Anfragen pro Stunde plus sichtbares Kachelflackern.
+
+**Vorschlag:** `USER_POS_TS = Date.now()` auch im Fehlerpfad; Karte nur bei echtem Ansichtswechsel
+neu bauen — die Variable `gleicheAnsicht` gibt es in `render()` bereits.
+
+## 9. Kein Tastaturweg in die Einstellungen unter 860 px [belegt]
+
+`audi-dashboard-ios.css:81` versteckt `.profilbtn` — den echten `<button aria-label="Einstellungen">` —
+und holt ihn erst in der Container-Abfrage ab 860 px zurück (`:230`). Der Ersatz ist ein
+Klick-Handler auf `#marke` (`:2965`), und das ist ein `<div class="rings" aria-label="Audi">`
+(`:3849`): ohne `role`, ohne `tabindex`.
+
+**Auswirkung:** In Telefonbreite gibt es für Tastatur- und Screenreader-Nutzer **keinen** Zugang zu
+den Einstellungen. Ein `<div>` mit `aria-label` ohne Rolle wird von den meisten Screenreadern nicht
+einmal angesagt. Gleiche Fehlerklasse wie das Swipe-Löschen aus `AUDIT_2026-08-10.md`.
+
+**Vorschlag:** `#marke` zu einem `<button aria-label="Einstellungen">` machen; dann kann auch
+`pointer-events:auto` in `audi-dashboard-ios.css:78` entfallen.
+
+## 10. `.navmarke` nur in der iOS-Auflage versteckt [belegt]
+
+`audi-dashboard-app.js:2956-2963` hängt den Ringklon **unbedingt** in `#tabbar`.
+`.navmarke{display:none}` steht ausschließlich in `audi-dashboard-ios.css:194`. `.tabbar` ist ein
+`display:grid` mit `repeat(5, 1fr)` (`audi-dashboard.css:211`).
+
+**Auswirkung:** Lädt `/local/audi-dashboard-ios.css` nicht (404, Cache), wird der Klon ein sechstes
+Grid-Element — alle Tabs rutschen eine Spalte weiter, „Tanken" fällt in eine zweite Zeile, die
+Menüleiste zerfällt. Kein theoretischer Fall: Commit `3548f77` dokumentiert genau dieses
+Deployment-Loch.
+
+**Vorschlag:** `.navmarke{display:none}` gehört in die Basis-CSS, die Sichtbarkeit in die Auflage.
+
+## 11. Standort-Menü ohne `pointercancel` [belegt]
+
+`standortMenuVerdrahten()` (`:706-731`) setzt `smY0` nur in `pointerup` zurück. Alle drei anderen
+Zeigergesten der Datei haben einen `pointercancel`-Handler (`:2929`, `:3055`, `:3122`), diese nicht.
+
+**Auswirkung:** Übernimmt das System die Berührung (iOS-Randgeste, Multitouch, eingehender Anruf),
+bleibt `smY0` gesetzt. Der `pointermove`-Handler ruft dann `preventDefault()` für jede weitere
+Bewegung — **Scrollen ist in der ganzen App blockiert**, bis irgendwo ein `pointerup` kommt, der
+dann ein `dy` aus einem veralteten Startpunkt auswertet.
+
+## 12. Fehlgeschlagenes Reverse-Geocoding wird dauerhaft gecacht [belegt]
+
+`:572-586` setzt `STANDORT_ADRESSE_KEY` auch im `catch`-Zweig.
+
+**Auswirkung:** Ein einziger fehlgeschlagener Nominatim-Abruf (Rate-Limit, kurzer Netzausfall) für
+eine Zelle führt dazu, dass für dieselbe Zelle die **gesamte Sitzung** lang nur Koordinaten
+angezeigt werden, auch wenn das Netz längst wieder da ist.
+
+**Vorschlag:** Key nur im Erfolgsfall setzen.
+
+## 13. Setup-Popup hält den `role="dialog"`-Vertrag nicht ein [belegt]
+
+`:2774` deklariert `role="dialog" aria-modal="true"`. Es fehlen: Escape zum Schließen (in der Datei
+gibt es keinen `keydown`-Handler), eine Fokusfalle (Tab wandert in den überdeckten Hintergrund),
+und der Schalter „Nur passende Sensoren anzeigen" (`:2779`) hat keinen zugänglichen Namen — der
+Beschriftungstext steht im Geschwister-`<span>` außerhalb des `<label>`.
+
+Dazu: Die Entitäts-Auswahl öffnet ausschließlich im `click`-Handler (`:3181`). Wer per Tab ins Feld
+springt und tippt, löst zwar den `input`-Handler aus, der bricht aber ab, weil `setupSucheOffen`
+noch `null` ist — sichtbar passiert nichts. `role="combobox"`, `aria-expanded` und `aria-controls`
+fehlen ebenfalls.
+
+## 14. Standort-Menü nicht per Tastatur bedienbar [belegt]
+
+Im eingeklappten Zustand steht das Blatt per `transform` überwiegend außerhalb des Sichtbereichs,
+bleibt aber vollständig im DOM und im Tab-Fokus — Adresse, Route-Link und Teilen-Knopf sind
+fokussierbar, ohne sichtbar zu sein (kein `inert`, kein `aria-hidden`). Öffnen geht gar nicht per
+Tastatur: `.standortmenu-griffzone` ist ein `<div>` mit reinen Pointer-Handlern. Der Umschalter
+Straße/Satellit (`:773`) hat kein `aria-pressed`, sein Label bleibt in beiden Zuständen gleich.
+
+## 15. `disconnectedCallback()` räumt nur eine von drei Karten ab [belegt]
+
+`:3815-3817` zerstört `MAP`, nicht aber `SMAP`/`TMAP`. Wird das Panel abgehängt, während Standort-
+oder Übersichtsseite offen ist, bleibt eine Leaflet-Instanz samt Resize-Listener und
+Kachel-Abrufen am Leben.
+
+---
+
+# Klein
+
+| Ort | Befund |
+|---|---|
+| `audi-dashboard-ios.css:88, 208` | `main{padding:…}` (0,0,1) verliert gegen `main#view` (1,0,1) in `audi-dashboard.css:197`. Auf Großbildschirmen bleibt der Seitenrand bei 20 px statt der beabsichtigten 44 px. **Achtung:** `.standort-vollbild{margin:0 -20px}` (`audi-dashboard.css:704`) passt heute genau dazu — beides gehört zusammen angefasst. |
+| `audi-dashboard-app.js:3190/3612` | „Nur passende Sensoren anzeigen" wirkt nicht, solange ein Dropdown offen ist: Der Klick-Handler ersetzt das Overlay-DOM, bevor das `change`-Event des Kontrollkästchens ausgeliefert wird. [plausibel] |
+| `audi-dashboard-app.js:2966` | Theme-Umschalten ruft kein `render()` — die Leaflet-Kacheln bleiben bis zum nächsten Backend-Update im alten Stil. Durch die neue Dauerkarte auf der Übersicht deutlich sichtbarer als früher. |
+| `audi-dashboard-app.js:804` | `${de(CAR.tankPct)} %` zeigt ohne Tanksensor „0 %“, während direkt daneben korrekt „Reichweite unbekannt“ steht. |
+| `audi-dashboard-app.js:496, 518, 117` | Toter Code: `fahrzeugGlyphPfade()` nie aufgerufen, `zustand.parkplatz` nie gelesen, `standortGenauigkeitM`/`standortZeit` gemappt aber ungenutzt. Kommentare behaupten das Gegenteil. |
+| `audi-dashboard-app.js:595` | Einzige Interpolation im neuen Code, die ohne `esc()` in ein Attribut geht. Heute nicht ausnutzbar, weil `_zu_zahl()` im Backend nur Zahlen durchlässt — als Härtung trotzdem sinnvoll, ebenso `Number.isFinite` in `standortBekannt()`. |
+
+---
+
+# Dokumentation
+
+## AGENTS.md widerspricht sich an sechs Stellen [belegt]
+
+Die Datei ist auf 427 Zeilen gewachsen; neue Einträge wurden angehängt statt eingearbeitet.
+
+| Stelle | Aussage | Widerspruch |
+|---|---|---|
+| Z. 94 | „trip detection via the iPhone WLAN sensor" | Z. 249 ff.: läuft über `ZUENDUNG_SENSOR`, WLAN „fully removed" |
+| Z. 110 | „Codec JSON → MQTT/TLS → Mosquitto" | Z. 227 ff.: Schwenk auf flespi, „not MQTT at all" |
+| Z. 93 | „4 modules" | tatsächlich 5 (`entitaeten.py` neu) |
+| Z. 97 | „3.130 lines" | tatsächlich 3.873 |
+| Z. 100 | „`einstellungen.py` — the one file edited before install" | genau das ersetzt jetzt das Setup-Menü |
+| Z. 320 | `STANDORT_TRACKER` „left empty" | steht auf `device_tracker.testzone_fmm003` |
+
+Dazu veraltete Codeverweise: `fakeTrack()` liegt bei `:421` statt `:414`, die Statistik-Behauptung
+in `INSTALL.md` bei Z. 229 statt Z. 204.
+
+Die Datei verlangt selbst „nicht festhalten, was Code und Git-History schon zeigen" (Z. 47) —
+Z. 282–401 sind 120 Zeilen Changelog-Prosa für fünf Einträge, und Z. 249–279 dupliziert inhaltlich
+Z. 133–153.
+
+## INSTALL.md [belegt]
+
+- **Zirkuläre Schrittfolge:** Schritt 4 verweist auf „siehe Schritt 9 zuerst" (Z. 96), Schritt 7
+  setzt Schritt 4 voraus (Z. 176). Die Reihenfolge 4→9→7→4 wird nirgends aufgelöst.
+- **Ausgelieferte Default-Entities werden verschwiegen:** `ZUENDUNG_SENSOR`, `BATTERIE_SENSOR` und
+  `STANDORT_TRACKER` sind mit den `testzone_fmm003`-Entities der Autoren-Instanz vorbelegt. Bei
+  einer Frischinstallation zeigen sie ins Leere. Z. 108–110 behauptet nur für KM/TANK/RANGE
+  „unbelegt".
+- **Override-Datei nicht benannt:** Z. 104 spricht von „einer Override-Datei" — der Pfad
+  `/config/audi_dashboard/entitaeten.json` steht nirgends, und ihre fehlende Sicherung (Befund 6)
+  ist nicht erwähnt.
+- Schritt 2 verweist auf `fahrzeugprofil.example.json`, deren Z. 2 weiterhin den „WLAN-Namen"
+  verlangt, obwohl `fahrzeug.wlan_name` im selben Branch entfernt wurde.
+
+## WLAN-Reste in der übrigen Doku [belegt]
+
+Im Code ist die Entfernung vollständig (keine Fundstelle). In der Doku nicht:
+`SPECIFICATION.md` (Z. 16, 147, 181, 196, 217), `homeassistant/README.md:106` und die Profilvorlage
+nennen WLAN-Sensor und `TommiG1/HA_VAG-EU-Data-Act` weiterhin als aktuellen Stand.
+
+## `update.ps1` [belegt]
+
+Für `www/` ist das Skript nach dem Fix **vollständig** — `audi-dashboard-ios.css` und `badges/`
+sind ergänzt, Cache-Busting greift auch für die neue CSS-Datei.
+
+**Verbleibende Lücke:** `homeassistant/data/shell_beleg_parser.py` ist Code, kein Datenbestand —
+`belegverarbeitung.py:41` lädt ihn aus `/config/audi_dashboard/`. `update.ps1` schließt `data/`
+pauschal aus, `INSTALL.md` behandelt ihn als Einmal-Kopie. **Änderungen am Beleg-Parser, dem
+einzigen getesteten Teil des Repos, kämen auf keiner Instanz an.**
+
+## `design/` [belegt]
+
+`dm360-host.html` lädt `audi-dashboard-app.js` (Z. 12) und `audi-dashboard-ios.css` (Z. 33) — beide
+existieren in `design/` nicht. Aus der Repo-Kopie ist das Board funktionslos; es läuft nur im
+Claude-Design-Projekt. Nirgends dokumentiert.
+
+`design/README.md:19` führt `audi-dashboard-ios.css` in der Inhaltstabelle des Ordners (die Datei
+liegt in `homeassistant/www/`) und behauptet, die Auflage „rührt `audi-dashboard-app.js` nicht an" —
+Z. 57–59 derselben Datei beschreibt, dass genau dort der Stylesheet-Loader ergänzt wurde.
+
+**Markenassets:** Der Diff fügt keine neuen Binärdateien hinzu. `DataMetric360 Board.dc.html`
+verwendet die vorhandenen Audi-Type-Dateien per `@font-face` — das Lizenzrisiko bleibt unverändert,
+nicht erhöht.
+
+## `.gitignore` [belegt]
+
+`installationspaket/` ist korrekt ergänzt und schließt nichts Getracktes aus. Es fehlt
+`data/entitaeten.json` neben den anderen drei Laufzeitdateien — heute harmlos, weil die Datei nur
+unter `/config/audi_dashboard/` entsteht, aber inkonsistent zum eigenen Grundsatz der Datei.
+
+---
+
+# Was den Branch `umsetzung-datametric360` betrifft
+
+**Der flespi-Schwenk macht `homeassistant/FMM003_MAPPING.md` überholt.** Das Dokument beschreibt
+Codec JSON über MQTT/TLS mit eigener CA und einem `mosquitto_sub`-Mitschnitt. Mit flespi läuft es
+über den nativen Codec8/TCP-Kanal mit IMEI-Authentifizierung, ohne Zertifikate und ohne eingehenden
+Port; die Feldzuordnung entstünde aus der flespi-REST-API. Beim Zusammenführen anpassen oder
+ersetzen.
+
+**Das CORS-Rätsel ist damit auch erklärt.** Die Notiz auf `main`, der `http:`-Block sei aus der
+`configuration.yaml` entfernt worden, „nachdem HA angefangen hat, ihn zu migrieren beziehungsweise
+zu ignorieren", erklärt, warum `cors_allowed_origins` in HA 2026.8 wirkungslos blieb — auch bei
+gleichem Ursprung. Gehört in `homeassistant/REVERSE_PROXY.md` nachgetragen.
+
+**Die Falle beim Zusammenführen** steht bereits in `AGENTS.md` dieses Branches: `profil_lesen()`
+gibt hier bei fehlender Profildatei `None` zurück, `profil.py` ist auf `main` unverändert und geht
+konfliktfrei durch — die dortigen Aufrufstellen prüfen das aber nicht.
+
+---
+
+# Empfehlung
+
+Reihenfolge nach Schaden:
+
+1. **Befund 1** (Datenverlust) — zwei Riegel, wenige Zeilen.
+2. **Befunde 2 und 5** (Zurücksetzen) — ein gemeinsamer Fix in `overrides_anwenden()`.
+3. **Befunde 3 und 4** (falsche Vorbelegung) — Index in den Vorschlag einbeziehen, Schwelle auf 5.
+4. **Befund 6** (Sicherung) — eine Zeile in `backup.py`, plus Wiederherstellung.
+5. **Befund 7** (Absicherung beim Lesen), **8** (Akku), **9/10** (Bedienbarkeit, Robustheit).
+
+Die Punkte 1 bis 4 betreffen alle das neue Setup-Menü und lassen sich in einem Zug erledigen.

SPECIFICATION.md

@@ -1,5 +1,21 @@
 # Audi Dashboard — Technical Specification
 
+> ## ⚠️ Teilweise überholt (Stand 2026-08-13)
+>
+> Dieses Dokument beschreibt den Stand **vor** der FMM003-Umstellung. Drei Dinge haben sich seither
+> geändert und gelten in diesem Dokument durchgehend als veraltet:
+>
+> 1. **Fahrterkennung** läuft über den Zündungssensor des FMM003, nicht mehr über den
+>    iPhone-WLAN-Sensor. `sensor.iphone_wifi_connection` und `fahrzeug.wlan_name` sind entfernt.
+> 2. **Datenquelle** ist der FMM003 über flespi (Codec8/TCP), nicht mehr die HACS-Integration
+>    `TommiG1/HA_VAG-EU-Data-Act`.
+> 3. **Entity-IDs** werden im Setup-Menü der App zugeordnet (Einstellungen → Fahrzeug einrichten →
+>    Setup) und in `data/entitaeten.json` abgelegt. `einstellungen.py` enthält nur noch die
+>    eingebauten Vorgabewerte und ist keine Pflicht-Bearbeitung mehr vor der Installation.
+>
+> Alles Übrige — Datenmodell, Geschäftsregeln, Frontend-Aufbau, §7 „Known Gaps" — gilt weiterhin.
+> Den aktuellen Stand führt `AGENTS.md`, Abschnitt B.
+
 **Audience:** an AI coding agent picking up this codebase with no prior context.
 **Scope:** the Home Assistant panel (`homeassistant/`) — the finished, in-use app. A separate sibling project, `design-system/`, is a standalone React component-library replica of this app's visual language, built solely to feed Claude Design (`claude.ai/design`) via the `/design-sync` skill; it is **not** part of this app and deliberately excludes Audi brand assets. `COMPANION_APP_ARCHITECTURE.md` documents a third, **not-yet-built** sibling project — an iOS/Android/HA-iframe companion app fed by a Teltonika FMM003 tracker instead of the WLAN-sensor/VAG-integration data sources described below; its design is decided but no code exists yet. Don't confuse any of the three.
 
@@ -25,33 +41,51 @@ A private, single-user Home Assistant `panel_custom` dashboard that replaces the
 
 ## 2. Concept & Design System
 
-### Visual language
-Dark ("Nacht") is the default and primary theme; a light ("Tag") theme exists as a toggle. No shadows, no gradients anywhere except the fade under the vehicle photo (`.szene`). Flat tiles, pill-shaped controls, hairline dividers.
+> **iOS-Optik ist seit 2026-08-13 die verbindliche Linie** (Entscheidung nach
+> `DESIGN_REVIEW_2026-08-13.md` §A, Option 1: „iOS-Optik als neue verbindliche Linie
+> dokumentieren"). Das ursprüngliche, reine Audi-CI-Design unten war bis dahin gültig und bleibt
+> wortgleich archiviert in [`AUDI_CI_ARCHIV_2026-08-13.md`](AUDI_CI_ARCHIV_2026-08-13.md) —
+> inklusive einer kurzen Anleitung, wie man technisch zurückwechselt (die Auflage ist rein additiv,
+> die Basis-Werte unten sind im Code nach wie vor vorhanden). `bauauftrag.md` §8 beschreibt weiterhin
+> das alte Design und gilt ab hier als überholt, wie es die Projektkonvention für Entscheidungen
+> vorsieht (siehe `AGENTS.md`).
+>
+> Bekannter, noch offener Folgefehler aus demselben Review: die Rot-Semantik ist in der iOS-Auflage
+> invertiert (`.aktion` füllt jede Primäraktion rot statt nur destruktive) — Befund B, noch nicht
+> behoben.
 
-### Colors (CSS custom properties, defined per-theme via `:root` / `[data-theme="tag"]`)
+### Visual language
+iOS-native Formensprache (`audi-dashboard-ios.css`, additive Auflage über der Audi-CI-Basis unten):
+große Titel, gruppierte 44-px-Zeilen, transluzente Tab-Leiste mit Blur, iOS-Schalter/-Segmente,
+gefüllte Aktionsknöpfe. Dunkel ("Nacht") bleibt Standard, "Tag" als Umschalter. Audi Type und das
+Rot `#F50537` bleiben führend (Typografie, Akzentfarbe) — Fläche, Radius und Signalfarben folgen
+iOS-Konventionen statt der ursprünglichen Audi-Palette.
+
+### Colors (CSS custom properties, iOS-Auflage überschreibt die Audi-CI-Basis pro Theme)
 
 | Role | Nacht (default) | Tag |
 |---|---|---|
-| `--canvas` (page background) | `#161b23` | `#FFFFFF` |
-| `--tile` | `#1f2733` | `#f2f2f2` |
-| `--tile-2` (inputs, hover) | `#2a3341` | `#e5e5e5` |
-| `--line` | `rgba(255,255,255,.10)` | `rgba(0,0,0,.10)` |
-| `--line-strong` | `rgba(255,255,255,.20)` | `rgba(0,0,0,.22)` |
+| `--canvas` (page background) | `#0C1014` | `#F2F2F7` |
+| `--tile` | `rgba(255,255,255,.055)` | `#FFFFFF` |
+| `--tile-2` | `rgba(255,255,255,.10)` | `#EFEFF4` |
+| `--line` | `rgba(255,255,255,.13)` | `rgba(60,60,67,.13)` |
+| `--line-strong` | `rgba(255,255,255,.24)` | `rgba(60,60,67,.24)` |
 | `--fg` | `#FFFFFF` | `#000000` |
-| `--fg2` (secondary text) | `#9aa1ad` | `#4c4c4c` |
-| `--fg3` (labels/eyebrows) | `#8a94a3` | `#666666` |
-| `--ok` | `#15da15` | `#0DA20D` |
-| `--warn` | `#ffaa00` | `#ffaa00` |
-| `--shade` | `rgba(255,255,255,.05)` | `rgba(0,0,0,.04)` |
-| `--bad` | `#fd2c4e` | `#eb0d3f` |
-| `--red` (accent, theme-independent) | `#F50537` | `#F50537` |
+| `--fg2` | `#BFC4CC` | `#3C3C43` |
+| `--fg3` | `#8E8E93` | `#8E8E93` |
+| `--ok` | `#30D158` | `#34C759` |
+| `--warn` | `#FFD60A` | `#FF9F0A` |
+| `--bad` | `#FF453A` | `#FF3B30` |
+| `--ios-tint` (Akzent/Aktionsfüllung, theme-unabhängig) | `#F50537` | `#F50537` |
 
-`--red` is used sparingly (accents, active states, destructive actions), not as a background fill.
+`.aktion` füllt sich vollflächig mit `--ios-tint` — abweichend von der ursprünglichen Regel „Rot nur
+als Akzent" (bekannter, offener Befund, siehe Kasten oben).
 
 ### Radii
-- `--r-tile: 20px` — tiles, the vehicle-photo "scene" container.
-- `--r-pill: 999px` — buttons, switches, segmented controls, progress bars.
-- Small functional elements (form inputs, placeholder/mini image boxes, popups) use **hardcoded literal pixel values** (6px / 12px / 14px respectively) rather than a shared token — see §7 for why this is a discrepancy from the brief.
+- `--r-tile: 16px` (iOS-Wert; Audi-CI-Basis war 20px, siehe Archiv) — Kacheln, Popups, Bildbereiche.
+- `--r-pill: 999px` unverändert — Buttons, Schalter, Segmente, Fortschrittsbalken.
+- `.setup-popup`/`.standortmenu` schreiben weiterhin `border-radius: 20px` als Literal
+  (Inkonsistenz zum 16px-Token, ebenfalls im Review dokumentiert, noch nicht bereinigt).
 
 ### Typography
 Three font-family names in play, all under the trademarked "Audi Type" family, embedded inline as base64 `woff2` directly in `audi-dashboard.css` (private-install only — see Licensing below):
@@ -231,7 +265,7 @@ These are places the shipped code and the original build brief disagree — load
 ## 8. File map
 
 ```
-Audi_app_TG/
+audi-app/
 ├── bauauftrag.md                       original build brief (German, historical — see §7)
 ├── dashboard-muster.html               the original static prototype (superseded, kept for reference)
 ├── SPECIFICATION.md                    this document

UMSETZUNGSPLAN.md

@@ -52,7 +52,7 @@ KI-Modell oder in einer frischen Session ohne Vorwissen abgearbeitet werden kann
 | 7 | Alle Screens umsetzen | 3, 6 | nein |
 | 8 | Audi-Assets einbauen | 7 | nein |
 | 9 | Tests (authentifiziert + Komponenten) | 6 | nein |
-| 10 | PWA + Capacitor/iOS-Sideload | 7 | Mac mit Xcode, iPhone |
+| 10 | PWA + Capacitor/iOS-Sideload | 7 | erledigt bis auf das Signieren aufs Geraet |
 | 11 | HA-Einbettung, Ablösung + Archivierung des Panels | 7–10 | HA-Produktivinstanz |
 | 12 | Externer Zugriff: Cloudflare Tunnel + Reverse Proxy | teils unabhängig | Domain/DNS, Besitzer |
 | 13 | FMM003: MQTT, Zertifikate, Mapping, Fahrterkennung | Hardware | **ja: FMM003 verbaut** |
@@ -91,7 +91,10 @@ einzige, die zwingend auf Hardware wartet.
 
 ---
 
-## Phase 2 — Pflege des bestehenden HA-Panels (Quick Wins, Block C aus AGENTS.md)
+## Phase 2 — Pflege des bestehenden HA-Panels ✅ ERLEDIGT (2026-08-11)
+
+> Doku-Drift behoben, `profil_lesen()` gehärtet und an der Testinstanz belegt.
+> Offen bleibt nur, was Betriebsdaten sind: Fahrzeugfotos und `steuer.faellig`.
 
 **Ziel:** Doku stimmt wieder mit dem Code überein; ein Crash-Risiko ist beseitigt. Reine Pflege —
 **keine** Funktionsänderungen.
@@ -132,7 +135,12 @@ Besitzer in der App/UI, kein Code).
 
 ---
 
-## Phase 3 — Design-Entwurf vervollständigen (Claude Design)
+## Phase 3 — Design-Entwurf vervollständigen ⏭️ ÜBERSPRUNGEN (2026-08-11)
+
+> Entscheidung des Besitzers: Die Screens wurden direkt aus den Views des alten
+> Panels abgeleitet, statt auf den Claude-Design-Entwurf zu warten. Dieser
+> Abschnitt bleibt stehen, falls der Entwurf später auf den Stand der
+> Umsetzung gebracht werden soll.
 
 **Ziel:** Der Entwurf zeigt das richtige Fahrzeug und alle Seiten, die das alte Panel hat.
 Diese Phase läuft im Claude-Design-Projekt
@@ -176,7 +184,7 @@ Hauptscreens sind entworfen; die 16 Unterseiten folgen dann dem gleichen Muster.
 
 ---
 
-## Phase 4 — Workspace und React-Gerüst in `companion-app/`
+## Phase 4 — Workspace und React-Gerüst ✅ ERLEDIGT (2026-08-11)
 
 **Ziel:** `companion-app/` ist ein lauffähiges Vite+React+TS-Projekt, das `@audi-dash/ui` als
 echte Dependency nutzt. Die bestehende Datenschicht (`src/api/`) bleibt unverändert liegen.
@@ -239,7 +247,7 @@ echte Dependency nutzt. Die bestehende Datenschicht (`src/api/`) bleibt unverän
 
 ---
 
-## Phase 5 — App-Shell: Theme, Router, responsives Layout
+## Phase 5 — App-Shell: Theme, Navigation, responsives Layout ✅ ERLEDIGT (2026-08-11)
 
 **Ziel:** Navigationsgerüst, das beide Layouts beherrscht (schmal: Tab-Leiste unten; breit ≥1000px:
 Seitenleiste), mit Tag/Nacht-Theme und Zurück-Navigation. Noch ohne echte Daten.
@@ -273,7 +281,7 @@ Seitenleiste), mit Tag/Nacht-Theme und Zurück-Navigation. Noch ohne echte Daten
 
 ---
 
-## Phase 6 — Onboarding, Datenanbindung, Offline-UX
+## Phase 6 — Onboarding, Datenanbindung, Offline-UX ✅ ERLEDIGT (2026-08-11)
 
 **Ziel:** Die App verbindet sich echt mit Home Assistant über die vorhandene Datenschicht.
 
@@ -313,7 +321,12 @@ Zugangsdaten-Verwaltung (`umgebung.ts`).
 
 ---
 
-## Phase 7 — Alle Screens umsetzen
+## Phase 7 — Alle Screens umsetzen ✅ ERLEDIGT (2026-08-11)
+
+> Alle 21 Seiten stehen. Die Entwurfsvorlage kam für die 16 Unterseiten aus den
+> Views des alten Panels statt aus Claude Design (Entscheidung des Besitzers,
+> 2026-08-11) — Phase 3 ist damit gegenstandslos, solange der Entwurf nicht
+> nachgezogen werden soll.
 
 **Ziel:** Funktionsgleichheit mit dem alten Panel plus die neuen Live-Ansichten. Pro Screen:
 Entwurf aus `design/` nachbauen (mit `@audi-dash/ui`-Komponenten), Logik aus der alten View
@@ -355,7 +368,7 @@ nicht ein Riesencommit.
 
 ---
 
-## Phase 8 — Audi-Assets einbauen
+## Phase 8 — Audi-Assets einbauen ✅ ERLEDIGT (2026-08-11)
 
 **Ziel:** Die App sieht aus wie das Original — Schriften, Ringe, Typenschilder.
 
@@ -376,7 +389,9 @@ nicht ein Riesencommit.
 
 ---
 
-## Phase 9 — Tests
+## Phase 9 — Tests ✅ ERLEDIGT (2026-08-11)
+
+> 90 Unit- und Rendertests, dazu 9 Prüfungen gegen die laufende Instanz.
 
 **Ziel:** Die ungeteste Hälfte der Datenschicht ist abgedeckt; die Kern-Rechenlogik hat Unit-Tests.
 
@@ -401,7 +416,24 @@ nicht ein Riesencommit.
 
 ---
 
-## Phase 10 — PWA und Capacitor (iPhone/Android, nur Sideload)
+## Phase 10 — PWA und Capacitor ✅ ERLEDIGT (2026-08-11)
+
+> PWA fertig. Native Hülle gebaut und in Betrieb: Capacitor 8 für iOS und
+> Android, Build im Simulator (iPhone 17 Pro, iOS 26.4) erfolgreich, App zeigt
+> echte Daten. `CapacitorHttp` umgeht die CORS-Beschränkung der WebView.
+> Offen bleibt allein das Signieren aufs eigene Gerät — das braucht das
+> angeschlossene iPhone und die Apple-ID des Besitzers.
+>
+> **2026-08-29: Schritt 7 erledigt.** Der Besitzer hat das bezahlte
+> Entwicklerkonto gelöst und das iPhone im Portal registriert; die Team-Kennung
+> blieb dabei `RMACS9VLS4` (die bezahlte Mitgliedschaft stuft das bestehende
+> Team hoch, sie legt kein neues an). Ergebnis: `companion-app/auslieferung/App.ipa`,
+> 2,4 MB, **Ad-hoc** signiert mit `Apple Distribution: Paul Nothaft`, Profil
+> gültig bis 29.08.2027. Zwei Skripte tragen das:
+> `scripts/ios-signieren.sh` (bauen und signieren) und `scripts/ios-luftweg.sh`
+> (Manifest und Installationsseite für die Übertragung über die Luft).
+> Offen bleibt allein ein HTTPS-Host, der die Dateien ausliefert — siehe
+> Schritt 8. Fallstricke und Diagnosen in `AGENTS.md` Abschnitt AI.
 
 **Ziel:** Die App läuft auf dem iPhone. Zwei Stufen — erst PWA (sofort nutzbar), dann Capacitor
 (Keychain + QR-Scan).
@@ -428,11 +460,27 @@ nicht ein Riesencommit.
    (Offline-JS-QR-Bibliothek, keine Netzabfrage) als QR anzeigt. Inhalt des QR: JSON
    `{"url": "...", "token": "..."}`. Wenn das zusammen > 1 Tag Aufwand wird: weglassen —
    manuelles Einfügen ist die beschlossene, ausreichende Lösung.
-7. **iOS-Sideload:** `npx cap open ios`, in Xcode Signing mit eigener Apple-ID, aufs Gerät bauen.
-   ⚠️ Entscheidungspunkt für den Besitzer: mit kostenlosem Apple-Konto läuft die Signatur nach
-   **7 Tagen** ab (App neu aufspielen); ein bezahltes Entwicklerkonto (99 €/Jahr) macht 1 Jahr.
-   Bei 7-Tage-Schmerz ist die PWA-Stufe die Alltagslösung, Capacitor das Extra für Keychain/QR.
-8. ✅ Fertig wenn: App startet nativ auf dem iPhone, Token liegt im Keychain (Test: App löschen und
+7. ✅ **iOS-Sideload (erledigt 2026-08-29):** `bash companion-app/scripts/ios-signieren.sh`
+   baut Webbündel, synchronisiert die Hülle, archiviert signiert und exportiert die `.ipa`
+   nach `companion-app/auslieferung/`. Die Team-Kennung steht im Skript, weil `ios/` gitignored
+   ist und jede in Xcode geklickte Einstellung beim nächsten `npx cap add ios` verschwinden würde.
+   Der Entscheidungspunkt Kostenlos-vs-Bezahlt ist entschieden: **bezahltes Konto**, damit
+   Signatur ein Jahr gültig statt sieben Tage, und Geräteregistrierung über das Portal ohne
+   angeschlossenes Telefon.
+   ⚠️ **Falle, die viel Zeit kostet:** beim ersten Signieren fragt der Schlüsselbund per Dialog
+   um Erlaubnis. Wird der nicht beantwortet, hängt `xcodebuild` wortlos minutenlang und endet
+   mit `errSecInternalComponent`. Im Dialog **„Immer erlauben"** wählen — ein Archiv signiert
+   über 25 Binärdateien und würde sonst jedes Mal erneut fragen.
+8. **Übertragung über die Luft** (statt Kabel): `bash companion-app/scripts/ios-luftweg.sh
+   https://<host>` erzeugt `manifest.plist`, Installationsseite und Symbole in
+   `ios/build/luftweg/`. Der Ordner muss über **HTTPS mit öffentlich vertrauenswürdigem
+   Zertifikat** ausgeliefert werden — iOS lehnt einfaches HTTP und selbstsignierte Zertifikate
+   ab, Home Assistant unter `/local/` genügt also **nicht**. Passend: `tailscale serve --bg
+   <ordner>` (echtes Let's-Encrypt-Zertifikat auf `*.ts.net`, kein offener Port, iPhone ohnehin
+   im Tailnet); der Cloudflare-Tunnel aus Phase 12 täte es später ebenso. Link auf dem iPhone in
+   **Safari** öffnen — andere Browser reichen `itms-services://` nicht ans System weiter.
+   ⏳ Offen: dieser Mac ist bei Tailscale abgemeldet, es läuft also noch kein Host.
+9. ✅ Fertig wenn: App startet nativ auf dem iPhone, Token liegt im Keychain (Test: App löschen und
    neu installieren → Token weg; Backup/Restore-Verhalten notieren), QR-Einrichtung funktioniert
    oder ist dokumentiert entfallen.
 9. Committen; `AGENTS.md` Block A Punkte QR/Secure-Storage abhaken.
@@ -461,45 +509,62 @@ nicht ein Riesencommit.
 
 ---
 
-## Phase 12 — Externer Zugriff: Cloudflare Tunnel + Reverse Proxy
+## Phase 12 — Externer Zugriff: Cloudflare Tunnel + Reverse Proxy 🟡 VORBEREITET
+
+> **2026-08-28 aktualisiert/teilweise überholt.** Die Schritte unten stammen aus der frühen
+> Planungsphase (2026-08-11) und enthalten inzwischen überholte Annahmen: zwei getrennte Hostnamen
+> (App-Domain + API-Subdomain — entfällt, die App wird nie als Web-Build ausgeliefert, siehe
+> `COMPANION_APP_ARCHITECTURE.md` §5 Punkt 4) und pyscript-Entitäts-/Dienstnamen (seit der
+> Integrations-Umstellung 2026-08-23 `sensor.audi_dashboard_*`/`audi_dashboard.<name>`, siehe
+> `AGENTS.md` Abschnitt H). Reverse-Proxy-Wahl (Nginx Proxy Manager) und die vollständige, aktuelle
+> Freigabeliste stehen bereits fest. **Maßgeblich für die tatsächliche Einrichtung sind
+> [`homeassistant/INTERNET_ZUGRIFF_EINRICHTEN.md`](homeassistant/INTERNET_ZUGRIFF_EINRICHTEN.md)
+> (Schritt-für-Schritt-Anleitung) und [`homeassistant/REVERSE_PROXY.md`](homeassistant/REVERSE_PROXY.md)
+> (die Freigabeliste selbst)** - die Liste unten bleibt nur als Entscheidungsprotokoll stehen, nicht
+> als aktuelle Anleitung.
 
 **Ziel:** Die App funktioniert von unterwegs (Mobilfunk), ohne dass HA selbst erreichbar ist.
 Referenz: `COMPANION_APP_ARCHITECTURE.md` §4/§5. Teilweise Besitzer-Aufgaben (Konten/DNS).
 
-1. **[Besitzer] Nameserver umstellen:** `datametric360.app` bei all-inkl auf die
+1. **[Besitzer] Nameserver umstellen:** `datametric360.de` bei all-inkl auf die
    Cloudflare-Nameserver zeigen lassen (Cloudflare-Konto → Site hinzufügen → „Full setup";
-   Domain trägt sonst nichts, Umstellung ist folgenlos). ✅ wenn `dig NS datametric360.app` die
+   Domain trägt sonst nichts, Umstellung ist folgenlos). ✅ wenn `dig NS datametric360.de` die
    Cloudflare-Server liefert.
-2. **Hostnamen festlegen** (Empfehlung aus dem Architekturdokument übernehmen): App unter
-   `https://datametric360.app`, API unter `https://api.datametric360.app` — getrennter
-   API-Hostname hält die Allowlist übersichtlich. Entscheidung in `AGENTS.md` protokollieren.
-3. **Cloudflared-Add-on** in HA installieren, Tunnel erstellen, zwei öffentliche Hostnamen:
-   `datametric360.app` → Reverse-Proxy-Port (statische App-Dateien + nichts weiter),
-   `api.datametric360.app` → Reverse-Proxy-Port (API-Pfade). Kein Router-Port wird geöffnet.
-4. **Reverse Proxy:** Nginx Proxy Manager-Add-on (Standard-Empfehlung; Traefik nur, falls NPM
-   an Grenzen stößt — Entscheidung dokumentieren). Allowlist ausschließlich:
-   - `GET /api/states/pyscript.audi_dashboard_*` und `GET /api/states/pyscript.reifen_*`
-   - `POST /api/services/pyscript/audi_dashboard_*`
-   - `GET /api/` (Verbindungsprüfung) und der WebSocket-Pfad `/api/websocket`
-   Alles andere (v. a. `/auth`, `/lovelace`, `/config`, `/api/config`) wird geblockt.
-   ⚠️ Ehrliche Einschränkung dokumentieren: `/api/websocket` lässt sich nicht pfadgenau
-   beschneiden — nach `auth_ok` sind darüber alle States lesbar. Schutzschicht bleibt der LLAT
-   (ohne Token keine Verbindung); das ist die im Architekturdokument akzeptierte Abwägung.
-5. **Prüfen von außen** (Mobilfunk, VPN aus): App lädt, Login klappt, `curl` auf einen
-   Nicht-Allowlist-Pfad (z. B. `/auth/authorize`) liefert 403/404; HA-Port 8123 ist von außen
-   nicht erreichbar.
-6. ✅ Fertig wenn: Schritt 5 vollständig besteht. Die endgültige Allowlist wortwörtlich in
-   `COMPANION_APP_ARCHITECTURE.md` §5.1 eintragen (dort als offener Punkt vorgemerkt) und in
-   `AGENTS.md` Block B abhaken.
+2. ~~Hostnamen festlegen (App-Domain + getrennter API-Hostname)~~ — **überholt, siehe Hinweis oben:**
+   ein einziger Hostname (`https://datametric360.de`) genügt, da die App nativ/sideload-only bleibt
+   und nie als eigener Web-Build ausgeliefert wird.
+3. **Cloudflared-Add-on** in HA installieren, Tunnel erstellen, **ein** öffentlicher Hostname
+   (`datametric360.de` → Reverse-Proxy-Port). Kein Router-Port wird geöffnet. Genaue Klicks:
+   `INTERNET_ZUGRIFF_EINRICHTEN.md` Schritt 3/5.
+4. **Reverse Proxy:** Nginx Proxy Manager-Add-on (entschieden, nicht Traefik). Die Allowlist ist
+   umfangreicher als unten ursprünglich skizziert (aktueller Entitäts-/Dienststand plus das
+   OTA-Bündel unter `/audi_dashboard_static/app/*`) - wortwörtlich in `REVERSE_PROXY.md` gepflegt,
+   nicht hier dupliziert. ⚠️ Ehrliche Einschränkung bleibt bestehen: `/api/websocket` lässt sich
+   nicht pfadgenau beschneiden — nach `auth_ok` sind darüber alle States lesbar. Schutzschicht
+   bleibt der LLAT (ohne Token keine Verbindung).
+5. **Prüfen von außen** (Mobilfunk, VPN aus): die Prüfbefehle stehen in `REVERSE_PROXY.md`
+   ("Nach der Einrichtung prüfen"). HA-Port 8123 ist von außen nicht erreichbar.
+6. ✅ Fertig wenn: Schritt 5 vollständig besteht und die Server-Adresse in der App eingetragen ist
+   (`INTERNET_ZUGRIFF_EINRICHTEN.md` Schritt 7). In `AGENTS.md` Block B abhaken.
 
-Schritte 2–4 können gegen die bestehende HA-API **vor** der FMM003-Hardware erledigt werden.
+Schritte 3–4 können gegen die bestehende HA-API erledigt werden (die FMM003-Hardware läuft seit
+2026-08-13 bereits über flespi, siehe Phase 13 unten — diese Phase hängt nicht mehr daran).
 
 ---
 
-## Phase 13 — FMM003-Inbetriebnahme (wartet auf Hardware)
+## Phase 13 — FMM003-Inbetriebnahme ✅ ÜBERHOLT — Hardware lief bereits über flespi
 
-**Ziel:** Live-Daten vom Fahrzeug fließen nach HA; Fahrterkennung läuft über die Zündung.
-Referenz: `COMPANION_APP_ARCHITECTURE.md` §2b. **Nichts hiervon vorab raten oder simulieren.**
+> **Diese Phase ist gegenstandslos.** Die FMM003-Hardware ist seit 2026-08-13 in Betrieb, aber über
+> den in `AGENTS.md` (§ FMM003/Datenpfad) beschriebenen Weg: **flespi (natives Codec8/TCP, IMEI-
+> Auth), nicht MQTT/Mosquitto.** Die Schritte unten (eigene CA, Mosquitto-Add-on, Zertifikate,
+> `mosquitto_sub`-Mitschnitt) beschreiben die zuerst geplante, dann verworfene Variante — stehen
+> nur noch als Entscheidungsprotokoll. `homeassistant/FMM003_MAPPING.md` (unten referenziert)
+> wurde beim Merge 2026-08-13 deshalb bewusst nicht übernommen. Maßgeblich ist ausschließlich
+> `AGENTS.md`.
+
+**Ziel (nicht mehr aktuell):** Live-Daten vom Fahrzeug fließen nach HA; Fahrterkennung läuft über
+die Zündung. Referenz: `COMPANION_APP_ARCHITECTURE.md` §2b. **Nichts hiervon vorab raten oder
+simulieren.**
 
 1. **Mosquitto-Add-on** in HA installieren, Benutzer für das Gerät anlegen.
 2. **Zertifikate:** kleine eigene CA (drei `openssl`-Befehle: CA-Schlüssel+Zertifikat,
@@ -562,6 +627,6 @@ kommen asynchron über Entitäten (Muster: Beleg-Upload).
 
 Die App gilt als fertig, wenn: alle Screens aus Phase 7 in beiden Layouts funktionieren; Onboarding,
 Offline-Queue und Beleg-Upload gegen die Produktiv-HA laufen; die App als PWA und (falls Capacitor
-umgesetzt) nativ auf dem iPhone installiert ist; der externe Zugriff über `datametric360.app`
+umgesetzt) nativ auf dem iPhone installiert ist; der externe Zugriff über `datametric360.de`
 funktioniert, ohne dass HA exponiert ist; das alte Panel archiviert ist; und `AGENTS.md` den
 Endstand widerspiegelt (alle Blöcke A–D abgehakt oder begründet gestrichen).

VERSIONIERUNG.md

@@ -0,0 +1,179 @@
+# Versionierung — eine Zahl, drei Verbraucher
+
+Kurzfassung für den Alltag: **Wenn du etwas änderst, erhöhe `version` in
+`custom_components/audi_dashboard/manifest.json`.** Alles Weitere ergibt sich
+daraus von selbst.
+
+---
+
+## Warum es diese Zahl braucht
+
+Das Panel und die iOS-App werden völlig unterschiedlich ausgeliefert:
+
+- **Panel:** gehört zur Integration und wird mit ihr zusammen installiert. Es
+  kann gar nicht hinterherhinken — ein Update der Integration ist automatisch
+  ein Update des Panels.
+- **iOS-App:** eine Capacitor-Hülle mit **fest gebündelten** Dateien. Sie
+  bleibt auf dem Stand, der beim Signieren in Xcode eingebaut wurde —
+  unbegrenzt.
+
+Die Paritätsregel in `AGENTS.md` sichert, dass beide Codebasen in derselben
+Sitzung geändert werden. Über das, was *läuft*, sagte lange nichts etwas: die
+iOS-App konnte wochenlang zurückliegen, ohne dass es irgendwo sichtbar wurde.
+
+Die Versionszahl schließt genau diese Lücke — nicht, indem sie die Abweichung
+verhindert (das kann keine Zahl), sondern indem sie sie **sichtbar** macht.
+
+## Wo sie steht
+
+In `custom_components/audi_dashboard/manifest.json`, Feld `version`. Format
+`2026.8.23.2` (Datum + laufende Nummer).
+
+Genau dort und nirgends sonst. Home Assistant verlangt das Feld für jede
+benutzerdefinierte Integration — eine zweite Quelle für dieselbe Angabe wäre
+eine zu viel. Sie hätten irgendwann auseinandergelegen, und dann wäre der
+Vergleich still falsch geworden statt laut.
+
+> HACS würde dieses Feld ebenfalls lesen und danach entscheiden, ob ein
+> Update bereitliegt — spielt hier aber keine Rolle: HACS kann laut eigener
+> Dokumentation grundsätzlich nicht mit privaten GitHub-Repositories
+> arbeiten, und das Repository ist privat (lizenzierte Audi-Assets). Das
+> Manifest-Feld bleibt trotzdem die einzig richtige Stelle - Home Assistant
+> selbst braucht es unabhängig von HACS.
+
+> Bis 2026-08-23 gab es dafür eine eigene Datei `VERSION` in der Repo-Wurzel,
+> daneben eine Unix-Sekundenzahl in `www/audi-dashboard-version.json` als
+> Cache-Brecher. Beide sind mit dem Umbau zur Integration entfallen: die
+> Version steht jetzt im Manifest, und die Oberflächen-Dateien tragen sie als
+> `?v=…` in ihrer URL — die Integration hängt sie beim Anmelden des Panels an.
+> Ein Cache-Brecher, der sich nur bei echten Änderungen ändert, ist der
+> bessere: er lädt nichts unnötig neu.
+
+## Wie sie durchs System läuft
+
+```
+manifest.json  { "version": "2026.8.23.2" }
+   │
+   ├─► Home Assistant führt sie als Version der Integration
+   │
+   ├─► die Integration veröffentlicht sie als
+   │      sensor.audi_dashboard_app_version
+   │        └─► die iOS-App vergleicht sie mit ihrer eigenen, einkompilierten
+   │            Zahl und zeigt bei Abweichung einen Hinweis in der
+   │            Hinweisleiste
+   │
+   ├─► sie hängt als ?v=… an der Panel-URL
+   │      └─► Browser laden Panel, CSS und Badges nur dann neu, wenn sich
+   │          wirklich etwas geändert hat
+   │
+   └─► companion-app: vite liest das Manifest beim Bauen und setzt sie als
+       __APP_VERSION__ ein (bricht ab, wenn das Feld fehlt)
+```
+
+Der Vergleich läuft in eine Richtung: **die Integration sagt, welcher Stand
+installiert ist; die App sagt, welchen sie hat.** Stimmen sie nicht überein,
+ist die App zu alt (oder, seltener, die Integration).
+
+**Verglichen wird der Reihe nach, nicht nur auf Gleichheit — geändert am
+04.09.2026.** Bis dahin galt hier ausdrücklich das Gegenteil (die Version sei
+eine Kennung und keine Zahl). Der Anlass war ein echter Fall: nach einem
+Xcode-Lauf lief die App auf `2026.9.4.17`, die Instanz stand noch auf
+`2026.9.4.5` — und die App bot an, sich auf `.5` zu erneuern. Ein Rückschritt um
+zwölf Fassungen, den eine Gleichheitsprüfung gar nicht sehen kann. Vorgabe des
+Eigentümers: **erkannt wird eine neuere Fassung und keine andere.**
+
+Der damalige Einwand ist nicht verworfen, sondern eingebaut: sortiert wird nur,
+was dem Format `JJJJ.M.T.N` entspricht, und zwar Stelle für Stelle als Zahl —
+zeichenweise stünde `.17` vor `.5`. Passt eine Seite nicht ins Schema, gilt sie
+als **nicht sortierbar**; dann meldet die App eine Abweichung ohne Richtung und
+bietet nichts an, statt eine Reihenfolge zu erfinden. Fehlt eine der beiden
+Seiten ganz, wird gar nicht verglichen und nichts gemeldet — ein älteres Backend
+oder ein Start ohne Netz darf keinen Fehlalarm auslösen.
+
+Daraus folgen vier Verhaltensweisen, entschieden in `src/daten/appVersion.ts`:
+
+| Lage | Streifen | Startblatt | Update-Knopf |
+|---|---|---|---|
+| App älter als der Server | bitte aktualisieren | ja | ja |
+| App neuer (frisch signiert) | still | nein | **nein** |
+| verschieden, nicht sortierbar | neutraler Hinweis | nein | nur bei Serverübereinstimmung |
+| gleich / nicht vergleichbar | still | nein | nein |
+
+## Was du tun musst
+
+**Bei einer Änderung an der Oberfläche oder am Backend:**
+
+1. `version` in `manifest.json` erhöhen — bei mehreren Änderungen am selben Tag
+   die laufende Nummer: `2026.8.23.2` → `2026.8.23.3`, am nächsten Tag
+   `2026.8.24.1`.
+2. **OTA-Bündel neu bauen: `npm run ota`** (in `companion-app/`). Baut die
+   Oberfläche und packt sie mit der neuen Versionsnummer — siehe
+   [OTA-Updates](#ota-updates-seit-2026-08-24) unten. Ohne diesen Schritt
+   trägt `frontend/app/bundle.json` noch die alte Nummer: die Hinweisleiste
+   sagt dann „du bist veraltet" (liest die Version live), die Update-Seite
+   sagt „du bist aktuell" (vergleicht gegen das eingefrorene, jetzt falsche
+   Bündel) — ein Widerspruch, aus dem es ohne diesen Schritt keinen Ausweg
+   gibt. `install.ps1` prüft das seit 2026-08-24 selbst und warnt, falls
+   vergessen — aber besser, es passiert gar nicht erst.
+3. Integration ausliefern: nach `git push` entweder in der App selbst unter
+   Einstellungen → Integration-Update auf „Auf Update prüfen" → „Update
+   installieren" (seit 2026-08-24, ersetzt install.ps1 als laufenden
+   Update-Weg — Windows Smart App Control blockiert dessen Ausführung
+   zuverlässig), danach Home Assistant neu starten; oder weiterhin
+   `homeassistant\installationspaket\Installieren.cmd` von Hand
+   (HACS scheidet aus — siehe Kasten oben, das Repository ist privat).
+4. iOS-App für Xcode neu bauen (`npm run build`), damit eine über App Store
+   Connect / Sideload signierte Fassung dieselbe Zahl einkompiliert bekommt.
+   Für alle, die die App schon installiert haben, erledigt Schritt 2 das
+   automatisch über OTA — dieser Schritt ist nur für die nächste
+   Neuinstallation oder Signatur-Erneuerung nötig.
+
+Vergisst du Schritt 4, ist das kein stiller Fehler mehr: die App meldet selbst,
+dass sie älter ist als der Server. Vergisst du Schritt 2, bleibt es leider
+still — deshalb die Prüfung in `install.ps1`.
+
+**Bei einer reinen Neuinstallation** ohne Codeänderung: nichts tun.
+
+## OTA-Updates (seit 2026-08-24)
+
+`@capgo/capacitor-updater` ist eingebaut. Für reine Oberflächen-Änderungen
+(JavaScript, CSS, Bilder) entfällt Schritt 3 oben — die App lädt sich den
+neuen Stand selbst, auf einen Tastendruck des Nutzers in Einstellungen →
+App-Update. Xcode wird nur noch für echte native Änderungen gebraucht
+(neue Plugins, Berechtigungen, `capacitor.config.ts`).
+
+**Woher das Bündel kommt.** `companion-app/scripts/ota-paket.ps1` packt
+`dist/` (ohne Sourcemaps) in
+`custom_components/audi_dashboard/frontend/app/bundle.zip`, daneben
+`bundle.json` mit Version, SHA-256 und Größe. Weil das im Integrationsordner
+liegt, reist es bei jeder Auslieferung automatisch mit — kein zweiter Weg, den
+man vergessen könnte. Ausgeliefert wird es unter
+`/audi_dashboard_static/app/bundle.zip`, gemeldet über dasselbe Feld, das
+schon den Versionsvergleich trägt: `sensor.audi_dashboard_app_version`,
+Attribut `daten.buendel`.
+
+**Was die App damit macht** (`companion-app/src/daten/ota.ts`): erscheint ein
+Bündel, dessen Version von der eigenen abweicht, zeigt Einstellungen →
+App-Update einen Knopf. Ein Tastendruck lädt die Zip, prüft sie clientseitig
+gegen die mitgelieferte SHA-256 (das Plugin selbst, nicht diese App) und
+tauscht die Oberfläche aus — die App startet dabei neu.
+
+**Die Rückfallebene.** `notifyAppReady()` läuft in `App.tsx`, sobald React
+tatsächlich gerendert hat. Bleibt diese Meldung aus, weil das neue Bündel
+die App zerlegt hat, rollt das Plugin nach der eingestellten Frist
+(`appReadyTimeout` in `capacitor.config.ts`) von selbst auf das vorherige
+Bündel zurück — ein kaputtes Update kann das Gerät deshalb nicht dauerhaft
+unbrauchbar machen.
+
+**Warum kein Selbstlauf.** `autoUpdate: false` — die App lädt nur auf
+ausdrücklichen Tastendruck, nie im Hintergrund. Ein Update, das während einer
+Fahrteintragung ungefragt die Oberfläche austauscht, wäre die falsche Sorte
+Hilfsbereitschaft.
+
+**HACS spielt hier keine Rolle und wird es auch nicht.** Das Update-Bündel
+reist mit jedem Weg, der die Integration ausliefert, automatisch mit —
+`install.ps1` für die Erstinstallation ebenso wie das Selbst-Update seit
+2026-08-24 (aktualisierung.py, ersetzt install.ps1 als laufenden Update-Weg,
+siehe Abschnitt J in AGENTS.md) — der Mechanismus hängt nicht daran, wie die
+Integration selbst auf die Instanz kommt, nur daran, dass das Bündel im
+Integrationsordner liegt.

companion-app/.gitignore

@@ -2,3 +2,9 @@ node_modules/
 dist/
 *.local
 .DS_Store
+
+# Native Huellen: von `npx cap add` erzeugt, aus dem Webbuendel jederzeit
+# wiederherstellbar. Die Projektdateien selbst (capacitor.config.ts) sind
+# getrackt.
+ios/
+android/

companion-app/README.md

@@ -1,81 +1,96 @@
-# DataMetric360 — companion app
+# companion-app — DataMetric360
 
-Private vehicle app for one car. Ships three ways from one codebase: native iOS and Android via
-Capacitor, and embedded as a plain iframe in the Home Assistant dashboard. Architecture and the
-decisions behind it: [`../COMPANION_APP_ARCHITECTURE.md`](../COMPANION_APP_ARCHITECTURE.md).
+Private Fahrzeug-App für einen Audi RS 4 Avant competition. Läuft als Web-App
+im Browser, als PWA auf dem Homescreen, später über Capacitor nativ auf
+iOS/Android und eingebettet als Iframe im Home-Assistant-Dashboard.
 
-## Status
+**Kein eigenes Backend.** Die App spricht direkt mit der REST- und
+WebSocket-Schnittstelle von Home Assistant und ruft dieselben
+`pyscript.audi_dashboard_*`-Dienste auf wie das bestehende Panel. Alle Daten
+liegen auf dem eigenen Server; das Gerät hält nur den Zugangstoken und einen
+Zwischenspeicher für die Offline-Anzeige.
 
-**Data layer only.** No UI yet — the screens come from the Claude Design draft
-([`../DESIGN_BRIEF_DATAMETRIC360.md`](../DESIGN_BRIEF_DATAMETRIC360.md)), and get implemented on top
-of `design-system/`'s React components once that draft settles. This package was written first on
-purpose: how the app talks to Home Assistant doesn't depend on what the screens look like, so it
-survives every design iteration untouched.
+Architektur: `../COMPANION_APP_ARCHITECTURE.md` · Umsetzungsschritte:
+`../UMSETZUNGSPLAN.md` · Projektstand: `../AGENTS.md`
 
-Not yet added (deliberately, they'd be guesses today): React/Vite, Capacitor, the native secure-storage
-adapter, and the Audi brand assets (fonts/rings/badges — those come from `homeassistant/www/` at
-implementation time, never into `design-system/`, see the licence note in the architecture doc).
+## Loslegen
 
-## Layout
-
-```
-src/api/
-├── types.ts           HA state shapes + domain types (Fahrt, Tankvorgang, …) + the entity-ID table
-├── umgebung.ts        runtime detection (capacitor/iframe/browser), credential storage, URL helpers
-├── rest.ts            REST client — replaces hass.states / hass.callService
-├── live.ts            WebSocket client — push updates, auto-reconnect with backoff
-├── warteschlange.ts   offline queue for writes made without a connection
-└── index.ts           DataMetricApi — ties the three together, exposes the domain operations
-scripts/smoke.ts       verification against a running HA instance
+```bash
+npm install          # im Repo-Wurzelverzeichnis, nicht hier (npm-Workspace)
+npm run build:ds     # Design-System bauen, die App importiert aus dessen dist/
+npm run dev --workspace datametric360
 ```
 
-Comments are in German, matching the rest of the project.
+Beim ersten Start fragt die App nach Server-Adresse und Zugangstoken. Für die
+Entwicklung setzt `../testumgebung/aufsetzen.sh` eine vollständige
+Home-Assistant-Instanz mit dem echten Backend auf.
 
-## What replaces what
+## Aufbau
 
-The old panel got a `hass` object injected by `panel_custom`. That object only exists inside the HA
-frontend, which is exactly why the old panel can't run as a standalone app. The mapping:
-
-| Old panel | Here |
+| Ordner | Inhalt |
 |---|---|
-| `hass.states[id].attributes.daten` | `rest.datenLesen(id)` / `DataMetricApi.profilLesen()` etc. |
-| `hass.callService(...)` | `warteschlange.einreihen(...)` via the `DataMetricApi` methods |
-| automatic re-render on state push | `live.aufZustand(...)` |
+| `src/api/` | Datenschicht: REST, WebSocket mit Wiederverbindung, Offline-Warteschlange, Zugangsdaten |
+| `src/daten/` | Fachlogik: Profil-Umrechnung, Statistik, Service-Prognose, Datenkontext |
+| `src/screens/` | Die 21 Seiten der App |
+| `src/stile/` | Layout, Bildschirmbausteine, Audi-Schrift |
+| `src/assets/audi/` | Schrift, Vier-Ringe, Typenschilder — **lizenzpflichtig, siehe unten** |
+| `src/tests/` | Testaufbau und Beispieldaten |
 
-Same entities, same pyscript services, same backend files written — only the transport changes.
+Gestaltung kommt vollständig aus `@audi-dash/ui` (`../design-system/`). Neue
+Komponenten entstehen dort, nicht hier.
 
-Every **write** goes through the queue rather than straight to REST. That's what makes offline edits
-behave the same as online ones, just delayed: a receipt photographed in a dead zone is persisted and
-sent when the connection returns, surviving an app restart in between.
-
-## Commands
-
-Node is installed at `C:\Program Files\nodejs` but is **not on PATH** — prefix it:
+## Prüfen
 
 ```bash
-$env:Path = "C:\Program Files\nodejs;" + $env:Path
+npm run typecheck    # TypeScript, sehr streng (exactOptionalPropertyTypes u. a.)
+npm run test         # 90 Tests: Rechenlogik, Layoutwechsel, alle Seiten gerendert
+npm run smoke        # Adressbildung und Endpunkte, ohne Token
+npm run smoke:auth   # gegen die laufende Testinstanz, mit Token
+npm run build        # Produktionsbündel
 ```
 
-```bash
-npm run typecheck
-```
+`smoke:auth` liest Adresse und Token aus `.env.local` (schreibt
+`../testumgebung/aufsetzen.sh`, gitignored). Ohne die Datei überspringt der
+Test sich selbst, statt fehlzuschlagen.
 
-```bash
-npm run smoke
-```
+Die Rendertests decken alle 21 Seiten in beiden Layouts ab — schmal mit
+Tab-Leiste, breit mit Seitenleiste.
 
-`smoke` targets `http://localhost:18123` (the `audi_ha_test` Docker container) by default; pass a
-different base URL as the first argument.
+## Rechtlicher Hinweis
 
-## Verification status (2026-08-10)
+`src/assets/audi/` enthält die Hausschrift Audi Type, das Vier-Ringe-Zeichen
+und die Modell-Typenschilder. Diese sind lizenz- beziehungsweise
+markenrechtlich geschützt und ausschließlich für diese eine private,
+unveröffentlichte Installation freigegeben (`../bauauftrag.md` §8/§12).
 
-`tsc --noEmit` clean under `strict` plus `noUncheckedIndexedAccess` and `exactOptionalPropertyTypes`.
-All 7 smoke checks pass against the running test container, covering URL normalisation, the
-http→ws/https→wss mapping, that `GET /api/` exists and rejects an unauthenticated request with 401,
-and that the WebSocket opens with `auth_required` — which is the message `live.ts`'s whole auth flow
-is built around.
+Daraus folgt: **Die App wird nur seitlich installiert, nie in einem App Store
+veröffentlicht**, und dieses Repository bleibt privat. `../design-system/`
+kommt bewusst ohne diese Dateien aus, weil es nach außen hochgeladen wird —
+dort niemals Markendateien ablegen.
 
-**Not yet verified — needs a token:** authenticated reads, service calls, and the queue's real
-round-trip. Those need a Long-Lived Access Token, which is a deliberate manual step (see the LLAT
-provisioning decision in the architecture doc). To do it: create a token in the HA profile page, then
-extend `scripts/smoke.ts` with authenticated cases.
+## Die signierte App
+
+`auslieferung/App.ipa` ist der fertige, **Ad-hoc signierte** Stand (Team
+`RMACS9VLS4`, Profil gültig bis 29.08.2027, nur für das eingetragene iPhone).
+Neu bauen: `bash scripts/ios-signieren.sh` - baut Webbündel, synchronisiert die
+Hülle, signiert und legt die `.ipa` wieder hier ab.
+
+Beim ersten Signieren fragt der Schlüsselbund um Erlaubnis. Dort **„Immer
+erlauben"** wählen, sonst hängt `xcodebuild` wortlos und endet nach Minuten mit
+`errSecInternalComponent`.
+
+## Noch offen
+
+- Native Hülle selbst: `ios/`/`android/` (von `npx cap add` erzeugt, absichtlich
+  gitignored) existieren in keinem Checkout dauerhaft und müssen auf einem Mac
+  (für iOS zwingend, Xcode) neu erzeugt werden - die sichere Tokenablage
+  (Keychain/Keystore) ist dagegen bereits vollständig angebunden
+  (`src/api/ablageNativ.ts`, von `main.tsx` aktiviert) und wird automatisch
+  aktiv, sobald die Hülle existiert
+- Übertragung über die Luft: `scripts/ios-luftweg.sh https://<host>` erzeugt
+  Manifest und Installationsseite; es fehlt nur noch ein Host, der den Ordner
+  über **HTTPS mit gültigem Zertifikat** ausliefert (`tailscale serve`
+  angedacht, dieser Mac ist dort noch abgemeldet)
+- QR-Einrichtung als Alternative zum Einfügen des Tokens
+- Live-Ansicht der laufenden Fahrt: gebaut, aber über
+  `src/funktionen.ts` abgeschaltet, bis der FMM003 echte Werte liefert

companion-app/auslieferung/index.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="de">
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DataMetric360 installieren</title>
+<style>
+  body { font-family: -apple-system, sans-serif; background: #161b23; color: #eef1f6;
+         margin: 0; display: grid; place-items: center; min-height: 100vh; }
+  main { text-align: center; padding: 2rem; }
+  h1 { font-weight: 300; font-size: 1.5rem; }
+  a { display: inline-block; margin-top: 1.5rem; padding: 0.9rem 2rem; border-radius: 999px;
+      background: #eef1f6; color: #161b23; text-decoration: none; font-size: 1.1rem; }
+  p { color: #8a94a3; font-size: 0.9rem; line-height: 1.5; }
+</style>
+<main>
+  <h1>DataMetric360</h1>
+  <p>Version 2026.9.4.17</p>
+  <a href="itms-services://?action=download-manifest&amp;url=https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung/manifest.plist">Installieren</a>
+  <p>In Safari oeffnen. Nach dem Antippen fragt iOS einmal nach,<br>danach erscheint die App auf dem Startbildschirm.</p>
+</main>
+</html>

companion-app/auslieferung/manifest.plist

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>items</key>
+  <array>
+    <dict>
+      <key>assets</key>
+      <array>
+        <dict>
+          <key>kind</key><string>software-package</string>
+          <key>url</key><string>https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung/App.ipa?v=2026.9.4.17</string>
+        </dict>
+        <dict>
+          <key>kind</key><string>display-image</string>
+          <key>url</key><string>https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung/symbol-192.png?v=2026.9.4.17</string>
+        </dict>
+        <dict>
+          <key>kind</key><string>full-size-image</string>
+          <key>url</key><string>https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung/symbol-512.png?v=2026.9.4.17</string>
+        </dict>
+      </array>
+      <key>metadata</key>
+      <dict>
+        <key>bundle-identifier</key><string>app.datametric360</string>
+        <key>bundle-version</key><string>2026.9.4.17</string>
+        <key>kind</key><string>software</string>
+        <key>title</key><string>DataMetric360</string>
+      </dict>
+    </dict>
+  </array>
+</dict>
+</plist>

companion-app/capacitor.config.ts

@@ -0,0 +1,72 @@
+import type { CapacitorConfig } from "@capacitor/cli"
+
+/**
+ * Capacitor-Konfiguration für die native Hülle.
+ *
+ * Nur Sideload, nie App Store: die Audi-Schrift und die Typenschilder sind
+ * ausschließlich für diese eine private Installation freigegeben.
+ *
+ * Ablauf: `npm run build && npx cap sync`, dann `npx cap open ios` und in
+ * Xcode signieren. Siehe `../UMSETZUNGSPLAN.md` Phase 10.
+ */
+const konfiguration: CapacitorConfig = {
+  appId: "app.datametric360",
+  appName: "DataMetric360",
+  webDir: "dist",
+  server: {
+    // https, damit die App als sicherer Ursprung gilt — sonst verweigern
+    // Browser-Bausteine wie die Zwischenablage ihren Dienst.
+    androidScheme: "https",
+    iosScheme: "https",
+  },
+  ios: {
+    // Die App zeichnet bis unter die Statusleiste und hält den sicheren
+    // Bereich selbst über env(safe-area-inset-*) frei.
+    contentInset: "never",
+    backgroundColor: "#161b23",
+  },
+  android: {
+    backgroundColor: "#161b23",
+  },
+  plugins: {
+    // Leitet fetch() über die native HTTP-Schicht statt über die WebView.
+    //
+    // Das ist hier nicht Feinschliff, sondern notwendig: Die native Hülle
+    // liefert die Oberfläche unter einem eigenen Ursprung aus, jede Anfrage an
+    // Home Assistant ist damit ursprungsübergreifend, und die WebView lehnt sie
+    // ohne CORS-Freigabe ab. Nativ gestellte Anfragen kennen keine
+    // CORS-Prüfung — die App braucht dadurch keinerlei CORS-Einstellung am
+    // Server. Die WebSocket-Verbindung läuft unberührt weiter.
+    CapacitorHttp: { enabled: true },
+
+    // Oberflächen-Updates ohne Xcode (siehe src/daten/ota.ts und
+    // ../VERSIONIERUNG.md). Das Bündel liegt in der Integration und wird
+    // über Home Assistant ausgeliefert — keine fremde Cloud beteiligt.
+    CapacitorUpdater: {
+      // Kein Selbstlauf: die App lädt nur, wenn der Benutzer den Knopf in den
+      // Einstellungen drückt. Ein Update, das ungefragt die Oberfläche
+      // austauscht, während jemand gerade eine Fahrt einträgt, wäre die
+      // schlechtere Sorte Hilfsbereitschaft.
+      autoUpdate: false,
+
+      // Kommt eine frisch signierte App über Xcode aufs Gerät, gilt wieder
+      // deren eingebautes Bündel — sonst liefe ein älteres OTA-Bündel weiter
+      // und überdeckte genau die native Änderung, für die Xcode nötig war.
+      resetWhenUpdate: true,
+
+      // Meldet sich die App nach einem Wechsel nicht binnen dieser Zeit als
+      // startklar (notifyAppReady in src/main.tsx), kehrt das Plugin von
+      // selbst zum vorherigen Bündel zurück. Das ist die Rückfallebene: ein
+      // kaputtes Bündel kann das Gerät nicht dauerhaft lahmlegen. Bewusst
+      // großzügiger als die 10 Sekunden Vorgabe — die Erstladung holt Profil,
+      // Fahrten und Tankvorgänge, und ein langsames Netz darf nicht wie ein
+      // defektes Bündel aussehen.
+      appReadyTimeout: 20000,
+
+      // Ein Bündel, das beim Start durchgefallen ist, wird nicht aufbewahrt.
+      autoDeleteFailed: true,
+    },
+  },
+}
+
+export default konfiguration

companion-app/docs/SHARE_EXTENSION.md

@@ -0,0 +1,127 @@
+# Tankbeleg aus dem Teilen-Blatt
+
+Ein PDF aus Mail (oder einer anderen App) über **Teilen → DataMetric360** direkt
+als Tankbeleg übernehmen.
+
+## Wie es zusammenhängt
+
+```
+Mail  ──Teilen──►  DataMetric360Share          (eigener Prozess)
+                        │
+                        │ PDF → Base64 → UserDefaults der App-Gruppe
+                        │                group.app.datametric360
+                        ▼
+                   datametric360://beleg       (öffnet die App)
+                        │
+                        ▼
+                   App.tsx  ──holt ab──►  Tanken-Seite ──►  belegLesen()
+```
+
+Eine Erweiterung ist ein eigener Prozess mit eigenem Dateibereich; der einzige
+gemeinsame Boden mit der App ist die **App-Gruppe**. Der Beleg reist deshalb
+Base64-kodiert durch die geteilten `UserDefaults` — die liest
+`@capacitor/preferences` ohnehin schon, sobald man ihm die Gruppe nennt. Eine
+Datei im Gruppen-Container wäre der sauberere Ort, bräuchte auf der App-Seite
+aber eigenen nativen Code, also ein zusätzliches Plugin für einen Weg, den es
+sonst nicht gäbe.
+
+Der Preis ist eine Größengrenze von 4 MB (`grenzeBytes` im
+`ShareViewController`). Ein Tankbeleg liegt bei einigen Dutzend Kilobyte; ein
+gescanntes Mehrseiten-PDF kann darüber liegen — dann sagt die Erweiterung das,
+und der Weg über **Beleg hochladen → Datei auswählen** in der App bleibt.
+
+## Wo was liegt
+
+| Datei | Rolle |
+|---|---|
+| `native/teilen/ShareViewController.swift` | nimmt das PDF entgegen, legt es ab, öffnet die App |
+| `native/teilen/Info.plist` | wann DataMetric360 im Teilen-Blatt erscheint (genau ein PDF) |
+| `native/teilen/DataMetric360Share.entitlements` | App-Gruppe für die Erweiterung |
+| `native/App.entitlements` | dieselbe App-Gruppe für die App |
+| `scripts/ios-teilen-einrichten.mjs` | hängt das alles ins erzeugte Xcode-Projekt |
+| `src/daten/geteilterBeleg.ts` | holt den Beleg ab, räumt ihn weg |
+| `src/App.tsx` | prüft beim Start und bei jeder Rückkehr, springt auf Tanken |
+| `src/screens/Tanken.tsx` | nimmt ihn auf und lädt ihn hoch |
+
+**`companion-app/ios/` ist gitignored** und wird von `npx cap add ios` neu
+gebaut. Alles Native muss deshalb unter `native/` liegen und bei jedem Bau
+eingespielt werden — dieselbe Regel, die schon die Team-Kennung und den
+Standort-Schlüssel in `ios-signieren.sh` getrieben hat.
+
+## Einmalig im Apple-Entwicklerportal
+
+Ohne diese drei Schritte schlägt das Signieren fehl (die App-Gruppe muss
+existieren, bevor ein Profil sie enthalten kann):
+
+1. **Identifiers → App Groups**: `group.app.datametric360` anlegen.
+2. **Identifiers → App IDs**: `app.datametric360.teilen` anlegen, Capability
+   *App Groups* aktivieren, die Gruppe zuordnen.
+3. Bei der bestehenden App-ID `app.datametric360` ebenfalls *App Groups*
+   aktivieren und dieselbe Gruppe zuordnen.
+
+Danach in Xcode einmal die Profile neu ziehen lassen — oder schlicht
+`ios-signieren.sh` laufen lassen, das macht `-allowProvisioningUpdates`
+selbst. **Merkposten aus Abschnitt AI:** ein zwischengespeichertes altes
+Profil wird stillschweigend weiterverwendet. Ändert sich etwas an den
+Berechtigungen, das passende `.mobileprovision` unter
+`~/Library/Developer/Xcode/UserData/Provisioning Profiles` löschen und neu
+exportieren.
+
+## Bauen
+
+```bash
+bash scripts/ios-signieren.sh
+```
+
+Der Schritt „Share-Erweiterung einrichten" läuft dort automatisch, vor dem
+Archivieren.
+
+## Wenn das Skript abbricht
+
+`ios-teilen-einrichten.mjs` bearbeitet die `project.pbxproj` über das
+npm-Paket `xcode`. **Erstmals auf einem Mac gelaufen am 2026-09-02**; dabei kam
+genau ein Fehler heraus, seither behoben: die Erweiterung wurde **zweimal**
+eingebettet, weil `addTarget()` für den Typ `app_extension` von sich aus schon
+eine Copy-Phase nach `PlugIns` anlegt und das Skript eine zweite hinzufügte.
+Xcode quittierte das mit `error: Unexpected duplicate tasks`. Das Anlegen des
+Ziels selbst, die Entitlements, das URL-Schema und die Idempotenz funktionierten
+auf Anhieb.
+
+Bricht es ab, ist nichts halb eingerichtet (es bricht vor dem Schreiben ab), und
+dasselbe lässt sich in Xcode von Hand erledigen:
+
+1. **File → New → Target… → Share Extension**, Name `DataMetric360Share`,
+   Sprache Swift, „Activate scheme" verneinen.
+2. Die von Xcode erzeugten `ShareViewController.swift`, `Info.plist` und das
+   `MainInterface.storyboard` **löschen** und stattdessen die Dateien aus
+   `native/teilen/` in das Ziel legen (Storyboard wird nicht gebraucht, die
+   Erweiterung hat keine eigene Oberfläche).
+3. Bundle-ID des Ziels auf `app.datametric360.teilen` setzen.
+4. Beide Ziele → **Signing & Capabilities → + Capability → App Groups**,
+   `group.app.datametric360` anhaken.
+5. Ziel `DataMetric360Share` → Build Settings → *Code Signing Entitlements* auf
+   `DataMetric360Share/DataMetric360Share.entitlements`; Ziel `App` auf
+   `App/App.entitlements`.
+6. Ziel `App` → Build Phases → **Embed App Extensions** muss
+   `DataMetric360Share.appex` enthalten.
+7. `ios/App/App/Info.plist`: URL-Schema `datametric360` unter
+   `CFBundleURLTypes` eintragen.
+
+Schritt 7 ist der leiseste: fehlt er, wird der Beleg abgelegt, die App aber
+nicht geöffnet — er taucht dann erst auf, wenn man die App das nächste Mal von
+Hand startet.
+
+## Prüfen, ob es wirkt
+
+1. In Mail ein PDF antippen → **Teilen** → DataMetric360 muss in der Liste
+   stehen (nur bei genau einem PDF, sonst absichtlich nicht).
+2. Antippen → die App kommt nach vorn, springt auf **Tanken**, das Formular ist
+   offen und liest den Beleg („Beleg wird gelesen …").
+3. Danach ist der Eintrag weg: dieselbe Datei ein zweites Mal zu teilen muss
+   wieder funktionieren, ein bloßes Wechseln in die App darf den Beleg **nicht**
+   erneut verarbeiten.
+
+## Was hier nicht steht
+
+Android. Der Ablauf ist dort ein anderer (`intent-filter` statt App-Gruppe),
+und die Android-Hülle dieses Projekts ist ohnehin nicht in Gebrauch.

companion-app/index.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="utf-8" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, viewport-fit=cover"
+    />
+    <meta name="color-scheme" content="dark light" />
+    <meta name="theme-color" content="#161b23" />
+    <link rel="manifest" href="./manifest.webmanifest" />
+    <link rel="icon" href="./symbol.svg" type="image/svg+xml" />
+    <!-- iOS wertet das Manifest nicht aus und braucht diese beiden Angaben,
+         damit "Zum Home-Bildschirm" ein eigenes Symbol und keine Browserleiste
+         zeigt. -->
+    <link rel="apple-touch-icon" href="./apple-touch-icon.png" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+    <meta name="apple-mobile-web-app-title" content="DataMetric360" />
+    <title>DataMetric360</title>
+  </head>
+  <body>
+    <div id="wurzel"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

companion-app/native/App.entitlements

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Entitlements der Haupt-App. Bislang hatte sie keine eigene Datei - erst die
+  App-Gruppe der Share-Erweiterung macht eine noetig. Derselbe Bezeichner wie
+  in native/teilen/DataMetric360Share.entitlements.
+-->
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.application-groups</key>
+  <array>
+    <string>group.app.datametric360</string>
+  </array>
+</dict>
+</plist>

companion-app/native/AppIcon.appiconset/Contents.json

@@ -0,0 +1,38 @@
+{
+  "images" : [
+    {
+      "filename" : "AppIcon-hell.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "dark"
+        }
+      ],
+      "filename" : "AppIcon-dunkel.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    },
+    {
+      "appearances" : [
+        {
+          "appearance" : "luminosity",
+          "value" : "tinted"
+        }
+      ],
+      "filename" : "AppIcon-getoent.png",
+      "idiom" : "universal",
+      "platform" : "ios",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

companion-app/native/BelegZwischenablage.swift

@@ -0,0 +1,99 @@
+//
+//  BelegZwischenablage.swift
+//  DataMetric360
+//
+//  Holt ein PDF aus der System-Zwischenablage — der Weg, den die Web-API
+//  nicht anbietet.
+//
+//  WARUM ES DAS BRAUCHT
+//  --------------------
+//  `navigator.clipboard.read()` gibt aus Datenschutzgründen nur Text, HTML
+//  und Bilder heraus; ein kopiertes PDF taucht dort NIE auf. Der Knopf „Aus
+//  Zwischenablage einfügen" endete deshalb auf dem Telefon zwangsläufig mit
+//  „In der Zwischenablage liegt kein PDF" (gemeldet vom Eigentümer,
+//  02.09.2026). Das ist keine Lücke in unserem Code, sondern die Grenze der
+//  Schnittstelle.
+//
+//  `UIPasteboard` kennt diese Grenze nicht: es gibt beliebige Typen heraus,
+//  auch `com.adobe.pdf`. Der Preis ist derselbe wie im Web — iOS zeigt beim
+//  Zugriff seine eigene Einfügen-Rückfrage, und das ist richtig so.
+//
+//  DREI FORMEN, IN DENEN EIN PDF IN DER ZWISCHENABLAGE LIEGT
+//  ---------------------------------------------------------
+//  1. Als Daten unter `com.adobe.pdf` — so legen es die meisten Apps ab.
+//  2. Als Datei-URL — Mail kopiert einen Anhang oft nur als Verweis auf eine
+//     temporäre Kopie. Ohne den zweiten Weg bliebe genau der Fall übrig, für
+//     den der Knopf gedacht ist.
+//  3. Als Zusage (`NSItemProvider`) — die Datei existiert dann noch gar nicht,
+//     die kopierende App liefert sie erst auf Anforderung. `data(forPasteboardType:)`
+//     gibt dabei nil zurück und `urls` bleibt leer; nur der Anbieter kennt sie.
+//     Das ist Apples eigener, empfohlener Weg und der einzige, der auch eine
+//     Datei aus einer Sandbox einer anderen App zuverlässig herausgibt — Weg 2
+//     scheitert dort am Lesezugriff. Er ist asynchron, deshalb steht er hier
+//     zuletzt: die beiden schnellen Wege sollen nicht auf ihn warten.
+//
+//  DIESE DATEI IST VERSIONIERT, ios/ NICHT.
+//  `npx cap add ios` erzeugt den nativen Ordner neu und würde alles darin
+//  verlieren. scripts/ios-teilen-einrichten.mjs kopiert sie bei jedem Bau
+//  wieder hinein und hängt sie an die Sources-Phase des App-Ziels.
+//
+
+import Capacitor
+import Foundation
+import UIKit
+import UniformTypeIdentifiers
+
+@objc(BelegZwischenablagePlugin)
+public class BelegZwischenablagePlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "BelegZwischenablagePlugin"
+    public let jsName = "BelegZwischenablage"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "pdfHolen", returnType: CAPPluginReturnPromise)
+    ]
+
+    /// Liefert `{ base64, name }`, wenn ein PDF in der Zwischenablage liegt —
+    /// sonst ein leeres Ergebnis. Bewusst kein Fehler: „nichts kopiert" ist
+    /// kein Fehlschlag, sondern eine Antwort, und die Oberfläche sagt dazu
+    /// ohnehin das Passende (zwischenablage.ts).
+    @objc func pdfHolen(_ call: CAPPluginCall) {
+        let ablage = UIPasteboard.general
+
+        if let daten = ablage.data(forPasteboardType: UTType.pdf.identifier) {
+            return call.resolve(["base64": daten.base64EncodedString(), "name": "beleg.pdf"])
+        }
+
+        // Mail legt den Anhang oft nur als Verweis ab.
+        for url in ablage.urls ?? [] where url.pathExtension.lowercased() == "pdf" {
+            // Sicherheitsbereich anfordern: die URL zeigt auf eine Datei
+            // außerhalb des eigenen Sandkastens, sonst schlägt das Lesen fehl.
+            let erlaubt = url.startAccessingSecurityScopedResource()
+            defer { if erlaubt { url.stopAccessingSecurityScopedResource() } }
+            if let daten = try? Data(contentsOf: url) {
+                return call.resolve([
+                    "base64": daten.base64EncodedString(),
+                    "name": url.lastPathComponent,
+                ])
+            }
+        }
+
+        // Dritter Weg: die Datei liegt nur als Zusage vor.
+        let anbieter = ablage.itemProviders.first {
+            $0.hasItemConformingToTypeIdentifier(UTType.pdf.identifier)
+        }
+        guard let anbieter else {
+            return call.resolve([:])
+        }
+        anbieter.loadDataRepresentation(forTypeIdentifier: UTType.pdf.identifier) { daten, _ in
+            guard let daten, !daten.isEmpty else {
+                // Kein Fehler: die Oberfläche sagt zu einem leeren Ergebnis
+                // ohnehin das Passende (zwischenablage.ts).
+                return call.resolve([:])
+            }
+            let name = anbieter.suggestedName.map { $0.hasSuffix(".pdf") ? $0 : $0 + ".pdf" }
+            call.resolve([
+                "base64": daten.base64EncodedString(),
+                "name": name ?? "beleg.pdf",
+            ])
+        }
+    }
+}

companion-app/native/KalenderTermin.swift

@@ -0,0 +1,135 @@
+//
+//  KalenderTermin.swift
+//  DataMetric360
+//
+//  Legt einen Termin über EventKit an — der Weg, den das Teilen-Blatt nicht
+//  anbietet.
+//
+//  WARUM ES DAS BRAUCHT
+//  --------------------
+//  Bis zum 03.09.2026 ging der Werkstatt- und der Radwechseltermin als
+//  .ics-Datei ins iOS-Teilen-Blatt. Dort erscheint nie ein Kalender, und das
+//  liegt nicht an der Datei: Apples Kalender-App meldet sich beim System
+//  überhaupt nicht als Teilen-Ziel an, für kein Format. Das Blatt kann sie
+//  deshalb gar nicht zeigen, egal wie die Datei aussieht.
+//
+//  Dass ein per Mail geschickter Anhang funktioniert, führt in die Irre: dort
+//  öffnet nicht das Teilen-Blatt, sondern die Dokumentvorschau des Systems
+//  (Quick Look). Die erkennt text/calendar und blendet „Alle hinzufügen" ein.
+//  Ein anderer Mechanismus, den eine App nicht aus dem Teilen-Blatt heraus
+//  erreicht. Gemeldet vom Eigentümer am 02.09.2026.
+//
+//  EventKit umgeht beides: der Termin geht direkt an den Kalender.
+//
+//  WARUM DER SYSTEM-EDITOR UND NICHT `EKEventStore.save`
+//  -----------------------------------------------------
+//  `EKEventEditViewController` zeigt den fertig ausgefüllten Termin und lässt
+//  ihn den Menschen bestätigen. Das passt zur Vorgabe des Eigentümers, dass
+//  der Werkstatttermin keine eigene Verwaltung bekommt (siehe Abschnitt BQ in
+//  AGENTS.md): die App liefert „was, wann, welche Werkstatt" und ist danach
+//  raus — gespeichert wird im Kalender, nicht bei uns.
+//
+//  Der zweite Grund ist die Berechtigung. Seit iOS 17 braucht der System-
+//  Editor keine (WWDC23, „Discover Calendar and EventKit"): er läuft außerhalb
+//  unseres Zugriffs, wir übergeben nur den Entwurf. Ein direktes `save()`
+//  bräuchte dagegen eine Freigabe samt Rückfrage. Deshalb wird hier auch
+//  `event.calendar` NICHT gesetzt — das würde `defaultCalendarForNewEvents`
+//  lesen und damit doch eine Freigabe verlangen; der Editor sucht den
+//  Standardkalender selbst.
+//
+//  DIESE DATEI IST VERSIONIERT, ios/ NICHT.
+//  `npx cap add ios` erzeugt den nativen Ordner neu und würde alles darin
+//  verlieren. scripts/ios-teilen-einrichten.mjs kopiert sie bei jedem Bau
+//  wieder hinein und hängt sie an die Sources-Phase des App-Ziels.
+//
+
+import Capacitor
+import EventKit
+import EventKitUI
+import Foundation
+import UIKit
+
+@objc(KalenderTerminPlugin)
+public class KalenderTerminPlugin: CAPPlugin, CAPBridgedPlugin, EKEventEditViewDelegate {
+    public let identifier = "KalenderTerminPlugin"
+    public let jsName = "KalenderTermin"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "terminAnlegen", returnType: CAPPluginReturnPromise)
+    ]
+
+    /// Muss den Editor überleben — eine lokale Instanz wäre beim Erscheinen
+    /// des Blatts schon wieder abgeräumt.
+    private let speicher = EKEventStore()
+
+    /// Der Aufruf wartet, bis der Mensch im Editor entschieden hat.
+    private var offenerAufruf: CAPPluginCall?
+
+    @objc func terminAnlegen(_ call: CAPPluginCall) {
+        guard let titel = call.getString("titel"), !titel.isEmpty else {
+            return call.reject("Ohne Titel kein Termin.")
+        }
+        guard let isoTag = call.getString("isoTag"), let tag = tagAus(isoTag) else {
+            return call.reject("Kein gültiges Datum (erwartet JJJJ-MM-TT).")
+        }
+
+        let termin = EKEvent(eventStore: speicher)
+        termin.title = titel
+        termin.isAllDay = true
+        // Ganztägig heißt für EventKit: Beginn und Ende am selben Tag. Deckt
+        // sich mit dem DTSTART;VALUE=DATE der bisherigen .ics.
+        termin.startDate = tag
+        termin.endDate = tag
+        if let ort = call.getString("ort"), !ort.isEmpty { termin.location = ort }
+        if let text = call.getString("beschreibung"), !text.isEmpty { termin.notes = text }
+        // Zwei Tage vorher erinnern - dieselbe Vorwarnzeit wie im TRIGGER:-P2D
+        // der .ics, die dieser Weg ablöst.
+        termin.addAlarm(EKAlarm(relativeOffset: -2 * 24 * 60 * 60))
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            guard let eltern = self.bridge?.viewController else {
+                return call.reject("Kein Fenster zum Anzeigen des Kalender-Editors.")
+            }
+
+            // Ein noch offener Aufruf kann nur von einem Editor stammen, der
+            // ohne Rueckmeldung verschwunden ist. Ihn stehen zu lassen hiesse,
+            // ein Versprechen nie einzuloesen.
+            self.offenerAufruf?.resolve(["status": "abgebrochen"])
+            self.offenerAufruf = call
+
+            let editor = EKEventEditViewController()
+            editor.event = termin
+            editor.eventStore = self.speicher
+            editor.editViewDelegate = self
+            // Wegwischen wuerde den Delegaten nicht rufen und den Aufruf oben
+            // haengen lassen; so bleiben nur "Hinzufuegen" und "Abbrechen".
+            editor.isModalInPresentation = true
+            eltern.present(editor, animated: true)
+        }
+    }
+
+    public func eventEditViewController(
+        _ controller: EKEventEditViewController,
+        didCompleteWith action: EKEventEditViewAction
+    ) {
+        controller.dismiss(animated: true)
+        let aufruf = offenerAufruf
+        offenerAufruf = nil
+        // .deleted gibt es hier nicht (der Termin ist neu), zaehlt aber wie ein
+        // Abbruch: gespeichert wurde nichts.
+        aufruf?.resolve(["status": action == .saved ? "gespeichert" : "abgebrochen"])
+    }
+
+    /// „2027-03-14" -> Mitternacht dieses Tages in der Zeitzone des Geräts.
+    private func tagAus(_ isoTag: String) -> Date? {
+        let teile = isoTag.split(separator: "-").compactMap { Int($0) }
+        guard teile.count == 3 else { return nil }
+        var komponenten = DateComponents()
+        komponenten.year = teile[0]
+        komponenten.month = teile[1]
+        komponenten.day = teile[2]
+        var kalender = Calendar(identifier: .gregorian)
+        kalender.timeZone = TimeZone.current
+        return kalender.date(from: komponenten)
+    }
+}

companion-app/native/teilen/DataMetric360Share.entitlements

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Die App-Gruppe ist der einzige gemeinsame Boden zwischen Erweiterung und
+  App - ohne sie kann die Erweiterung nichts uebergeben. Derselbe Bezeichner
+  muss in App.entitlements stehen und im Apple-Entwicklerportal als App Group
+  angelegt sein.
+-->
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.application-groups</key>
+  <array>
+    <string>group.app.datametric360</string>
+  </array>
+</dict>
+</plist>

companion-app/native/teilen/Info.plist

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Info.plist der Share-Erweiterung.
+
+  NSExtensionActivationRule entscheidet, wann DataMetric360 im Teilen-Blatt
+  ueberhaupt auftaucht. Bewusst eng: genau EIN PDF, sonst nichts. Die
+  Erweiterung kann nur Tankbelege, und ein Eintrag, der bei jedem Foto und
+  jedem Link mitangeboten wird und dann ablehnt, ist schlechter als keiner.
+
+  NSExtensionPrincipalClass zeigt auf die Swift-Klasse ohne Storyboard -
+  die Erweiterung hat keine eigene Oberflaeche, sie nimmt die Datei entgegen
+  und oeffnet die App. Deshalb steht hier auch kein NSExtensionMainStoryboard.
+-->
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>de</string>
+  <key>CFBundleDisplayName</key>
+  <string>DataMetric360</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key>
+  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>XPC!</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>NSExtension</key>
+  <dict>
+    <key>NSExtensionAttributes</key>
+    <dict>
+      <key>NSExtensionActivationRule</key>
+      <dict>
+        <key>NSExtensionActivationSupportsFileWithMaxCount</key>
+        <integer>1</integer>
+        <key>NSExtensionActivationSupportsAttachmentsWithMaxCount</key>
+        <integer>1</integer>
+      </dict>
+    </dict>
+    <key>NSExtensionPointIdentifier</key>
+    <string>com.apple.share-services</string>
+    <key>NSExtensionPrincipalClass</key>
+    <string>$(PRODUCT_MODULE_NAME).ShareViewController</string>
+  </dict>
+</dict>
+</plist>

companion-app/native/teilen/ShareViewController.swift

@@ -0,0 +1,172 @@
+//
+//  ShareViewController.swift
+//  DataMetric360Share
+//
+//  Nimmt ein PDF aus dem iOS-Teilen-Blatt entgegen (typischerweise ein
+//  Tankbeleg aus Mail) und reicht es an die App weiter.
+//
+//  WIE DIE ÜBERGABE FUNKTIONIERT — UND WARUM SO
+//  --------------------------------------------
+//  Eine Share-Erweiterung ist ein eigener Prozess mit eigenem Dateibereich.
+//  Sie kann der App nichts direkt geben; der einzige gemeinsame Boden ist
+//  eine App-Gruppe. Der Weg hier:
+//
+//    1. Das PDF wird in den Container der App-Gruppe geschrieben.
+//    2. Die Erweiterung öffnet die App über ihr URL-Schema und gibt den
+//       Pfad mit: `datametric360://beleg?pfad=<file://…>`.
+//    3. Die App liest die Datei über @capacitor/filesystem (das volle
+//       file://-Pfade ausdrücklich unterstützt) und löscht sie danach.
+//
+//  DER ERSTE ENTWURF GING ÜBER USERDEFAULTS UND HAT NIE FUNKTIONIERT.
+//  Er legte das PDF base64-kodiert unter `dm360_geteilter_beleg` in
+//  `UserDefaults(suiteName: gruppe)` ab, weil die App UserDefaults über
+//  @capacitor/preferences ohnehin liest. Nur liest dieses Plugin (8.0.1,
+//  ios/Sources/PreferencesPlugin/Preferences.swift) IMMER
+//  `UserDefaults.standard` der App — `configure({ group })` wechselt nicht
+//  den Container, sondern setzt nur ein Schlüssel-Präfix. Die App suchte
+//  also `group.app.datametric360.dm360_geteilter_beleg` in ihrem eigenen
+//  Bereich, während hier der plain Schlüssel im Gruppen-Container lag:
+//  falscher Behälter und falscher Schlüssel. Gemeldet am 02.09.2026
+//  („es wird kein Tankvorgang angelegt beim Teilen mit der App“).
+//
+//  Die Datei hat zwei weitere Vorteile: keine Base64-Aufblähung um ein
+//  Drittel, und keine 4-MB-Grenze — UserDefaults ist für Einstellungen
+//  gedacht, nicht für Anhänge. Geblieben ist eine Obergrenze, aber eine
+//  großzügige (GRENZE_BYTES).
+//
+//  DIESE DATEI IST VERSIONIERT, ios/ NICHT.
+//  `npx cap add ios` erzeugt den nativen Ordner neu und würde alles darin
+//  verlieren. scripts/ios-teilen-einrichten.mjs kopiert diese Datei bei
+//  jedem Bau wieder hinein und hängt das Ziel ins Xcode-Projekt.
+//
+
+import UIKit
+import Social
+import UniformTypeIdentifiers
+
+class ShareViewController: UIViewController {
+
+    /// Muss zur App-Gruppe in beiden Entitlements-Dateien passen.
+    private let gruppe = "group.app.datametric360"
+
+    /// Unterordner im Gruppen-Container, in dem geteilte Belege liegen.
+    private let ordner = "geteilte-belege"
+
+    /// 24 MB. Kein technisches Limit mehr, sondern eine Vernunftgrenze:
+    /// ein Tankbeleg liegt bei einigen Dutzend Kilobyte, alles jenseits
+    /// davon ist kein Beleg, sondern ein Versehen.
+    private let grenzeBytes = 24 * 1024 * 1024
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        view.backgroundColor = .clear
+        pdfUebernehmen()
+    }
+
+    private func pdfUebernehmen() {
+        guard
+            let eintrag = (extensionContext?.inputItems as? [NSExtensionItem])?.first,
+            let anhaenge = eintrag.attachments
+        else {
+            return abschliessen()
+        }
+
+        let pdfTyp = UTType.pdf.identifier
+        guard let anhang = anhaenge.first(where: { $0.hasItemConformingToTypeIdentifier(pdfTyp) })
+        else {
+            return melden("Kein PDF dabei.")
+        }
+
+        anhang.loadItem(forTypeIdentifier: pdfTyp, options: nil) { [weak self] wert, _ in
+            guard let self else { return }
+
+            // Je nach Quelle kommt eine URL, ein Data-Objekt oder nichts
+            // Brauchbares an — Mail liefert eine URL auf eine temporäre
+            // Kopie, andere Apps reichen die Bytes direkt.
+            var daten: Data?
+            var name = "beleg.pdf"
+
+            if let url = wert as? URL {
+                daten = try? Data(contentsOf: url)
+                name = url.lastPathComponent
+            } else if let roh = wert as? Data {
+                daten = roh
+            }
+
+            guard let daten else {
+                return self.melden("Der Beleg ließ sich nicht lesen.")
+            }
+            guard daten.count <= self.grenzeBytes else {
+                return self.melden(
+                    "Der Beleg ist zu groß für diesen Weg. In der App über „Beleg hochladen“ → „Datei auswählen“.")
+            }
+
+            self.ablegen(daten: daten, name: name)
+        }
+    }
+
+    private func ablegen(daten: Data, name: String) {
+        guard
+            let container = FileManager.default.containerURL(
+                forSecurityApplicationGroupIdentifier: gruppe)
+        else {
+            return melden("Die App-Gruppe ist nicht eingerichtet.")
+        }
+
+        let ziel = container.appendingPathComponent(ordner, isDirectory: true)
+        // Ein Zeitstempel im Namen: zwei rasch nacheinander geteilte Belege
+        // sollen sich nicht gegenseitig überschreiben, und der Name bleibt
+        // für den Nutzer lesbar, falls er den Container je zu sehen bekommt.
+        let datei = ziel.appendingPathComponent(
+            "\(Int(Date().timeIntervalSince1970))-\(name)")
+
+        do {
+            try FileManager.default.createDirectory(
+                at: ziel, withIntermediateDirectories: true)
+            try daten.write(to: datei, options: .atomic)
+        } catch {
+            return melden("Der Beleg ließ sich nicht übergeben.")
+        }
+
+        DispatchQueue.main.async { [weak self] in
+            self?.appOeffnen(pfad: datei)
+            self?.abschliessen()
+        }
+    }
+
+    /// Öffnet die Host-App. Eine Erweiterung darf `UIApplication.shared` nicht
+    /// benutzen, deshalb der Umweg über die Responder-Kette — der einzige von
+    /// Apple vorgesehene Weg aus einer Erweiterung heraus.
+    private func appOeffnen(pfad: URL) {
+        // Der Pfad wandert als Abfrageparameter mit. Er zeigt in den
+        // Gruppen-Container, den die App mit derselben Berechtigung lesen
+        // darf - kein zusätzliches Plugin nötig.
+        var bau = URLComponents()
+        bau.scheme = "datametric360"
+        bau.host = "beleg"
+        bau.queryItems = [URLQueryItem(name: "pfad", value: pfad.absoluteString)]
+        guard let ziel = bau.url else { return }
+        var antwort: UIResponder? = self
+        while let r = antwort {
+            if let app = r as? UIApplication {
+                app.open(ziel, options: [:], completionHandler: nil)
+                return
+            }
+            antwort = r.next
+        }
+    }
+
+    private func melden(_ text: String) {
+        DispatchQueue.main.async { [weak self] in
+            let hinweis = UIAlertController(title: "DataMetric360", message: text, preferredStyle: .alert)
+            hinweis.addAction(UIAlertAction(title: "Verstanden", style: .default) { _ in
+                self?.abschliessen()
+            })
+            self?.present(hinweis, animated: true)
+        }
+    }
+
+    private func abschliessen() {
+        extensionContext?.completeRequest(returningItems: [], completionHandler: nil)
+    }
+}

companion-app/package.json

@@ -2,14 +2,47 @@
   "name": "datametric360",
   "version": "0.1.0",
   "private": true,
-  "description": "DataMetric360 — private Fahrzeug-App (iOS/Android via Capacitor, zusätzlich als Iframe im Home-Assistant-Dashboard). Dieses Paket enthält vorerst nur die Datenschicht; die Oberfläche folgt aus dem Claude-Design-Entwurf.",
+  "description": "DataMetric360 — private Fahrzeug-App (iOS/Android via Capacitor, zusätzlich als Iframe im Home-Assistant-Dashboard). Datenschicht plus Oberfläche auf Basis von @audi-dash/ui.",
   "type": "module",
   "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview",
     "typecheck": "tsc --noEmit",
-    "smoke": "node --experimental-strip-types scripts/smoke.ts"
+    "smoke": "node --experimental-strip-types scripts/smoke.ts",
+    "smoke:auth": "node --experimental-strip-types scripts/smoke-auth.ts",
+    "ota": "powershell -ExecutionPolicy Bypass -File scripts/ota-paket.ps1 -Bauen",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@aparajita/capacitor-secure-storage": "^8.0.0",
+    "@audi-dash/ui": "*",
+    "@capacitor/android": "^8.5.0",
+    "@capacitor/app": "^8.1.1",
+    "@capacitor/core": "^8.5.0",
+    "@capacitor/filesystem": "^8.1.3",
+    "@capacitor/ios": "^8.5.0",
+    "@capacitor/preferences": "^8.0.1",
+    "@capacitor/share": "^8.0.1",
+    "@capgo/capacitor-updater": "^8.51.14",
+    "jsqr": "^1.4.0",
+    "leaflet": "^1.9.4",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
   },
   "devDependencies": {
+    "@capacitor/cli": "^8.5.0",
+    "@testing-library/react": "^16.3.2",
+    "@types/leaflet": "^1.9.12",
     "@types/node": "^24.13.3",
-    "typescript": "^5.7.2"
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "jsdom": "^29.1.1",
+    "qrcode": "^1.5.4",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.7",
+    "vitest": "^2.1.8",
+    "xcode": "^3.0.1"
   }
 }

companion-app/public/manifest.webmanifest

@@ -0,0 +1,33 @@
+{
+  "name": "DataMetric360",
+  "short_name": "DM360",
+  "description": "Fahrzeugdaten, Fahrtenbuch und Tankvorgänge vom eigenen Server.",
+  "lang": "de",
+  "dir": "ltr",
+  "start_url": "./",
+  "scope": "./",
+  "display": "standalone",
+  "orientation": "portrait-primary",
+  "background_color": "#161b23",
+  "theme_color": "#161b23",
+  "icons": [
+    {
+      "src": "./symbol.svg",
+      "sizes": "any",
+      "type": "image/svg+xml",
+      "purpose": "any"
+    },
+    {
+      "src": "./symbol-192.png",
+      "sizes": "192x192",
+      "type": "image/png",
+      "purpose": "any maskable"
+    },
+    {
+      "src": "./symbol-512.png",
+      "sizes": "512x512",
+      "type": "image/png",
+      "purpose": "any maskable"
+    }
+  ]
+}

companion-app/public/symbol.svg

@@ -0,0 +1,5 @@
+<svg xmlns='http://www.w3.org/2000/svg' width='512' height='512' viewBox='0 0 512 512'>
+  <rect width='512' height='512' rx='114' fill='#161b23'/>
+  <path d='M150 176h74c48 0 78 31 78 80s-30 80-78 80h-74z' fill='none' stroke='#ffffff' stroke-width='26' stroke-linejoin='round'/>
+  <path d='M330 336V176l46 54 46-54v160' fill='none' stroke='#F50537' stroke-width='26' stroke-linecap='round' stroke-linejoin='round'/>
+</svg>

companion-app/scripts/ios-luftweg.sh

@@ -0,0 +1,141 @@
+#!/usr/bin/env bash
+# Bereitet die Installation ueber die Luft vor: legt neben der signierten .ipa
+# die manifest.plist und eine kleine Installationsseite ab.
+#
+#   bash scripts/ios-luftweg.sh https://mein-mac.tailnetname.ts.net
+#
+# Warum das noetig ist: iOS installiert eine App nur dann ueber die Luft, wenn
+# ein itms-services-Link auf eine manifest.plist zeigt, die wiederum die
+# Adresse der .ipa enthaelt. Beide Adressen muessen ueber **HTTPS mit einem
+# oeffentlich vertrauenswuerdigen Zertifikat** erreichbar sein - einfaches HTTP
+# und selbstsignierte Zertifikate lehnt iOS kommentarlos ab. Home Assistant
+# unter /local/ genuegt dafuer nicht, das laeuft im Tailnet unverschluesselt.
+#
+# Passend dazu und ohne offenen Port: `tailscale serve` liefert ein echtes
+# Let's-Encrypt-Zertifikat auf <maschine>.<tailnet>.ts.net aus. Voraussetzung
+# ist, dass in der Tailscale-Verwaltung HTTPS-Zertifikate aktiviert sind.
+#
+#   tailscale serve --bg ios/build/luftweg
+#
+# Danach den ausgegebenen Link auf dem iPhone in **Safari** oeffnen (andere
+# Browser reichen itms-services nicht an das System weiter).
+set -euo pipefail
+
+if [ $# -lt 1 ]; then
+  echo "Aufruf: bash scripts/ios-luftweg.sh <basis-url> [zielordner]" >&2
+  echo "Beispiel: bash scripts/ios-luftweg.sh https://mein-mac.tailnetname.ts.net" >&2
+  echo "Gitea:    bash scripts/ios-luftweg.sh \\" >&2
+  echo "            https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung \\" >&2
+  echo "            auslieferung" >&2
+  exit 1
+fi
+
+BASIS="${1%/}"
+if [ "${BASIS#https://}" = "$BASIS" ]; then
+  echo "FEHLER: Die Basis-Adresse muss mit https:// beginnen." >&2
+  echo "iOS verweigert die Installation ueber die Luft ueber unverschluesseltes HTTP." >&2
+  exit 1
+fi
+
+HIER="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+APP="$(dirname "$HIER")"
+IPA="$APP/auslieferung/App.ipa"
+# Zweites Argument erlaubt es, direkt in den versionierten Ordner zu schreiben -
+# noetig, wenn nicht ein eigener Host ausliefert, sondern das Repository selbst.
+ZIEL="$APP/${2:-ios/build/luftweg}"
+
+[ -f "$IPA" ] || { echo "FEHLER: $IPA fehlt - erst scripts/ios-signieren.sh laufen lassen." >&2; exit 1; }
+
+# Version aus der .ipa selbst lesen statt sie hier zu wiederholen: zwei Quellen
+# fuer dieselbe Angabe waeren eine zu viel.
+AUSPACK="$(mktemp -d)"
+trap 'rm -rf "$AUSPACK"' EXIT
+unzip -q "$IPA" -d "$AUSPACK"
+PLIST="$(find "$AUSPACK/Payload" -maxdepth 2 -name Info.plist | head -1)"
+KENNUNG="$(/usr/libexec/PlistBuddy -c "Print :CFBundleIdentifier" "$PLIST")"
+VERSION="$(/usr/libexec/PlistBuddy -c "Print :CFBundleShortVersionString" "$PLIST")"
+
+mkdir -p "$ZIEL"
+[ "$IPA" -ef "$ZIEL/App.ipa" ] || cp "$IPA" "$ZIEL/App.ipa"
+cp "$APP/public/symbol-192.png" "$ZIEL/symbol-192.png"
+cp "$APP/public/symbol-512.png" "$ZIEL/symbol-512.png"
+
+# Die Adressen tragen die Version als Anhaengsel (?v=...). Sie zeigen sonst bei
+# jedem Bau auf dieselbe Zeichenkette, und der Installations-Dienst von iOS haelt
+# eine einmal geholte .ipa dann fuer schon bekannt - sichtbar als Wolke mit Pfeil,
+# die nie fertig wird, oder als "kann nicht installiert werden". Dieselbe Vorsorge
+# trifft das Panel seit jeher fuer sein eigenes Buendel (siehe ota.ts).
+cat > "$ZIEL/manifest.plist" <<PLISTENDE
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>items</key>
+  <array>
+    <dict>
+      <key>assets</key>
+      <array>
+        <dict>
+          <key>kind</key><string>software-package</string>
+          <key>url</key><string>$BASIS/App.ipa?v=$VERSION</string>
+        </dict>
+        <dict>
+          <key>kind</key><string>display-image</string>
+          <key>url</key><string>$BASIS/symbol-192.png?v=$VERSION</string>
+        </dict>
+        <dict>
+          <key>kind</key><string>full-size-image</string>
+          <key>url</key><string>$BASIS/symbol-512.png?v=$VERSION</string>
+        </dict>
+      </array>
+      <key>metadata</key>
+      <dict>
+        <key>bundle-identifier</key><string>$KENNUNG</string>
+        <key>bundle-version</key><string>$VERSION</string>
+        <key>kind</key><string>software</string>
+        <key>title</key><string>DataMetric360</string>
+      </dict>
+    </dict>
+  </array>
+</dict>
+</plist>
+PLISTENDE
+
+# Das kaufmaennische Und muss in HTML maskiert werden, sonst schneidet Safari
+# den Link hinter dem url-Parameter ab.
+cat > "$ZIEL/index.html" <<HTMLENDE
+<!doctype html>
+<html lang="de">
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>DataMetric360 installieren</title>
+<style>
+  body { font-family: -apple-system, sans-serif; background: #161b23; color: #eef1f6;
+         margin: 0; display: grid; place-items: center; min-height: 100vh; }
+  main { text-align: center; padding: 2rem; }
+  h1 { font-weight: 300; font-size: 1.5rem; }
+  a { display: inline-block; margin-top: 1.5rem; padding: 0.9rem 2rem; border-radius: 999px;
+      background: #eef1f6; color: #161b23; text-decoration: none; font-size: 1.1rem; }
+  p { color: #8a94a3; font-size: 0.9rem; line-height: 1.5; }
+</style>
+<main>
+  <h1>DataMetric360</h1>
+  <p>Version $VERSION</p>
+  <a href="itms-services://?action=download-manifest&amp;url=$BASIS/manifest.plist">Installieren</a>
+  <p>In Safari oeffnen. Nach dem Antippen fragt iOS einmal nach,<br>danach erscheint die App auf dem Startbildschirm.</p>
+</main>
+</html>
+HTMLENDE
+
+echo "Ordner fertig: $ZIEL"
+echo
+echo "Wenn ein eigener Host ausliefert:"
+echo "  tailscale serve --bg $ZIEL"
+echo "  dann auf dem iPhone in Safari oeffnen:  $BASIS/"
+echo
+# Gitea liefert rohe Dateien grundsaetzlich als text/plain aus - die
+# index.html wird dort also als Quelltext angezeigt statt gerendert. Deshalb
+# hier zusaetzlich der fertige Link zum Einfuegen in die Safari-Adresszeile;
+# der funktioniert unabhaengig davon, ob eine Seite drumherum existiert.
+echo "Ohne Seite (z. B. aus dem Repository heraus) direkt in Safari einfuegen:"
+echo "  itms-services://?action=download-manifest&url=$BASIS/manifest.plist"

companion-app/scripts/ios-signieren.sh

@@ -0,0 +1,424 @@
+#!/usr/bin/env bash
+# Baut die native iOS-Huelle und signiert sie zu einer installierbaren .ipa.
+# Nur auf einem Mac mit Xcode lauffaehig. Siehe ../../UMSETZUNGSPLAN.md Phase 10.
+#
+# Warum es dieses Skript gibt: `ios/` ist absichtlich gitignored (aus dem
+# Webbuendel jederzeit wiederherstellbar). Damit verschwindet aber auch jede
+# Signatureinstellung, die man in Xcode von Hand setzt, beim naechsten
+# `npx cap add ios` wieder. Die Team-Kennung gehoert deshalb hierher - in eine
+# versionierte Datei - und wird dem Build von aussen mitgegeben.
+#
+# Voraussetzung, die dieses Skript nicht herstellen kann: das Zielgeraet muss
+# im Team eingetragen sein. Das Ad-hoc-Profil traegt eine feste Liste von
+# Geraetekennungen, ein unbekanntes Telefon lehnt die fertige .ipa ab. Ein
+# neues Geraet wird einmalig angemeldet - per Kabel an diesem Mac, dann
+# erledigt es -allowProvisioningUpdates selbst, oder von Hand auf
+# developer.apple.com. Bricht der Archivschritt mit "Your team has no devices"
+# ab, fehlt genau dieser Eintrag; das ist kein Fehler im Projekt.
+#
+# Stand des Kontos, am 2026-08-29 am ausgestellten Profil nachgesehen statt
+# vermutet: bezahlte Mitgliedschaft, Team RMACS9VLS4, Laufzeit ein Jahr. Die
+# frueher hier vermerkten sieben Tage galten dem kostenlosen Personal Team und
+# gelten nicht mehr; ebensowenig das "keine Geraeteverwaltung auf
+# developer.apple.com", das daran hing.
+#
+# Der Export ueber -exportArchive ist erprobt und kein offener Punkt mehr: die
+# ausgelieferten .ipa vom 2026-08-29 und 2026-08-30 sind auf genau diesem Weg
+# entstanden und wurden ueber die Luft installiert (siehe ios-luftweg.sh).
+# Scheitert er doch einmal, bleibt der direkte Weg aufs angeschlossene Geraet:
+#   xcodebuild -project ios/App/App.xcodeproj -scheme App \
+#     -destination 'id=<UDID>' -allowProvisioningUpdates \
+#     DEVELOPMENT_TEAM=$TEAM install
+set -euo pipefail
+
+HIER="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+APP="$(dirname "$HIER")"
+# Dieselbe Kennung wie zu Zeiten des kostenlosen Kontos: die bezahlte
+# Mitgliedschaft hat das bestehende Team hochgestuft, statt ein neues
+# anzulegen. Zwischenzeitlich stand hier das Gegenteil - widerlegt am
+# 2026-08-29 durch das ausgestellte Profil (Team RMACS9VLS4, Laufzeit ein
+# Jahr statt sieben Tage). Ueberschreibbar ueber APPLE_TEAM_ID.
+TEAM="${APPLE_TEAM_ID:-RMACS9VLS4}"
+AUSGABE="$APP/ios/build"
+ARCHIV="$AUSGABE/DataMetric360.xcarchive"
+
+cd "$APP"
+
+# Ohne diese Pruefung baut/signiert das Skript zuverlaessig - aber nur den
+# Stand, der gerade lokal ausgecheckt ist. Ein vergessener Abgleich mit dem
+# Server waere damit ein stiller Veraltungsfehler wie schon mehrfach an anderer
+# Stelle in diesem Projekt (Cache-Busting, OTA-Buendel-Abgleich,
+# VERSIONIERUNG.md). Deshalb holt das Skript den Serverstand selbst und rueckt
+# den Klon zurecht, wo das verlustfrei ist - und bricht sonst laut ab, statt
+# einen optisch/inhaltlich alten Build auszuliefern.
+echo "==> Git-Stand pruefen"
+if [ -n "$(git status --porcelain)" ]; then
+  echo "FEHLER: Uncommittete Aenderungen im Arbeitsverzeichnis." >&2
+  git status --short >&2
+  echo "Erst committen oder stashen, dann erneut versuchen." >&2
+  exit 1
+fi
+git fetch origin
+LOKAL="$(git rev-parse HEAD)"
+FERN="$(git rev-parse origin/main)"
+# Ziel dieses Blocks: der Klon steht danach auf origin/main - oder das Skript
+# bricht ab. Zurechtruecken darf es sich selbst, solange dabei nachweislich
+# nichts verlorengeht; der saubere Arbeitsbaum ist oben bereits Bedingung.
+if [ "$LOKAL" != "$FERN" ]; then
+  BASIS="$(git merge-base "$LOKAL" "$FERN")"
+  if git merge-base --is-ancestor "$LOKAL" "$FERN"; then
+    echo "    Klon war zurueck - wird vorgespult."
+    git merge --ff-only "$FERN" >/dev/null
+    LOKAL="$(git rev-parse HEAD)"
+  elif git diff --quiet "$BASIS" "$LOKAL"; then
+    # Hier liegen Commits, die origin/main nicht hat - aber ihr Tree ist derselbe
+    # wie der des gemeinsamen Vorfahren, sie tragen inhaltlich also NICHTS bei.
+    # Genau so sieht ein Klon aus, der noch vor einem Rewrite der Gegenseite steht
+    # (am 07.09.2026 einmal geschehen). Ein 'git pull' waere hier falsch: der Merge
+    # holt die entfernten Commits zurueck, und der naechste Push stellt sie auf dem
+    # Server wieder her - sogar ohne --force. Verwerfen kostet dagegen keine einzige
+    # Datei; das Reflog haelt sie noch 90 Tage.
+    echo "    Nur hier vorhanden, inhaltlich ohne Wirkung - wird verworfen:"
+    git log --oneline "$BASIS..$LOKAL" | sed "s/^/      /"
+    git reset --hard "$FERN" >/dev/null
+    LOKAL="$(git rev-parse HEAD)"
+    echo "    Zurueckgesetzt auf origin/main. Rueckholbar ueber: git reflog"
+  else
+    echo "FEHLER: Lokaler Stand ($LOKAL) weicht von origin/main ($FERN) ab." >&2
+    echo "" >&2
+    echo "Diese Commits liegen nur hier und aendern auch den Inhalt:" >&2
+    git log --oneline "$BASIS..$LOKAL" >&2
+    echo "" >&2
+    echo "Das sieht nach eigener, noch ungepushter Arbeit aus - deshalb entscheidet" >&2
+    echo "das Skript hier nichts. Entweder pushen:" >&2
+    echo "       git push" >&2
+    echo "oder verwerfen, falls die Gegenseite sie absichtlich entfernt hat:" >&2
+    echo "       git fetch origin && git reset --hard origin/main" >&2
+    echo "" >&2
+    echo "Kein 'git pull': ein Merge haengt die Commits wieder in die Historie." >&2
+    exit 1
+  fi
+fi
+echo "    HEAD == origin/main ($LOKAL), aktuell."
+
+echo "==> Webbuendel bauen"
+npm run build
+
+echo "==> Native Huelle synchronisieren"
+if [ ! -d ios ]; then
+  echo "==> ios/ fehlt, wird neu erzeugt"
+  npx cap add ios
+fi
+npx cap sync ios
+
+# Standort-Berechtigung ins Info.plist eintragen.
+#
+# Ohne diesen Schluessel zeigt iOS beim Aufruf von navigator.geolocation in
+# der WebView (src/screens/Standort.tsx) ueberhaupt keine Rueckfrage: der
+# Aufruf scheitert sofort, die App meldet "GPS-Freigabe fehlt", und unter
+# Einstellungen > DataMetric360 > Ort fehlt die Auswahl "Beim Verwenden der
+# App" - es bleiben nur "Nie" und "Beim Teilen". Nachgewiesen am 2026-08-31
+# an der ausgelieferten App.ipa: kein einziger Location-Schluessel darin.
+#
+# Warum hier und nicht in Xcode: ios/ ist gitignored und wird von
+# `npx cap add ios` aus Capacitors Vorlage neu erzeugt - die kennt keine
+# Standort-Schluessel. Ein Eintrag von Hand in Xcode waere beim naechsten
+# Erzeugen wieder verschwunden, genau wie es der Team-Kennung oben ergangen
+# waere. Deshalb steht er versioniert hier und wird nach jedem `cap sync`
+# neu gesetzt.
+#
+# Nur "WhenInUse": berechnet wird der Abstand zum geparkten Fahrzeug, waehrend
+# jemand die Standort-Seite ansieht. Hintergrundortung braucht die App nicht,
+# und was sie nicht braucht, soll sie auch nicht erfragen.
+echo "==> Standort-Berechtigung eintragen"
+PLIST="ios/App/App/Info.plist"
+GRUND="Zeigt auf der Standort-Karte, wie weit du vom geparkten Fahrzeug entfernt bist."
+if ! /usr/libexec/PlistBuddy -c "Set :NSLocationWhenInUseUsageDescription $GRUND" "$PLIST" 2>/dev/null; then
+  /usr/libexec/PlistBuddy -c "Add :NSLocationWhenInUseUsageDescription string $GRUND" "$PLIST"
+fi
+/usr/libexec/PlistBuddy -c "Print :NSLocationWhenInUseUsageDescription" "$PLIST" >/dev/null || {
+  echo "FEHLER: NSLocationWhenInUseUsageDescription liess sich nicht setzen." >&2
+  exit 1
+}
+
+# Kalender-Berechtigung, aus demselben Grund an derselben Stelle.
+#
+# Warum ZWEI Schluessel: seit iOS 17 gibt es einen eigenen Nur-Schreiben-Zugriff
+# (NSCalendarsWriteOnlyAccessUsageDescription), aeltere Fassungen kennen nur den
+# alten Sammelschluessel. Der System-Editor (native/KalenderTermin.swift) fragt
+# auf iOS 17+ von sich aus gar nicht - die Schluessel sind die Absicherung fuer
+# den Fall, dass EventKit doch einmal fragt. Fehlt der passende, beendet iOS die
+# App wortlos, statt eine Rueckfrage zu zeigen.
+echo "==> Kalender-Berechtigung eintragen"
+KALENDERGRUND="Traegt Werkstatt- und Wechseltermine in deinen Kalender ein."
+for SCHLUESSEL in NSCalendarsWriteOnlyAccessUsageDescription NSCalendarsUsageDescription; do
+  if ! /usr/libexec/PlistBuddy -c "Set :$SCHLUESSEL $KALENDERGRUND" "$PLIST" 2>/dev/null; then
+    /usr/libexec/PlistBuddy -c "Add :$SCHLUESSEL string $KALENDERGRUND" "$PLIST"
+  fi
+  /usr/libexec/PlistBuddy -c "Print :$SCHLUESSEL" "$PLIST" >/dev/null || {
+    echo "FEHLER: $SCHLUESSEL liess sich nicht setzen." >&2
+    exit 1
+  }
+done
+
+# Kamera, fuer den QR-Scanner der Ersteinrichtung.
+#
+# Gelesen wird der Code in der WebView (jsQR ueber getUserMedia), nicht von
+# einem nativen Plugin - siehe den Kopf von src/screens/QrScanner.tsx, warum
+# nicht GoogleMLKit. Dieser Schluessel ist trotzdem noetig: ohne ihn beendet
+# iOS die App in dem Moment, in dem sie die Kamera anfordert.
+echo "==> Kamera-Berechtigung eintragen"
+KAMERAGRUND="Liest den QR-Code deines Zugangs-Tokens bei der Ersteinrichtung."
+if ! /usr/libexec/PlistBuddy -c "Set :NSCameraUsageDescription $KAMERAGRUND" "$PLIST" 2>/dev/null; then
+  /usr/libexec/PlistBuddy -c "Add :NSCameraUsageDescription string $KAMERAGRUND" "$PLIST"
+fi
+/usr/libexec/PlistBuddy -c "Print :NSCameraUsageDescription" "$PLIST" >/dev/null || {
+  echo "FEHLER: NSCameraUsageDescription liess sich nicht setzen." >&2
+  exit 1
+}
+
+# Share-Erweiterung ins Xcode-Projekt haengen.
+#
+# Aus demselben Grund wie die Team-Kennung und der Standort-Schluessel oben:
+# ios/ ist gitignored, also verschwindet jedes von Hand angelegte Ziel beim
+# naechsten `npx cap add ios`. Die Quellen liegen versioniert unter native/,
+# das Skript spielt sie bei jedem Bau wieder ein. Es ist idempotent - ein
+# zweiter Lauf ueber ein fertiges Projekt aendert nichts.
+#
+# Schlaegt es fehl, bricht der ganze Bau ab: eine App ohne den Eintrag im
+# Teilen-Blatt sieht fertig aus und ist es nicht, und der Unterschied faellt
+# erst auf dem Geraet auf.
+echo "==> Share-Erweiterung einrichten"
+node scripts/ios-teilen-einrichten.mjs
+
+# App-Symbol einspielen.
+#
+# Capacitors Vorlage bringt ein eigenes Platzhalter-Symbol mit, und ios/ ist
+# gitignored - ein in Xcode eingesetztes Symbol waere beim naechsten
+# `npx cap add ios` wieder weg. Die Vorlage liegt deshalb versioniert unter
+# native/AppIcon.appiconset und wird hier ueber die von Capacitor erzeugte
+# gelegt.
+#
+# Drei Ausfuehrungen, wie iOS 18 sie erwartet: hell mit eigenem Grund, dunkel
+# und getoent ohne - dort legt das System seinen eigenen Grund darunter, und
+# ein mitgeliefertes Schwarz bliebe darauf als Kasten sichtbar.
+echo "==> App-Symbol einspielen"
+SYMBOLZIEL="ios/App/App/Assets.xcassets/AppIcon.appiconset"
+rm -rf "$SYMBOLZIEL"
+mkdir -p "$SYMBOLZIEL"
+cp -R native/AppIcon.appiconset/. "$SYMBOLZIEL"/
+[ -f "$SYMBOLZIEL/Contents.json" ] || { echo "FEHLER: App-Symbol nicht eingespielt." >&2; exit 1; }
+echo "    hell, dunkel, getoent"
+
+# Versionsnummer aus der manifest.json in die App schreiben.
+#
+# Capacitors Vorlage setzt 1.0/1 und laesst es dabei - zwei nacheinander
+# aufgespielte .ipa sind auf dem Geraet dadurch nicht zu unterscheiden, und
+# man weiss nicht, welche gerade drauf ist. Dieselbe Zahl, die schon Panel,
+# OTA-Buendel und __APP_VERSION__ tragen (siehe VERSIONIERUNG.md): eine
+# Quelle, kein zweiter Ort zum Vergessen.
+echo "==> Versionsnummer eintragen"
+VERSION="$(node -p "require('../custom_components/audi_dashboard/manifest.json').version")"
+[ -n "$VERSION" ] || { echo "FEHLER: keine Version in der manifest.json." >&2; exit 1; }
+if ! /usr/libexec/PlistBuddy -c "Set :CFBundleShortVersionString $VERSION" "$PLIST" 2>/dev/null; then
+  /usr/libexec/PlistBuddy -c "Add :CFBundleShortVersionString string $VERSION" "$PLIST"
+fi
+BUILDNR="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleVersion' "$PLIST" 2>/dev/null || echo 1)"
+# In der Info.plist der App steht dort KEINE Zahl, sondern der Platzhalter
+# einer Build-Einstellung ($(CURRENT_PROJECT_VERSION), aus dem Capacitor-
+# Geruest). Fuer das App-Ziel loest Xcode ihn zu 1 auf - das Ziel der
+# Erweiterung kennt die Einstellung aber gar nicht, dort wurde daraus LEER,
+# und ein Buendel ohne CFBundleVersion lehnt iOS beim Installieren ab
+# ("kann nicht installiert werden"). Genau so ist die .ipa vom 04.09.2026
+# unbrauchbar geworden - an der ausgelieferten Datei nachgemessen: App
+# CFBundleVersion 1, Erweiterung gar keine. Deshalb hier nur eine echte Zahl
+# weiterreichen, sonst die 1.
+case "$BUILDNR" in
+  ""|*'$('*|*[!0-9.]*) BUILDNR=1 ;;
+esac
+
+# Die Share-Erweiterung MUSS dieselben beiden Nummern tragen wie die App.
+#
+# Apples App Extension Programming Guide verlangt das ausdruecklich, und iOS
+# haelt sich daran: stimmen CFBundleShortVersionString und CFBundleVersion
+# nicht ueberein, registriert das System die Erweiterung nicht - sie taucht im
+# Teilen-Blatt dann gar nicht erst auf, ohne jede Fehlermeldung. Genau das war
+# in der .ipa vom 03.09.2026 der Fall: App 2026.9.3.3, Erweiterung 1.0 (an der
+# ausgelieferten Datei nachgemessen, nicht vermutet - native/teilen/Info.plist
+# traegt die 1.0 fest, und dieser Schritt schrieb bis dahin nur $PLIST).
+ERW_PLIST="ios/App/DataMetric360Share/Info.plist"
+if [ -f "$ERW_PLIST" ]; then
+  /usr/libexec/PlistBuddy -c "Set :CFBundleShortVersionString $VERSION" "$ERW_PLIST"
+  /usr/libexec/PlistBuddy -c "Set :CFBundleVersion $BUILDNR" "$ERW_PLIST"
+  echo "    $VERSION ($BUILDNR), App und Erweiterung"
+else
+  echo "    $VERSION ($BUILDNR) - Erweiterung nicht gefunden, nur die App"
+fi
+
+# Zwischengespeicherte Bereitstellungsprofile dieser App wegraeumen.
+#
+# `-allowProvisioningUpdates` zieht ein neues Profil nur, wenn kein passendes
+# herumliegt - ein vorhandenes wird stillschweigend weiterbenutzt, auch wenn
+# sich seither die Berechtigungen geaendert haben. Genau daran ist am
+# 2026-08-29 eine Installation gescheitert ("Integritaet konnte nicht
+# geprueft werden"): das eingebettete Profil kannte ein Geraet, das Team
+# hatte inzwischen zwei. Mit der App-Gruppe der Share-Erweiterung ist
+# derselbe Fall erneut eingetreten - jedes vor dem 2026-08-31 gezogene
+# Profil kennt sie nicht.
+#
+# Weggeraeumt wird nur, was zu dieser App gehoert (Bundle-ID im entpackten
+# Profil gesucht), nicht der ganze Ordner - dort liegen auch die Profile
+# anderer Projekte. Mit --profile-behalten laesst sich der Schritt
+# ueberspringen.
+if [ "${1:-}" != "--profile-behalten" ]; then
+  echo "==> Alte Bereitstellungsprofile wegraeumen"
+  PROFILE="$HOME/Library/Developer/Xcode/UserData/Provisioning Profiles"
+  if [ -d "$PROFILE" ]; then
+    ANZAHL=0
+    for datei in "$PROFILE"/*.mobileprovision; do
+      [ -e "$datei" ] || continue
+      if security cms -D -i "$datei" 2>/dev/null | grep -qF "app.datametric360"; then
+        rm -f "$datei"
+        ANZAHL=$((ANZAHL + 1))
+      fi
+    done
+    echo "    $ANZAHL entfernt - xcodebuild zieht sie gleich neu"
+  else
+    echo "    keine vorhanden"
+  fi
+else
+  echo "==> Bereitstellungsprofile bleiben (--profile-behalten)"
+fi
+
+echo "==> Archiv bauen und signieren (Team $TEAM)"
+rm -rf "$AUSGABE"
+mkdir -p "$AUSGABE"
+xcodebuild \
+  -project ios/App/App.xcodeproj \
+  -scheme App \
+  -configuration Release \
+  -destination 'generic/platform=iOS' \
+  -archivePath "$ARCHIV" \
+  -allowProvisioningUpdates \
+  DEVELOPMENT_TEAM="$TEAM" \
+  archive
+
+# Ad-hoc, nicht development: das ist die von Apple vorgesehene Art fuer die
+# Installation ueber die Luft (siehe ios-luftweg.sh) und deckt den Weg per
+# Kabel gleich mit ab. Sie verlangt ein Apple-Distribution-Zertifikat, das
+# -allowProvisioningUpdates bei Bedarf selbst anlegt - moeglich erst seit der
+# bezahlten Mitgliedschaft. Die Signatur laeuft damit ein Jahr.
+cat > "$AUSGABE/ExportOptions.plist" <<PLIST
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>method</key><string>ad-hoc</string>
+  <key>teamID</key><string>$TEAM</string>
+  <key>signingStyle</key><string>automatic</string>
+  <key>stripSwiftSymbols</key><true/>
+</dict>
+</plist>
+PLIST
+
+echo "==> .ipa exportieren"
+xcodebuild -exportArchive \
+  -archivePath "$ARCHIV" \
+  -exportOptionsPlist "$AUSGABE/ExportOptions.plist" \
+  -exportPath "$AUSGABE" \
+  -allowProvisioningUpdates
+
+
+# Am FERTIGEN Buendel gegenlesen, nicht am Projekt.
+#
+# Abschnitt AK der AGENTS.md: von fuenf Fehlern in der nativen Huelle haben
+# vier einen erfolgreichen Archivlauf erzeugt und sind erst am entpackten
+# .ipa aufgefallen. Geprueft wird hier genau das, was still schiefgehen kann:
+# eine Erweiterung ohne Programm, ohne App-Gruppe, oder mit abweichender
+# Versionsnummer (dann registriert iOS sie nicht und sie fehlt im
+# Teilen-Blatt).
+echo "==> Fertige .ipa gegenlesen"
+PRUEF="$(mktemp -d)"
+if unzip -q "$AUSGABE/App.ipa" -d "$PRUEF"; then
+  ERW="$PRUEF/Payload/App.app/PlugIns/DataMetric360Share.appex"
+  if [ ! -x "$ERW/DataMetric360Share" ] && [ ! -f "$ERW/DataMetric360Share" ]; then
+    echo "    WARNUNG: die Erweiterung hat kein Programm - sie wird nichts tun."
+  fi
+  ERW_V="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$ERW/Info.plist" 2>/dev/null || echo '?')"
+  APP_V="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$PRUEF/Payload/App.app/Info.plist" 2>/dev/null || echo '?')"
+  if [ "$ERW_V" != "$APP_V" ]; then
+    echo "    WARNUNG: Erweiterung $ERW_V, App $APP_V - iOS registriert die"
+    echo "             Erweiterung dann nicht, sie fehlt im Teilen-Blatt."
+  else
+    echo "    Erweiterung und App tragen beide $APP_V"
+  fi
+  # CFBundleVersion ist Pflicht. Fehlt sie in EINEM der beiden Buendel,
+  # verweigert iOS die Installation der ganzen App - ohne Hinweis darauf,
+  # woran es liegt. Deshalb hart pruefen, nicht nur warnen.
+  for ZIEL in "$PRUEF/Payload/App.app" "$ERW"; do
+    BV="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleVersion' "$ZIEL/Info.plist" 2>/dev/null || echo '')"
+    case "$BV" in
+      ""|*'$('*)
+        echo "    FEHLER: $(basename "$ZIEL") hat keine brauchbare CFBundleVersion ('$BV')." >&2
+        echo "            iOS wuerde die Installation ablehnen - Bau abgebrochen." >&2
+        rm -rf "$PRUEF"
+        exit 1 ;;
+    esac
+  done
+  for ZIEL in "$PRUEF/Payload/App.app" "$ERW"; do
+    if ! codesign -d --entitlements :- "$ZIEL" 2>/dev/null | grep -q "group.app.datametric360"; then
+      echo "    WARNUNG: $(basename "$ZIEL") ohne App-Gruppe - Teilen kann nichts uebergeben."
+    fi
+  done
+  # Eigene Plugins muessen in packageClassList stehen. Capacitor 8 sucht
+  # Plugin-Klassen NICHT im Programm (registerPlugins() in
+  # CapacitorBridge.swift liest nur diese Liste) - eine einkompilierte
+  # Klasse, die dort fehlt, existiert fuer die Bruecke nicht. Genau so kam
+  # die .ipa vom 04.09.2026 heraus: Zwischenablage und Kalendertermin waren
+  # im Programm und trotzdem tot.
+  KONF="$PRUEF/Payload/App.app/capacitor.config.json"
+  for KLASSE in $(grep -ho "@objc([A-Za-z0-9_]*)" "$APP/native"/*.swift | sed "s/@objc(//;s/)//"); do
+    if ! grep -q "$KLASSE" "$KONF" 2>/dev/null; then
+      echo "    FEHLER: $KLASSE fehlt in packageClassList - das Plugin bliebe stumm." >&2
+      rm -rf "$PRUEF"
+      exit 1
+    fi
+  done
+  echo "    packageClassList: eigene Plugins eingetragen"
+fi
+rm -rf "$PRUEF"
+
+# Erst JETZT ablegen. auslieferung/ ist versioniert und wird ausgeliefert -
+# eine Datei, die die Pruefung oben nicht besteht, darf dort nicht landen und
+# schon gar nicht committet werden. (ios/ ist gitignored, sonst existierte das
+# Ergebnis nur auf diesem einen Mac.)
+mkdir -p "$APP/auslieferung"
+cp "$AUSGABE/App.ipa" "$APP/auslieferung/App.ipa"
+
+# Auslieferung ueber die Luft gleich mitschreiben.
+#
+# manifest.plist und die Installationsseite hingen bisher an einem zweiten,
+# von Hand aufzurufenden Skript - und ohne sie ist die frische .ipa auf dem
+# Telefon nicht installierbar, obwohl sie fertig im Repo liegt. Ein Schritt,
+# den man vergessen kann, gehoert in den Bau.
+#
+# Die Basis-Adresse ist die des Gitea-Repos: es liefert die Dateien bereits
+# ueber HTTPS mit oeffentlich vertrauenswuerdigem Zertifikat aus, was iOS
+# fuer diesen Weg zwingend verlangt (siehe ios-luftweg.sh). Ueberschreibbar
+# ueber LUFTWEG_BASIS, falls der Weg einmal ueber einen eigenen Host geht.
+echo "==> Auslieferung ueber die Luft vorbereiten"
+LUFTWEG_BASIS="${LUFTWEG_BASIS:-https://gitea.nothaft.cloud/paul/audi-app/raw/branch/main/companion-app/auslieferung}"
+bash "$HIER/ios-luftweg.sh" "$LUFTWEG_BASIS" auslieferung
+
+echo
+echo "Fertig: $APP/auslieferung/App.ipa"
+echo "Version: $VERSION"
+echo
+echo "Noch zu tun:"
+echo "  1. git add companion-app/auslieferung && git commit && git push"
+echo "     (die .ipa und manifest.plist muessen im Repo liegen, sonst kann"
+echo "      das Telefon sie nicht laden)"
+echo "  2. Auf dem iPhone in Safari oeffnen:"
+echo "     itms-services://?action=download-manifest&url=$LUFTWEG_BASIS/manifest.plist"
+echo
+echo "Per Kabel stattdessen: xcrun devicectl device install app --device <UDID> $APP/auslieferung/App.ipa"

companion-app/scripts/ios-teilen-einrichten.mjs

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+/**
+ * Hängt die Share-Erweiterung ins erzeugte Xcode-Projekt.
+ *
+ * WARUM ES DIESES SKRIPT GIBT
+ * ---------------------------
+ * `companion-app/ios/` ist absichtlich gitignored — `npx cap add ios` baut den
+ * Ordner aus dem Webbündel jederzeit neu. Damit verschwindet aber auch jedes
+ * Ziel, das man in Xcode von Hand anlegt. Dieselbe Falle, die schon die
+ * Team-Kennung und den Standort-Schlüssel in `ios-signieren.sh` getrieben hat:
+ * was den nächsten `cap add` überleben soll, muss versioniert sein und bei
+ * jedem Bau neu eingespielt werden.
+ *
+ * Die Quellen liegen deshalb unter `companion-app/native/`; dieses Skript
+ * kopiert sie nach `ios/App/` und trägt das Erweiterungsziel in die
+ * `project.pbxproj` ein.
+ *
+ * WAS ES ANLEGT
+ * -------------
+ * - Ziel `DataMetric360Share` (App-Erweiterung, Bundle-ID
+ *   `app.datametric360.teilen`)
+ * - dessen Quelldateien, Info.plist und Entitlements
+ * - die App-Gruppe `group.app.datametric360` auf BEIDEN Zielen
+ * - die Einbettung der Erweiterung in die App (Build-Phase
+ *   „Embed App Extensions")
+ * - das URL-Schema `datametric360://`, über das die Erweiterung die App holt
+ *
+ * IDEMPOTENT
+ * ----------
+ * Ein zweiter Lauf über ein bereits eingerichtetes Projekt ändert nichts und
+ * meldet das. Wichtig, weil `ios-signieren.sh` bei jedem Bau durchläuft und
+ * `ios/` nicht immer neu erzeugt wird.
+ *
+ * NICHT GETESTET AUF EINEM MAC
+ * ----------------------------
+ * Geschrieben ohne Zugriff auf macOS/Xcode. Die pbxproj-Bearbeitung folgt der
+ * API des npm-Pakets `xcode`; scheitert sie, bricht das Skript mit einer
+ * klaren Meldung ab und `docs/SHARE_EXTENSION.md` beschreibt die Handgriffe,
+ * die dasselbe in Xcode erledigen. Lieber ein lauter Abbruch mit Anleitung
+ * als ein halb eingerichtetes Projekt.
+ */
+
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync } from "node:fs"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+
+import xcode from "xcode"
+
+const HIER = dirname(fileURLToPath(import.meta.url))
+const APP = dirname(HIER)
+
+const ZIEL_NAME = "DataMetric360Share"
+const BUNDLE_ID = "app.datametric360.teilen"
+const GRUPPE = "group.app.datametric360"
+
+/* Eigene Capacitor-Plugins der App - je eine Swift-Datei, die neben der
+   Erweiterung ins App-Ziel gehört. Sie liegen aus demselben Grund unter
+   native/ wie alles andere hier: ios/ ist gitignored und wird neu erzeugt. */
+const PLUGIN_DATEIEN = ["BelegZwischenablage.swift", "KalenderTermin.swift"]
+
+/** pbxproj-Wert ohne die optionalen Anfuehrungszeichen. */
+const entquotet = (wert) => String(wert ?? "").replace(/^"|"$/g, "")
+const SCHEMA = "datametric360"
+
+const iosApp = join(APP, "ios", "App")
+const pbxPfad = join(iosApp, "App.xcodeproj", "project.pbxproj")
+const quelleErw = join(APP, "native", "teilen")
+const zielErw = join(iosApp, ZIEL_NAME)
+
+function melden(text) {
+  console.log("  " + text)
+}
+
+function abbruch(text) {
+  console.error("")
+  console.error("FEHLER: " + text)
+  console.error("")
+  console.error("Die Share-Erweiterung ist damit NICHT eingerichtet. Die App selbst")
+  console.error("baut und läuft weiterhin - nur der Eintrag im Teilen-Blatt fehlt.")
+  console.error("Von Hand nachziehen: companion-app/docs/SHARE_EXTENSION.md")
+  process.exit(1)
+}
+
+if (!existsSync(pbxPfad)) {
+  abbruch(`${pbxPfad} nicht gefunden - erst 'npx cap sync ios' laufen lassen.`)
+}
+
+/* ---------------------------------------------------------------- Dateien */
+
+mkdirSync(zielErw, { recursive: true })
+for (const datei of ["ShareViewController.swift", "Info.plist", `${ZIEL_NAME}.entitlements`]) {
+  copyFileSync(join(quelleErw, datei), join(zielErw, datei))
+}
+copyFileSync(join(APP, "native", "App.entitlements"), join(iosApp, "App", "App.entitlements"))
+for (const datei of PLUGIN_DATEIEN) {
+  copyFileSync(join(APP, "native", datei), join(iosApp, "App", datei))
+}
+melden(`Quellen nach ios/App/${ZIEL_NAME}/ kopiert`)
+
+/* ------------------------------------------ Eigene Plugins registrieren */
+
+/* Capacitor 8 sucht Plugin-Klassen NICHT im Programm. `registerPlugins()`
+   in CapacitorBridge.swift liest ausschliesslich `packageClassList` aus der
+   capacitor.config.json des Buendels und loest jeden Eintrag ueber
+   NSClassFromString auf - was dort nicht steht, existiert fuer die Bruecke
+   nicht, auch wenn die Klasse einkompiliert ist.
+
+   Genau daran sind beide eigenen Plugins gescheitert: `cap sync` erzeugt die
+   Liste aus den installierten npm-Paketen, und unsere Plugins sind keine.
+   In der ausgelieferten .ipa vom 04.09.2026 standen dort nur die sechs
+   Fremd-Plugins - die Zwischenablage meldete deshalb 'diese App-Fassung
+   enthaelt den nativen Teil noch nicht' (Nutzerbefund), obwohl
+   BelegZwischenablagePlugin nachweislich im Programm lag, und der
+   Kalendertermin fiel still auf das Teilen-Blatt zurueck, das den Kalender
+   gar nicht erreichen kann (siehe AGENTS.md Abschnitt BS).
+
+   Die Klassennamen kommen aus den Swift-Dateien selbst (@objc(...)), damit
+   sie nicht an zwei Stellen gepflegt werden muessen. */
+const konfigPfad = join(iosApp, "App", "capacitor.config.json")
+if (!existsSync(konfigPfad)) {
+  abbruch(`${konfigPfad} nicht gefunden - erst 'npx cap sync ios' laufen lassen.`)
+}
+const eigeneKlassen = PLUGIN_DATEIEN.map((datei) => {
+  const quelle = readFileSync(join(APP, "native", datei), "utf8")
+  const treffer = /@objc\(([A-Za-z0-9_]+)\)/.exec(quelle)
+  if (!treffer) abbruch(`${datei}: kein @objc(...)-Name gefunden`)
+  return treffer[1]
+})
+const konfig = JSON.parse(readFileSync(konfigPfad, "utf8"))
+konfig.packageClassList = konfig.packageClassList ?? []
+const fehlten = eigeneKlassen.filter((k) => !konfig.packageClassList.includes(k))
+if (fehlten.length) {
+  konfig.packageClassList.push(...fehlten)
+  writeFileSync(konfigPfad, JSON.stringify(konfig, null, 2) + String.fromCharCode(10))
+}
+melden(`packageClassList: ${eigeneKlassen.join(", ")} eingetragen`)
+
+/* ------------------------------------------------------------- URL-Schema */
+
+/* Ohne dieses Schema kann die Erweiterung die App nicht holen - sie legt den
+   Beleg zwar ab, aber niemand merkt es, bis die App das nächste Mal von Hand
+   geöffnet wird. */
+const appPlistPfad = join(iosApp, "App", "Info.plist")
+let appPlist = readFileSync(appPlistPfad, "utf8")
+if (!appPlist.includes("CFBundleURLTypes")) {
+  const eintrag = [
+    "\t<key>CFBundleURLTypes</key>",
+    "\t<array>",
+    "\t\t<dict>",
+    "\t\t\t<key>CFBundleURLName</key>",
+    `\t\t\t<string>app.datametric360</string>`,
+    "\t\t\t<key>CFBundleURLSchemes</key>",
+    "\t\t\t<array>",
+    `\t\t\t\t<string>${SCHEMA}</string>`,
+    "\t\t\t</array>",
+    "\t\t</dict>",
+    "\t</array>",
+    "</dict>",
+  ].join("\n")
+  const letztes = appPlist.lastIndexOf("</dict>")
+  if (letztes < 0) abbruch("ios/App/App/Info.plist hat keine schließende <dict>-Marke.")
+  appPlist = appPlist.slice(0, letztes) + eintrag + appPlist.slice(letztes + "</dict>".length)
+  writeFileSync(appPlistPfad, appPlist, "utf8")
+  melden(`URL-Schema ${SCHEMA}:// eingetragen`)
+} else {
+  melden("URL-Schema war bereits eingetragen")
+}
+
+/* ---------------------------------------------------------------- Projekt */
+
+const projekt = xcode.project(pbxPfad)
+projekt.parseSync()
+
+/* ------------------------------------------------ Eigene Plugins (App-Ziel)
+
+   Steht VOR dem Ausstieg unten: die Erweiterung ist nach dem ersten Lauf
+   vorhanden, die Plugins müssen trotzdem bei jedem Bau geprüft werden - ios/
+   wird von `npx cap add ios` jederzeit neu erzeugt.
+
+   `addSourceFile` ohne Gruppe hängt die Datei an die ERSTE Sources-Phase des
+   Projekts, und das ist die des App-Ziels - genau die richtige. (Mit Gruppe
+   landete die Datei nur im Navigator; daran ist am 02.09.2026 die Erweiterung
+   ohne Programm entstanden, siehe unten.)
+
+   Ohne Gruppe geht `addSourceFile` intern über `addPluginFile`, und das legt
+   die Datei in eine Projektgruppe namens "Plugins". Ein Capacitor-Projekt hat
+   die nicht, `pbxGroupByName` liefert null, und das Skript stirbt mit
+   "Cannot read properties of null (reading 'path')" (03.09.2026). Die Gruppe
+   wird deshalb angelegt, falls sie fehlt - sie ist reine Ablage im Navigator
+   und ändert am Bau nichts. */
+if (!projekt.pbxGroupByName("Plugins")) {
+  projekt.addPbxGroup([], "Plugins", '""')
+  melden("Projektgruppe Plugins angelegt (von addSourceFile vorausgesetzt)")
+}
+
+let pluginsGeaendert = false
+for (const datei of PLUGIN_DATEIEN) {
+  if (JSON.stringify(projekt.pbxSourcesBuildPhaseObj()).includes(datei)) {
+    melden(`${datei} war bereits im App-Ziel`)
+    continue
+  }
+  projekt.addSourceFile(`App/${datei}`)
+  melden(`${datei} ins App-Ziel gehängt`)
+  pluginsGeaendert = true
+}
+if (pluginsGeaendert) {
+  writeFileSync(pbxPfad, projekt.writeSync())
+  // Nach dem Schreiben neu einlesen: der Rest des Skripts arbeitet sonst auf
+  // einem Stand, der die eigene Änderung nicht kennt.
+  projekt.parseSync()
+}
+
+const vorhanden = Object.values(projekt.pbxNativeTargetSection()).some(
+  (z) => z && typeof z === "object" && z.name === ZIEL_NAME,
+)
+if (vorhanden) {
+  melden(`Ziel ${ZIEL_NAME} war bereits im Projekt - nichts geändert`)
+  process.exit(0)
+}
+
+let ziel
+try {
+  ziel = projekt.addTarget(ZIEL_NAME, "app_extension", ZIEL_NAME, BUNDLE_ID)
+
+  // Eigene Build-Phasen: ohne sie hat das Ziel keine Quelldateien und keine
+  // Ressourcen, und Xcode baut ein leeres Bündel.
+  //
+  // Die Quelle gehoert hier hinein und nicht in ein spaeteres addSourceFile:
+  // reicht man diesem eine Gruppe mit, legt es die Datei nur in die Gruppe
+  // (Navigator) und haengt sie an keine Sources-Phase. Das Ergebnis war ein
+  // .appex ganz ohne Programm - nur Info.plist und Signatur, obwohl
+  // CFBundleExecutable eines versprach (2026-09-02 an der fertigen .ipa
+  // gemessen). Xcode meldet dabei nichts; der Bau gilt als erfolgreich.
+  // Pfad relativ zum Projektordner (ios/App), nicht nur der Dateiname: ohne
+  // Gruppe loest Xcode den Namen gegen die Projektwurzel auf und sucht dann
+  // ios/App/ShareViewController.swift - "Build input file cannot be found".
+  projekt.addBuildPhase(
+    [`${ZIEL_NAME}/ShareViewController.swift`],
+    "PBXSourcesBuildPhase",
+    "Sources",
+    ziel.uuid,
+  )
+  projekt.addBuildPhase([], "PBXResourcesBuildPhase", "Resources", ziel.uuid)
+  projekt.addBuildPhase([], "PBXFrameworksBuildPhase", "Frameworks", ziel.uuid)
+
+  // Nur zur Anzeige in Xcode. Die Quelle ist oben bereits der Sources-Phase
+  // zugeordnet und steht deshalb hier nicht noch einmal.
+  const gruppe = projekt.addPbxGroup(
+    ["Info.plist", `${ZIEL_NAME}.entitlements`],
+    ZIEL_NAME,
+    ZIEL_NAME,
+  )
+  // In die Projektwurzel einhängen, sonst taucht die Gruppe in Xcode nicht auf.
+  const wurzel = Object.keys(projekt.hash.project.objects.PBXGroup).find(
+    (k) => projekt.hash.project.objects.PBXGroup[k].name === "CustomTemplate",
+  )
+  if (wurzel) projekt.addToPbxGroup(gruppe.uuid, wurzel)
+
+  // Einstellungen, die `addTarget` nicht selbst setzt.
+  const konfigs = projekt.pbxXCBuildConfigurationSection()
+  for (const schluessel of Object.keys(konfigs)) {
+    const eintrag = konfigs[schluessel]
+    if (!eintrag || typeof eintrag !== "object" || !eintrag.buildSettings) continue
+    const s = eintrag.buildSettings
+    // Ohne Anfuehrungszeichen vergleichen: die pbxproj fuehrt Werte mal mit,
+    // mal ohne. Was `addTarget` schreibt, ist gequotet ("app.datametric360.
+    // teilen"), was Capacitor fuer die App erzeugt, steht nackt da
+    // (app.datametric360). Der Vergleich auf die gequotete Form traf deshalb
+    // die App nie - sie wurde ohne App-Gruppe signiert, waehrend die
+    // Erweiterung sie hatte. Ergebnis waere ein stiller Ausfall gewesen:
+    // teilen meldet Erfolg, die App findet nichts (2026-09-02 an der
+    // fertigen .ipa gemessen - Entitlements der App ohne
+    // application-groups).
+    if (entquotet(s.PRODUCT_BUNDLE_IDENTIFIER) === BUNDLE_ID || entquotet(s.PRODUCT_NAME) === ZIEL_NAME) {
+      s.INFOPLIST_FILE = `"${ZIEL_NAME}/Info.plist"`
+      s.CODE_SIGN_ENTITLEMENTS = `"${ZIEL_NAME}/${ZIEL_NAME}.entitlements"`
+      s.IPHONEOS_DEPLOYMENT_TARGET = "14.0"
+      s.SWIFT_VERSION = "5.0"
+      s.TARGETED_DEVICE_FAMILY = `"1,2"`
+      s.SKIP_INSTALL = "YES"
+    }
+    // Die App selbst braucht ihre neue Entitlements-Datei.
+    if (entquotet(s.PRODUCT_BUNDLE_IDENTIFIER) === "app.datametric360") {
+      s.CODE_SIGN_ENTITLEMENTS = `"App/App.entitlements"`
+    }
+  }
+
+  // Eingebettet wird die Erweiterung bereits von `addTarget`: die Bibliothek
+  // legt fuer den Typ "app_extension" von sich aus eine Copy-Phase nach
+  // PlugIns am ersten Ziel an. Hier noch eine zweite anzulegen, hat genau das
+  // erzeugt, wogegen Xcode sich wehrt (2026-09-02, erster Lauf ueberhaupt auf
+  // einem Mac):
+  //     error: Unexpected duplicate tasks
+  //     note: Target 'App': ValidateEmbeddedBinary .../DataMetric360Share.appex
+  //     note: Target 'App': ValidateEmbeddedBinary .../DataMetric360Share.appex
+  // Beide Phasen zeigten auf dieselbe Datei und dasselbe Ziel - die .appex
+  // waere zweimal an denselben Ort kopiert worden.
+
+  writeFileSync(pbxPfad, projekt.writeSync(), "utf8")
+} catch (fehler) {
+  abbruch(`Das Xcode-Projekt ließ sich nicht bearbeiten: ${fehler.message}`)
+}
+
+melden(`Ziel ${ZIEL_NAME} angelegt und eingebettet`)
+melden(`App-Gruppe ${GRUPPE} auf beiden Zielen`)
+console.log("")
+console.log("  Einmalig im Apple-Entwicklerportal nötig, sonst schlägt das Signieren fehl:")
+console.log(`    - App-Gruppe ${GRUPPE} anlegen`)
+console.log(`    - App-ID ${BUNDLE_ID} anlegen und der Gruppe zuordnen`)
+console.log(`    - App-ID app.datametric360 ebenfalls der Gruppe zuordnen`)
+console.log("")

companion-app/scripts/logo-bauen.cjs

@@ -0,0 +1,135 @@
+/**
+ * Baut die drei App-Symbol-Vorlagen als SVG.
+ *
+ * Gewaehlt wurde Entwurf 3 bei 54 % Fahrzeuggroesse: DataMetric oben, das
+ * CI-Fahrzeug in der Mitte, 360 in Audi-Rot unten, auf Nacht-Grund.
+ *
+ * WARUM DIE SCHRIFTEN EINGEBETTET WERDEN
+ * --------------------------------------
+ * Eine SVG-Datei, die nur `font-family: "Audi Type"` nennt, sieht nur dort
+ * richtig aus, wo die Schrift installiert ist. Auf einem anderen Rechner - und
+ * in jedem Rasterisierer - faellt sie auf eine Ersatzschrift zurueck, und das
+ * faellt erst am fertigen Symbol auf. Die woff2-Dateien stecken deshalb als
+ * data:-URI in der Datei; sie ist damit fuer sich allein vollstaendig.
+ *
+ * DIE DREI AUSFUEHRUNGEN VON iOS 18
+ * ---------------------------------
+ * hell    - die Kachel wie entworfen, mit eigenem Grund.
+ * dunkel  - ohne Grund. iOS legt seinen eigenen dunklen Verlauf darunter; ein
+ *           mitgeliefertes Schwarz wuerde darauf als Kasten sichtbar bleiben.
+ * getoent - ohne Grund und ohne Farbe. iOS faerbt das Bild selbst nach der
+ *           Wahl des Nutzers ein und wertet dafuer die Helligkeit aus - das
+ *           Rot der 360 wird deshalb zu einem helleren Grau als der Rest,
+ *           damit die Zahl auch getoent noch abgesetzt bleibt.
+ *
+ * MASSE
+ * -----
+ * Alles als Anteil der Kantenlaenge, hergeleitet aus dem freigegebenen
+ * Entwurf (Flex-Spalte, Abstand 0,02 - siehe index.html):
+ *
+ *   Wort 0,095 | Abstand 0,02 | Fahrzeug 0,54 | Abstand 0,02 | Zahl 0,17
+ *   zusammen 0,845, der Rest verteilt sich gleichmaessig oben und unten.
+ */
+
+const fs = require("fs")
+const path = require("path")
+
+const SCHRIFTEN = path.join(__dirname, "..", "src", "assets", "audi", "schriften")
+
+/* Das CI-Fahrzeug kommt aus dem Panel selbst - eine zweite Kopie des Pfades
+   waere eine zweite Quelle fuer dieselbe Form. */
+const PANEL = path.join(
+  __dirname,
+  "..",
+  "..",
+  "custom_components",
+  "audi_dashboard",
+  "frontend",
+  "audi-dashboard-app.js",
+)
+const MARKE = "audi: '<path"
+const roh = fs.readFileSync(PANEL, "utf8")
+const von = roh.indexOf(MARKE)
+if (von < 0) throw new Error("ICONS.audi nicht in audi-dashboard-app.js gefunden")
+const dVon = roh.indexOf('d="', von) + 3
+const dBis = roh.indexOf('"', dVon)
+const AUTO = roh.slice(dVon, dBis)
+if (!AUTO.startsWith("M")) throw new Error("Pfad sieht nicht wie erwartet aus: " + AUTO.slice(0, 30))
+
+function schriftDaten(datei) {
+  return fs.readFileSync(path.join(SCHRIFTEN, datei)).toString("base64")
+}
+
+const TYPE = schriftDaten("audi-type-400.woff2")
+const WIDE = schriftDaten("audi-type-wide-300.woff2")
+
+/* Anteile der Kantenlaenge. */
+const A = {
+  wort: 0.095,
+  fahrzeug: 0.54,
+  zahl: 0.17,
+  abstand: 0.02,
+}
+
+const S = 1024
+const gesamt = (A.wort + A.abstand + A.fahrzeug + A.abstand + A.zahl) * S
+const oben = (S - gesamt) / 2
+
+const wortMitte = oben + (A.wort * S) / 2
+const autoOben = oben + (A.wort + A.abstand) * S
+const autoKante = A.fahrzeug * S
+const zahlMitte = autoOben + autoKante + A.abstand * S + (A.zahl * S) / 2
+
+/** Das CI-Fahrzeug aus dem 24er-Raster auf seine Kachelgroesse gebracht. */
+function fahrzeug(farbe) {
+  const faktor = autoKante / 24
+  const links = (S - autoKante) / 2
+  return `<g transform="translate(${links.toFixed(2)} ${autoOben.toFixed(2)}) scale(${faktor.toFixed(5)})"><path d="${AUTO}" fill="${farbe}"/></g>`
+}
+
+/**
+ * @param {object} o
+ * @param {string|null} o.grund  Hintergrund, oder null fuer keinen
+ * @param {string} o.vorn        Wort und Fahrzeug
+ * @param {string} o.akzent      die 360
+ */
+function symbol({ grund, vorn, akzent }) {
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${S}" height="${S}" viewBox="0 0 ${S} ${S}">
+  <style>
+    @font-face { font-family: "Audi Type"; font-weight: 400; src: url(data:font/woff2;base64,${TYPE}) format("woff2"); }
+    @font-face { font-family: "Audi Type Wide"; font-weight: 300; src: url(data:font/woff2;base64,${WIDE}) format("woff2"); }
+    .wort { font-family: "Audi Type"; font-weight: 400; letter-spacing: -0.01em; }
+    .zahl { font-family: "Audi Type Wide"; font-weight: 300; letter-spacing: -0.03em; }
+  </style>
+${grund ? `  <rect width="${S}" height="${S}" fill="${grund}"/>\n` : ""}\
+  <text class="wort" x="${S / 2}" y="${wortMitte.toFixed(2)}" font-size="${(A.wort * S).toFixed(2)}" fill="${vorn}" text-anchor="middle" dominant-baseline="central">DataMetric</text>
+${fahrzeug(vorn)}
+  <text class="zahl" x="${S / 2}" y="${zahlMitte.toFixed(2)}" font-size="${(A.zahl * S).toFixed(2)}" fill="${akzent}" text-anchor="middle" dominant-baseline="central">360</text>
+</svg>
+`
+}
+
+const AUSFUEHRUNGEN = {
+  /* Nacht-Canvas und Audi-Rot aus den Tokens des Projekts. */
+  hell: { grund: "#0C1014", vorn: "#FFFFFF", akzent: "#F50537" },
+  dunkel: { grund: null, vorn: "#FFFFFF", akzent: "#F50537" },
+  /* Getoent wertet iOS die Helligkeit aus: Weiss fuer Wort und Fahrzeug, ein
+     helles Grau fuer die Zahl - so bleibt sie abgesetzt, ohne eine Farbe zu
+     behaupten, die es getoent nicht gibt. */
+  getoent: { grund: null, vorn: "#FFFFFF", akzent: "#B4B4B8" },
+}
+
+const ZIEL = path.join(__dirname, "..", "native", "logo")
+fs.mkdirSync(ZIEL, { recursive: true })
+
+for (const [name, o] of Object.entries(AUSFUEHRUNGEN)) {
+  const datei = path.join(ZIEL, `AppIcon-${name}.svg`)
+  fs.writeFileSync(datei, symbol(o), "utf8")
+  console.log(`${path.basename(datei)}  ${(fs.statSync(datei).size / 1024).toFixed(0)} KB`)
+}
+
+console.log("")
+console.log("Masse bei 1024:")
+console.log(`  Wort      Mitte y=${wortMitte.toFixed(1)}  Groesse ${(A.wort * S).toFixed(1)}`)
+console.log(`  Fahrzeug  oben  y=${autoOben.toFixed(1)}  Kante  ${autoKante.toFixed(1)}`)
+console.log(`  Zahl      Mitte y=${zahlMitte.toFixed(1)}  Groesse ${(A.zahl * S).toFixed(1)}`)

companion-app/scripts/ota-paket.ps1

@@ -0,0 +1,153 @@
+<#
+.SYNOPSIS
+  Packt die gebaute Companion-App als OTA-Bündel in die Integration.
+
+.BESCHREIBUNG
+  Erzeugt aus companion-app/dist zwei Dateien:
+
+      custom_components/audi_dashboard/frontend/app/bundle.zip
+      custom_components/audi_dashboard/frontend/app/bundle.json
+
+  Die iOS-App lädt die Zip zur Laufzeit nach und tauscht ihre Oberfläche aus,
+  ohne dass Xcode gebraucht wird (siehe companion-app/src/daten/ota.ts).
+
+  WARUM DAS BÜNDEL IN DER INTEGRATION LIEGT
+  -----------------------------------------
+  Weil es dann von selbst dorthin kommt, wo die App es sucht. install.ps1
+  (der einzige Installationsweg - HACS scheidet aus, siehe VERSIONIERUNG.md)
+  kopiert den Ordner custom_components/audi_dashboard/ vollständig - das
+  Bündel reist bei jedem Lauf mit, ohne zweiten Auslieferungsweg. Ein
+  Ablageort unter /config/www/ hätte einen eigenen Weg dorthin gebraucht, den
+  man beim Ausliefern hätte vergessen können.
+
+  Der Nebeneffekt ist der eigentliche Gewinn: Bündel und Integration können
+  gar nicht auseinanderlaufen, weil sie dieselbe Datei sind.
+
+  DREI DINGE, DIE HIER BEWUSST SO SIND
+  ------------------------------------
+  1. **Sourcemaps fliegen raus.** Sie machen rund zwei Drittel von dist/ aus
+     (1,4 von 2,0 MB) und werden auf dem Gerät nie gebraucht. Sie mitzuladen
+     hieße, bei jedem Update das Dreifache über die Leitung zu schicken.
+
+  2. **Die Einträge werden von Hand geschrieben, nicht von einer Bequem-API.**
+     Die Zip-Spezifikation verlangt "/" als Trennzeichen. Windows PowerShell
+     5.1 läuft auf dem .NET Framework, und dort schreiben SOWOHL
+     Compress-Archive ALS AUCH [IO.Compression.ZipFile]::CreateFromDirectory
+     Backslashes in die Einträge von Unterordnern (in .NET Core behoben, hier
+     aber nicht verfügbar). Nachgemessen: die erste Fassung dieses Skripts
+     erzeugte "assets\index-*.js" statt "assets/index-*.js" - iOS hätte daraus
+     Dateien mit Backslash im Namen gemacht statt einen Ordner, und die App
+     wäre mit fehlenden Assets gestartet.
+
+     Deshalb ZipFile::Open plus CreateEntryFromFile mit selbst gebautem
+     Eintragsnamen: dann steht genau das im Archiv, was hier steht. Der Inhalt
+     liegt ohne umschließenden Ordner in der Wurzel, index.html also direkt
+     dort - genau das erwartet das Plugin; fehlt es, wirft set() "no index.html
+     file inside the bundle folder".
+
+  3. **SHA-256 über die Zip, klein geschrieben.** Das Plugin rechnet auf dem
+     Gerät denselben Hash über die heruntergeladene Datei (calcChecksum in
+     CapgoUpdater.swift) und verwirft das Bündel bei Abweichung. Ein
+     abgeschnittener Download oder eine halb gespiegelte Datei fällt damit
+     auf, bevor die App sie startet.
+
+.PARAMETER Bauen
+  Vorher "npm run build" ausführen. Ohne das wird der Inhalt von dist/
+  genommen, wie er gerade daliegt.
+
+.BEISPIEL
+  .\ota-paket.ps1 -Bauen
+  npm run ota
+#>
+param(
+    [switch]$Bauen
+)
+
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.IO.Compression
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+
+$hier     = $PSScriptRoot
+$app      = Split-Path $hier -Parent
+$projekt  = Split-Path $app -Parent
+$dist     = Join-Path $app "dist"
+$manifest = Join-Path $projekt "custom_components\audi_dashboard\manifest.json"
+$ziel     = Join-Path $projekt "custom_components\audi_dashboard\frontend\app"
+
+function Gut($t)  { Write-Host "  [ok]   $t" -ForegroundColor Green }
+function Info($t) { Write-Host "  [info] $t" -ForegroundColor DarkGray }
+
+Write-Host ""
+Write-Host "  OTA-Bündel bauen" -ForegroundColor White
+Write-Host "  ================" -ForegroundColor White
+
+if ($Bauen) {
+    Info "npm run build ..."
+    Push-Location $app
+    try { npm run build; if ($LASTEXITCODE -ne 0) { throw "npm run build fehlgeschlagen" } }
+    finally { Pop-Location }
+}
+
+if (-not (Test-Path (Join-Path $dist "index.html"))) {
+    throw "$dist\index.html fehlt - erst 'npm run build' laufen lassen (oder -Bauen benutzen)."
+}
+
+$version = (Get-Content $manifest -Raw | ConvertFrom-Json).version
+if (-not $version) { throw "Kein 'version'-Feld in $manifest" }
+Gut "Version: $version"
+
+# In einen Zwischenordner spiegeln, damit die Sourcemaps nicht mitwandern -
+# dist/ selbst bleibt unangetastet (die Maps sind beim Entwickeln nützlich).
+$tmp = Join-Path ([IO.Path]::GetTempPath()) ("dm360-ota-" + [Guid]::NewGuid().ToString("N"))
+New-Item -ItemType Directory -Force -Path $tmp | Out-Null
+try {
+    Copy-Item "$dist\*" $tmp -Recurse -Force
+    $maps = Get-ChildItem $tmp -Recurse -File -Filter "*.map"
+    $maps | ForEach-Object { Remove-Item $_.FullName -Force }
+    Info "$($maps.Count) Sourcemap(s) ausgelassen"
+
+    if (-not (Test-Path (Join-Path $tmp "index.html"))) {
+        throw "index.html liegt nicht in der Wurzel des Bündels - das Plugin würde es ablehnen."
+    }
+
+    New-Item -ItemType Directory -Force -Path $ziel | Out-Null
+    $zip = Join-Path $ziel "bundle.zip"
+    if (Test-Path $zip) { Remove-Item $zip -Force }
+
+    # Eintragsnamen selbst bauen (siehe Punkt 2 im Kopfkommentar): relativer
+    # Pfad ab dem Zwischenordner, Backslashes durch "/" ersetzt.
+    $archiv = [IO.Compression.ZipFile]::Open($zip, [System.IO.Compression.ZipArchiveMode]::Create)
+    try {
+        foreach ($datei in Get-ChildItem $tmp -Recurse -File | Sort-Object FullName) {
+            $name = $datei.FullName.Substring($tmp.Length + 1).Replace("\", "/")
+            [void][IO.Compression.ZipFileExtensions]::CreateEntryFromFile(
+                $archiv, $datei.FullName, $name, [IO.Compression.CompressionLevel]::Optimal)
+        }
+    }
+    finally { $archiv.Dispose() }
+
+    $hash   = (Get-FileHash $zip -Algorithm SHA256).Hash.ToLower()
+    $groesse = (Get-Item $zip).Length
+    Gut ("bundle.zip  {0:N0} Bytes" -f $groesse)
+    Gut "sha256      $hash"
+
+    # Kleingeschriebener Hex-Hash, weil das Plugin auf dem Geraet ebenfalls
+    # kleingeschrieben vergleicht.
+    $daten = [ordered]@{
+        version = $version
+        sha256  = $hash
+        bytes   = $groesse
+        gebaut  = (Get-Date).ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ")
+    }
+    $json = ($daten | ConvertTo-Json -Compress)
+    [IO.File]::WriteAllText((Join-Path $ziel "bundle.json"), $json, (New-Object Text.UTF8Encoding($false)))
+    Gut "bundle.json geschrieben"
+}
+finally {
+    Remove-Item $tmp -Recurse -Force -ErrorAction SilentlyContinue
+}
+
+Write-Host ""
+Write-Host "  Fertig. Das Bündel wird mit der Integration ausgeliefert -" -ForegroundColor Green
+Write-Host "  homeassistant\installationspaket\Installieren.cmd nimmt es automatisch mit."
+Write-Host ""

companion-app/scripts/smoke-auth.ts

@@ -0,0 +1,198 @@
+/* Rauchtest mit echtem Zugangstoken gegen die laufende HA-Testinstanz.
+   Ergänzt scripts/smoke.ts um alles, was ohne Anmeldung nicht prüfbar ist:
+   echte Lesevorgänge, ein echter Dienstaufruf und ein vollständiger Umlauf
+   durch die Warteschlange.
+
+   Zugangsdaten kommen aus companion-app/.env.local (schreibt
+   testumgebung/aufsetzen.sh). Ohne sie bricht der Test mit einem Hinweis ab,
+   ohne zu scheitern - damit er in einer Umgebung ohne Testinstanz nicht
+   fälschlich rot wird.
+
+   Aufruf:  npm run smoke:auth  */
+
+import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import { dirname, resolve } from "node:path"
+
+import { DIENST_DOMAIN, ENTITAETEN } from "../src/api/types.ts"
+import { HassRest } from "../src/api/rest.ts"
+import { Warteschlange } from "../src/api/warteschlange.ts"
+import { ablageSetzen, websocketUrl, type Ablage } from "../src/api/umgebung.ts"
+
+/* ------------------------------------------------------ Zugangsdaten */
+
+const hier = dirname(fileURLToPath(import.meta.url))
+const umgebungsdatei = resolve(hier, "../.env.local")
+
+function umgebungLesen(): Record<string, string> {
+  try {
+    const inhalt = readFileSync(umgebungsdatei, "utf8")
+    const werte: Record<string, string> = {}
+    for (const zeile of inhalt.split("\n")) {
+      const treffer = /^([A-Z_]+)=(.*)$/.exec(zeile.trim())
+      if (treffer?.[1] && treffer[2] !== undefined) werte[treffer[1]] = treffer[2]
+    }
+    return werte
+  } catch {
+    return {}
+  }
+}
+
+const umgebung = umgebungLesen()
+const BASIS = umgebung["VITE_TEST_URL"] ?? "http://localhost:18123"
+const TOKEN = umgebung["VITE_TEST_TOKEN"] ?? process.env["VITE_TEST_TOKEN"] ?? ""
+
+if (!TOKEN) {
+  console.log("übersprungen: kein Token in companion-app/.env.local")
+  console.log("               testumgebung/aufsetzen.sh ausführen, dann erneut versuchen.")
+  process.exit(0)
+}
+
+/* ------------------------------------------------------------ Rahmen */
+
+let fehler = 0
+function pruefe(bezeichnung: string, bedingung: boolean, zusatz = ""): void {
+  console.log(`${bedingung ? "PASS" : "FAIL"}  ${bezeichnung}${zusatz ? `  (${zusatz})` : ""}`)
+  if (!bedingung) fehler += 1
+}
+
+/** Ablage im Arbeitsspeicher — Node hat kein localStorage. */
+class SpeicherAblage implements Ablage {
+  #werte = new Map<string, string>()
+  async lesen(schluessel: string) {
+    return this.#werte.get(schluessel) ?? null
+  }
+  async schreiben(schluessel: string, wert: string) {
+    this.#werte.set(schluessel, wert)
+  }
+  async loeschen(schluessel: string) {
+    this.#werte.delete(schluessel)
+  }
+}
+ablageSetzen(new SpeicherAblage())
+
+const zugang = { basisUrl: BASIS, token: TOKEN }
+const rest = new HassRest(zugang)
+
+/* ------------------------------------------------------------- Lesen */
+
+try {
+  const antwort = await rest.verbindungPruefen()
+  pruefe("verbindungPruefen mit Token", typeof antwort.message === "string", antwort.message)
+} catch (e) {
+  pruefe("verbindungPruefen mit Token", false, e instanceof Error ? e.message : String(e))
+}
+
+try {
+  const profil = await rest.datenLesen<Record<string, unknown>>(ENTITAETEN.profil)
+  pruefe(
+    "Profil liefert die erwarteten Abschnitte",
+    Boolean(profil["fahrzeug"] && profil["einstellungen"] && profil["reifen"]),
+    Object.keys(profil).join(", "),
+  )
+} catch (e) {
+  pruefe("Profil lesen", false, e instanceof Error ? e.message : String(e))
+}
+
+try {
+  const status = await rest.datenLesen<Record<string, unknown>>(ENTITAETEN.fahrzeugstatus)
+  /* Die Feldnamen sind der Grund für diesen Test: ein früherer Entwurf der
+     Typen hatte tank_prozent/sicher_abgestellt/sicherheit angenommen, das
+     Backend schreibt aber tankprozent/gesichert/sicherheitscheck. */
+  pruefe(
+    "Fahrzeugstatus benutzt die erwarteten Feldnamen",
+    "tankprozent" in status && "gesichert" in status && "sicherheitscheck" in status,
+    Object.keys(status).slice(0, 6).join(", "),
+  )
+  /* Wie viele Punkte es sind, hängt an der Sensor-Zuordnung der Instanz: vier
+     Türen, vier Fenster, Heckklappe, Motorhaube — unbelegte Rollen liefern gar
+     keinen Eintrag. Eine feste Zahl zu erwarten hieße, die Zuordnung der
+     Testinstanz zu prüfen statt das Backend; genau daran scheiterte diese
+     Prüfung seit dem Entfernen der Türschloss-Erkennung (16 → 10), ohne dass
+     irgendetwas kaputt gewesen wäre. Geprüft wird deshalb die vereinbarte
+     Form: label ist Text, ok ist true/false/null (null = Sensor unbekannt). */
+  const punkte = (status["sicherheitscheck"] ?? []) as { label?: unknown; ok?: unknown }[]
+  pruefe(
+    "Sicherheitscheck liefert Punkte in der vereinbarten Form",
+    Array.isArray(punkte) &&
+      punkte.every((p) => typeof p.label === "string" && (p.ok === null || typeof p.ok === "boolean")),
+    `${punkte.length} Punkte`,
+  )
+} catch (e) {
+  pruefe("Fahrzeugstatus lesen", false, e instanceof Error ? e.message : String(e))
+}
+
+for (const [name, id] of [
+  ["Fahrten", ENTITAETEN.fahrten],
+  ["Tankvorgänge", ENTITAETEN.tankvorgaenge],
+] as const) {
+  try {
+    const liste = await rest.datenLesen<unknown[]>(id)
+    pruefe(`${name} sind eine Liste`, Array.isArray(liste), `${liste.length} Einträge`)
+  } catch (e) {
+    pruefe(`${name} lesen`, false, e instanceof Error ? e.message : String(e))
+  }
+}
+
+/* -------------------------------------------------------- Dienstaufruf */
+
+try {
+  await rest.dienstAufrufen(DIENST_DOMAIN, "jetzt_aktualisieren")
+  pruefe("Dienstaufruf audi_dashboard.jetzt_aktualisieren", true)
+} catch (e) {
+  pruefe("Dienstaufruf audi_dashboard.jetzt_aktualisieren", false, e instanceof Error ? e.message : String(e))
+}
+
+/* ------------------------------------------------------ Warteschlange */
+
+try {
+  const warteschlange = new Warteschlange(rest)
+  await warteschlange.einreihen(DIENST_DOMAIN, "jetzt_aktualisieren", {}, "Rauchtest")
+
+  /* einreihen() stößt die Abarbeitung selbst an, ohne sie abzuwarten - ein
+     sofortiger eigener abarbeiten()-Aufruf liefe deshalb ins Leere (der Lauf
+     ist schon aktiv). Also warten, bis die Schlange tatsächlich leer ist. */
+  const frist = Date.now() + 10_000
+  while (warteschlange.anzahl > 0 && Date.now() < frist) {
+    await new Promise((weiter) => setTimeout(weiter, 100))
+  }
+  pruefe(
+    "Warteschlange arbeitet einen Auftrag vollständig ab",
+    warteschlange.anzahl === 0,
+    `${warteschlange.anzahl} verblieben`,
+  )
+} catch (e) {
+  pruefe("Warteschlangen-Umlauf", false, e instanceof Error ? e.message : String(e))
+}
+
+/* ----------------------------------------- WebSocket mit Anmeldung */
+
+try {
+  const ergebnis = await new Promise<string>((aufloesen, ablehnen) => {
+    const ws = new WebSocket(websocketUrl(BASIS))
+    const frist = setTimeout(() => {
+      ablehnen(new Error("Zeitüberschreitung"))
+      ws.close()
+    }, 10_000)
+    ws.onmessage = (nachricht) => {
+      const daten = JSON.parse(String(nachricht.data)) as { type: string }
+      if (daten.type === "auth_required") {
+        ws.send(JSON.stringify({ type: "auth", access_token: TOKEN }))
+      } else if (daten.type === "auth_ok" || daten.type === "auth_invalid") {
+        clearTimeout(frist)
+        aufloesen(daten.type)
+        ws.close()
+      }
+    }
+    ws.onerror = () => {
+      clearTimeout(frist)
+      ablehnen(new Error("WebSocket-Fehler"))
+    }
+  })
+  pruefe("WebSocket meldet sich mit dem Token an", ergebnis === "auth_ok", ergebnis)
+} catch (e) {
+  pruefe("WebSocket-Anmeldung", false, e instanceof Error ? e.message : String(e))
+}
+
+console.log(fehler === 0 ? "\nAlle Prüfungen bestanden." : `\n${fehler} Prüfung(en) fehlgeschlagen.`)
+process.exitCode = fehler === 0 ? 0 : 1

companion-app/src/App.tsx

@@ -0,0 +1,168 @@
+import { useCallback, useEffect, useMemo, useState } from "react"
+
+import { bilderVorladen } from "./screens/bilder"
+
+import { App as CapacitorApp } from "@capacitor/app"
+
+import { DataMetricApi, zugangLesen } from "./api"
+import { DatenAnbieter, useDaten } from "./daten/DatenKontext"
+import { geteiltenBelegLesen, geteiltenBelegSetzen } from "./daten/geteilterBeleg"
+import { startklarMelden } from "./daten/ota"
+import { Shell } from "./Shell"
+import type { Route, SeitenName } from "./navigation"
+import { useTabBeschriftung, useTheme } from "./theme"
+import { Bestaetigungsblatt } from "./screens/bestaetigung"
+import { Einrichtung } from "./screens/Einrichtung"
+import { Hinweisleiste } from "./screens/Hinweisleiste"
+import { Versionshinweis } from "./screens/Versionshinweis"
+import { SeiteFuer } from "./screens/register"
+import { zugangMerken } from "./screens/zugang"
+
+import "./stile/rahmen.css"
+import "./stile/screens.css"
+
+type Startzustand = "pruefen" | "einrichten" | "bereit"
+
+/**
+ * Wurzel der App. Entscheidet zuerst, ob Zugangsdaten vorliegen — ohne sie
+ * gibt es nichts anzuzeigen außer der Ersteinrichtung. Danach hängt alles
+ * unter dem Datenkontext.
+ */
+export function App() {
+  const [theme] = useTheme()
+  const [start, setzeStart] = useState<Startzustand>("pruefen")
+
+  // Genau eine Instanz für die Lebensdauer der App: sie hält die
+  // WebSocket-Verbindung und die Warteschlange.
+  const api = useMemo(() => new DataMetricApi(), [])
+
+  useEffect(() => {
+    void zugangLesen().then(async (zugang) => {
+      // Adresse für Bild-URLs merken, bevor der erste Screen rendert.
+      if (zugang) await zugangMerken()
+      setzeStart(zugang ? "bereit" : "einrichten")
+    })
+  }, [])
+
+  return (
+    <div className="ads-root dm-wurzel" data-theme={theme}>
+      {/* Einmal fuer die ganze App: die Rueckfrage vor loeschenden Aktionen
+          (siehe screens/bestaetigung.tsx). Rendert nichts, solange nichts
+          gefragt ist. */}
+      <Bestaetigungsblatt />
+      {start === "pruefen" && <div className="dm-laden">Einen Moment …</div>}
+      {start === "einrichten" && <Einrichtung fertig={() => setzeStart("bereit")} />}
+      {start === "bereit" && (
+        <DatenAnbieter api={api}>
+          <AngemeldeteApp beiAbmeldung={() => setzeStart("einrichten")} />
+        </DatenAnbieter>
+      )}
+    </div>
+  )
+}
+
+function AngemeldeteApp({ beiAbmeldung }: { beiAbmeldung: () => void }) {
+  const [route, setzeRoute] = useState<Route>({ name: "home" })
+  const [tabBeschriftung, setzeTabBeschriftung] = useTabBeschriftung()
+  const daten = useDaten()
+
+  const geheZu = useCallback((name: SeitenName, id?: string) => {
+    setzeRoute(id === undefined ? { name } : { name, id })
+    document.querySelector(".dm-inhalt")?.scrollTo({ top: 0 })
+  }, [])
+
+  // Ein abgelaufener oder zurückgezogener Token führt zurück in die
+  // Ersteinrichtung statt in eine endlose Fehlerschleife.
+  useEffect(() => {
+    if (daten.verbindung === "nicht_angemeldet") beiAbmeldung()
+  }, [daten.verbindung, beiAbmeldung])
+
+  // Meldet dem OTA-Plugin, dass diese Fassung hochgekommen ist (siehe
+  // daten/ota.ts). Bewusst hier und nicht in main.tsx: erst wenn diese
+  // Komponente rendert, hat React tatsächlich etwas auf den Schirm gebracht.
+  // Ein Absturz vor diesem Punkt bleibt unbestätigt, und das Plugin rollt
+  // nach appReadyTimeout von selbst auf das vorherige Bündel zurück.
+  useEffect(() => {
+    void startklarMelden()
+  }, [])
+
+  /* Fahrzeugfotos einmal vorab holen und dekodieren, sobald Daten da sind -
+     siehe bilderVorladen(). Damit erscheint beim Umschalten der Seiten sofort
+     das Bild statt kurz des Platzhalters. */
+  useEffect(() => {
+    if (daten.verbindung === "verbunden") bilderVorladen()
+  }, [daten.verbindung])
+
+  /* Belege aus dem Teilen-Blatt.
+
+     Die Erweiterung legt das PDF ab und oeffnet die App - beim ersten Start
+     kommt die App dadurch frisch hoch, bei einer schon laufenden App nur
+     nach vorn. Deshalb beide Faelle: einmal beim Aufbau, und danach bei
+     jeder Rueckkehr in den Vordergrund.
+
+     Der Beleg wandert in den geteilten Speicher und die App springt auf
+     Tanken - dort nimmt ihn Tanken.tsx auf und laedt ihn hoch, ueber
+     genau denselben Weg wie eine von Hand gewaehlte Datei. */
+  useEffect(() => {
+    let abgemeldet = false
+
+    /* Der Beleg kommt im Aufruf mit: die Teilen-Erweiterung schreibt ihn in
+       den Container der App-Gruppe und öffnet die App mit dem Pfad
+       (ShareViewController.swift). Zwei Wege hierher, weil iOS beide benutzt:
+       war die App zu, steht der Aufruf in getLaunchUrl(); lief sie schon,
+       kommt er als appUrlOpen.
+
+       Bis zum 02.09.2026 stand hier "resume" plus ein Griff in die
+       UserDefaults - der konnte nie etwas finden, die Begründung steht in
+       geteilterBeleg.ts. */
+    const holen = async (url: string | null | undefined) => {
+      const datei = await geteiltenBelegLesen(url)
+      if (abgemeldet || !datei) return
+      geteiltenBelegSetzen(datei)
+      geheZu("fuel")
+    }
+
+    void CapacitorApp.getLaunchUrl().then((start) => holen(start?.url))
+
+    const horcher = CapacitorApp.addListener("appUrlOpen", (ereignis) => {
+      void holen(ereignis.url)
+    })
+    return () => {
+      abgemeldet = true
+      void horcher.then((h) => h.remove())
+    }
+  }, [geheZu])
+
+  return (
+    <Shell
+      route={route}
+      geheZu={geheZu}
+      tabBeschriftung={tabBeschriftung}
+      statusStand={daten.statusStand}
+      // Ziehen zum Aktualisieren gibt es im Panel nur auf der Übersicht.
+      beiAktualisieren={route.name === "home" ? daten.jetztAktualisieren : undefined}
+      hinweis={
+        <Hinweisleiste
+          verbindung={daten.verbindung}
+          warteschlange={daten.warteschlange}
+          versionsstand={daten.versionsstand}
+        />
+      }
+    >
+      <SeiteFuer
+        route={route}
+        geheZu={geheZu}
+        tabBeschriftung={tabBeschriftung}
+        setzeTabBeschriftung={setzeTabBeschriftung}
+        beiAbmeldung={beiAbmeldung}
+      />
+      {/* Erscheint von selbst, sobald der erste Datenabruf eine neuere
+          Fassung meldet - siehe screens/Versionshinweis.tsx. */}
+      <Versionshinweis
+        versionsstand={daten.versionsstand}
+        serverVersion={daten.serverVersion}
+        otaBuendel={daten.otaBuendel}
+      />
+    </Shell>
+  )
+}

companion-app/src/ErrorGrenze.tsx

@@ -0,0 +1,51 @@
+/**
+ * Auffangnetz für Abstürze irgendwo im Baum.
+ *
+ * Ohne diese Grenze unmountet React die gesamte App bei jedem unbehandelten
+ * Fehler beim Rendern - #wurzel bleibt leer, und übrig bleibt nur der
+ * Seitenhintergrund (im Nacht-Theme praktisch schwarz). Genau das wurde als
+ * "schwarze Seite nach Update prüfen" gemeldet: kein hängender Ladezustand,
+ * sondern ein stiller Absturz, dessen eigentliche Fehlermeldung nirgends
+ * ankam. Ein "zurück und wieder rein" half nur, weil das erneute Öffnen den
+ * Baum komplett neu aufbaut und der auslösende Zustand dabei verschwindet.
+ *
+ * Diese Grenze behebt nicht die eigentliche Ursache - sie sorgt nur dafür,
+ * dass ein Absturz ab jetzt sichtbar ist (Fehlertext, Neu-laden-Knopf) statt
+ * unsichtbar zu bleiben, und dass der Fehlertext in der Konsole landet, um
+ * die eigentliche Ursache beim nächsten Mal fassen zu können.
+ */
+
+import { Component, type ReactNode } from "react"
+
+import { ActionButton } from "@audi-dash/ui"
+
+export class ErrorGrenze extends Component<
+  { children: ReactNode },
+  { fehler: Error | null }
+> {
+  state: { fehler: Error | null } = { fehler: null }
+
+  static getDerivedStateFromError(fehler: Error) {
+    return { fehler }
+  }
+
+  componentDidCatch(fehler: Error, info: { componentStack?: string | null }) {
+    console.error("ErrorGrenze: unbehandelter Fehler beim Rendern", fehler, info.componentStack)
+  }
+
+  render() {
+    if (!this.state.fehler) return this.props.children
+    return (
+      <div className="dm-leer" style={{ minHeight: "100vh", justifyContent: "center" }}>
+        <span className="dm-leer__titel">Etwas ist schiefgelaufen</span>
+        <p className="dm-leer__text">
+          Die Seite konnte nicht dargestellt werden. Ein Neuladen behebt das in der Regel.
+        </p>
+        <p className="dm-leer__text" style={{ fontFamily: "monospace", fontSize: "12px" }}>
+          {this.state.fehler.message}
+        </p>
+        <ActionButton onClick={() => window.location.reload()}>Neu laden</ActionButton>
+      </div>
+    )
+  }
+}

companion-app/src/Shell.test.tsx

@@ -0,0 +1,73 @@
+/**
+ * Abnahmekriterien aus Phase 5 des Umsetzungsplans: Die App muss beide
+ * Layouts beherrschen und die Zurück-Navigation über die ZURUECK-Tabelle
+ * korrekt auflösen.
+ */
+
+import { fireEvent, render, screen } from "@testing-library/react"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+import { Shell } from "./Shell"
+import { bereichVon } from "./navigation"
+import { bildschirmbreiteSetzen } from "./tests/aufbau"
+
+function rahmen(routeName: Parameters<typeof bereichVon>[0], geheZu = vi.fn()) {
+  render(
+    <Shell route={{ name: routeName }} geheZu={geheZu} tabBeschriftung>
+      <p>Inhalt</p>
+    </Shell>,
+  )
+  return geheZu
+}
+
+describe("Shell", () => {
+  beforeEach(() => {
+    bildschirmbreiteSetzen(390)
+  })
+
+  it("zeigt auf schmalen Bildschirmen die Tab-Leiste unten", () => {
+    const { container } = render(
+      <Shell route={{ name: "home" }} geheZu={vi.fn()} tabBeschriftung>
+        <p>Inhalt</p>
+      </Shell>,
+    )
+    expect(container.querySelector(".ads-tabbar")).not.toBeNull()
+    expect(container.querySelector(".dm-seitenleiste")).toBeNull()
+  })
+
+  it("zeigt auf breiten Bildschirmen die Seitenleiste statt der Tab-Leiste", () => {
+    bildschirmbreiteSetzen(1280)
+    const { container } = render(
+      <Shell route={{ name: "home" }} geheZu={vi.fn()} tabBeschriftung>
+        <p>Inhalt</p>
+      </Shell>,
+    )
+    expect(container.querySelector(".dm-seitenleiste")).not.toBeNull()
+    expect(container.querySelector(".ads-tabbar")).toBeNull()
+  })
+
+  it("führt der Zurück-Pfeil zur übergeordneten Seite", () => {
+    const geheZu = rahmen("beitrag")
+    fireEvent.click(screen.getByLabelText("Zurück"))
+    // beitrag -> vers laut ZURUECK-Tabelle
+    expect(geheZu).toHaveBeenCalledWith("vers")
+  })
+
+  it("blendet den Zurück-Pfeil auf Hauptbereichen aus", () => {
+    rahmen("trips")
+    expect(screen.queryByLabelText("Zurück")).toBeNull()
+  })
+
+  it("hebt den Hauptbereich hervor, zu dem eine Unterseite gehört", () => {
+    // schutz -> vertragsdetails -> vers -> audi
+    expect(bereichVon("schutz")).toBe("audi")
+    expect(bereichVon("fill")).toBe("fuel")
+    expect(bereichVon("trip")).toBe("trips")
+  })
+
+  it("erreicht die Einstellungen über die Ringe, nicht über die Tab-Leiste", () => {
+    const geheZu = rahmen("home")
+    fireEvent.click(screen.getByLabelText("Einstellungen"))
+    expect(geheZu).toHaveBeenCalledWith("einst")
+  })
+})

companion-app/src/Shell.tsx

@@ -0,0 +1,450 @@
+/**
+ * Rahmen der App: Kopfzeile, Navigation, Inhaltsfläche.
+ *
+ * Zwei Layouts aus derselben Zusammensetzung — die entscheidende Anforderung
+ * aus dem Design-Auftrag: schmal (Handy) mit Tab-Leiste unten, breit (Tablet,
+ * eingebettet in Home Assistant) mit Seitenleiste links. Der Umschaltpunkt
+ * liegt bei 1000px.
+ */
+
+import { useEffect, useRef, useState } from "react"
+import type {
+  MutableRefObject,
+  PointerEvent as ReactPointerEvent,
+  ReactNode,
+  RefObject,
+} from "react"
+
+import { TabBar } from "@audi-dash/ui"
+
+import { standAlter } from "./format"
+import { useBreiterBildschirm } from "./hooks/useBreiterBildschirm"
+import { VierRinge } from "./screens/Typenschild"
+import type { Hauptbereich, Route, SeitenName } from "./navigation"
+import { TITEL, ZURUECK, bereichVon, istHauptbereich } from "./navigation"
+import {
+  SymbolAktualisieren,
+  SymbolAudi,
+  SymbolFahrten,
+  SymbolStatistik,
+  SymbolTanken,
+  SymbolUebersicht,
+  SymbolZahnradVoll,
+  SymbolZurueck,
+} from "./symbole"
+
+export interface ShellProps {
+  route: Route
+  geheZu: (name: SeitenName, id?: string) => void
+  tabBeschriftung: boolean
+  /** Wird über der Kopfzeile eingeblendet (Offline-Hinweis, Warteschlange). */
+  hinweis?: ReactNode | undefined
+  /** Zeitpunkt des letzten Datenstands — steht als „vor 3 Std." unter dem Titel. */
+  statusStand?: string | null | undefined
+  /** Neuabfrage beim Fahrzeug, ausgelöst durch Ziehen zum Aktualisieren. */
+  beiAktualisieren?: (() => Promise<void>) | undefined
+  /** Heißt `children`, weil JSX-Verschachtelung genau diesen Namen erwartet. */
+  children: ReactNode
+}
+
+/** Ziehen zum Aktualisieren, 1:1 nach der ptr-Logik des Panels. */
+const PTR_SCHWELLE = 56
+
+/*
+ * Vom linken Rand nach rechts wischen = zurück.
+ *
+ * Warum von Hand: die App ist EINE WebView mit einer flachen Route (siehe
+ * navigation.ts), kein Verlaufsstapel. iOS' eigene Zurück-Geste hängt am
+ * Navigationsstapel eines UINavigationControllers - den gibt es hier nicht,
+ * also gibt es die Geste auch nicht geschenkt. Bis zum 02.09.2026 war der
+ * Pfeil oben links der einzige Weg zurück (gemeldet vom Eigentümer).
+ *
+ * RAND: die Geste muss am linken Rand beginnen. Das ist keine Nachahmung um
+ * ihrer selbst willen, sondern die einzige Art, sie von allem anderen
+ * Waagerechten sauber zu trennen - dem Wischen an einer Listenzeile
+ * (WischLoeschen), dem seitlichen Schieben in der Fotogalerie.
+ *
+ * SCHWELLE: erst ab dieser Strecke wird zurückgegangen. Darunter federt die
+ * Seite zurück - eine angefangene Geste ist damit widerrufbar, indem man den
+ * Finger zurückführt, genau wie bei iOS.
+ */
+/* Dieselben Zahlen wie randwischenVerdrahten() im Panel (26px Rand, 62px
+   Auslösung) - die Geste soll sich in beiden Oberflächen gleich anfühlen. */
+const ZURUECK_RAND = 26
+const ZURUECK_SCHWELLE = 62
+const ZURUECK_WEG = 140
+
+function useWischZurueck(
+  inhalt: RefObject<HTMLElement | null>,
+  zurueck: (() => void) | undefined,
+  belegt: MutableRefObject<boolean>,
+) {
+  const [zug, setzeZug] = useState<number | null>(null)
+  const start = useRef<{ x: number; y: number } | null>(null)
+
+  useEffect(() => {
+    const el = inhalt.current
+    // Der Aussteiger sitzt IM Effekt, nicht davor - sonst hinge die
+    // Hook-Reihenfolge davon ab, ob es ein Zurück-Ziel gibt.
+    if (!el || !zurueck) return undefined
+
+    const beiStart = (e: TouchEvent) => {
+      if (e.touches.length !== 1) return
+      const t = e.touches[0]!
+      if (t.clientX > ZURUECK_RAND) return
+      start.current = { x: t.clientX, y: t.clientY }
+    }
+    const beiBewegung = (e: TouchEvent) => {
+      const s = start.current
+      if (!s || e.touches.length !== 1) return
+      const t = e.touches[0]!
+      const dx = t.clientX - s.x
+      const dy = t.clientY - s.y
+      if (dx <= 0 || Math.abs(dx) < Math.abs(dy) * 1.5) {
+        // Senkrecht oder rückwärts gemeint: die Geste gehört uns nicht.
+        if (Math.abs(dy) > 10) start.current = null
+        return
+      }
+      // Solange wir ziehen, hält sich das Ziehen-zum-Aktualisieren heraus.
+      belegt.current = true
+      setzeZug(Math.min(ZURUECK_WEG, dx))
+      e.preventDefault()
+    }
+    const beiEnde = () => {
+      const gezogen = zug ?? 0
+      start.current = null
+      belegt.current = false
+      setzeZug(null)
+      if (gezogen >= ZURUECK_SCHWELLE) zurueck()
+    }
+
+    el.addEventListener("touchstart", beiStart, { passive: true })
+    el.addEventListener("touchmove", beiBewegung, { passive: false })
+    el.addEventListener("touchend", beiEnde)
+    el.addEventListener("touchcancel", beiEnde)
+    return () => {
+      el.removeEventListener("touchstart", beiStart)
+      el.removeEventListener("touchmove", beiBewegung)
+      el.removeEventListener("touchend", beiEnde)
+      el.removeEventListener("touchcancel", beiEnde)
+    }
+  })
+
+  return zug
+}
+
+function useZiehenAktualisieren(
+  inhalt: RefObject<HTMLElement | null>,
+  beiAktualisieren: (() => Promise<void>) | undefined,
+  belegt: MutableRefObject<boolean>,
+) {
+  const [zug, setzeZug] = useState(0)
+  const [laedt, setzeLaedt] = useState(false)
+  const start = useRef<number | null>(null)
+
+  const beenden = () => {
+    if (start.current === null || !beiAktualisieren) return
+    start.current = null
+    if (zug >= PTR_SCHWELLE) {
+      setzeLaedt(true)
+      void beiAktualisieren().finally(() => {
+        setzeLaedt(false)
+        setzeZug(0)
+      })
+    } else {
+      setzeZug(0)
+    }
+  }
+
+  const starten = (y: number) => {
+    if (laedt || belegt.current) return
+    if ((inhalt.current?.scrollTop ?? 0) > 0) return
+    start.current = y
+    setzeZug(0)
+  }
+  /* Gibt true zurück, wenn die Geste uns gehört — der Aufrufer muss dann
+     preventDefault() rufen. */
+  const bewegen = (y: number): boolean => {
+    if (start.current === null) return false
+    if (belegt.current) {
+      start.current = null
+      setzeZug(0)
+      return false
+    }
+    const dy = y - start.current
+    if (dy > 0 && (inhalt.current?.scrollTop ?? 0) <= 0) {
+      // Widerstand wie bei iOS: halbe Strecke, gedeckelt bei 90px.
+      setzeZug(Math.min(90, dy * 0.5))
+      return true
+    }
+    start.current = null
+    setzeZug(0)
+    return false
+  }
+
+  /* Auf dem Finger läuft die Geste über Touch-Ereignisse, nicht über Pointer.
+     Grund: preventDefault() auf einem Pointer-Ereignis verhindert laut
+     Spezifikation kein Scrollen — darüber entscheidet allein touch-action. Auf
+     einem echten Gerät übernimmt der Browser die senkrechte Geste deshalb
+     sofort, schickt pointercancel und stellt pointermove ein; der Zug wurde
+     zurückgesetzt, bevor er die Schwelle erreichte. Am Rechner fällt das nie
+     auf, eine Maus kennt keine Scroll-Übernahme. Der Listener muss von Hand
+     und mit passive:false hängen — React registriert touchmove passiv, dort
+     wäre preventDefault() wirkungslos. */
+  useEffect(() => {
+    const el = inhalt.current
+    // Der Aussteiger sitzt IM Effekt, nicht davor: ein vorgezogenes return
+    // wuerde diesen Hook je nach Bildschirmbreite mal aufrufen und mal nicht
+    // und damit die Hook-Reihenfolge brechen.
+    if (!el || !beiAktualisieren) return undefined
+    const beiStart = (e: TouchEvent) => {
+      if (e.touches.length === 1) starten(e.touches[0]!.clientY)
+    }
+    const beiBewegung = (e: TouchEvent) => {
+      if (e.touches.length !== 1) return
+      if (bewegen(e.touches[0]!.clientY)) e.preventDefault()
+    }
+    el.addEventListener("touchstart", beiStart, { passive: true })
+    el.addEventListener("touchmove", beiBewegung, { passive: false })
+    el.addEventListener("touchend", beenden)
+    el.addEventListener("touchcancel", beenden)
+    return () => {
+      el.removeEventListener("touchstart", beiStart)
+      el.removeEventListener("touchmove", beiBewegung)
+      el.removeEventListener("touchend", beenden)
+      el.removeEventListener("touchcancel", beenden)
+    }
+  })
+
+  if (!beiAktualisieren) {
+    return { zug: 0, laedt: false, handler: {} as Record<string, never> }
+  }
+
+  return {
+    zug,
+    laedt,
+    handler: {
+      // Nur Maus/Stift — der Finger läuft über die Touch-Ereignisse oben.
+      onPointerDown: (e: ReactPointerEvent) => {
+        if (!e.isPrimary || e.pointerType === "touch") return
+        starten(e.clientY)
+      },
+      onPointerMove: (e: ReactPointerEvent) => {
+        if (!e.isPrimary || e.pointerType === "touch") return
+        bewegen(e.clientY)
+      },
+      onPointerUp: beenden,
+      onPointerCancel: beenden,
+    },
+  }
+}
+
+const BEREICHE: { key: Hauptbereich; label: string; icon: ReactNode }[] = [
+  { key: "home", label: "Übersicht", icon: <SymbolUebersicht /> },
+  { key: "audi", label: "Mein Audi", icon: <SymbolAudi /> },
+  { key: "trips", label: "Fahrten", icon: <SymbolFahrten /> },
+  { key: "stat", label: "Statistik", icon: <SymbolStatistik /> },
+  { key: "fuel", label: "Tanken", icon: <SymbolTanken /> },
+]
+
+export function Shell({
+  route,
+  geheZu,
+  tabBeschriftung,
+  hinweis,
+  statusStand,
+  beiAktualisieren,
+  children,
+}: ShellProps) {
+  const breit = useBreiterBildschirm()
+  const aktiverBereich = bereichVon(route.name)
+  const zurueckZiel = ZURUECK[route.name]
+
+  const unterseite = !istHauptbereich(route.name)
+  const inhaltRef = useRef<HTMLElement | null>(null)
+  // Eine Geste zur Zeit: läuft der Wisch nach rechts, hält sich das Ziehen
+  // zum Aktualisieren heraus. Ohne das zeigte eine schräge Geste am oberen
+  // Seitenrand beides gleichzeitig.
+  const gesteBelegt = useRef(false)
+  const zurueckZug = useWischZurueck(
+    inhaltRef,
+    zurueckZiel && !breit ? () => geheZu(zurueckZiel) : undefined,
+    gesteBelegt,
+  )
+  const ptr = useZiehenAktualisieren(
+    inhaltRef,
+    breit ? undefined : beiAktualisieren,
+    gesteBelegt,
+  )
+
+  // Der Text tickt mit, wie standAlterTicken() im Panel (Sekundentakt).
+  const [, neuZeichnen] = useState(0)
+  useEffect(() => {
+    if (route.name !== "home") return undefined
+    const uhr = window.setInterval(() => neuZeichnen((n) => n + 1), 1000)
+    return () => window.clearInterval(uhr)
+  }, [route.name])
+
+  const kopf = (
+    <header className={unterseite ? "dm-kopf dm-kopf--unterseite" : "dm-kopf"}>
+      {zurueckZiel && !breit ? (
+        <button
+          type="button"
+          className="dm-kopf__zurueck"
+          aria-label="Zurück"
+          onClick={() => geheZu(zurueckZiel)}
+        >
+          <SymbolZurueck groesse={22} />
+        </button>
+      ) : null}
+      {/* Kein Eyebrow: das Panel blendet seinen (`.eyebrow{display:none}` in
+          audi-dashboard-ios.css) auf Telefonbreite vollständig aus - der feste
+          Text "DataMetric360" stand hier über jedem Bildschirm, im Panel steht
+          dort nichts. */}
+      <div className="dm-kopf__titel">
+        <div className="ads-title">{TITEL[route.name]}</div>
+        {/* Datenstand nur auf der Übersicht, wie `#sync` im Panel. */}
+        {route.name === "home" && (
+          <div className="dm-stand">
+            <SymbolAktualisieren groesse={13} />
+            <span>{standAlter(statusStand)}</span>
+          </div>
+        )}
+      </div>
+      {/* `kopf` wird nur in der schmalen Spalte gerendert (breit hat seinen
+          eigenen Seitenleisten-Kopf, siehe unten) - dort sind die Audi-Ringe
+          oben rechts der einzige Zugang zu Einstellungen, das Zahnrad
+          entfällt, "damit oben rechts nur ein Element sitzt" (Design-Audit
+          2026-08-13, siehe .rings/.profilbtn in audi-dashboard-ios.css).
+          Nur auf den Tab-Ebenen: auf Unterseiten blendet das Panel die Ringe
+          aus (`#marke`.style.display in render()), dort steht links der
+          Zurück-Pfeil. */}
+      {!unterseite ? (
+        <button
+          type="button"
+          className="dm-kopf__aktion"
+          aria-label="Einstellungen"
+          onClick={() => geheZu("einst")}
+        >
+          <VierRinge hoehe={17} />
+        </button>
+      ) : (
+        /* Gegengewicht zum Zurueck-Pfeil.
+
+           Der Titel ist auf Unterseiten mittig gesetzt - aber nur innerhalb
+           seines eigenen Kastens, und der beginnt erst hinter dem
+           Zurueck-Pfeil. Ohne ein gleich breites Element auf der rechten
+           Seite sass die Ueberschrift deshalb um dessen halbe Breite zu
+           weit rechts: live gemessen 17px Versatz auf "Standort"
+           (2026-08-31), und zwar auf jeder Unterseite, nicht nur dort.
+
+           Ein leerer Platzhalter statt einer absoluten Positionierung: so
+           behaelt ein langer Titel weiterhin seinen eigenen Platz und
+           schiebt sich nicht unter die Knoepfe. */
+        <span className="dm-kopf__gegengewicht" aria-hidden="true" />
+      )}
+    </header>
+  )
+
+  if (breit) {
+    return (
+      <>
+        <nav className="dm-seitenleiste" aria-label="Hauptbereiche">
+          <div className="dm-seitenleiste__marke">
+            <VierRinge hoehe={18} />
+            <span className="ads-eyebrow">DataMetric360</span>
+          </div>
+          {BEREICHE.map((bereich) => (
+            <button
+              key={bereich.key}
+              type="button"
+              className={
+                bereich.key === aktiverBereich
+                  ? "dm-seitenleiste__punkt dm-seitenleiste__punkt--an"
+                  : "dm-seitenleiste__punkt"
+              }
+              aria-current={bereich.key === aktiverBereich ? "page" : undefined}
+              onClick={() => geheZu(bereich.key)}
+            >
+              {bereich.icon}
+              <span>{bereich.label}</span>
+            </button>
+          ))}
+          <div className="dm-seitenleiste__fuss">
+            <button
+              type="button"
+              className={
+                route.name === "einst"
+                  ? "dm-seitenleiste__punkt dm-seitenleiste__punkt--an"
+                  : "dm-seitenleiste__punkt"
+              }
+              onClick={() => geheZu("einst")}
+            >
+              <SymbolZahnradVoll />
+              <span>Einstellungen</span>
+            </button>
+          </div>
+        </nav>
+        <div className="dm-spalte">
+          {hinweis}
+          {!istHauptbereich(route.name) && zurueckZiel ? (
+            <div className="dm-brotkrume">
+              <button type="button" onClick={() => geheZu(zurueckZiel)}>
+                <SymbolZurueck groesse={16} />
+                <span>{TITEL[zurueckZiel]}</span>
+              </button>
+            </div>
+          ) : null}
+          <main className="dm-scroll dm-inhalt dm-inhalt--breit">{children}</main>
+        </div>
+      </>
+    )
+  }
+
+  return (
+    <div className="dm-spalte">
+      {hinweis}
+      {kopf}
+      {/* Ziehen zum Aktualisieren wie im Panel (`.ptr`): das Band wächst
+          während der Geste aus der Höhe 0 heraus. */}
+      <div
+        className={ptr.laedt ? "dm-ptr dm-ptr--dreht" : "dm-ptr"}
+        style={{ height: ptr.laedt ? "56px" : `${ptr.zug}px` }}
+        aria-hidden={ptr.zug === 0 && !ptr.laedt}
+      >
+        <SymbolAktualisieren groesse={14} />
+        <span>
+          {ptr.laedt
+            ? "Aktualisieren …"
+            : ptr.zug >= 56
+              ? "Loslassen zum Aktualisieren"
+              : "Ziehen zum Aktualisieren"}
+        </span>
+      </div>
+      <main
+        className="dm-scroll dm-inhalt"
+        ref={inhaltRef}
+        {...ptr.handler}
+        /* Die Seite folgt dem Finger, damit die Geste sichtbar widerrufbar
+           bleibt: zurückführen unter die Schwelle, und sie federt zurück.
+           Ohne Zug steht hier kein transform - eine stehende Transformation
+           erzeugt einen eigenen Malkontext und hätte position:fixed im Inhalt
+           an sich gebunden. */
+        style={
+          zurueckZug === null
+            ? undefined
+            : { transform: `translateX(${zurueckZug}px)`, transition: "none" }
+        }
+      >
+        {children}
+      </main>
+      <TabBar
+        items={BEREICHE}
+        activeKey={aktiverBereich}
+        onChange={(schluessel) => geheZu(schluessel as Hauptbereich)}
+        iconOnly={!tabBeschriftung}
+        className="dm-tableiste"
+      />
+    </div>
+  )
+}

companion-app/src/api/ablageNativ.ts

@@ -0,0 +1,88 @@
+/* ================================================================
+   Sichere Ablage auf dem Gerät (iOS Keychain / Android Keystore)
+   ================================================================
+   Der Zugangstoken hat vollen Zugriff auf die Home-Assistant-Schnittstelle.
+   Im Browser bleibt nur localStorage; in der nativen Hülle gehört er in den
+   Schlüsselbund des Betriebssystems.
+
+   **Noch nicht in Betrieb**: das Plugin ist bewusst keine Abhängigkeit,
+   solange die Capacitor-Hülle nicht gebaut ist. Der Adapter greift deshalb
+   defensiv auf die Laufzeit zu, statt zu importieren — fehlt das Plugin,
+   bleibt es bei der Browser-Variante, und die App läuft trotzdem.
+
+   In Betrieb nehmen (UMSETZUNGSPLAN.md Phase 10 Stufe 2):
+     npm i @aparajita/capacitor-secure-storage
+   Danach ruft main.tsx `nativeAblageEinrichten()` auf. */
+
+import { BrowserAblage, ablageSetzen, umgebungErkennen, type Ablage } from "./umgebung.ts";
+
+/** Form des Plugins, so weit die App sie braucht. */
+interface SicherheitsPlugin {
+  get(optionen: { key: string }): Promise<{ value: string | null }>;
+  set(optionen: { key: string; value: string }): Promise<void>;
+  remove(optionen: { key: string }): Promise<void>;
+}
+
+function pluginHolen(): SicherheitsPlugin | null {
+  if (typeof window === "undefined") return null;
+  const global = window as unknown as {
+    Capacitor?: { Plugins?: Record<string, unknown> };
+  };
+  const plugin = global.Capacitor?.Plugins?.["SecureStorage"];
+  if (!plugin) return null;
+  const kandidat = plugin as Partial<SicherheitsPlugin>;
+  return typeof kandidat.get === "function" &&
+    typeof kandidat.set === "function" &&
+    typeof kandidat.remove === "function"
+    ? (plugin as SicherheitsPlugin)
+    : null;
+}
+
+export class NativeAblage implements Ablage {
+  readonly #plugin: SicherheitsPlugin;
+  /* Fällt einzeln auf den Browser zurück, wenn ein Aufruf scheitert - besser
+     eine Sitzung ohne Schlüsselbund als eine App, die nicht startet. */
+  readonly #ersatz = new BrowserAblage();
+
+  constructor(plugin: SicherheitsPlugin) {
+    this.#plugin = plugin;
+  }
+
+  async lesen(schluessel: string): Promise<string | null> {
+    try {
+      const { value } = await this.#plugin.get({ key: schluessel });
+      return value ?? null;
+    } catch {
+      return this.#ersatz.lesen(schluessel);
+    }
+  }
+
+  async schreiben(schluessel: string, wert: string): Promise<void> {
+    try {
+      await this.#plugin.set({ key: schluessel, value: wert });
+    } catch {
+      await this.#ersatz.schreiben(schluessel, wert);
+    }
+  }
+
+  async loeschen(schluessel: string): Promise<void> {
+    try {
+      await this.#plugin.remove({ key: schluessel });
+    } catch {
+      await this.#ersatz.loeschen(schluessel);
+    }
+  }
+}
+
+/**
+ * Schaltet auf die sichere Ablage um, sofern die App nativ läuft und das
+ * Plugin vorhanden ist. Gibt zurück, ob umgeschaltet wurde — praktisch für
+ * eine Anzeige in den Einstellungen.
+ */
+export function nativeAblageEinrichten(): boolean {
+  if (umgebungErkennen() !== "capacitor") return false;
+  const plugin = pluginHolen();
+  if (!plugin) return false;
+  ablageSetzen(new NativeAblage(plugin));
+  return true;
+}

companion-app/src/api/index.ts

@@ -11,13 +11,69 @@ export * from "./umgebung.ts";
 export * from "./rest.ts";
 export * from "./live.ts";
 export * from "./warteschlange.ts";
+export * from "./ablageNativ.ts";
 
-import { ENTITAETEN } from "./types.ts";
-import type { Fahrt, Fahrzeugstatus, Profil, Tankvorgang } from "./types.ts";
+import { DIENST_DOMAIN, ENTITAETEN } from "./types.ts";
+import type {
+  AppVersionAngabe,
+  CsvImportErgebnis,
+  Fahrt,
+  Fahrzeugstatus,
+  ImportErgebnis,
+  Profil,
+  Tankvorgang,
+} from "./types.ts";
 import { HassRest } from "./rest.ts";
 import { HassLive } from "./live.ts";
 import { Warteschlange } from "./warteschlange.ts";
 
+/** Eingabefelder für Tankvorgänge. Die Namen sind die des Backends
+    (belegverarbeitung.py), nicht die des Datensatzes - deshalb "liter" statt
+    "liters" und "kosten" statt "fuel_total_eur". */
+export interface TankvorgangFelder {
+  ts?: string;
+  liter?: number | null;
+  kosten?: number | null;
+  km?: number | null;
+  ersparnis?: number | null;
+  station?: string | null;
+  distanz?: number | null;
+  kraftstoff?: string | null;
+  /** Aus einem vorab gelesenen Beleg (Upload ohne tank_id) - so übergibt sie
+      auch das Panel beim Speichern eines neuen Tankvorgangs mit Beleg. */
+  receipt_key?: string | null;
+  receipt_file?: string | null;
+}
+
+/** Eingabefelder für Fahrten - Namen wie beim Backend (fahrterkennung.py:
+    fahrt_manuell_anlegen/fahrt_aktualisieren).
+    Alles außer den Zeitpunkten ist optional: leer bleibt es liegen, bis das
+    Kilometerstand-Screening (§7.2) oder eine spätere Bearbeitung es füllt. */
+/** Eingabefelder für einen archivierten Reifensatz - Namen wie beim Backend
+    (reifen.py: reifen_archiv_aktualisieren). */
+export interface ReifenArchivFelder {
+  ersetzt_am?: string;
+  km?: number | null;
+  marke?: string | null;
+  modell?: string | null;
+  dot?: string | null;
+  mass?: string | null;
+  druck_vorne?: string | null;
+  druck_hinten?: string | null;
+  kommentar?: string | null;
+}
+
+export interface FahrtFelder {
+  ts_start?: string;
+  ts_end?: string;
+  art?: "privat" | "arbeitsweg";
+  start_ort?: string | null;
+  ziel_ort?: string | null;
+  odo_start?: number | null;
+  odo_end?: number | null;
+  distanz?: number | null;
+}
+
 /** Bündelt die drei Bausteine und bildet die Fachvorgänge ab, die das alte
     Dashboard über hass.callService erledigt hat. */
 export class DataMetricApi {
@@ -62,8 +118,8 @@ export class DataMetricApi {
 
   profilSchreiben(profil: Profil): Promise<unknown> {
     return this.warteschlange.einreihen(
-      "pyscript",
-      "audi_dashboard_profil_schreiben",
+      DIENST_DOMAIN,
+      "profil_schreiben",
       { profil_json: JSON.stringify(profil) },
       "Fahrzeugdaten speichern",
     );
@@ -71,33 +127,271 @@ export class DataMetricApi {
 
   belegHochladen(pdfBase64: string, dateiname: string, tankId?: string): Promise<unknown> {
     return this.warteschlange.einreihen(
-      "pyscript",
-      "audi_dashboard_beleg_hochladen",
+      DIENST_DOMAIN,
+      "beleg_hochladen",
       { pdf_base64: pdfBase64, dateiname, ...(tankId ? { tank_id: tankId } : {}) },
       `Beleg „${dateiname}" hochladen`,
     );
   }
 
+  /**
+   * Fahrzeugfoto hochladen bzw. ersetzen. Dieselben Dienste, die das Panel
+   * über `data-bildupload` anspricht (`bild_hochladen`/`bild_loeschen` in
+   * services.yaml). Die App konnte Fotos bisher gar nicht ändern — sie
+   * verwies stattdessen auf die Verwaltung in Home Assistant.
+   */
+  bildHochladen(dateiname: string, datenBase64: string): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "bild_hochladen",
+      { dateiname, daten_base64: datenBase64 },
+      `Foto „${dateiname}" hochladen`,
+    )
+  }
+
+  bildLoeschen(dateiname: string): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "bild_loeschen",
+      { dateiname },
+      `Foto „${dateiname}" löschen`,
+    )
+  }
+
+  /** Legt eine Fahrt von Hand an — für Fahrten ohne automatische Erkennung. */
+  fahrtAnlegen(felder: FahrtFelder): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "fahrt_manuell_anlegen",
+      { ...felder },
+      "Fahrt eintragen",
+    );
+  }
+
+  /** Bearbeitet eine bestehende Fahrt, gleich ob automatisch erkannt oder von
+      Hand angelegt. */
+  fahrtAktualisieren(tripId: string, felder: FahrtFelder): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "fahrt_aktualisieren",
+      { trip_id: tripId, ...felder },
+      "Fahrt ändern",
+    );
+  }
+
   fahrtLoeschen(tripId: string): Promise<unknown> {
     return this.warteschlange.einreihen(
-      "pyscript",
-      "audi_dashboard_fahrt_loeschen",
+      DIENST_DOMAIN,
+      "fahrt_loeschen",
       { trip_id: tripId },
       "Fahrt löschen",
     );
   }
 
+  /** Felder eines Tankvorgangs, wie sie das Backend erwartet (deutsche
+      Parameternamen — belegverarbeitung.py). */
+  tankvorgangAnlegen(felder: TankvorgangFelder): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "tankvorgang_manuell",
+      { ...felder },
+      "Tankvorgang eintragen",
+    );
+  }
+
+  tankvorgangAktualisieren(tankId: string, felder: TankvorgangFelder): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "tankvorgang_aktualisieren",
+      { tank_id: tankId, ...felder },
+      "Tankvorgang ändern",
+    );
+  }
+
   tankvorgangLoeschen(tankId: string): Promise<unknown> {
     return this.warteschlange.einreihen(
-      "pyscript",
-      "audi_dashboard_tankvorgang_loeschen",
+      DIENST_DOMAIN,
+      "tankvorgang_loeschen",
       { tank_id: tankId },
       "Tankvorgang löschen",
     );
   }
 
+  /** Löscht einen Tageseintrag aus der Batteriespannungs-Messwertliste. */
+  batterieverlaufEintragLoeschen(datum: string): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "batterieverlauf_loeschen",
+      { datum },
+      "Messwert löschen",
+    );
+  }
+
+  /** "Neue Räder anlegen": archiviert den aktuellen Stand von `satz` und legt
+      einen frischen (km 0) an. */
+  reifenArchivieren(satz: "sommer" | "winter"): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "reifen_archivieren",
+      { satz },
+      "Neue Räder anlegen",
+    );
+  }
+
+  /** Korrigiert nur den Kilometerzähler von `satz` - bewusst kein
+      profilSpeichern() (siehe reifenzaehler.py): ein eigener Dienst, der
+      referenz_odo_km unangetastet lässt, damit die nächste automatische
+      Fortschreibung ab dem neuen Stand weiterzählt statt ihn zu
+      überschreiben. Deckungsgleich mit data-kmspeichern im Panel. */
+  reifenKmSetzen(satz: "sommer" | "winter", km: number): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "reifen_km_setzen",
+      { satz, km },
+      "Kilometerstand korrigieren",
+    );
+  }
+
+  reifenArchivAktualisieren(id: string, felder: ReifenArchivFelder): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "reifen_archiv_aktualisieren",
+      { id, ...felder },
+      "Archivierten Reifensatz ändern",
+    );
+  }
+
+  reifenArchivLoeschen(id: string): Promise<unknown> {
+    return this.warteschlange.einreihen(
+      DIENST_DOMAIN,
+      "reifen_archiv_loeschen",
+      { id },
+      "Archivierten Reifensatz löschen",
+    );
+  }
+
   /** Stößt eine sofortige Aktualisierung im Backend an (Pull-to-refresh). */
   jetztAktualisieren(): Promise<unknown> {
-    return this.rest.dienstAufrufen("pyscript", "audi_dashboard_jetzt_aktualisieren");
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "jetzt_aktualisieren");
+  }
+
+  /** Nutzlast von sensor.audi_dashboard_app_version: welchen Stand das
+      Backend ausliefert (`app`, siehe VERSIONIERUNG.md) und ob ein
+      OTA-Bündel bereitliegt (`buendel`, siehe daten/ota.ts). Beides kommt
+      aus derselben Entität und wird deshalb in einem Aufruf gelesen statt in
+      zweien. `null` bei jedem Fehler — fehlende Entität (älteres Backend),
+      Netzproblem, was auch immer; dann wird nichts verglichen und nichts
+      gemeldet, statt einen Fehlalarm auszulösen. */
+  async appVersionAngabeLesen(): Promise<AppVersionAngabe | null> {
+    try {
+      const zustand = await this.rest.zustandLesen<{ daten?: AppVersionAngabe }>(
+        ENTITAETEN.appVersion,
+      );
+      return zustand.attributes?.daten ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /* ------------------------------------------------- Selbst-Update der
+     Integration (aktualisierung.py) - Ersatz für install.ps1, das Windows
+     Smart App Control blockiert. Bewusst NICHT über die Warteschlange, wie
+     historieImportieren() oben: beides sind ausdrückliche, sofortige
+     Aktionen, kein Zustand, den man im Funkloch absetzt und später
+     nachgeholt haben will. Ergebnis kommt über
+     appVersionAngabeLesen()/daten.integration_update zurück, nicht über den
+     Rückgabewert dieser Aufrufe. */
+
+  /** Fragt nur nach, ob eine neuere Fassung vorliegt - lädt nichts herunter. */
+  updatePruefen(): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "update_pruefen");
+  }
+
+  /** Lädt die neueste Fassung und ersetzt den Integrationsordner. Home
+      Assistant muss danach neu gestartet werden. */
+  updateInstallieren(): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "update_installieren");
+  }
+
+  /** Startet Home Assistant komplett neu - der letzte Schritt nach
+      updateInstallieren(), damit die neue Fassung tatsächlich geladen wird
+      (ein reiner Reload reicht dafür nicht, siehe AGENTS.md Abschnitt J).
+      Kein audi_dashboard-Dienst, deshalb der Bereich "homeassistant" statt
+      DIENST_DOMAIN. */
+  homeAssistantNeuStarten(): Promise<unknown> {
+    return this.rest.dienstAufrufen("homeassistant", "restart");
+  }
+
+  /* ------------------------------------------- Import aus dem HA-Verlauf
+     Bewusst NICHT über die Warteschlange, anders als die übrigen
+     schreibenden Vorgänge: der Import ist keine Eingabe, die man im Funkloch
+     absetzt und später ausgeführt haben will. Er dauert lange, sein Ergebnis
+     ist der eigentliche Zweck des Aufrufs, und ein nachträglich aus der
+     Warteschlange abgefeuerter Lauf käme für den Nutzer aus dem Nichts.
+     Ohne Netz gehört er schlicht nicht angeboten. */
+
+  /** Startet den Import. Kehrt zurück, sobald das Backend den Auftrag
+      angenommen hat — nicht, wenn er fertig ist; dafür importStatusLesen(). */
+  /** Beendet die laufende Fahrt sofort, mit vorlaeufigem Ende.
+
+     Wie historieImportieren() bewusst NICHT ueber die Warteschlange: im
+     Funkloch abgesetzt und Stunden spaeter nachgeholt wuerde sie eine Fahrt
+     schliessen, die laengst regulaer zu Ende ist. */
+  fahrtJetztBeenden(): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "fahrt_jetzt_beenden", {});
+  }
+
+  /** Traegt einen Dienste-Token ein oder loescht ihn (leerer Text = loeschen).
+
+     Nicht ueber die Warteschlange: ein Token, der Stunden spaeter aus dem
+     Funkloch nachgereicht wird, ueberschriebe womoeglich einen inzwischen
+     eingetragenen neuen. Und der Wert kommt nie zurueck - was gesetzt ist,
+     steht in daten.zugaenge, der Token selbst nirgends. */
+  zugangSetzen(dienst: string, token: string): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "zugang_setzen", { dienst, token });
+  }
+
+  /** Liest die Konfiguration des Dongles - und schreibt dabei eine vorgemerkte
+     Aenderung, falls eine offen ist (siehe flespi.py).
+
+     Wie zugangSetzen bewusst NICHT ueber die Warteschlange: der Abruf gelingt
+     nur bei laufender Zuendung, und Stunden spaeter aus dem Funkloch nachgeholt
+     traefe er das Geraet garantiert im Schlaf an. */
+  dongleLesen(): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "dongle_lesen", {});
+  }
+
+  historieImportieren(start: string, ende: string): Promise<unknown> {
+    return this.rest.dienstAufrufen(DIENST_DOMAIN, "historie_importieren", {
+      start,
+      ende,
+    });
+  }
+
+  /** Stand des laufenden bzw. letzten Imports: "laeuft" | "fertig" |
+      "fehler", plus Zählwerte im Attribut "daten". */
+  async importStatusLesen(): Promise<{ zustand: string; daten: ImportErgebnis }> {
+    const zustand = await this.rest.zustandLesen<{ daten: ImportErgebnis }>(
+      ENTITAETEN.importStatus,
+    );
+    return { zustand: zustand.state, daten: zustand.attributes?.daten ?? {} };
+  }
+
+  /* --------------------------------------------------- CSV-Import
+     Wie historieImportieren() bewusst NICHT über die Warteschlange: eine
+     bewusste, einmalige Aktion, deren Ergebnis der eigentliche Zweck des
+     Aufrufs ist, kein Formularfeld, das man auch offline abschicken würde.
+     Anders als dort aber synchron im Backend (csv_import.py) - der
+     Dienstaufruf kehrt erst zurück, wenn sensor.audi_dashboard_import_status
+     den neuen Stand schon trägt, keine Wartezeit nötig. */
+  async csvImportieren(
+    art: "fahrten" | "tanken" | "service",
+    inhalt: string,
+  ): Promise<CsvImportErgebnis> {
+    await this.rest.dienstAufrufen(DIENST_DOMAIN, "csv_importieren", { art, inhalt });
+    const zustand = await this.rest.zustandLesen<{ daten: CsvImportErgebnis }>(
+      ENTITAETEN.importStatus,
+    );
+    return { art, ...(zustand.attributes?.daten ?? {}) };
   }
 }

companion-app/src/api/rest.ts

@@ -5,20 +5,24 @@
    hass-Objekt geleistet hat (SPECIFICATION.md §3 "Data flow"):
      hass.states[id].attributes.daten   ->  zustandLesen()/datenLesen()
      hass.callService(...)              ->  dienstAufrufen()
-   Dieselben Entitäten, dieselben pyscript-Dienste - nur über HTTP statt über
-   ein Objekt, das nur innerhalb des HA-Frontends existiert. */
+   Dieselben Entitäten, dieselben Dienste der Integration - nur über HTTP statt
+   über ein Objekt, das nur innerhalb des HA-Frontends existiert. */
 
 import type { DatenEntity, HassState } from "./types.ts";
 import { zugangLesen, type Zugang } from "./umgebung.ts";
 
 export class ApiFehler extends Error {
-  constructor(
-    message: string,
-    readonly status: number | null,
-    readonly ursache?: unknown,
-  ) {
+  /* Eigene Felder statt Parameter-Eigenschaften: Node kann letztere im
+     Strip-Modus (--experimental-strip-types) nicht übersetzen, und darüber
+     laufen die Rauchtests dieses Pakets. */
+  readonly status: number | null;
+  readonly ursache: unknown;
+
+  constructor(message: string, status: number | null, ursache?: unknown) {
     super(message);
     this.name = "ApiFehler";
+    this.status = status;
+    this.ursache = ursache;
   }
 
   /** Fehlt oder taugt das Token nicht mehr - dann muss die Oberfläche zurück
@@ -32,6 +36,20 @@ export class ApiFehler extends Error {
   get istNetzproblem(): boolean {
     return this.status === null;
   }
+
+  /** Vorübergehend nicht erreichbar: kein Netz, oder ein Server, der
+      gerade hochfährt.
+
+      502/503/504 sind genau das, was ein Neustart von Home Assistant
+      liefert - der Vorschaltserver antwortet schon, Home Assistant selbst
+      noch nicht. Das ist für die Oberfläche dasselbe wie kein Netz: warten
+      und den zwischengespeicherten Stand zeigen, nicht eine Fehlerzeile
+      stehen lassen, die niemand mehr wegbekommt. 500 gehört bewusst NICHT
+      dazu - das ist ein echter Fehler in der Anfrage, der sich durch
+      Warten nicht bessert. */
+  get istVoruebergehend(): boolean {
+    return this.istNetzproblem || this.status === 502 || this.status === 503 || this.status === 504;
+  }
 }
 
 export interface AnfrageOptionen {
@@ -120,8 +138,8 @@ export class HassRest {
     return (zustand as DatenEntity<T>).attributes.daten;
   }
 
-  /** Ruft einen Dienst auf, z. B. dienstAufrufen("pyscript",
-      "audi_dashboard_profil_schreiben", { profil_json }). */
+  /** Ruft einen Dienst auf, z. B. dienstAufrufen("audi_dashboard",
+      "profil_schreiben", { profil_json }). */
   async dienstAufrufen(
     bereich: string,
     dienst: string,

companion-app/src/api/types.ts

@@ -4,10 +4,10 @@
    Die Fachtypen (Fahrt, Tankvorgang, ...) sind aus SPECIFICATION.md §5
    "Data files" abgeleitet - also aus dem, was das Backend tatsächlich in
    fahrten.jsonl / tankvorgaenge.jsonl schreibt, nicht aus Wunschdenken.
-   Felder, die laut §7 im Schema stehen, aber von keinem Codepfad je gefüllt
-   werden (start_lat, avg_speed_kmh, route, ...), sind hier bewusst als
-   optional markiert - sie können null/undefined sein und die Oberfläche darf
-   sich nie darauf verlassen. */
+   Mehrere Felder (start_lat/-lon, end_lat/-lon, route, avg_speed_kmh) sind
+   nur befüllt, wenn ein GPS-Sensor zugeordnet ist (screening.py/
+   historienimport.py) - ohne Zuordnung bleiben sie null. Deshalb hier bewusst
+   optional markiert; die Oberfläche darf sich nie auf ihre Existenz verlassen. */
 
 /** Roher Zustand einer HA-Entität, wie ihn /api/states liefert. */
 export interface HassState<A = Record<string, unknown>> {
@@ -19,7 +19,7 @@ export interface HassState<A = Record<string, unknown>> {
   context?: { id: string; parent_id: string | null; user_id: string | null };
 }
 
-/** Die pyscript.*-Entitäten transportieren ihre Nutzlast im Attribut "daten". */
+/** Die Entitäten der Integration transportieren ihre Nutzlast im Attribut "daten". */
 export interface DatenAttribute<T> {
   daten: T;
   [weitere: string]: unknown;
@@ -40,7 +40,10 @@ export interface Fahrt {
   duration_s: number;
   distance_km: number | null;
   /** "odometer" ist der einzige Wert, den das Backend je erzeugt (§7.1). */
-  km_quelle: "odometer" | "gps" | null;
+  /* "odometer+gnss": der Kilometerstand des Fahrzeugs als Anker, die
+     Nachkommastelle vom GNSS-Zaehler des Geraets - siehe screening.py.
+     "sensor"/"manuell" kommen aus dem Rueckblick bzw. von Hand. */
+  km_quelle: "odometer" | "odometer+gnss" | "gps" | "sensor" | "manuell" | null;
   odo_start: number | null;
   odo_end: number | null;
   art: Fahrtart;
@@ -49,13 +52,29 @@ export interface Fahrt {
   edited_fields?: string[];
   /* Ab FMM003 erstmals real befüllbar - bis dahin durchgehend null (§7.2). */
   avg_speed_kmh?: number | null;
+  vmax_kmh?: number | null;
   start_lat?: number | null;
   start_lon?: number | null;
   end_lat?: number | null;
   end_lon?: number | null;
   start_address?: string | null;
   end_address?: string | null;
-  route?: unknown | null;
+  /* Nur der Ortsname, vom Backend aufgeloest (geokodierung.py). Die Liste
+     hat je Fahrt eine Zeile - zwei volle Anschriften passen dort nicht. */
+  start_stadt?: string | null;
+  end_stadt?: string | null;
+  route?: [number, number][] | null;
+  /** Näherung aus der Literstand-Differenz (TANK_LITER_SENSOR) ÷ Distanz, kein
+   * vom Fahrzeug selbst für diese eine Fahrt gemeldeter Wert - siehe
+   * verbrauch_aus_literstaenden() im Backend. */
+  verbrauch_l_100km?: number | null;
+  /** Das Ende steht nur vorlaeufig fest (Knopf "Fahrt beenden", das Geraet
+      hat sein Zuendungs-Aus noch nicht gemeldet). */
+  ende_vorlaeufig?: boolean;
+  /** Kilometer am Anfang der Fahrt, die das Geraet verschlafen hat. */
+  luecke_km?: number | null;
+  /** Die Zuordnung dieser Luecke ist unsicher - siehe screening.py. */
+  luecke_unsicher?: boolean;
   pausen?: unknown[];
 }
 
@@ -70,6 +89,9 @@ export interface Tankvorgang {
   /** Immer aus fuel_total_eur/liters berechnet, nie aus dem Beleg gelesen. */
   price_per_l: number | null;
   station_name?: string | null;
+  /** Kopfmarke des Belegs (shell_beleg_parser). Fehlt bei Vorgaengen ohne
+      Beleg und bei Belegen, deren Datei nicht mehr liegt. */
+  station_brand?: string | null;
   station_id?: string | null;
   station_address?: string | null;
   fuel_type?: string | null;
@@ -88,18 +110,43 @@ export interface Tankvorgang {
   edited_fields?: string[];
 }
 
-/** Einzelprüfung aus _sicherheitscheck: ok===null heißt "Sensor unbekannt". */
+/** Einzelprüfung aus _sicherheitscheck: ok===null heißt "Sensor unbekannt".
+    "gruppe" fasst mehrere Punkte zu einer Sammelzeile zusammen (verriegelt /
+    tueren_klappen / fenster_dach / licht), siehe Fahrzeugstatus.tsx. */
 export interface SicherheitsPunkt {
   label: string;
   ok: boolean | null;
+  gruppe: "verriegelt" | "tueren_klappen" | "fenster_dach" | "licht";
 }
 
+/** Feldnamen an der laufenden Instanz abgelesen, nicht aus der Spezifikation
+    abgeleitet: veroeffentlichung.py schreibt "tankprozent",
+    "gesichert" und "sicherheitscheck" — ein früherer Entwurf dieser Datei
+    hatte "tank_prozent"/"sicher_abgestellt"/"sicherheit" angenommen, womit
+    die Oberfläche still überall undefined gelesen hätte. */
 export interface Fahrzeugstatus {
   km?: number | null;
-  tank_prozent?: number | null;
+  tankprozent?: number | null;
   reichweite_km?: number | null;
-  sicher_abgestellt?: boolean | null;
-  sicherheit?: SicherheitsPunkt[];
+  batteriespannung?: number | null;
+  gesichert?: boolean | null;
+  sicherheitscheck?: SicherheitsPunkt[];
+  /** Diagnosecodes im Fehlerspeicher. Getrennt vom Sicherheitscheck, weil ein
+      Eintrag nichts darueber sagt, ob der Wagen verschlossen dasteht. */
+  fehlerspeicher?: { anzahl: number | null; ok: boolean | null } | null;
+  /** Zustand des Zündungssensors — ausdrücklich nicht „fährt": es gibt keinen
+      Bewegungssensor, und die Zündung meldet an auch bei Zubehörstellung oder
+      im Stand. `null`/fehlend heißt „kein Zündungssensor zugeordnet", also
+      unbekannt — ebenfalls nicht „steht". */
+  zuendung?: boolean | null;
+  standort_lat?: number | null;
+  standort_lon?: number | null;
+  standort_genauigkeit_m?: number | null;
+  standort_zeit?: string | null;
+  oelwechsel_faellig_ts?: string | null;
+  oelwechsel_faellig_km?: number | null;
+  inspektion_faellig_ts?: string | null;
+  inspektion_faellig_km?: number | null;
   [weitere: string]: unknown;
 }
 
@@ -113,24 +160,204 @@ export interface Profil {
   steuer?: Record<string, unknown>;
   reifen?: Record<string, unknown>;
   service?: Record<string, unknown>;
-  technik?: Record<string, unknown>;
-  ausstattung?: Record<string, unknown>;
+  /* Beide sind Listen von Gruppen, keine Objekte - an der echten
+     fahrzeugprofil.json abgelesen. Ein früherer Entwurf hatte sie wie die
+     übrigen Abschnitte als Record deklariert. */
+  technik?: unknown[];
+  ausstattung?: unknown[];
   [weitere: string]: unknown;
 }
 
+/** Ergebnis eines Historien-Imports (custom_components/audi_dashboard/historienimport.py). Die
+    Zählwerte fehlen, solange der Lauf noch nicht fertig ist; `meldung` steht
+    nur im Fehlerfall. */
+export interface ImportErgebnis {
+  von?: string;
+  bis?: string;
+  /** Frühester Zeitpunkt mit Aufzeichnung im gewählten Fenster — erklärt ein
+      leeres Ergebnis („weiter zurück bewahrt HA nichts mehr auf"). */
+  ab_wann_daten?: string | null;
+  fahrten_angelegt?: number;
+  fahrten_uebersprungen?: number;
+  fahrten_zu_kurz?: number;
+  fahrten_nicht_gefahren?: number;
+  tankvorgaenge_angelegt?: number;
+  tankvorgaenge_uebersprungen?: number;
+  batterie_tage?: number;
+  meldung?: string;
+}
+
+/** Ergebnis eines CSV-Imports (custom_components/audi_dashboard/csv_import.py) -
+    dieselbe Entität wie ImportErgebnis (sensor.audi_dashboard_import_status),
+    aber eine andere Kennzahlform: Zeilenabgleich statt Fahrten/Tankvorgänge/
+    Batterie getrennt. */
+export interface CsvImportErgebnis {
+  art?: string;
+  angelegt?: number;
+  aktualisiert?: number;
+  uebersprungen?: number;
+}
+
+/** Das OTA-Bündel, das die Integration mit ausliefert (siehe
+    custom_components/audi_dashboard/koordinator.py `_buendel_lesen()` und
+    companion-app/scripts/ota-paket.ps1). `null`, solange keine
+    bundle.json neben der Integration liegt — ein völlig normaler Zustand,
+    kein Fehler: wer nur das Panel nutzt, braucht kein App-Bündel. */
+export interface Buendelangabe {
+  version: string;
+  sha256: string;
+  bytes: number;
+  gebaut: string;
+  /** Pfad relativ zur Home-Assistant-Basis-URL, z. B.
+      "/audi_dashboard_static/app/bundle.zip". Von der Integration
+      angehängt, steht nicht in bundle.json selbst. */
+  url: string;
+}
+
+/** Ergebnis der letzten "Auf Update prüfen"/"Update installieren"-Aktion
+    (custom_components/audi_dashboard/aktualisierung.py, dienste.py). `null`,
+    solange noch nie geprüft wurde - ein normaler Zustand, kein Fehler.
+    Ersetzt install.ps1 als Update-Weg, weil Windows Smart App Control es
+    zuverlässig blockiert. */
+export interface IntegrationUpdateAngabe {
+  verfuegbar: boolean;
+  version: string | null;
+  geprueft_am: string;
+  /** true unmittelbar nach einer erfolgreichen Installation. */
+  installiert: boolean;
+  /** Ob nach der Installation wirklich ein Home-Assistant-Neustart nötig ist.
+
+      Der Updater entscheidet das am Datei-Vergleich: betrifft das Update nur
+      `frontend/`, reicht ein Neuladen der Seite - die Oberflächendateien
+      werden direkt von der Platte ausgeliefert. Nur geänderter Python-Code
+      braucht einen Neustart, weil Home Assistant seine Module einmal beim
+      Start importiert.
+
+      Fehlt das Feld (ältere Integration), gilt "Neustart nötig". */
+  neustart_noetig?: boolean;
+  fehler: string | null;
+}
+
+/** Ein Dienste-Token dieser Installation (zugaenge.py).
+
+    Der Token selbst ist hier BEWUSST nicht enthalten und kommt auch nie ueber
+    die Leitung: gezeigt wird nur, ob einer gesetzt ist, und seine letzten vier
+    Zeichen zum Wiedererkennen. */
+export interface ZugangAngabe {
+  dienst: string;
+  titel: string;
+  zweck: string;
+  /** Laeuft die App ohne diesen Token gar nicht? Beide heutigen tun es. */
+  erforderlich: boolean;
+  gesetzt: boolean;
+  rest: string | null;
+}
+
+/** Was am Dongle steht und was noch aussteht (flespi.py).
+
+    `aktiv` ist false, solange kein flespi-Token hinterlegt ist - dann gibt es
+    nichts zu zeigen. `stand` traegt seinen eigenen Zeitstempel: eine Angabe von
+    gestern soll nicht wie eine frische aussehen. Was noch zum Geraet unterwegs
+    ist, steht je Wert in `offen` - flespi haelt es vor, wir nicht. */
+export interface DongleWert {
+  schluessel: string;
+  /** Die Nummer im flespi-Configurator - danach sucht man dort. */
+  nummer: string;
+  titel: string;
+  einheit: string;
+  geraet: unknown;
+  /** Was noch zum Gerät unterwegs ist (flespis `pending`) - null, wenn nichts
+      aussteht. */
+  offen: unknown;
+  /** Unser eigener Wert, sofern es einen zu vergleichen gibt. */
+  unser: number | null;
+  /** Dreiwertig: true weicht ab, false stimmt überein, **null kein
+      Urteil** — der Wert wurde nie vom Gerät bestätigt, oder es ist
+      gerade eine Änderung zu ihm unterwegs. Bis zum 04.09.2026 war das
+      ein Bool, und `false` behauptete Übereinstimmung auch gegen einen
+      tagealten Wert. */
+  abweichung: boolean | null;
+  /** Wann das Gerät diesen Wert zuletzt bestätigt hat (flespis
+      `updated`) — null heißt: nie. */
+  gemeldet_am?: string | null;
+}
+
+export interface DongleStand {
+  geraet?: number;
+  gelesen_am: string;
+  anzahl?: number;
+  werte?: DongleWert[];
+  abweichungen?: number;
+  /** Zeilen ohne Urteil: nie bestätigt oder gerade unterwegs. */
+  unbekannt?: number;
+  /** Welche Zwischenspeicher dieser Abruf geleert hat. */
+  geleert?: string[];
+  /** Wie viele der gezeigten Werte noch zum Gerät unterwegs sind. */
+  offen?: number;
+  fehler: string | null;
+}
+
+export interface DongleAngabe {
+  aktiv: boolean;
+  stand: DongleStand | null;
+}
+
+/** Ein einzelner Wert aus der letzten Meldung des Dongles (geraet.py). */
+export interface DatensatzWert {
+  name: string;
+  wert: string;
+  einheit: string | null;
+}
+
+/** Die letzte Meldung des Dongles, so wie sie in Home Assistant ankam.
+    "angekommen" ist die Ankunftszeit, "meldezeit" die Zeit des Geraets -
+    der Abstand zwischen beiden ist der Puffer-Rueckstand. */
+export interface LetzterDatensatz {
+  geraet: string;
+  angekommen: string;
+  meldezeit: string | null;
+  werte: DatensatzWert[];
+  gesamt: number;
+}
+
+/** Nutzlast von sensor.audi_dashboard_app_version. */
+export interface AppVersionAngabe {
+  app: string | null;
+  buendel: Buendelangabe | null;
+  integration_update: IntegrationUpdateAngabe | null;
+  zugaenge?: ZugangAngabe[];
+  dongle?: DongleAngabe;
+  letzter_datensatz?: LetzterDatensatz | null;
+  /** Zeitstempel je vorhandenem Fahrzeugfoto - siehe bilder.staende(). */
+  bildstaende?: Record<string, number> | null;
+}
+
 /* -------------------------------------------------- Entitäts-Verzeichnis */
 
-/** Alle vom Backend veröffentlichten pyscript-Entitäten an einer Stelle.
+/** Alle vom Backend veröffentlichten Entitäten an einer Stelle.
     Kein Hardcoding über die App verstreut: wer eine Entität umbenennt,
-    ändert genau diese Tabelle. */
+    ändert genau diese Tabelle.
+
+    Die Namen sind ein Vertrag mit custom_components/audi_dashboard/const.py;
+    das HA-Panel führt dieselbe Tabelle in audi-dashboard-app.js. Bis
+    2026-08-23 hießen sie pyscript.audi_dashboard_*, weil pyscript sie
+    bereitstellte und die Domain besaß. Seit dem Umbau zur eigenen Integration
+    sind es echte Entitäten dieser Integration. */
 export const ENTITAETEN = {
-  profil: "pyscript.audi_dashboard_profil",
-  fahrten: "pyscript.audi_dashboard_fahrten",
-  tankvorgaenge: "pyscript.audi_dashboard_tankvorgaenge",
-  fahrzeugstatus: "pyscript.audi_dashboard_fahrzeugstatus",
-  batterieverlauf: "pyscript.audi_dashboard_batterieverlauf",
-  belegErgebnis: "pyscript.audi_dashboard_beleg_ergebnis",
-  updateStatus: "pyscript.audi_dashboard_update_status",
+  profil: "sensor.audi_dashboard_profil",
+  fahrten: "sensor.audi_dashboard_fahrten",
+  tankvorgaenge: "sensor.audi_dashboard_tankvorgaenge",
+  fahrzeugstatus: "sensor.audi_dashboard_fahrzeugstatus",
+  batterieverlauf: "sensor.audi_dashboard_batterieverlauf",
+  belegErgebnis: "sensor.audi_dashboard_beleg_ergebnis",
+  importStatus: "sensor.audi_dashboard_import_status",
+  appVersion: "sensor.audi_dashboard_app_version",
 } as const;
 
 export type EntitaetsSchluessel = keyof typeof ENTITAETEN;
+
+/** Die Domain, unter der das Backend seine Dienste anbietet:
+    `audi_dashboard.<name>`. Früher `pyscript.audi_dashboard_<name>` - der
+    doppelte Präfix war nur nötig, weil sich alle pyscript-Dienste eine Domain
+    teilten. Siehe custom_components/audi_dashboard/dienste.py. */
+export const DIENST_DOMAIN = "audi_dashboard";

companion-app/src/api/umgebung.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Das Schema der Server-Adresse.
+ *
+ * Anlass: beim Neuverbinden stand „localhost:5173" im Feld — die App machte
+ * daraus `https://localhost:5173` und meldete „Der Server ist unter dieser
+ * Adresse nicht erreichbar". Das Beispiel im Feld selbst
+ * (`192.168.1.20:8123`) hatte dasselbe Problem: im Heimnetz gibt es kein
+ * Zertifikat, Home Assistant spricht dort `http`.
+ */
+
+import { describe, expect, it } from "vitest"
+
+import { basisUrlNormalisieren } from "./umgebung"
+
+describe("basisUrlNormalisieren", () => {
+  it("nimmt http fuer das eigene Netz", () => {
+    // Genau die Vorlage aus dem Eingabefeld, und der gemeldete Fall.
+    expect(basisUrlNormalisieren("192.168.1.20:8123")).toBe("http://192.168.1.20:8123")
+    expect(basisUrlNormalisieren("localhost:5173")).toBe("http://localhost:5173")
+    expect(basisUrlNormalisieren("127.0.0.1:8123")).toBe("http://127.0.0.1:8123")
+    expect(basisUrlNormalisieren("10.0.0.5:8123")).toBe("http://10.0.0.5:8123")
+    expect(basisUrlNormalisieren("172.16.3.4:8123")).toBe("http://172.16.3.4:8123")
+    expect(basisUrlNormalisieren("homeassistant.local:8123")).toBe(
+      "http://homeassistant.local:8123",
+    )
+  })
+
+  it("bleibt bei https fuer alles von aussen Erreichbare", () => {
+    // Der echte Betriebsfall: die Domain laeuft ueber Cloudflare.
+    expect(basisUrlNormalisieren("datametric360.de")).toBe("https://datametric360.de")
+    expect(basisUrlNormalisieren("ha.example.com:8123")).toBe("https://ha.example.com:8123")
+    // 172.32 liegt bereits AUSSERHALB des privaten Bereichs (nur 16-31).
+    expect(basisUrlNormalisieren("172.32.0.1")).toBe("https://172.32.0.1")
+  })
+
+  it("raet gar nicht, wenn ein Schema dasteht", () => {
+    expect(basisUrlNormalisieren("https://192.168.1.20:8123")).toBe("https://192.168.1.20:8123")
+    expect(basisUrlNormalisieren("http://datametric360.de")).toBe("http://datametric360.de")
+  })
+
+  it("schneidet abschliessende Schraegstriche ab", () => {
+    // Sonst entstehen Adressen wie "https://host//api/states".
+    expect(basisUrlNormalisieren("  https://datametric360.de///  ")).toBe(
+      "https://datametric360.de",
+    )
+    expect(basisUrlNormalisieren("192.168.1.20:8123/")).toBe("http://192.168.1.20:8123")
+  })
+})

companion-app/src/api/umgebung.ts

@@ -101,7 +101,7 @@ const SCHLUESSEL_BASIS = "dm360.basis_url";
 const SCHLUESSEL_TOKEN = "dm360.token";
 
 export interface Zugang {
-  /** Basis-URL ohne abschließenden Schrägstrich, z. B. https://audi.datametric360.app */
+  /** Basis-URL ohne abschließenden Schrägstrich, z. B. https://audi.datametric360.de */
   basisUrl: string;
   /** Long-Lived Access Token aus dem HA-Benutzerprofil. */
   token: string;
@@ -129,9 +129,42 @@ export async function zugangVerwerfen(): Promise<void> {
 
 /** Schneidet abschließende Schrägstriche ab und ergänzt fehlendes Schema.
     Ohne das entstehen sonst Adressen wie "https://host//api/states". */
+/**
+ * Adressen, die per Definition im eigenen Netz liegen - dort gibt es kein
+ * Zertifikat, also spricht der Server http.
+ *
+ * Home Assistant im Heimnetz ist genau dieser Fall: "192.168.1.20:8123" steht
+ * sogar als Beispiel im Eingabefeld. Bis zum 04.09.2026 setzte die App davor
+ * blind https:// - die eigene Vorlage, so eingetippt, ergab damit eine
+ * Adresse, unter der nichts antwortet ("Der Server ist unter dieser Adresse
+ * nicht erreichbar", gemeldet beim Neuverbinden).
+ *
+ * Umgekehrt bleibt https richtig fuer alles, was von aussen erreichbar ist -
+ * datametric360.de laeuft ueber Cloudflare, dort waere http ein Rueckschritt.
+ * Deshalb nicht generell umgestellt, sondern nach dem Ziel unterschieden.
+ */
+function imEigenenNetz(host: string): boolean {
+  const h = host.toLowerCase().replace(/:[0-9]+$/, "").replace(/^\[|\]$/g, "");
+  if (h === "localhost" || h === "::1") return true;
+  if (h.endsWith(".local") || h.endsWith(".home.arpa") || h.endsWith(".localhost")) return true;
+  const v4 = /^([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})\.([0-9]{1,3})$/.exec(h);
+  if (!v4) return false;
+  const a = Number(v4[1]);
+  const b = Number(v4[2]);
+  return a === 127 || a === 10 || (a === 192 && b === 168) || (a === 172 && b >= 16 && b <= 31);
+}
+
+/** Schneidet abschliessende Schraegstriche ab und ergaenzt fehlendes Schema.
+    Ohne das entstehen sonst Adressen wie "https://host//api/states".
+
+    Geraten wird nur, wenn kein Schema dasteht - wer http:// oder https://
+    tippt, bekommt genau das. */
 export function basisUrlNormalisieren(eingabe: string): string {
   let url = eingabe.trim();
-  if (!/^https?:\/\//i.test(url)) url = `https://${url}`;
+  if (!/^https?:\/\//i.test(url)) {
+    const ziel = url.split("/")[0] ?? "";
+    url = `${imEigenenNetz(ziel) ? "http" : "https"}://${url}`;
+  }
   return url.replace(/\/+$/, "");
 }
 

companion-app/src/api/warteschlange.ts

@@ -41,8 +41,14 @@ export class Warteschlange {
   #geladen = false;
   #laeuft = false;
   #horcher = new Set<WarteschlangenHorcher>();
+  /* Bewusst als eigenes Feld statt als Parameter-Eigenschaft im Konstruktor:
+     Node kann Parameter-Eigenschaften im Strip-Modus (--experimental-strip-types)
+     nicht übersetzen, und genau darüber laufen die Rauchtests dieses Pakets. */
+  readonly rest: HassRest;
 
-  constructor(private readonly rest: HassRest) {}
+  constructor(rest: HassRest) {
+    this.rest = rest;
+  }
 
   async laden(): Promise<void> {
     if (this.#geladen) return;

companion-app/src/assets/audi/audi-rings-black.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="100" width="289">
+  <defs></defs>
+  <defs>
+    <clipPath id="a" clipPathUnits="userSpaceOnUse">
+      <path d="M0 100h289V0H0z"></path>
+    </clipPath>
+  </defs>
+  <g clip-path="url(#a)" transform="matrix(1 0 0 -1 0 100.00040017)">
+    <path d="M239 11.1914c-8.885 0-17.075 3.008-23.624 8.05 6.646 8.489 10.624 19.165 10.624 30.759 0 11.593-3.978 22.269-10.624 30.759 6.549 5.041 14.739 8.05 23.624 8.05 21.399 0 38.809-17.41 38.809-38.809 0-21.4-17.41-38.809-38.809-38.809m-86.625 8.05c6.647 8.489 10.625 19.165 10.625 30.759 0 11.593-3.978 22.269-10.624 30.759 6.548 5.041 14.74 8.05 23.624 8.05 8.885 0 17.075-3.009 23.624-8.05-6.646-8.49-10.624-19.166-10.624-30.759 0-11.594 3.978-22.27 10.624-30.759-6.549-5.042-14.739-8.05-23.624-8.05-8.884 0-17.076 3.008-23.625 8.05m-63 0C96.022 27.7304 100 38.4064 100 50.0004c0 11.593-3.978 22.269-10.624 30.759 6.548 5.041 14.74 8.05 23.624 8.05 8.884 0 17.076-3.009 23.624-8.05-6.646-8.49-10.624-19.166-10.624-30.759 0-11.594 3.978-22.27 10.624-30.759-6.548-5.042-14.74-8.05-23.624-8.05-8.884 0-17.076 3.008-23.625 8.05m-78.184 30.759c0 21.399 17.41 38.809 38.809 38.809 8.884 0 17.076-3.009 23.624-8.05C66.978 72.2694 63 61.5934 63 50.0004c0-11.594 3.978-22.27 10.624-30.759-6.548-5.042-14.74-8.05-23.624-8.05-21.399 0-38.809 17.409-38.809 38.809M81.5 27.3734c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m63 0c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m63 0c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m31.5 72.627c-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.568 11.207-31.5 11.207-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.569 11.207-31.5 11.207-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.569 11.207-31.5 11.207-27.57 0-50-22.43-50-50 0-27.571 22.43-50 50-50 11.931 0 22.896 4.206 31.5 11.207C90.104 4.2064 101.068.0004 113 .0004c11.931 0 22.896 4.206 31.5 11.207 8.604-7.001 19.568-11.207 31.5-11.207 11.932 0 22.896 4.206 31.5 11.207 8.604-7.001 19.568-11.207 31.5-11.207 27.57 0 50 22.429 50 50 0 27.57-22.43 50-50 50"></path>
+  </g>
+</svg>

companion-app/src/assets/audi/audi-rings-white.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" height="100" width="289">
+  <defs></defs>
+  <defs>
+    <clipPath id="a" clipPathUnits="userSpaceOnUse">
+      <path d="M0 100h289V0H0z"></path>
+    </clipPath>
+  </defs>
+  <g clip-path="url(#a)" transform="matrix(1 0 0 -1 0 100.00040017)">
+    <path d="M239 11.1914c-8.885 0-17.075 3.008-23.624 8.05 6.646 8.489 10.624 19.165 10.624 30.759 0 11.593-3.978 22.269-10.624 30.759 6.549 5.041 14.739 8.05 23.624 8.05 21.399 0 38.809-17.41 38.809-38.809 0-21.4-17.41-38.809-38.809-38.809m-86.625 8.05c6.647 8.489 10.625 19.165 10.625 30.759 0 11.593-3.978 22.269-10.624 30.759 6.548 5.041 14.74 8.05 23.624 8.05 8.885 0 17.075-3.009 23.624-8.05-6.646-8.49-10.624-19.166-10.624-30.759 0-11.594 3.978-22.27 10.624-30.759-6.549-5.042-14.739-8.05-23.624-8.05-8.884 0-17.076 3.008-23.625 8.05m-63 0C96.022 27.7304 100 38.4064 100 50.0004c0 11.593-3.978 22.269-10.624 30.759 6.548 5.041 14.74 8.05 23.624 8.05 8.884 0 17.076-3.009 23.624-8.05-6.646-8.49-10.624-19.166-10.624-30.759 0-11.594 3.978-22.27 10.624-30.759-6.548-5.042-14.74-8.05-23.624-8.05-8.884 0-17.076 3.008-23.625 8.05m-78.184 30.759c0 21.399 17.41 38.809 38.809 38.809 8.884 0 17.076-3.009 23.624-8.05C66.978 72.2694 63 61.5934 63 50.0004c0-11.594 3.978-22.27 10.624-30.759-6.548-5.042-14.74-8.05-23.624-8.05-21.399 0-38.809 17.409-38.809 38.809M81.5 27.3734c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m63 0c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m63 0c-4.593 6.375-7.309 14.187-7.309 22.627 0 8.439 2.716 16.252 7.309 22.627 4.593-6.375 7.309-14.188 7.309-22.627 0-8.44-2.716-16.252-7.309-22.627m31.5 72.627c-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.568 11.207-31.5 11.207-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.569 11.207-31.5 11.207-11.932 0-22.896-4.207-31.5-11.207-8.604 7-19.569 11.207-31.5 11.207-27.57 0-50-22.43-50-50 0-27.571 22.43-50 50-50 11.931 0 22.896 4.206 31.5 11.207C90.104 4.2064 101.068.0004 113 .0004c11.931 0 22.896 4.206 31.5 11.207 8.604-7.001 19.568-11.207 31.5-11.207 11.932 0 22.896 4.206 31.5 11.207 8.604-7.001 19.568-11.207 31.5-11.207 27.57 0 50 22.429 50 50 0 27.57-22.43 50-50 50" fill="#fff"></path>
+  </g>
+</svg>

companion-app/src/assets/audi/audi-sport.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 284 34"><defs></defs><title>AS_RGB_pos_red</title><g id="boundingbox"><rect class="cls-1" width="284" height="34"></rect></g><g id="AS_4C_0_100_90_0" data-name="AS_4C_0/100/90/0"><path class="cls-2" d="M266,8.67h4.17l.56-4.45h4.62V8.67h8.11v4h-8.11v7c0,2.19.87,3,3.48,3a18,18,0,0,0,4.76-.62v4a20,20,0,0,1-5.87.94c-5.36,0-7.76-2.3-7.76-6.68V12.64h-4Z"></path><path class="cls-2" d="M221.28,17.58c0-5.74,4.21-9.46,11.93-9.46s11.93,3.47,11.93,9.49c0,5.74-4.21,9.46-11.93,9.46S221.28,23.59,221.28,17.58Zm18.26,0c0-3.37-2.54-5.49-6.33-5.49s-6.33,2.08-6.33,5.46,2.54,5.49,6.33,5.49S239.54,21,239.54,17.61Z"></path><path class="cls-2" d="M249.62,8.67h5l.21,3.27a6.66,6.66,0,0,1,6.33-3.75,9.73,9.73,0,0,1,2.57.31v4.73a15.84,15.84,0,0,0-3-.28c-2.92,0-4.76,1.11-5.63,2.37V26.51h-5.46Z"></path><path class="cls-2" d="M167.52,25.43V21.12a31.58,31.58,0,0,0,9.59,1.67c5.15,0,7.58-1.22,7.58-3.3,0-1.64-1.94-2.37-6.92-3.37-6.67-1.33-10.15-3.62-10.15-7.72,0-4.39,3.51-7.62,12.24-7.62a23.91,23.91,0,0,1,9.08,1.56V6.62a30.22,30.22,0,0,0-9.08-1.53c-4.52,0-6.54,1.15-6.54,3.06,0,1.64,2.05,2.37,7,3.38,6.67,1.32,10.15,3.4,10.15,7.75s-4.17,7.79-13.14,7.79A27.76,27.76,0,0,1,167.52,25.43Z"></path><path class="cls-2" d="M200,8.67l.35,1.95A12.34,12.34,0,0,1,208,8.12c6.3,0,10,3.47,10,9.28s-3.58,9.67-10.22,9.67a13.5,13.5,0,0,1-7.13-1.74v8.52h-5.46V8.67Zm12.49,8.94c0-3.34-2-5.22-5.67-5.22a12,12,0,0,0-6.12,1.47V21.4a12,12,0,0,0,6.12,1.46C210.49,22.86,212.48,21,212.48,17.61Z"></path><path class="cls-2" d="M70.56,1.34h5.85L89.62,26.51H83.33L80.61,21.3H66.25l-2.67,5.21H57.35ZM68.34,17H78.56L73.45,6.76Z"></path><path class="cls-2" d="M107.73,24.74a13.22,13.22,0,0,1-7.26,2.33c-4.63,0-8.8-1.53-8.8-7.89V8.67h5.46v9.81c0,3,1.35,4.42,4.66,4.42a11.25,11.25,0,0,0,5.6-1.5V8.67h5.46V26.51h-4.77Z"></path><path class="cls-2" d="M117.61,17.58c0-5.88,3.69-9.46,10.43-9.46A13.34,13.34,0,0,1,135,9.86V1.34h5.46V26.51h-4.76l-.38-2a11.78,11.78,0,0,1-7.51,2.51C121.33,27.07,117.61,23.52,117.61,17.58ZM135,21.4V13.82a12.08,12.08,0,0,0-6.12-1.46c-3.68,0-5.66,1.88-5.66,5.22s2,5.28,5.66,5.28A12,12,0,0,0,135,21.4Z"></path><rect class="cls-2" x="145.95" y="1.34" width="5.46" height="4.73"></rect><rect class="cls-2" x="145.95" y="8.67" width="5.46" height="17.84"></rect><polygon class="cls-2" points="0.15 33.84 17.72 0.79 53.18 0.79 35.61 33.84 0.15 33.84"></polygon></g></svg>

companion-app/src/daten/DatenKontext.test.tsx

@@ -0,0 +1,134 @@
+/**
+ * Was passiert, wenn Home Assistant neu startet.
+ *
+ * Gemeldet vom Eigentümer (2026-08-31): während eines Neustarts zeigte die App
+ * „502 Error“, und die Meldung blieb stehen, nachdem Home Assistant längst
+ * wieder lief — erst ein Beenden der App half. Zwei Ursachen, beide hier
+ * abgesichert:
+ *
+ *  1. 502 galt als harter Ladefehler statt als „Server kommt gerade hoch“.
+ *  2. Nach dem Wiederverbinden wurde genau einmal nachgeladen. Schlug das
+ *     fehl (die Websocket-Verbindung steht regelmäßig ein paar Sekunden vor
+ *     der REST-Schnittstelle), kam nie wieder ein „verbunden“ — und damit nie
+ *     wieder ein Versuch.
+ */
+
+import { render, screen, waitFor } from "@testing-library/react"
+import { describe, expect, it, vi } from "vitest"
+
+import { ApiFehler, type DataMetricApi } from "../api"
+import { DatenAnbieter, useDaten } from "./DatenKontext"
+import { beispielApi } from "../tests/beispieldaten"
+
+function Anzeige() {
+  const { bereit, ladefehler } = useDaten()
+  return (
+    <div>
+      <span data-testid="bereit">{bereit ? "ja" : "nein"}</span>
+      <span data-testid="fehler">{ladefehler ?? "-"}</span>
+    </div>
+  )
+}
+
+/** Eine API, deren `profilLesen` sich auf Kommando wie ein gerade startender
+    Home Assistant verhält: die nächsten n Aufrufe mit 502 abweisen, danach
+    wieder normal antworten.
+
+    Die Fehlschläge werden bewusst gezählt und nicht an der Aufrufnummer
+    festgemacht: der Horcher meldet beim Abonnieren sofort "verbunden", die
+    Zählung liefe sonst schon beim Aufbau los. */
+function apiMitNeustart() {
+  const echt = beispielApi()
+  let verbindungHorcher: ((z: string) => void) | null = null
+  let offeneFehlschlaege = 0
+  const profilLesen = vi.fn(async () => {
+    if (offeneFehlschlaege > 0) {
+      offeneFehlschlaege -= 1
+      throw new ApiFehler("Bad Gateway", 502)
+    }
+    return echt.profilLesen()
+  })
+  const api = {
+    ...echt,
+    profilLesen,
+    live: {
+      ...echt.live,
+      aufVerbindung: (h: (z: string) => void) => {
+        verbindungHorcher = h
+        h("verbunden")
+        return () => {}
+      },
+    },
+  } as unknown as DataMetricApi
+  return {
+    api,
+    profilLesen,
+    /** Home Assistant startet neu: die nächsten n Ladeversuche laufen ins
+        502, dann meldet sich die Websocket-Verbindung zurück. */
+    neustartMelden: (fehlschlaege: number) => {
+      offeneFehlschlaege = fehlschlaege
+      verbindungHorcher?.("verbunden")
+    },
+  }
+}
+
+describe("Neustart von Home Assistant", () => {
+  it("meldet 502 nicht als Ladefehler, solange Daten da sind", async () => {
+    const { api, neustartMelden } = apiMitNeustart()
+    render(
+      <DatenAnbieter api={api}>
+        <Anzeige />
+      </DatenAnbieter>,
+    )
+    await waitFor(() => expect(screen.getByTestId("bereit").textContent).toBe("ja"))
+
+    neustartMelden(1)
+
+    // Der fehlgeschlagene Versuch darf keine Fehlerzeile hinterlassen.
+    await waitFor(() => expect(screen.getByTestId("fehler").textContent).toBe("-"))
+    expect(screen.getByTestId("bereit").textContent).toBe("ja")
+  })
+
+  it("versucht es nach einem fehlgeschlagenen Nachladen erneut", async () => {
+    vi.useFakeTimers({ shouldAdvanceTime: true })
+    try {
+      const { api, profilLesen, neustartMelden } = apiMitNeustart()
+      render(
+        <DatenAnbieter api={api}>
+          <Anzeige />
+        </DatenAnbieter>,
+      )
+      await waitFor(() => expect(screen.getByTestId("bereit").textContent).toBe("ja"))
+      const vorher = profilLesen.mock.calls.length
+
+      neustartMelden(2)
+      await waitFor(() => expect(profilLesen.mock.calls.length).toBe(vorher + 1))
+
+      // Ohne Wiederholung bliebe es bei diesem einen Versuch — und die App
+      // auf dem Stand von vor dem Neustart, bis jemand sie beendet.
+      await vi.advanceTimersByTimeAsync(3000)
+      await waitFor(() => expect(profilLesen.mock.calls.length).toBe(vorher + 2))
+      await vi.advanceTimersByTimeAsync(5000)
+      await waitFor(() => expect(profilLesen.mock.calls.length).toBe(vorher + 3))
+
+      expect(screen.getByTestId("fehler").textContent).toBe("-")
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe("ApiFehler.istVoruebergehend", () => {
+  it("gilt für kein Netz und für einen startenden Server", () => {
+    expect(new ApiFehler("offline", null).istVoruebergehend).toBe(true)
+    expect(new ApiFehler("bad gateway", 502).istVoruebergehend).toBe(true)
+    expect(new ApiFehler("unavailable", 503).istVoruebergehend).toBe(true)
+    expect(new ApiFehler("timeout", 504).istVoruebergehend).toBe(true)
+  })
+
+  it("gilt nicht für einen echten Serverfehler", () => {
+    // 500 bessert sich durch Warten nicht — das muss sichtbar bleiben.
+    expect(new ApiFehler("kaputt", 500).istVoruebergehend).toBe(false)
+    expect(new ApiFehler("nicht da", 404).istVoruebergehend).toBe(false)
+  })
+})

companion-app/src/daten/DatenKontext.tsx

@@ -0,0 +1,326 @@
+/**
+ * Ein Zugang zu allen Daten für die gesamte Oberfläche.
+ *
+ * Hält die vier Datentöpfe (Profil, Fahrten, Tankvorgänge, Fahrzeugstatus),
+ * lauscht über die WebSocket-Verbindung auf Änderungen und reicht den
+ * Verbindungszustand sowie die Warteschlange nach außen. Die Screens kennen
+ * weder REST noch WebSocket — sie lesen aus diesem Kontext.
+ */
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from "react"
+
+import {
+  ApiFehler,
+  DataMetricApi,
+  ENTITAETEN,
+  type Buendelangabe,
+  type Fahrt,
+  type Fahrzeugstatus,
+  type IntegrationUpdateAngabe,
+  type DongleAngabe,
+  type LetzterDatensatz,
+  type ZugangAngabe,
+  type Profil,
+  type Tankvorgang,
+  type Verbindungszustand,
+  type WartenderAuftrag,
+} from "../api"
+import { bildStaendeSetzen } from "../screens/bilder"
+import type { Versionsstand } from "./appVersion"
+import { eigeneVersion, versionVergleichen } from "./appVersion"
+import type { Einstellungen, Fahrzeug } from "./profilAdapter"
+import { profilZuEinstellungen, profilZuFahrzeug, zusammenfuehren } from "./profilAdapter"
+
+/** Abstaende zwischen zwei Ladeversuchen nach einem Wiederverbinden.
+
+    Wachsend, in Millisekunden, zusammen gut zwei Minuten. Der erste
+    Abstand ist kurz, weil Home Assistant nach einem Neustart meist binnen
+    Sekunden antwortet; die spaeteren sind lang, damit ein wirklich
+    abgestuerzter Server nicht dauernd angefragt wird. */
+const WIEDERHOLABSTAENDE_MS = [2000, 4000, 8000, 15000, 30000, 60000]
+
+export interface DatenWert {
+  bereit: boolean
+  /** Erste Ladung fehlgeschlagen und noch nie Daten gesehen. */
+  ladefehler: string | null
+  verbindung: Verbindungszustand
+  warteschlange: readonly WartenderAuftrag[]
+  /** Zeitpunkt der letzten Statusmeldung — treibt die Veraltet-Anzeige. */
+  statusStand: string | null
+  /** Ob diese App noch dem Stand entspricht, den das Backend ausliefert.
+      Siehe appVersion.ts und VERSIONIERUNG.md. */
+  versionsstand: Versionsstand
+  /** Die vom Backend gemeldete Integrationsversion (`APP_VERSION`,
+      `sensor.audi_dashboard_app_version`'s `app`-Feld), oder null vor der
+      ersten Antwort. Panel-Gegenstück: die "Version"-Kachel in vEinst()
+      ("Installiert: ..."), die hier bislang fehlte, weil nur das
+      Vergleichsergebnis (`versionsstand`), nie der Rohwert selbst,
+      weitergereicht wurde. */
+  serverVersion: string | null
+  /** Das OTA-Bündel, das die Integration mitliefert (siehe daten/ota.ts),
+      oder null — kein Fehler, sondern der Zustand ohne Bündel oder ohne
+      Verbindung. */
+  otaBuendel: Buendelangabe | null
+  /** Ergebnis der letzten Selbst-Update-Prüfung/-Installation der
+      Integration (aktualisierung.py), oder null vor der ersten Prüfung. */
+  integrationUpdate: IntegrationUpdateAngabe | null
+  zugaenge: ZugangAngabe[]
+  /** Konfiguration des Dongles und eine ggf. vorgemerkte Aenderung
+      (flespi.py). null, solange kein flespi-Token hinterlegt ist. */
+  dongle: DongleAngabe | null
+  letzterDatensatz: LetzterDatensatz | null
+
+  einstellungen: Einstellungen | null
+  fahrzeug: Fahrzeug | null
+  fahrten: readonly Fahrt[]
+  tankvorgaenge: readonly Tankvorgang[]
+  rohprofil: Profil | null
+
+  api: DataMetricApi
+  /** Laedt alles neu; `true`, wenn es geklappt hat. Aufrufer duerfen den
+      Rueckgabewert ignorieren - er ist fuer die Wiederholung nach einem
+      Wiederverbinden da. */
+  neuLaden: () => Promise<boolean>
+  jetztAktualisieren: () => Promise<void>
+  /** Speichert geänderte Einstellungen/Fahrzeugdaten als ganzes Profil. */
+  profilSpeichern: (aenderung: {
+    einstellungen?: Einstellungen
+    fahrzeug?: Fahrzeug
+  }) => Promise<void>
+}
+
+const Kontext = createContext<DatenWert | null>(null)
+
+export function useDaten(): DatenWert {
+  const wert = useContext(Kontext)
+  if (!wert) throw new Error("useDaten außerhalb von <DatenAnbieter> verwendet")
+  return wert
+}
+
+export function DatenAnbieter({
+  api,
+  children,
+}: {
+  api: DataMetricApi
+  children: ReactNode
+}) {
+  const [rohprofil, setzeRohprofil] = useState<Profil | null>(null)
+  const [status, setzeStatus] = useState<Fahrzeugstatus>({})
+  const [statusStand, setzeStatusStand] = useState<string | null>(null)
+  const [fahrten, setzeFahrten] = useState<readonly Fahrt[]>([])
+  const [tankvorgaenge, setzeTankvorgaenge] = useState<readonly Tankvorgang[]>([])
+  const [bereit, setzeBereit] = useState(false)
+  const [ladefehler, setzeLadefehler] = useState<string | null>(null)
+  const [verbindung, setzeVerbindung] = useState<Verbindungszustand>("getrennt")
+  const [warteschlange, setzeWarteschlange] = useState<readonly WartenderAuftrag[]>([])
+  const [serverVersion, setzeServerVersion] = useState<string | null>(null)
+  const [otaBuendel, setzeOtaBuendel] = useState<Buendelangabe | null>(null)
+  const [zugaenge, setzeZugaenge] = useState<ZugangAngabe[]>([])
+  const [dongle, setzeDongle] = useState<DongleAngabe | null>(null)
+  const [letzterDatensatz, setzeLetzterDatensatz] = useState<LetzterDatensatz | null>(null)
+  const [integrationUpdate, setzeIntegrationUpdate] = useState<IntegrationUpdateAngabe | null>(
+    null,
+  )
+
+  // Damit profilSpeichern immer gegen den neuesten Rohstand arbeitet, auch
+  // wenn zwischendurch ein Push hereinkam.
+  const rohprofilRef = useRef<Profil | null>(null)
+  rohprofilRef.current = rohprofil
+
+  // Dasselbe fuer `bereit`: neuLaden liest den Wert nur, darf aber nicht
+  // davon abhaengen. Stand er in den Abhaengigkeiten, bekaeme der Effekt
+  // unten (der bewusst nur an `api` haengt) fuer immer die Fassung vom
+  // ersten Rendern mit `bereit === false` - und wuerde nach einem
+  // Wiederverbinden jeden Aussetzer als harten Ladefehler melden, obwohl
+  // laengst Daten da sind.
+  const bereitRef = useRef(false)
+  bereitRef.current = bereit
+
+  /** Laedt alles neu. Gibt zurueck, ob es geklappt hat - der Aufrufer
+      entscheidet, ob er es noch einmal versucht. */
+  const neuLaden = useCallback(async (): Promise<boolean> => {
+    try {
+      const [p, f, t, s] = await Promise.all([
+        api.profilLesen(),
+        api.fahrtenLesen(),
+        api.tankvorgaengeLesen(),
+        api.rest.zustandLesen<{ daten: Fahrzeugstatus }>(ENTITAETEN.fahrzeugstatus),
+      ])
+      setzeRohprofil(p)
+      setzeFahrten(f ?? [])
+      setzeTankvorgaenge(t ?? [])
+      setzeStatus(s.attributes.daten ?? {})
+      setzeStatusStand(s.last_updated)
+      setzeLadefehler(null)
+      setzeBereit(true)
+      // Bewusst außerhalb des Promise.all oben und ohne eigenes catch hier:
+      // appVersionAngabeLesen() schluckt seine Fehler selbst und liefert dann
+      // null. Ein fehlender Versionsvergleich darf die Erstladung nie
+      // aufhalten - er ist ein Hinweis, keine Betriebsvoraussetzung.
+      const versionsangabe = await api.appVersionAngabeLesen()
+      setzeServerVersion(versionsangabe?.app ?? null)
+      setzeOtaBuendel(versionsangabe?.buendel ?? null)
+      setzeIntegrationUpdate(versionsangabe?.integration_update ?? null)
+      setzeZugaenge(versionsangabe?.zugaenge ?? [])
+      setzeDongle(versionsangabe?.dongle ?? null)
+      setzeLetzterDatensatz(versionsangabe?.letzter_datensatz ?? null)
+      // Kein React-Zustand: die Bildadressen werden beim Rendern gebraucht,
+      // teils ausserhalb von Komponenten (bilderVorladen) - dieselbe
+      // Ueberlegung wie bei zugangMerken().
+      bildStaendeSetzen(versionsangabe?.bildstaende ?? null)
+      return true
+    } catch (fehler) {
+      // Ein voruebergehender Ausfall ist kein Ladefehler, solange schon
+      // Daten da sind — dann zeigt die App den zwischengespeicherten Stand
+      // mit Offline-Hinweis. Dazu zaehlt auch ein Home Assistant, der
+      // gerade neu startet (502/503/504), siehe istVoruebergehend.
+      const wartet = fehler instanceof ApiFehler && fehler.istVoruebergehend
+      if (!wartet || !bereitRef.current) {
+        setzeLadefehler(fehler instanceof Error ? fehler.message : String(fehler))
+      }
+      return false
+    }
+  }, [api])
+
+  // Erstladung plus Live-Verbindung.
+  useEffect(() => {
+    let abgemeldet = false
+    let nachladeUhr: ReturnType<typeof setTimeout> | null = null
+
+    /** Versucht es so lange, bis eine Ladung durchgeht - mit wachsendem
+        Abstand, damit ein dauerhaft nicht erreichbarer Server nicht im
+        Sekundentakt angefragt wird. Nach gut zwei Minuten ist Schluss;
+        dann hilft nur noch das naechste "verbunden" oder ein Zug nach
+        unten auf der Uebersicht. */
+    const nachladenBisEsKlappt = async (versuch = 0): Promise<void> => {
+      if (abgemeldet) return
+      if (await neuLaden()) return
+      if (abgemeldet || versuch >= WIEDERHOLABSTAENDE_MS.length) return
+      nachladeUhr = setTimeout(() => {
+        void nachladenBisEsKlappt(versuch + 1)
+      }, WIEDERHOLABSTAENDE_MS[versuch])
+    }
+
+    void neuLaden()
+    void api.warteschlange.laden()
+
+    const abVerbindung = api.live.aufVerbindung((zustand) => {
+      setzeVerbindung(zustand)
+      // Nach einem Wiederverbinden kann während der Trennung etwas passiert
+      // sein, das kein Ereignis mehr ausgelöst hat.
+      //
+      // Warum das nicht ein einzelner Aufruf sein darf: nach einem Neustart
+      // von Home Assistant steht die Websocket-Verbindung regelmaessig ein
+      // paar Sekunden, bevor die REST-Schnittstelle antwortet - dazwischen
+      // kommt 502. Ein einziger Versuch schlug dann fehl, und weil danach
+      // kein weiteres "verbunden" mehr folgt, blieb die App bis zum
+      // Beenden auf dem Stand von vor dem Neustart stehen, mitsamt der
+      // Fehlerzeile (vom Eigentuemer gemeldet, 2026-08-31).
+      if (zustand === "verbunden") void nachladenBisEsKlappt()
+    })
+
+    const abZustand = api.live.aufZustand(({ entity_id, new_state }) => {
+      if (!new_state) return
+      const daten = (new_state.attributes as { daten?: unknown }).daten
+      switch (entity_id) {
+        case ENTITAETEN.profil:
+          setzeRohprofil((daten ?? null) as Profil | null)
+          break
+        case ENTITAETEN.fahrten:
+          setzeFahrten((daten ?? []) as Fahrt[])
+          break
+        case ENTITAETEN.tankvorgaenge:
+          setzeTankvorgaenge((daten ?? []) as Tankvorgang[])
+          break
+        case ENTITAETEN.fahrzeugstatus:
+          setzeStatus((daten ?? {}) as Fahrzeugstatus)
+          setzeStatusStand(new_state.last_updated)
+          break
+        default:
+          break
+      }
+    })
+
+    const abWarteschlange = api.warteschlange.aufAenderung(setzeWarteschlange)
+    void api.live.starten()
+
+    return () => {
+      abgemeldet = true
+      if (nachladeUhr) clearTimeout(nachladeUhr)
+      abVerbindung()
+      abZustand()
+      abWarteschlange()
+      api.live.beenden()
+    }
+    // Absichtlich nur an `api` gebunden: neuLaden ändert sich mit `bereit`,
+    // was hier sonst die Verbindung bei jeder Erstladung neu aufbauen würde.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [api])
+
+  const einstellungen = useMemo(
+    () => (rohprofil ? profilZuEinstellungen(rohprofil) : null),
+    [rohprofil],
+  )
+  const fahrzeug = useMemo(
+    () => (rohprofil ? profilZuFahrzeug(rohprofil, status) : null),
+    [rohprofil, status],
+  )
+
+  const profilSpeichern = useCallback(
+    async (aenderung: { einstellungen?: Einstellungen; fahrzeug?: Fahrzeug }) => {
+      const roh = rohprofilRef.current
+      if (!roh) throw new Error("Kein Profil geladen — Speichern nicht möglich.")
+      const neu = zusammenfuehren(
+        roh,
+        aenderung.einstellungen ?? profilZuEinstellungen(roh),
+        aenderung.fahrzeug ?? profilZuFahrzeug(roh, status),
+      )
+      // Sofort lokal übernehmen, damit die Oberfläche nicht auf den
+      // Rückweg über das Backend warten muss (die Warteschlange kann im
+      // Funkloch beliebig lange brauchen).
+      setzeRohprofil(neu)
+      await api.profilSchreiben(neu)
+    },
+    [api, status],
+  )
+
+  const jetztAktualisieren = useCallback(async () => {
+    await api.jetztAktualisieren()
+    await neuLaden()
+  }, [api, neuLaden])
+
+  const wert: DatenWert = {
+    bereit,
+    ladefehler,
+    verbindung,
+    warteschlange,
+    statusStand,
+    versionsstand: versionVergleichen(eigeneVersion(), serverVersion).stand,
+    serverVersion,
+    otaBuendel,
+    integrationUpdate,
+    zugaenge,
+    dongle,
+    letzterDatensatz,
+    einstellungen,
+    fahrzeug,
+    fahrten,
+    tankvorgaenge,
+    rohprofil,
+    api,
+    neuLaden,
+    jetztAktualisieren,
+    profilSpeichern,
+  }
+
+  return <Kontext.Provider value={wert}>{children}</Kontext.Provider>
+}

companion-app/src/daten/appVersion.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest"
+
+import { versionOrdnung, versionVergleichen } from "./appVersion"
+
+/* Der Vergleich entscheidet, ob die App dem Nutzer sagt „ich bin älter als der
+   Server". Beide Fehlrichtungen sind teuer: ein Fehlalarm schickt ihn grundlos
+   an Xcode, ein verschluckter Hinweis lässt genau die stille Veraltung zu, die
+   die ganze Mechanik verhindern soll. */
+describe("versionVergleichen", () => {
+  it("meldet Gleichstand bei identischer Version", () => {
+    const v = versionVergleichen("2026.08.23.1", "2026.08.23.1")
+    expect(v.stand).toBe("gleich")
+  })
+
+  it("nennt die Richtung, statt nur eine Abweichung zu melden", () => {
+    expect(versionVergleichen("2026.08.23.1", "2026.08.24.1").stand).toBe("aelter")
+    expect(versionVergleichen("2026.08.23.2", "2026.08.23.1").stand).toBe("neuer")
+  })
+
+  it("meldet ohne erkennbares Format eine Abweichung ohne Richtung", () => {
+    // Der Einwand, der bis zum 04.09.2026 GEGEN jede Sortierung sprach: bei
+    // einem Formatwechsel darf nichts erfunden werden.
+    expect(versionVergleichen("2026.8.23.1", "fruehling-2").stand).toBe("abweichend")
+  })
+
+  it("vergleicht nicht, wenn das Backend nichts meldet", () => {
+    // Altes Backend ohne die Versions-Entität, oder offline. Ein Hinweis waere
+    // hier geraten, nicht gewusst.
+    expect(versionVergleichen("2026.08.23.1", null).stand).toBe("unbekannt")
+  })
+
+  it("vergleicht nicht, wenn die App ihre eigene Version nicht kennt", () => {
+    expect(versionVergleichen(null, "2026.08.23.1").stand).toBe("unbekannt")
+  })
+
+  it("behandelt eine leere Zeichenkette wie fehlend, nicht wie einen Wert", () => {
+    expect(versionVergleichen("", "2026.08.23.1").stand).toBe("unbekannt")
+    expect(versionVergleichen("2026.08.23.1", "").stand).toBe("unbekannt")
+  })
+
+  it("gibt beide Staende zur Anzeige zurueck", () => {
+    const v = versionVergleichen("2026.08.23.1", "2026.08.24.1")
+    expect(v.app).toBe("2026.08.23.1")
+    expect(v.server).toBe("2026.08.24.1")
+  })
+})
+
+/* versionOrdnung() ist die Stelle, an der aus zwei Kennungen ein Vorher und
+   ein Nachher wird. Sie entscheidet, ob der Update-Knopf erscheint - und ein
+   Vorzeichenfehler hier böte einen Rückschritt an, wie am 04.09.2026 real
+   geschehen (App .17, Instanz .5). */
+describe("versionOrdnung", () => {
+  it("erkennt die letzte Stelle, auch zweistellig", () => {
+    // Genau der gemeldete Fall: 5 gegen 17. Zeichenweise verglichen stuende
+    // "17" vor "5" - deshalb wird je Stelle als Zahl verglichen.
+    expect(versionOrdnung("2026.9.4.5", "2026.9.4.17")).toBe(-1)
+    expect(versionOrdnung("2026.9.4.17", "2026.9.4.5")).toBe(1)
+  })
+
+  it("vergleicht Stelle für Stelle von links", () => {
+    expect(versionOrdnung("2026.8.31.9", "2026.9.1.1")).toBe(-1)
+    expect(versionOrdnung("2026.9.1.1", "2025.12.31.9")).toBe(1)
+  })
+
+  it("behandelt fehlende Stellen als Null", () => {
+    expect(versionOrdnung("2026.9.4", "2026.9.4.0")).toBe(0)
+    expect(versionOrdnung("2026.9.4", "2026.9.4.1")).toBe(-1)
+  })
+
+  it("stoert sich nicht an fuehrenden Nullen", () => {
+    expect(versionOrdnung("2026.08.23.1", "2026.8.23.1")).toBe(0)
+  })
+
+  it("sortiert nicht, was nicht ins Format passt", () => {
+    // parseInt haette "4b" klaglos als 4 gelesen - genau die scheingenaue
+    // Antwort, die hier nicht entstehen darf.
+    expect(versionOrdnung("2026.9.4b", "2026.9.5")).toBeNull()
+    expect(versionOrdnung("v2026.9.4", "2026.9.5")).toBeNull()
+    expect(versionOrdnung("2026..4", "2026.9.4")).toBeNull()
+  })
+
+  it("nennt zeichengleiche Kennungen gleich, auch ohne lesbares Format", () => {
+    expect(versionOrdnung("fruehling-2", "fruehling-2")).toBe(0)
+  })
+
+  it("entscheidet nichts, wenn eine Seite fehlt", () => {
+    expect(versionOrdnung(null, "2026.9.4.1")).toBeNull()
+    expect(versionOrdnung("2026.9.4.1", "")).toBeNull()
+  })
+})

companion-app/src/daten/appVersion.ts

@@ -0,0 +1,99 @@
+/**
+ * Vergleich zwischen dem Stand, den diese App mitbringt, und dem, den das
+ * Backend ausliefert. Hintergrund: ../../VERSIONIERUNG.md
+ *
+ * Warum es das braucht: Das Panel lädt seine Dateien bei jedem Seitenaufruf
+ * frisch und kann gar nicht veralten. Die iOS-App trägt ihre Dateien fest
+ * gebündelt und bleibt auf dem Stand vom Signieren — unbegrenzt und bisher
+ * unbemerkt. Diese Datei macht daraus ein sichtbares Signal.
+ *
+ * ENTSCHEIDUNG GEÄNDERT AM 04.09.2026 — vorher stand hier ausdrücklich
+ * „bewusst kein größer/kleiner-Vergleich: die Version ist eine Kennung, keine
+ * Zahl". Der Anlass war ein echter Fall: nach einem Xcode-Lauf lief die App
+ * auf `2026.9.4.17`, die Instanz stand noch auf `2026.9.4.5` — und die App bot
+ * an, sich auf `.5` zu „erneuern". Ein Rückschritt, den die Gleichheitsprüfung
+ * gar nicht sehen konnte. Vorgabe des Eigentümers: erkannt werden soll eine
+ * NEUERE Fassung und keine andere.
+ *
+ * Der damalige Einwand bleibt gültig und ist deshalb eingebaut, statt
+ * verworfen: sortiert wird nur, was dem Format `JJJJ.M.T.N` entspricht. Passt
+ * eine der beiden Zeichenketten nicht ins Schema (Formatwechsel), liefert der
+ * Vergleich „abweichend" statt einer erfundenen Reihenfolge — dann sagt die
+ * App, dass etwas nicht übereinstimmt, aber nicht, in welche Richtung.
+ */
+
+export type Versionsstand =
+  /** App und Backend melden denselben Stand. */
+  | "gleich"
+  /** Die App ist nachweislich älter — nur hier gibt es etwas zu holen. */
+  | "aelter"
+  /** Die App ist nachweislich neuer, etwa direkt nach einem Xcode-Lauf,
+      solange die Instanz noch nicht nachgezogen hat. Kein Handlungsbedarf. */
+  | "neuer"
+  /** Verschieden, aber nicht in eine Reihenfolge zu bringen (Formatwechsel). */
+  | "abweichend"
+  /** Kein Vergleich möglich (Backend meldet nichts, offline, altes Backend). */
+  | "unbekannt"
+
+export interface Versionsvergleich {
+  stand: Versionsstand
+  app: string | null
+  server: string | null
+}
+
+/** Die in diese App einkompilierte Version (vite, siehe vite.config.ts). */
+export function eigeneVersion(): string | null {
+  // Der Zugriff ist abgesichert, weil die Konstante in Testläufen und im
+  // Dev-Server nicht zwingend gesetzt ist. Fehlt sie, wird nicht verglichen,
+  // statt eine Abweichung zu behaupten.
+  return typeof __APP_VERSION__ === "string" && __APP_VERSION__ ? __APP_VERSION__ : null
+}
+
+/** Zerlegt `2026.9.4.17` in [2026, 9, 4, 17]. `null`, sobald ein Teil keine
+    reine Ziffernfolge ist — dann wird nicht sortiert (siehe Modulkopf). */
+function teile(version: string): number[] | null {
+  const stuecke = version.split(".")
+  if (stuecke.length === 0) return null
+  const zahlen: number[] = []
+  for (const stueck of stuecke) {
+    // Bewusst kein parseInt: das würde "4b" klaglos als 4 lesen und damit
+    // genau die scheingenaue Sortierung erzeugen, vor der der Modulkopf warnt.
+    if (!/^[0-9]+$/.test(stueck)) return null
+    zahlen.push(Number(stueck))
+  }
+  return zahlen
+}
+
+/**
+ * `-1` wenn `a` älter ist als `b`, `0` bei Gleichstand, `+1` wenn `a` neuer
+ * ist — und `null`, wenn sich das nicht entscheiden lässt.
+ *
+ * Fehlende Stellen zählen als 0, damit `2026.9.4` und `2026.9.4.0` denselben
+ * Stand bezeichnen.
+ */
+export function versionOrdnung(a: string | null, b: string | null): number | null {
+  if (!a || !b) return null
+  // Zeichengleich ist gleich, auch wenn das Format unbekannt ist.
+  if (a === b) return 0
+  const links = teile(a)
+  const rechts = teile(b)
+  if (!links || !rechts) return null
+  const laenge = Math.max(links.length, rechts.length)
+  for (let i = 0; i < laenge; i++) {
+    const l = links[i] ?? 0
+    const r = rechts[i] ?? 0
+    if (l !== r) return l < r ? -1 : 1
+  }
+  return 0
+}
+
+export function versionVergleichen(
+  app: string | null,
+  server: string | null,
+): Versionsvergleich {
+  if (!app || !server) return { stand: "unbekannt", app, server }
+  const ordnung = versionOrdnung(app, server)
+  if (ordnung === null) return { stand: "abweichend", app, server }
+  if (ordnung === 0) return { stand: "gleich", app, server }
+  return { stand: ordnung < 0 ? "aelter" : "neuer", app, server }
+}

companion-app/src/daten/belegentwurf.test.ts

@@ -0,0 +1,93 @@
+/**
+ * Tests zur Uebernahme eines eingelesenen Belegs ins Tankformular.
+ *
+ * Die Nutzlast unten ist KEIN erfundenes Beispiel: sie ist die Ausgabe von
+ * shell_beleg_parser._parsen() fuer den Beleg, den der Eigentuemer am
+ * 04.09.2026 ueber das Teilen-Blatt hereingereicht hat und der in der App nur
+ * mit Datum und Uhrzeit ankam (Shell, Richard-Wagner-Str. 9, Ingolstadt,
+ * 43,87 l fuer 95,60 EUR). Genau dieser Fall gehoert in einen Test.
+ */
+
+import { describe, expect, it } from "vitest"
+
+import { belegFormularwerte } from "./belegentwurf"
+
+/* Wortgleich mit dem, was belege._beleg_felder() fuer diesen Beleg
+   veroeffentlicht - die Feldnamen sind der Punkt dieser Suite. */
+const GETEILT = {
+  receipt_key: "0000000459_3368-082-00082_2026-04-03T00:55",
+  receipt_no: "3368/082/00082",
+  tse_beleg_nr: "73912",
+  ts: "2026-04-03T00:55:00",
+  ts_payment: "2026-04-03T00:52:43",
+  ts_tse: "2026-04-03T00:55:01",
+  station_id: "0000000459",
+  station_brand: "Shell",
+  station_name: "Shell, Richard-Wagner-Str. 9, Ingolstadt",
+  station_address: "Richard-Wagner-Str. 9, 85057 Ingolstadt",
+  article_no: "000013",
+  product_name: "V-Power Racing",
+  fuel_type: "V-Power Racing",
+  liters: 43.87,
+  fuel_total_eur: 95.6,
+  price_per_l: 2.1792,
+  discount: 11.84,
+  discount_per_l: 0.27,
+  list_price_per_l: 2.449,
+  receipt_total_eur: 95.6,
+  net_eur: 80.34,
+  vat_eur: 15.26,
+  receipt_file: "/config/audi_dashboard/belege/e-receipt (7).pdf",
+}
+
+describe("belegFormularwerte", () => {
+  it("fuellt das ganze Formular, nicht nur Datum und Uhrzeit", () => {
+    // Der gemeldete Fehler: alles ausser zeitpunkt blieb leer, weil die App
+    // liter/kosten/station/ersparnis/kraftstoff abfragte statt der
+    // Belegfelder.
+    expect(belegFormularwerte(GETEILT)).toEqual({
+      zeitpunkt: "2026-04-03T00:55",
+      liter: "43.87",
+      kosten: "95.6",
+      ersparnis: "11.84",
+      station: "Shell, Richard-Wagner-Str. 9, Ingolstadt",
+      kraftstoff: "V-Power Racing",
+    })
+  })
+
+  it("nimmt den realen Betrag, nicht den Listenpreis", () => {
+    // fuel_total_eur ist bereits rabattiert; receipt_total_eur waere hier
+    // zufaellig gleich, list_price_per_l dagegen ein Preis je Liter.
+    expect(belegFormularwerte(GETEILT).kosten).toBe(String(GETEILT.fuel_total_eur))
+  })
+
+  it("laesst Felder leer, die der Beleg nicht nennt", () => {
+    // Ein Beleg ohne Rabatt ist normal (BelegOhneRabatt im Parsertest) - das
+    // Formularfeld soll dann nicht auf "null" stehen.
+    expect(belegFormularwerte({ ...GETEILT, discount: null })).toMatchObject({ ersparnis: "" })
+    expect(belegFormularwerte({ ts: "2026-04-03T00:55:00" })).toEqual({
+      zeitpunkt: "2026-04-03T00:55",
+      liter: "",
+      kosten: "",
+      ersparnis: "",
+      station: "",
+      kraftstoff: "",
+    })
+  })
+
+  it("laesst eine echte Null durch", () => {
+    // 0 ist ein Wert, kein fehlendes Feld - ein Beleg mit 0,00 EUR Rabatt
+    // darf nicht wie "kein Rabatt angegeben" aussehen.
+    expect(belegFormularwerte({ ...GETEILT, discount: 0 }).ersparnis).toBe("0")
+  })
+
+  it("kommt mit gar keinem Beleg zurecht", () => {
+    expect(belegFormularwerte(null).zeitpunkt).toBe("")
+    expect(belegFormularwerte(undefined).liter).toBe("")
+  })
+
+  it("uebernimmt keinen Kilometerstand", () => {
+    // SPECIFICATION.md §7.7 Regel 2: der kommt immer vom Fahrzeug.
+    expect(Object.keys(belegFormularwerte(GETEILT))).not.toContain("km")
+  })
+})

companion-app/src/daten/belegentwurf.ts

@@ -0,0 +1,68 @@
+/**
+ * Was ein eingelesener Beleg ins Tankformular traegt.
+ *
+ * WARUM DAS HIER STEHT UND NICHT IM BILDSCHIRM
+ * -------------------------------------------
+ * Bis zum 04.09.2026 stand die Uebernahme als Folge von `if`-Zeilen in
+ * `Tanken.tsx` - und fragte `liter`/`kosten`/`station`/`ersparnis`/
+ * `kraftstoff` ab, also die Namen der FORMULARFELDER. Veroeffentlicht werden
+ * aber die Namen des BELEGS (`_beleg_felder` in belege.py, dieselben, die auch
+ * im Tankvorgang landen). Uebereingestimmt hat allein `ts`.
+ *
+ * Sichtbar war das als: ein eingelesener Beleg fuellte Datum und Uhrzeit,
+ * sonst nichts (Befund des Eigentuemers, 04.09.2026 - gemeldet fuer einen
+ * ueber das Teilen-Blatt hereingereichten Beleg, betraf aber jeden Weg
+ * gleichermassen, weil beide durch `belegLesen()` laufen). Als eigene
+ * Funktion laesst sich die Zuordnung gegen eine echte Nutzlast pruefen; in
+ * den `if`-Zeilen des Bildschirms konnte sie es nicht.
+ *
+ * KEIN KILOMETERSTAND
+ * -------------------
+ * Er kommt immer vom Fahrzeug, nie vom Beleg (SPECIFICATION.md §7.7 Regel 2).
+ * Das Panel haelt es in `tankFelder()` genauso.
+ */
+
+/** Die Felder, die belege.py nach dem Lesen eines Belegs veroeffentlicht. */
+export interface BelegEntwurf {
+  ts?: string
+  liters?: number | null
+  /** Der reale, bereits rabattierte Betrag. */
+  fuel_total_eur?: number | null
+  /** SmartDeal-Ersparnis. */
+  discount?: number | null
+  station_name?: string | null
+  fuel_type?: string | null
+  receipt_key?: string | null
+  receipt_file?: string | null
+}
+
+/** Was davon in welches Formularfeld geht - leere Zeichenkette heisst: nicht
+    setzen, das Feld behaelt seinen bisherigen Wert. */
+export interface Formularwerte {
+  zeitpunkt: string
+  liter: string
+  kosten: string
+  ersparnis: string
+  station: string
+  kraftstoff: string
+}
+
+/**
+ * Zahl in die Zeichenkette eines Zahlenfelds. `0` ist ein gueltiger Wert und
+ * muss durchkommen - nur `null`/`undefined` bedeuten "steht nicht im Beleg".
+ */
+function zahl(wert: number | null | undefined): string {
+  return wert == null ? "" : String(wert)
+}
+
+export function belegFormularwerte(e: BelegEntwurf | null | undefined): Formularwerte {
+  return {
+    // Das Eingabefeld will "JJJJ-MM-TTThh:mm", der Beleg liefert Sekunden mit.
+    zeitpunkt: e?.ts ? e.ts.slice(0, 16) : "",
+    liter: zahl(e?.liters),
+    kosten: zahl(e?.fuel_total_eur),
+    ersparnis: zahl(e?.discount),
+    station: e?.station_name ?? "",
+    kraftstoff: e?.fuel_type ?? "",
+  }
+}

companion-app/src/daten/buendelversion.test.ts

@@ -0,0 +1,27 @@
+/**
+ * Das OTA-Bündel muss dieselbe Fassung tragen wie das Manifest der
+ * Integration.
+ *
+ * Am 05.09.2026 am iPhone aufgefallen: der Server meldete 2026.9.5.29, das
+ * mitgelieferte Bündel war noch 2026.9.5.28. `buendelPasst()` verlangt
+ * Gleichheit — die App hielt sich deshalb für nicht erneuerbar und schickte
+ * den Eigentümer zu Xcode, obwohl nur die Veröffentlichung unvollständig war:
+ * die Versionsnummer war erhöht worden, ohne `npm run ota` laufen zu lassen.
+ *
+ * Dieser Test macht daraus einen Fehlschlag vor der Auslieferung statt einer
+ * irreführenden Meldung auf dem Telefon.
+ */
+
+import { readFileSync } from "node:fs"
+
+import { describe, expect, it } from "vitest"
+
+const lies = (pfad: string) => JSON.parse(readFileSync(pfad, "utf8")) as { version?: string }
+
+describe("OTA-Bündel und Manifest", () => {
+  it("tragen dieselbe Versionsnummer", () => {
+    const manifest = lies("../custom_components/audi_dashboard/manifest.json")
+    const buendel = lies("../custom_components/audi_dashboard/frontend/app/bundle.json")
+    expect(buendel.version).toBe(manifest.version)
+  })
+})

companion-app/src/daten/fahrzeugmodelle.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Die Modellliste der App muss der des Panels entsprechen.
+ *
+ * Bis zum 05.09.2026 war Modell in der App ein freies Textfeld, im Panel ein
+ * Auswahlfeld - vom Eigentümer bemerkt. Beim Nachziehen entstand eine
+ * Zweitschrift der Liste; dieser Test schneidet die Panel-Fassung aus der
+ * Quelle heraus und vergleicht sie, damit die beiden nicht auseinanderlaufen.
+ */
+
+import { readFileSync } from "node:fs"
+
+import { describe, expect, it } from "vitest"
+
+import { FAHRZEUG_MODELLE, modellauswahl } from "./fahrzeugmodelle"
+
+function panelListe(): string[] {
+  const quelle = readFileSync(
+    "../custom_components/audi_dashboard/frontend/audi-dashboard-app.js",
+    "utf8",
+  )
+  const start = quelle.indexOf("const FAHRZEUG_MODELLE = [")
+  if (start < 0) throw new Error("FAHRZEUG_MODELLE nicht in der Panel-Quelle gefunden")
+  const ende = quelle.indexOf("];", start)
+  const roh = quelle.slice(start, ende)
+  return [...roh.matchAll(/"([^"]+)"/g)].map((m) => m[1] as string)
+}
+
+describe("Modellliste", () => {
+  it("stimmt mit der des Panels überein", () => {
+    expect([...FAHRZEUG_MODELLE]).toEqual(panelListe())
+  })
+
+  it("stellt einen unbekannten gespeicherten Titel voran", () => {
+    const auswahl = modellauswahl("RS 6 Avant performance")
+    expect(auswahl[0]).toBe("RS 6 Avant performance")
+    expect(auswahl).toHaveLength(FAHRZEUG_MODELLE.length + 1)
+  })
+
+  it("laesst die Liste unveraendert, wenn der Titel darin steht", () => {
+    expect(modellauswahl("RS 4 Avant")).toEqual(FAHRZEUG_MODELLE)
+  })
+})

companion-app/src/daten/fahrzeugmodelle.ts

@@ -0,0 +1,38 @@
+/**
+ * Die Modelle, zu denen ein echtes Badge vorliegt.
+ *
+ * Zweitschrift von `FAHRZEUG_MODELLE` im Panel
+ * (custom_components/audi_dashboard/frontend/audi-dashboard-app.js). Zwei
+ * Codebasen, eine Liste - dass sie gleich bleiben, sichert
+ * `fahrzeugmodelle.test.ts`, der die Panel-Quelle einliest und Eintrag für
+ * Eintrag vergleicht.
+ *
+ * Beschränkt auf Modelle mit Badge: für alles andere stünde ein falsches oder
+ * gar kein Badge auf der Übersicht. Die Ausführung („competition",
+ * „performance") gehört nicht hierher, sondern in das Feld „Ausführung" -
+ * Entscheidung des Eigentümers vom 05.09.2026.
+ */
+export const FAHRZEUG_MODELLE = [
+  "RS 3 Sportback",
+  "RS 3 Limousine",
+  "RS 4 Avant",
+  "RS 5 Coupé",
+  "RS 5 Sportback",
+  "RS 6 Avant",
+  "RS 7 Sportback",
+  "S3 Sportback",
+  "S3 Limousine",
+  "SQ7",
+] as const
+
+/** Die Liste, wie sie im Auswahlfeld stehen muss.
+ *
+ *  Ein gespeicherter Titel, der nicht (mehr) in der Liste steht, wird
+ *  vorangestellt statt verschluckt - sonst fiele die Auswahl still auf den
+ *  ersten Eintrag zurück und änderte das Fahrzeug des Nutzers. Wortgleich mit
+ *  dem Panel. */
+export function modellauswahl(titel: string): readonly string[] {
+  return FAHRZEUG_MODELLE.includes(titel as (typeof FAHRZEUG_MODELLE)[number])
+    ? FAHRZEUG_MODELLE
+    : [titel, ...FAHRZEUG_MODELLE]
+}

companion-app/src/daten/geokodierung.ts

@@ -0,0 +1,162 @@
+/**
+ * Adresse → Koordinaten (Vorwärts-Geokodierung über Nominatim), mit Cache im
+ * localStorage. Gegenstück zur Rückwärts-Auflösung in `Standort.tsx`.
+ *
+ * Gebraucht wird sie für die Tankstellennadel auf dem Einzelbeleg: der Beleg
+ * trägt nur eine Anschrift, und das Backend füllt `station_lat`/`station_lon`
+ * nie — ohne diesen Schritt bliebe die Karte dort dauerhaft ohne Nadel. Das
+ * Panel macht es seit jeher genau so (`adresseAufloesen()`); der App fehlte
+ * beides, Karte wie Auflösung.
+ *
+ * Der Cache liegt bewusst im localStorage und nicht nur im Speicher: eine
+ * Tankstellenadresse ändert ihre Lage nicht, und Nominatim bittet in seinen
+ * Nutzungsbedingungen ausdrücklich darum, Ergebnisse zu behalten. Auch ein
+ * erfolgloser Treffer wird als `null` vermerkt, damit eine Adresse, die
+ * Nominatim nicht kennt, nicht bei jedem Öffnen erneut abgefragt wird — ein
+ * Netzfehler dagegen nicht, der ist kein „gibt es nicht".
+ */
+
+export interface Koordinate {
+  lat: number
+  lon: number
+}
+
+const CACHE_SCHLUESSEL = "dm360.geocache"
+
+/* Arten, bei denen der Eigenname aussagekräftiger ist als die Anschrift
+   (Feld type der Nominatim-Antwort). */
+const PLATZ_ARTEN = new Set([
+  "parking",
+  "parking_space",
+  "parking_entrance",
+  "bicycle_parking",
+  "motorcycle_parking",
+  "rest_area",
+  "services",
+  "fuel",
+  "charging_station",
+])
+
+function cacheLesen(): Record<string, Koordinate | string | null> {
+  try {
+    const roh = localStorage.getItem(CACHE_SCHLUESSEL)
+    return roh ? (JSON.parse(roh) as Record<string, Koordinate | string | null>) : {}
+  } catch {
+    return {}
+  }
+}
+
+/** Adresstext im selben Ablagefach merken (Schlüssel mit "rev:"-Vorsatz). */
+function adresseMerken(schluessel: string, adresse: string): void {
+  try {
+    const roh = localStorage.getItem(CACHE_SCHLUESSEL)
+    const cache = roh ? (JSON.parse(roh) as Record<string, unknown>) : {}
+    cache[schluessel] = adresse
+    localStorage.setItem(CACHE_SCHLUESSEL, JSON.stringify(cache))
+  } catch {
+    // Privatmodus oder volle Ablage — dann eben ohne Cache.
+  }
+}
+
+function cacheSchreiben(suche: string, treffer: Koordinate | null): void {
+  try {
+    const cache = cacheLesen()
+    cache[suche] = treffer
+    localStorage.setItem(CACHE_SCHLUESSEL, JSON.stringify(cache))
+  } catch {
+    // Privatmodus oder volle Ablage — dann eben ohne Cache.
+  }
+}
+
+/**
+ * Koordinaten → Adresse. Der Cache ist hier genauso wichtig wie bei der
+ * Vorwärtsrichtung, aus einem anderen Grund: Nominatim drosselt und sperrt
+ * bei häufigen Abrufen, und die Antwort kommt dann ohne CORS-Kopf zurück —
+ * im Browser ununterscheidbar von einem Netzfehler. Ohne dauerhaften Cache
+ * stand an einer längst aufgelösten Stelle plötzlich wieder nur ein
+ * Koordinatenpaar. Auf drei Nachkommastellen gerundet (~110 m), damit ein
+ * paar Meter Abweichung keinen neuen Abruf auslösen.
+ */
+/** Ein bereits aufgeloester Ort aus dem Zwischenspeicher - OHNE Netzabruf.
+ *  
+ *  Die Einzelfahrt loest Koordinaten bei Bedarf auf und legt das Ergebnis im
+ *  selben Fach ab wie die Standortansicht. Was einmal dort steht, kann die
+ *  Liste umsonst mitbenutzen: kein zusaetzlicher Abruf, keine Wartezeit, kein
+ *  Flackern beim Zeichnen.
+ *  
+ *  Bewusst NUR aus dem Speicher. Ein Abruf je Zeile waere genau der
+ *  Vorratsabruf, um dessen Unterlassung Nominatim in seinen
+ *  Nutzungsbedingungen bittet - bei zweihundert Fahrten waeren das
+ *  vierhundert Anfragen fuer einen Blick auf die Liste.
+ *  
+ *  Schluessel wie bei der Aufloesung: drei Nachkommastellen (~110 m). */
+export async function koordinatenAufloesen(lat: number, lon: number): Promise<string | null> {
+  const schluessel = `rev:${lat.toFixed(3)},${lon.toFixed(3)}`
+  const cache = cacheLesen()
+  const gemerkt = cache[schluessel]
+  if (typeof gemerkt === "string") return gemerkt
+
+  try {
+    const antwort = await fetch(
+      `https://nominatim.openstreetmap.org/reverse?format=jsonv2&lat=${lat}&lon=${lon}&zoom=18&addressdetails=1`,
+      { headers: { "Accept-Language": "de" } },
+    )
+    const daten = (await antwort.json()) as {
+      name?: string
+      type?: string
+      address?: Record<string, string>
+      display_name?: string
+    }
+    const a = daten.address ?? {}
+    const strasse = [a["road"], a["house_number"]].filter(Boolean).join(" ")
+    const stadt = (a["city"] ?? a["town"] ?? a["village"] ?? "").trim()
+    const ort = [a["postcode"], stadt].filter(Boolean).join(" ")
+    /* Steht das Auto auf einem benannten Platz — Parkplatz, Parkhaus,
+       Rastplatz, Ladesäule —, sagt dessen Name mehr als die nächstgelegene
+       Hausnummer: "Parkhaus Westentor" statt "Rathausstraße 4". Nominatim
+       liefert ihn im Feld name, zusammen mit der Art der getroffenen Fläche;
+       ohne die Prüfung auf diese Art würde auch jedes beliebige Gebäude, das
+       zufällig einen Namen trägt, die Anschrift verdrängen. Der Ort bleibt
+       angehängt, damit erkennbar ist, wo der Platz liegt. */
+    const platz = PLATZ_ARTEN.has(daten.type ?? "") ? (daten.name ?? "").trim() : ""
+    const adresse = platz
+      ? [platz, ort].filter(Boolean).join(", ")
+      : [strasse, ort].filter(Boolean).join(", ") || daten.display_name || null
+    // Nur echte Treffer merken: eine gedrosselte Antwort ist kein "hier gibt
+    // es keine Adresse", die soll beim nächsten Mal erneut versucht werden.
+    if (adresse) adresseMerken(schluessel, adresse)
+    return adresse
+  } catch {
+    return null
+  }
+}
+
+export async function adresseAufloesen(adresse: string | null | undefined): Promise<Koordinate | null> {
+  const suche = (adresse ?? "").trim()
+  if (!suche) return null
+  const cache = cacheLesen()
+  if (Object.prototype.hasOwnProperty.call(cache, suche)) {
+    const gemerkt = cache[suche]
+    return typeof gemerkt === "object" ? gemerkt : null
+  }
+
+  let treffer: Koordinate | null = null
+  try {
+    const antwort = await fetch(
+      `https://nominatim.openstreetmap.org/search?format=jsonv2&limit=1&q=${encodeURIComponent(suche)}`,
+      { headers: { "Accept-Language": "de" } },
+    )
+    const daten: unknown = await antwort.json()
+    if (Array.isArray(daten) && daten.length > 0) {
+      const erster = daten[0] as { lat?: string; lon?: string }
+      const lat = Number.parseFloat(erster.lat ?? "")
+      const lon = Number.parseFloat(erster.lon ?? "")
+      if (Number.isFinite(lat) && Number.isFinite(lon)) treffer = { lat, lon }
+    }
+  } catch {
+    // Netzfehler: nichts merken, damit der nächste Aufruf es erneut versucht.
+    return null
+  }
+  cacheSchreiben(suche, treffer)
+  return treffer
+}

companion-app/src/daten/geteilterBeleg.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Die Auswertung eines geteilten Belegs — der Teil, der ohne Gerät prüfbar
+ * ist. Das Ablegen selbst passiert nativ (ShareViewController.swift) und kann
+ * hier nicht nachgestellt werden; geprüft wird, was die App mit dem Aufruf und
+ * der abgelegten Datei macht.
+ *
+ * `@capacitor/core` und `@capacitor/filesystem` werden ersetzt: das eine
+ * meldet sonst „kein natives Gerät" und das Lesen steigt sofort aus, das
+ * andere greift auf einen Dateibereich zu, den es hier nicht gibt.
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest"
+
+const dateien = new Map<string, string>()
+
+vi.mock("@capacitor/core", () => ({
+  Capacitor: { isNativePlatform: () => true },
+}))
+
+vi.mock("@capacitor/filesystem", () => ({
+  Filesystem: {
+    readFile: vi.fn(async ({ path }: { path: string }) => {
+      const inhalt = dateien.get(path)
+      if (inhalt === undefined) throw new Error("nicht gefunden")
+      return { data: inhalt }
+    }),
+    deleteFile: vi.fn(async ({ path }: { path: string }) => {
+      dateien.delete(path)
+    }),
+  },
+}))
+
+/** Ein winziges, gültiges PDF als Base64 — der Inhalt ist hier gleichgültig. */
+const PDF_BASE64 = btoa("%PDF-1.4\n%%EOF\n")
+
+const PFAD = "file:///var/mobile/Shared/AppGroup/abc/geteilte-belege/1756832400-beleg.pdf"
+const AUFRUF = `datametric360://beleg?pfad=${encodeURIComponent(PFAD)}`
+
+describe("Belegpfad aus dem Aufruf", () => {
+  it("erkennt den Pfad", async () => {
+    const { belegpfadAusUrl } = await import("./geteilterBeleg")
+    expect(belegpfadAusUrl(AUFRUF)).toBe(PFAD)
+  })
+
+  it("lässt fremde Aufrufe in Ruhe", async () => {
+    const { belegpfadAusUrl } = await import("./geteilterBeleg")
+    expect(belegpfadAusUrl("datametric360://einstellungen")).toBeNull()
+    expect(belegpfadAusUrl("https://example.org/?pfad=x")).toBeNull()
+    expect(belegpfadAusUrl(null)).toBeNull()
+  })
+
+  it("verträgt einen Aufruf ohne Pfad", async () => {
+    const { belegpfadAusUrl } = await import("./geteilterBeleg")
+    expect(belegpfadAusUrl("datametric360://beleg")).toBeNull()
+    expect(belegpfadAusUrl("datametric360://beleg?anderes=1")).toBeNull()
+  })
+})
+
+describe("geteilten Beleg lesen", () => {
+  beforeEach(() => {
+    dateien.clear()
+    vi.resetModules()
+  })
+
+  it("liefert nichts ohne Aufruf", async () => {
+    const { geteiltenBelegLesen } = await import("./geteilterBeleg")
+    expect(await geteiltenBelegLesen(null)).toBeNull()
+  })
+
+  it("liest die Datei und gibt sie als PDF zurück", async () => {
+    dateien.set(PFAD, PDF_BASE64)
+    const { geteiltenBelegLesen } = await import("./geteilterBeleg")
+    const datei = await geteiltenBelegLesen(AUFRUF)
+    expect(datei).not.toBeNull()
+    expect(datei?.type).toBe("application/pdf")
+    expect(datei?.name).toBe("1756832400-beleg.pdf")
+    expect(datei?.size).toBeGreaterThan(0)
+  })
+
+  /* Der Grund, warum überhaupt gelöscht wird: sonst käme derselbe Beleg bei
+     jedem Öffnen erneut, und weil der Upload im Backend einen Vorgang anlegt,
+     wären das echte Doppeleinträge. */
+  it("räumt die Datei weg, holt sie also genau einmal", async () => {
+    dateien.set(PFAD, PDF_BASE64)
+    const { geteiltenBelegLesen } = await import("./geteilterBeleg")
+    expect(await geteiltenBelegLesen(AUFRUF)).not.toBeNull()
+    expect(dateien.has(PFAD)).toBe(false)
+    expect(await geteiltenBelegLesen(AUFRUF)).toBeNull()
+  })
+
+  it("verschluckt sich nicht an einer fehlenden Datei", async () => {
+    const { geteiltenBelegLesen } = await import("./geteilterBeleg")
+    expect(await geteiltenBelegLesen(AUFRUF)).toBeNull()
+  })
+})
+
+describe("Übergabe an die Tanken-Seite", () => {
+  beforeEach(() => vi.resetModules())
+
+  it("meldet jeden Wechsel an die Horcher", async () => {
+    const { geteiltenBelegSetzen, geteiltenBelegStand, geteiltenBelegHorchen } =
+      await import("./geteilterBeleg")
+    let gerufen = 0
+    const abmelden = geteiltenBelegHorchen(() => gerufen++)
+    const datei = new File([new Uint8Array([1])], "beleg.pdf", { type: "application/pdf" })
+
+    geteiltenBelegSetzen(datei)
+    expect(geteiltenBelegStand()).toBe(datei)
+    expect(gerufen).toBe(1)
+
+    geteiltenBelegSetzen(null)
+    expect(geteiltenBelegStand()).toBeNull()
+    expect(gerufen).toBe(2)
+
+    abmelden()
+    geteiltenBelegSetzen(datei)
+    expect(gerufen).toBe(2)
+  })
+})

companion-app/src/daten/geteilterBeleg.ts

@@ -0,0 +1,124 @@
+/**
+ * Belege, die über das iOS-Teilen-Blatt hereinkommen.
+ *
+ * Die Gegenseite ist `native/teilen/ShareViewController.swift`: sie schreibt
+ * das geteilte PDF in den Container der App-Gruppe `group.app.datametric360`
+ * und öffnet danach die App mit dem Pfad im Aufruf:
+ *
+ *     datametric360://beleg?pfad=file:///…/geteilte-belege/1756832400-beleg.pdf
+ *
+ * Diese Datei liest ihn über `@capacitor/filesystem`, das volle `file://`-Pfade
+ * ausdrücklich unterstützt (README: „Simply leave out the `directory` param to
+ * use a full file path"), und löscht die Datei danach.
+ *
+ * DER ERSTE ENTWURF GING ÜBER USERDEFAULTS UND HAT NIE FUNKTIONIERT
+ * ----------------------------------------------------------------
+ * Er legte das PDF base64-kodiert unter `dm360_geteilter_beleg` in
+ * `UserDefaults(suiteName: gruppe)` ab und holte es hier mit
+ * `@capacitor/preferences` und `configure({ group })` wieder heraus — in der
+ * Annahme, das Plugin lese damit die UserDefaults der Gruppe. Das tut es
+ * nicht. Sein iOS-Code (8.0.1, `ios/Sources/PreferencesPlugin/Preferences.swift`)
+ * liest **immer** `UserDefaults.standard` der App; `group` setzt lediglich ein
+ * Schlüssel-Präfix. Gesucht wurde also
+ * `group.app.datametric360.dm360_geteilter_beleg` im eigenen Bereich der App,
+ * während der Eintrag unter dem blanken Schlüssel im Gruppen-Container lag:
+ * falscher Behälter und falscher Schlüssel.
+ *
+ * Sichtbar war davon nur, dass die App aufging und nichts passierte — gemeldet
+ * am 02.09.2026 („es wird kein Tankvorgang angelegt beim Teilen mit der App").
+ *
+ * ABGEHOLT WIRD GENAU EINMAL
+ * --------------------------
+ * Die Datei wird nach dem Lesen gelöscht. Bliebe sie liegen, käme derselbe
+ * Beleg bei jedem Öffnen erneut — und weil der Upload beim Backend einen
+ * Vorgang anlegt, wären das echte Doppeleinträge.
+ */
+
+import { Capacitor } from "@capacitor/core"
+import { Filesystem } from "@capacitor/filesystem"
+
+/** Muss zum Schema in ShareViewController.swift passen. */
+const SCHEMA = "datametric360://beleg"
+
+function base64ZuDatei(base64: string, name: string): File {
+  const roh = atob(base64)
+  const bytes = new Uint8Array(roh.length)
+  for (let i = 0; i < roh.length; i++) bytes[i] = roh.charCodeAt(i)
+  return new File([bytes], name, { type: "application/pdf" })
+}
+
+/**
+ * Zieht den Belegpfad aus einem Aufruf der App. `null`, wenn der Aufruf ein
+ * anderer war (die App kann über dasselbe Schema auch anders geöffnet werden).
+ */
+export function belegpfadAusUrl(url: string | null | undefined): string | null {
+  if (!url || !url.startsWith(SCHEMA)) return null
+  try {
+    const frage = url.indexOf("?")
+    if (frage < 0) return null
+    const pfad = new URLSearchParams(url.slice(frage + 1)).get("pfad")
+    return pfad || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Liest den geteilten Beleg und räumt ihn weg. `null`, wenn der Aufruf keinen
+ * Pfad trug oder die Datei nicht lesbar war.
+ */
+export async function geteiltenBelegLesen(url: string | null | undefined): Promise<File | null> {
+  if (!Capacitor.isNativePlatform()) return null
+  const pfad = belegpfadAusUrl(url)
+  if (!pfad) return null
+
+  let base64: string
+  try {
+    const gelesen = await Filesystem.readFile({ path: pfad })
+    base64 = typeof gelesen.data === "string" ? gelesen.data : ""
+  } catch (fehler) {
+    console.warn("Geteilter Beleg: Datei nicht lesbar", fehler)
+    return null
+  }
+  if (!base64) return null
+
+  // Erst wegräumen, dann zurückgeben: schlägt das Hochladen später fehl, ist
+  // die Datei zwar weg - aber ein liegengebliebener Beleg, der bei jedem
+  // Öffnen erneut hochlädt, wäre der schlimmere Fehler.
+  try {
+    await Filesystem.deleteFile({ path: pfad })
+  } catch {
+    // Halb so wild: der Name trägt einen Zeitstempel, ein Rest überschreibt
+    // nichts und wird nie wieder gelesen - die App kommt nur über einen
+    // frischen Aufruf an einen Pfad.
+  }
+
+  const name = decodeURIComponent(pfad.split("/").pop() || "beleg.pdf")
+  return base64ZuDatei(base64, name)
+}
+
+/* ------------------------------------------------------------- Übergabe
+
+   Zwischen dem Abholen (App.tsx, beim Start und bei jedem Aufruf) und dem
+   Verarbeiten (Tanken.tsx) liegt ein Bildschirmwechsel. Ein kleiner geteilter
+   Speicher nach dem Muster von theme.ts überbrückt ihn — ein Zustand, der
+   außerhalb des Komponentenbaums lebt und den beide Seiten sehen. */
+
+let wartend: File | null = null
+const horcher = new Set<() => void>()
+
+export function geteiltenBelegSetzen(datei: File | null): void {
+  wartend = datei
+  for (const bei of horcher) bei()
+}
+
+export function geteiltenBelegStand(): File | null {
+  return wartend
+}
+
+export function geteiltenBelegHorchen(bei: () => void): () => void {
+  horcher.add(bei)
+  return () => {
+    horcher.delete(bei)
+  }
+}

companion-app/src/daten/ota.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest"
+
+import { buendelPasst } from "./ota"
+import type { Buendelangabe } from "../api"
+
+const buendel = (teil: Partial<Buendelangabe> = {}): Buendelangabe => ({
+  version: "2026.8.24.1",
+  sha256: "a".repeat(64),
+  bytes: 224186,
+  gebaut: "2026-08-24T00:00:00Z",
+  url: "/audi_dashboard_static/app/bundle.zip",
+  ...teil,
+})
+
+/* buendelPasst() entscheidet, ob der Update-Knopf überhaupt erscheint - ein
+   Fehler hier zeigt entweder einen Knopf, der ins Leere läuft (kein Bündel
+   da), oder verbirgt ein echtes Update dauerhaft. */
+describe("buendelPasst", () => {
+  it("lehnt ab, wenn kein Bündel vorliegt", () => {
+    expect(buendelPasst(null, "2026.8.23.2")).toBe(false)
+  })
+
+  it("lehnt ab, wenn Bündel- und eigene Version übereinstimmen", () => {
+    expect(buendelPasst(buendel({ version: "2026.8.24.1" }), "2026.8.24.1")).toBe(false)
+  })
+
+  it("akzeptiert bei abweichender Version", () => {
+    expect(buendelPasst(buendel({ version: "2026.8.24.2" }), "2026.8.24.1")).toBe(true)
+  })
+
+  it("lehnt ab, wenn die eigene Version unbekannt ist", () => {
+    // null heißt "diese App weiß nicht, welche Version sie ist" (z. B. im
+    // Dev-Server ohne eingebautes __APP_VERSION__) - dann lässt sich ein
+    // Update nicht sinnvoll anbieten, weil "abweichend" nicht feststellbar ist.
+    expect(buendelPasst(buendel(), null)).toBe(false)
+  })
+
+  it("lehnt ab, wenn dem Bündel Pflichtfelder fehlen", () => {
+    expect(buendelPasst(buendel({ url: "" }), "2026.8.23.2")).toBe(false)
+    expect(buendelPasst(buendel({ sha256: "" }), "2026.8.23.2")).toBe(false)
+    expect(buendelPasst(buendel({ version: "" }), "2026.8.23.2")).toBe(false)
+  })
+
+  /* Der eigentliche Zweck, und bis zum 03.09.2026 nur ein Kommentar: das
+     Bündel muss zu der Fassung gehören, die der Server ausliefert. Ohne
+     diese Prüfung meldete die App "diese Fassung ändert auch Natives",
+     obwohl nur das Bündel nach einem Versionssprung nicht neu gebaut war. */
+  it("akzeptiert, wenn das Bündel die Fassung des Servers ist", () => {
+    expect(buendelPasst(buendel({ version: "2026.9.3.11" }), "2026.9.3.10", "2026.9.3.11")).toBe(
+      true,
+    )
+  })
+
+  it("lehnt ab, wenn das Bündel hinter dem Server zurückliegt", () => {
+    expect(buendelPasst(buendel({ version: "2026.9.3.10" }), "2026.9.3.9", "2026.9.3.11")).toBe(
+      false,
+    )
+  })
+
+  it("prüft ohne bekannte Serverfassung nur gegen die eigene", () => {
+    // Offline oder altes Backend: einen Vergleich, den man nicht anstellen
+    // kann, darf der Knopf nicht ausbaden.
+    expect(buendelPasst(buendel({ version: "2026.9.3.11" }), "2026.9.3.10", null)).toBe(true)
+  })
+})
+
+/* Der gemeldete Fall vom 04.09.2026: nach einem Xcode-Lauf lief die App auf
+   2026.9.4.17, die Instanz stand noch auf 2026.9.4.5 - und bot an, sich auf
+   .5 zu "erneuern". Das Bündel passte zur Serverfassung, war also nach der
+   damaligen Prüfung in Ordnung; dass es ein Rückschritt ist, konnte sie nicht
+   sehen. Vorgabe des Eigentümers: erkannt wird eine NEUERE Fassung, sonst
+   keine. */
+describe("buendelPasst geht nur vorwaerts", () => {
+  it("lehnt den gemeldeten Rueckschritt ab, obwohl das Buendel zum Server passt", () => {
+    expect(
+      buendelPasst(buendel({ version: "2026.9.4.5" }), "2026.9.4.17", "2026.9.4.5"),
+    ).toBe(false)
+  })
+
+  it("nimmt dieselbe Lage nach dem Nachziehen der Instanz an", () => {
+    // Sobald die Integration auf .18 steht, geht es wieder vorwaerts.
+    expect(
+      buendelPasst(buendel({ version: "2026.9.4.18" }), "2026.9.4.17", "2026.9.4.18"),
+    ).toBe(true)
+  })
+
+  it("lehnt einen Rueckschritt auch ohne bekannte Serverfassung ab", () => {
+    expect(buendelPasst(buendel({ version: "2026.9.4.5" }), "2026.9.4.17", null)).toBe(false)
+  })
+
+  it("vergleicht die letzte Stelle als Zahl, nicht zeichenweise", () => {
+    // "9" gegen "10": zeichenweise stuende "10" davor.
+    expect(buendelPasst(buendel({ version: "2026.9.4.10" }), "2026.9.4.9", null)).toBe(true)
+    expect(buendelPasst(buendel({ version: "2026.9.4.9" }), "2026.9.4.10", null)).toBe(false)
+  })
+
+  it("bleibt beim alten Verhalten, wenn sich die Reihenfolge nicht bestimmen laesst", () => {
+    // Formatwechsel: dann entscheidet weiterhin allein die Serverfassung -
+    // eine Reihenfolge zu erfinden waere schlechter als die alte Regel.
+    expect(buendelPasst(buendel({ version: "fruehling-3" }), "2026.9.4.17", "fruehling-3")).toBe(
+      true,
+    )
+  })
+})

companion-app/src/daten/ota.ts

@@ -0,0 +1,179 @@
+/**
+ * Oberflächen-Updates ohne Xcode („OTA").
+ *
+ * Die native Hülle trägt ihre Oberfläche fest gebündelt — sie bleibt auf dem
+ * Stand vom Signieren, unbegrenzt. Diese Datei ist der Ausweg: die App lädt
+ * ein neues Bündel von der eigenen Home-Assistant-Instanz und tauscht es aus.
+ *
+ * WOHER DAS BÜNDEL KOMMT
+ * ----------------------
+ * Aus der Integration selbst: `custom_components/audi_dashboard/frontend/app/`
+ * enthält `bundle.zip` und `bundle.json`, ausgeliefert unter
+ * `/audi_dashboard_static/app/`. Damit reist das Bündel bei jedem
+ * HACS-Update mit, und es kann gar nicht zur Integration unpassend sein — es
+ * ist dieselbe Lieferung. Gebaut wird es von
+ * `companion-app/scripts/ota-paket.ps1`.
+ *
+ * Welche Fassung bereitliegt, sagt `sensor.audi_dashboard_app_version` im
+ * Attribut `daten.buendel`. Kein zweiter Abruf, keine zweite Quelle.
+ *
+ * WAS OTA NICHT KANN
+ * ------------------
+ * Nur Weboberfläche — HTML, CSS, JavaScript, Bilder. Alles Native (Plugins,
+ * Capacitor selbst, Berechtigungen, iOS-Einstellungen) braucht weiterhin
+ * Xcode. Deshalb setzt `resetWhenUpdate` in capacitor.config.ts nach einer
+ * frischen Xcode-Installation wieder auf das eingebaute Bündel zurück: sonst
+ * überdeckte ein älteres OTA-Bündel genau die native Änderung, für die man
+ * Xcode gebraucht hat.
+ *
+ * DIE RÜCKFALLEBENE
+ * -----------------
+ * `startklarMelden()` unten muss nach jedem Start laufen. Bleibt die Meldung
+ * aus (weil das neue Bündel gar nicht erst hochkommt), kehrt das Plugin nach
+ * `appReadyTimeout` von selbst zum vorherigen Bündel zurück. Ein kaputtes
+ * Bündel kann das Gerät deshalb nicht dauerhaft unbrauchbar machen — man
+ * landet wieder da, wo man vorher war.
+ */
+
+import { Capacitor } from "@capacitor/core"
+import { CapacitorUpdater } from "@capgo/capacitor-updater"
+
+import type { Buendelangabe } from "../api"
+import { versionOrdnung } from "./appVersion"
+
+/** Läuft die App in der nativen Hülle? Nur dort gibt es etwas auszutauschen —
+    im Browser und im HA-Panel lädt ohnehin jeder Seitenaufruf den aktuellen
+    Stand. */
+export function otaMoeglich(): boolean {
+  return Capacitor.isNativePlatform()
+}
+
+/**
+ * Meldet dem Plugin, dass dieses Bündel hochgekommen ist.
+ *
+ * Ohne diesen Aufruf rollt das Plugin nach kurzer Zeit auf das vorherige
+ * Bündel zurück — was genau richtig ist, wenn ein Update die App zerlegt hat.
+ * Deshalb steht der Aufruf bewusst dort, wo React nachweislich gerendert hat
+ * (App.tsx), und nicht schon in main.tsx: ein Absturz beim ersten Rendern
+ * soll als Fehlschlag gelten und den Rückfall auslösen.
+ */
+export async function startklarMelden(): Promise<void> {
+  if (!otaMoeglich()) return
+  try {
+    await CapacitorUpdater.notifyAppReady()
+  } catch (fehler) {
+    // Nur protokollieren: Scheitert die Meldung, greift der Rückfall — das
+    // ist unangenehm, aber sicher. Ein Absturz an dieser Stelle wäre schlimmer.
+    console.warn("OTA: notifyAppReady fehlgeschlagen", fehler)
+  }
+}
+
+/** Ist ein anderes Bündel verfügbar als das gerade laufende?
+    Dieselbe Vorsicht wie in versionVergleichen() (appVersion.ts): kennt die
+    App ihre eigene Version nicht (eigene === null — praktisch nur im
+    Dev-Server, ein natives Release baut nie ohne __APP_VERSION__), gilt das
+    als "nicht vergleichbar", nicht als "abweichend". Alles andere böte einen
+    Update-Knopf an, dessen Ziel man mit der laufenden Fassung gar nicht
+    abgleichen konnte. */
+export function buendelPasst(
+  buendel: Buendelangabe | null,
+  eigene: string | null,
+  serverVersion?: string | null,
+): boolean {
+  if (!buendel?.version || !buendel.url || !buendel.sha256 || !eigene) return false
+  // Es muss etwas ANDERES sein als das, was gerade läuft - sonst gibt es
+  // nichts zu holen.
+  if (buendel.version === eigene) return false
+  // Und es muss VORWAERTS gehen. Am 04.09.2026 lief die App nach einem
+  // Xcode-Lauf auf 2026.9.4.17, während die Instanz noch 2026.9.4.5
+  // auslieferte - angeboten wurde ein Rückschritt auf .5, der die
+  // Oberfläche still um zwölf Fassungen zurückgedreht hätte. Die
+  // Gleichheitsprüfung konnte das nicht sehen; siehe appVersion.ts.
+  const ordnung = versionOrdnung(buendel.version, eigene)
+  if (ordnung !== null && ordnung <= 0) return false
+  // Und es muss die Fassung sein, die diese Installation ausliefert. Ohne
+  // bekannte Serverfassung bleibt es beim alten Verhalten - ein Vergleich,
+  // den man nicht anstellen kann, darf den Knopf nicht wegnehmen.
+  if (serverVersion == null) return true
+  return buendel.version === serverVersion
+}
+
+export class OtaFehler extends Error {}
+
+/**
+ * Erklärt einen fehlgeschlagenen Download, statt die Meldung des Plugins
+ * durchzureichen.
+ *
+ * „Checksum" heißt: die geladenen Bytes sind nicht die erwarteten. In diesem
+ * Projekt war die Ursache bisher nie ein kaputtes Bündel (Ablage, Auslieferung
+ * und Prüfsumme sind nachweislich deckungsgleich), sondern ein Download, der
+ * mitten in einen Neustart von Home Assistant lief. Das ist keine Sackgasse,
+ * sondern ein Grund, es gleich noch einmal zu versuchen - und genau das soll
+ * dort stehen, wo der Fehler steht.
+ */
+function ladefehlerText(fehler: unknown): string {
+  const meldung = fehler instanceof Error ? fehler.message : String(fehler)
+  if (/checksum|prüfsumme|pruefsumme/i.test(meldung)) {
+    return (
+      "Das Update kam unvollständig an. Das passiert, wenn Home Assistant " +
+      "während des Ladens neu startet. Sobald es wieder läuft, noch einmal " +
+      `versuchen. (${meldung})`
+    )
+  }
+  return `Das Update konnte nicht geladen werden (${meldung}).`
+}
+
+/**
+ * Lädt das Bündel und schaltet darauf um.
+ *
+ * Kehrt im Erfolgsfall **nie** zurück: `set()` zerstört den JavaScript-Kontext
+ * und lädt die App neu. Alles, was danach stünde, liefe nicht mehr — deshalb
+ * steht hier auch keine Erfolgsmeldung. Der Erfolg ist, dass die App neu
+ * startet.
+ *
+ * @param basisUrl Adresse der Home-Assistant-Instanz, wie beim Einrichten
+ *                 hinterlegt. Die Bündel-URL aus der Entität ist ein Pfad.
+ */
+export async function buendelAnwenden(
+  buendel: Buendelangabe,
+  basisUrl: string,
+): Promise<never> {
+  if (!otaMoeglich()) throw new OtaFehler("Updates gibt es nur in der App auf dem Gerät.")
+
+  // Die Fassung hängt als Abfrageteil an der Adresse.
+  //
+  // Home Assistant liefert /audi_dashboard_static/ ohne Cache-Control, aber
+  // mit ETag und Last-Modified (nachgemessen). Genau dann darf jeder Zwischen-
+  // speicher - der des Geräts wie einer im Weg - die Datei nach eigenem
+  // Ermessen eine Weile behalten. Käme dabei die vorherige Zip zurück, während
+  // die Prüfsumme aus der Entität längst die neue nennt, scheiterte jedes
+  // Update mit einem Prüfsummenfehler, ohne dass irgendetwas kaputt wäre.
+  // Dieselbe Vorsorge trifft das Panel seit jeher für sein eigenes Bündel.
+  const adresse = new URL(buendel.url, basisUrl)
+  adresse.searchParams.set("v", buendel.version)
+  let geladen
+  try {
+    geladen = await CapacitorUpdater.download({
+      url: adresse.href,
+      version: buendel.version,
+      // Das Plugin rechnet auf dem Gerät SHA-256 über die heruntergeladene
+      // Zip und verwirft sie bei Abweichung (calcChecksum in
+      // CapgoUpdater.swift). Ein abgebrochener Download oder eine halb
+      // gespiegelte Datei fällt damit auf, bevor die App sie startet.
+      checksum: buendel.sha256,
+    })
+  } catch (fehler) {
+    throw new OtaFehler(ladefehlerText(fehler))
+  }
+
+  try {
+    await CapacitorUpdater.set({ id: geladen.id })
+  } catch (fehler) {
+    throw new OtaFehler(
+      `Das Update wurde geladen, ließ sich aber nicht starten (${fehler instanceof Error ? fehler.message : String(fehler)}).`,
+    )
+  }
+  // Unerreichbar: set() lädt die App neu. Steht hier, damit der Rückgabetyp
+  // ehrlich bleibt.
+  throw new OtaFehler("Die App hätte an dieser Stelle neu starten müssen.")
+}

companion-app/src/daten/paritaet_hu.test.ts

@@ -0,0 +1,74 @@
+import { readFileSync } from "node:fs"
+import { describe, expect, it } from "vitest"
+import { hauptuntersuchungFaellig } from "./service"
+
+/* Vergleicht die Ableitung der Hauptuntersuchung Zeile für Zeile gegen die
+   ECHTEN Panel-Funktionen, aus der Panel-Quelle herausgeschnitten. */
+const quelle = readFileSync(
+  "../custom_components/audi_dashboard/frontend/audi-dashboard-app.js", "utf8")
+const block = (kopf: string) => {
+  const i = quelle.indexOf(kopf)
+  if (i < 0) throw new Error("fehlt: " + kopf)
+  let tiefe = 0
+  for (let k = quelle.indexOf("{", i); k < quelle.length; k++) {
+    if (quelle[k] === "{") tiefe++
+    else if (quelle[k] === "}" && !--tiefe) return quelle.slice(i, k + 1)
+  }
+  throw new Error("unvollstaendig: " + kopf)
+}
+const zeile = (muster: RegExp) => {
+  const m = muster.exec(quelle)
+  if (!m) throw new Error("fehlt: " + muster)
+  return m[0]
+}
+
+const panel = new Function(`
+  ${zeile(/^const DATUM_ISO = .*$/m)}
+  ${zeile(/^const DATUM_TAG = .*$/m)}
+  ${zeile(/^const DATUM_MONAT = .*$/m)}
+  ${zeile(/^const DATUM_ISO_MONAT = .*$/m)}
+  ${block("function datumBauen")}
+  ${zeile(/^const gueltigesDatum = .*$/m)}
+  ${block("function datumAusText")}
+  ${block("function dat(")}
+  ${zeile(/^function monatePlus.*$/m)}
+  return { datumAusText, monatePlus };
+`)() as {
+  datumAusText: (w: string) => { zeit: Date; genau: string } | null
+  monatePlus: (d: string | Date, m: number) => Date
+}
+
+const iso = (d: Date | null) => d === null ? null
+  : `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+
+/* Wie hauptuntersuchungsTermin() im Panel, nur ohne dessen CAR-Zugriff.
+
+   Beide Seiten führen die Genauigkeit mit, nur in verschiedener Form: das
+   Panel als Merkmal `genau` am Termin, die App als ISO-Monat im Text
+   ("2028-03"). Verglichen wird deshalb die normalisierte Form - dieselbe
+   Aussage, nicht dieselbe Darstellung. */
+const panelHU = (erst: string, eintragDe?: string) => {
+  if (eintragDe) return iso(panel.monatePlus(eintragDe, 24))
+  const z = panel.datumAusText(erst)
+  if (!z) return null
+  const ziel = iso(panel.monatePlus(z.zeit, 36))
+  return z.genau === "monat" ? ziel!.slice(0, 7) : ziel
+}
+
+describe("Hauptuntersuchung: Panel und App rechnen gleich", () => {
+  for (const erst of ["01.03.2025", "2025-03-01", "15.01.2025", "20.11.2025",
+                      "10.02.2025", "29.02.2024", "31.12.2023", "03/2025",
+                      "31.02.2025", "", "Unsinn"]) {
+    it(`Erstzulassung ${JSON.stringify(erst)}`, () => {
+      expect(hauptuntersuchungFaellig([], erst)).toBe(panelHU(erst))
+    })
+  }
+  const paare: [string, string][] = [["15.01.2025", "2025-01-15"], ["20.11.2025", "2025-11-20"],
+                                    ["10.02.2025", "2025-02-10"], ["29.02.2024", "2024-02-29"]]
+  for (const [de, isoDatum] of paare) {
+    it(`Wartungsplan ${de}`, () => {
+      expect(hauptuntersuchungFaellig([{ art: "Hauptuntersuchung", datum: isoDatum }], "01.03.2025"))
+        .toBe(panelHU("01.03.2025", de))
+    })
+  }
+})