integrate heating rule fix and quality workflow

.dockerignore

@@ -1,16 +0,0 @@
-.env
-.env.*
-!.env.example
-.venv
-.venv/*
-__pycache__
-.mypy_cache
-.pytest_cache
-.ruff_cache
-node_modules
-.idea
-.vscode
-.git
-.gitignore
-.dockerignore
-docker-compose*.yml

.env.example

@@ -1,15 +1,3 @@
+# Copy to .env for local development. Do not commit real tokens.
 SILLYHOME_HA_URL=http://homeassistant.local:8123
-SILLYHOME_HA_TOKEN=REPLACE_ME_WITH_LONG_LIVED_TOKEN
-SILLYHOME_MODEL_STORE=.model_store
-SILLYHOME_AUTOMATION_STORE=.automation_store
-SILLYHOME_ACTUATOR_STORE=.actuator_store
-SILLYHOME_HISTORY_DAYS=14
-SILLYHOME_MIN_TRAINING_POINTS=24
-SILLYHOME_RETRAIN_STALE_HOURS=24
-SILLYHOME_RECONCILE_INTERVAL_SECONDS=900
-SILLYHOME_MIN_BEHAVIOR_ACTIONS=3
-SILLYHOME_PREDICTION_CONFIDENCE=0.82
-SILLYHOME_PREDICTION_WINDOW_MINUTES=30
-SILLYHOME_PREDICTION_INTERVAL_SECONDS=60
-SILLYHOME_EXECUTION_COOLDOWN_SECONDS=900
-SILLYHOME_TIMEZONE=Europe/Berlin
+SILLYHOME_HA_TOKEN=replace-with-a-long-lived-access-token

.gitea/workflows/quality.yml

@@ -1,24 +1,31 @@
-name: quality
+name: Quality
 
 on:
   push:
-    branches: ["main", "otto/**", "feature/**"]
+    branches:
+      - "**"
   pull_request:
 
 jobs:
   test:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.11", "3.13"]
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
         with:
-          python-version: ${{ matrix.python-version }}
-          cache: pip
-      - run: python -m pip install --upgrade pip
-      - run: python -m pip install -e ".[dev]"
-      - run: python -m pytest
-      - run: ruff check .
-      - run: mypy
+          python-version: "3.11"
+
+      - name: Install project
+        run: python -m pip install --upgrade pip && python -m pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -q
+
+      - name: Run Ruff
+        run: ruff check .
+
+      - name: Run Mypy
+        run: mypy app tests

.gitignore

@@ -4,10 +4,10 @@
 /.vscode
 __pycache__/
 *.pyc
-*.egg-info/
 .mypy_cache/
 .pytest_cache/
 .ruff_cache/
 .env
 .env.local
 .env.*
+!.env.example

ARCHITECTURE.md

@@ -1,21 +1,13 @@
 # SillyHome Next — Architekturübersicht
 
-Ziel ist ein lokales, datensparsames und erklärbares Smart-Home-Intelligenzsystem
-für Home Assistant. Nutzer wählen ausschließlich erlaubte Aktoren. Das System
-ordnet Kontext automatisch zu, erkennt historische Nutzerhandlungen, trainiert
-pro Aktor ein Verhaltensmodell und trifft zunächst nur Shadow-Vorhersagen.
-Autonomes Schalten wird separat pro Aktor freigegeben.
+Ziel ist ein lokales, datensparsames, erklärbares Smart-Home-Intelligenzsystem für Home Assistant. Es analysiert Historie, erkennt Gewohnheiten, erstellt Vorhersagen, empfiehlt Automationen und kann auf Wunsch einfach in Automationen übersetzen. Vier Intelligenzebenen sind vorgesehen: regelbasiert, ML-gestützt, LLM-unterstützt und autonomer Hausagent.
 
 ## Leitentscheidungen
 
 - Lokal-first und datensparsam; keine Cloudpflicht.
-- Trennung von Datenintegration, Kontextzuordnung, Verhaltenslernen,
-  Vorhersage und Aktorausführung.
-- Logbook-basierte Herkunftserkennung; bekannte Automationen und eigene
-  Schaltungen werden nicht als Nutzerhandlungen trainiert.
-- Ausführung nur für freigegebene, reversible Domains und Zustände sowie mit
-  Konfidenzschwelle und Cooldown.
-- Standardintegration über die lokale Home-Assistant-REST-API.
-- Persistenz als atomische lokale Modell- und Aktorartefakte.
-- Deployment als Home-Assistant-Add-on oder über Docker Compose.
+- Trennung von Datenintegration, Trainingspipeline, Vorhersageservice und Erklärungsschicht.
+- Standardintegration über MQTT und Home Assistant WebSocket plus REST.
+- Schnittstellen über FastAPI und OpenAI-kompatible Endpunkte.
+- Langzeitdaten in PostgreSQL und TimescaleDB; Vektoren für semantische Suche optional.
+- Deployment über Docker Compose; Kubernetes optional für erweiterte Betriebsgrößen.
 - Tests, Docs und Changelog sind Pflichtbestandteil jeder Änderung.

CHANGELOG.md

@@ -1,78 +1,5 @@
 # Changelog
 
-## 0.6.1 - 2026-06-14
-- Manuelle Prüfung als `Aktuelle Situation auswerten` eindeutig von Simulation
-  oder Aktorschaltung abgegrenzt
-- Sichtbare Rückmeldung mit Prüfzeitpunkt, vorhergesagtem Zustand und Sicherheit
-  oder klarem Hinweis auf einen fehlenden frischen Sensorwechsel
-
-## 0.6.0 - 2026-06-14
-- Kausales Shadow-Lernen erkennt frische Kontextwechsel unmittelbar vor einer
-  Aktorhandlung, etwa `Tür geschlossen → offen` vor `Licht aus → an`
-- Historische Home-Assistant-Automationen dürfen Vorhersagen begründen, zählen
-  aber weiterhin niemals als eindeutige Benutzerhandlung oder Ausführungsfreigabe
-- Aktuelle `last_changed`-Zeitpunkte verhindern Vorhersagen aus längst
-  unveränderten Sensorzuständen
-- Oberfläche trennt gelernte Benutzerhandlungen und erkannte HA-Automationen
-
-## 0.5.4 - 2026-06-14
-- Tür-, Bewegungs- und andere belastbare Kontextsensoren werden auch ohne
-  numerischen Sensor als vollständige automatische Kontextzuordnung angezeigt
-- Status und Zuordnungssicherheit bilden das aktive Verhaltenslernen ab statt
-  eines optionalen numerischen Modells
-- Ausführungsfreigabe erscheint erst, wenn genügend eindeutig manuelle
-  Bedienungen vorliegen; bis dahin nennt die Oberfläche die noch fehlende Anzahl
-
-## 0.5.3 - 2026-06-14
-- Verhindert fachlich falsche Sensorzuordnungen nur aufgrund generischer Namen wie
-  `Licht` oder `Lichtschalter`
-- Übernimmt numerische Sensoren nur noch bei einem belastbaren absoluten Score und
-  einer eindeutigen Abgrenzung zum zweitbesten Kandidaten
-- Begrenzt Zusatzkontext auf relevante Sensoren und bevorzugt bei Lichtaktoren
-  echte Beleuchtungsstärke gegenüber fremden Leistungs- oder Energiezählern
-
-## 0.5.2 - 2026-06-14
-- Add-on-Build invalidiert den Docker-Cache bei jeder Versionsänderung, damit
-  Versionsmetadaten und tatsächlich ausgelieferter Anwendungscode übereinstimmen
-- Korrigierte Ingress-Oberfläche aus 0.5.1 dadurch erstmals zuverlässig ausgeliefert
-
-## 0.5.1 - 2026-06-14
-- Technische Modell-, Intervall- und Sicherheitsparameter aus der normalen
-  Home-Assistant-Add-on-Konfiguration entfernt; sichere Standardwerte bleiben aktiv
-- Ingress um einen klaren Ablauf mit Aktorauswahl, Beobachtungsphase und späterer
-  Ausführungsfreigabe ergänzt
-- Bedienelemente und Diagnosen in verständlicher Alltagssprache erklärt
-
-## 0.5.0 - 2026-06-14
-- Ingress auf reine Aktorauswahl, automatischen Lernstatus und Vorhersagen reduziert
-- Automatische Kontextzuordnung ohne Sensor-Overrides oder Review-Blockade
-- Historische Handlungserkennung aus HA-State-History und Logbook-Herkunft
-- Persistentes Verhaltensmodell pro Aktor mit Zeit-, Wochentags- und Kontextmustern
-- Shadow-Vorhersagen vor jeder Ausführungsfreigabe
-- Explizite Aktivierung pro Aktor, Konfidenzschwelle, Cooldown und enge Service-Whitelist
-- Schutz vor dem Lernen erkannter HA-Automationen und eigener Schaltvorgänge
-- Automation-Proposal- und Override-Endpunkte aus dem aktiven Produkt entfernt
-
-## 0.4.0 - 2026-06-13
-- Aktuator-zentrierte Einrichtung: Nutzer wählen nur noch Aktuatoren, Sensoren werden deterministisch gefunden und bewertet
-- Persistente automatische und manuelle Sensorzuordnungen mit Evidenz, Confidence, Review-Gating und Neustart-Sicherheit
-- Autonomer Modell-Lebenszyklus auf echter HA-Historie: Training, Retraining bei Staleness oder Datenänderung, Archivierung von Waisen
-- Neues Dashboard und API für Aktuatorauswahl, Reconciliation, Overrides, Modellstatus und Audit-Trail
-- Neue Container-/Add-on-Defaults für Aktuator-Store und periodische Reconciliation ohne zusätzliche Gerätesteuerung
-
-## 0.2.0 - 2026-06-13
-- Klassifizierte Home-Assistant-Entity-Discovery mit Lernrelevanz und Filtern
-- Validierter Zugriff auf die Home-Assistant-History-API
-- Normalisierte, chronologisch sortierte numerische Zeitreihen über `/v1/history`
-- Trainierbares statistisches Baseline-Modell mit persistierten Parametern
-- Numerische Vorhersagen mit Confidence sowie MAE-/RMSE-Evaluation
-
-## 0.1.0 - 2026-06-13
+## Unreleased
 - Projektinitiierung
 - Architektur, ADRs und Roadmap
-- Einheitliche produktive FastAPI-App für HA- und ML-Routen
-- Funktionierende ENV-Konfiguration und sauberer HA-503-Zustand
-- Persistente, validierte und gegen Path Traversal gehärtete Model Registry
-- Reproduzierbares Packaging, CI-Gates und gehärteter non-root Container
-- Definierte API-Fehler und korrigierte Evaluationsmetriken
-- Scheduler-tauglicher Retraining-Service mit API und atomischem Registry-Update

Dockerfile

@@ -1,39 +0,0 @@
-FROM python:3.13-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1 \
-    SILLYHOME_MODEL_STORE=/app/data/models
-ENV SILLYHOME_AUTOMATION_STORE=/app/data/automations \
-    SILLYHOME_ACTUATOR_STORE=/app/data/actuators \
-    SILLYHOME_HISTORY_DAYS=14 \
-    SILLYHOME_MIN_TRAINING_POINTS=24 \
-    SILLYHOME_RETRAIN_STALE_HOURS=24 \
-    SILLYHOME_RECONCILE_INTERVAL_SECONDS=900 \
-    SILLYHOME_MIN_BEHAVIOR_ACTIONS=3 \
-    SILLYHOME_PREDICTION_CONFIDENCE=0.82 \
-    SILLYHOME_PREDICTION_WINDOW_MINUTES=30 \
-    SILLYHOME_PREDICTION_INTERVAL_SECONDS=60 \
-    SILLYHOME_EXECUTION_COOLDOWN_SECONDS=900 \
-    SILLYHOME_TIMEZONE=Europe/Berlin
-
-WORKDIR /app
-
-RUN addgroup --system sillyhome && adduser --system --ingroup sillyhome sillyhome
-
-COPY pyproject.toml README.md ./
-COPY app ./app
-COPY backend ./backend
-RUN python -m pip install --upgrade pip && \
-    python -m pip install . && \
-    mkdir -p /app/data/models /app/data/automations /app/data/actuators && \
-    chown -R sillyhome:sillyhome /app/data
-
-EXPOSE 8000
-
-USER sillyhome
-
-HEALTHCHECK --interval=30s --timeout=3s --start-period=10s --retries=3 \
-    CMD ["python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/health', timeout=2)"]
-
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,14 +1,6 @@
 # SillyHome Next
 
-Lokaler, datenschutzfreundlicher API-Prototyp für Home Assistant.
-
-## Reifegrad
-
-Die aktuelle Entwicklungslinie ist vollständig aktor-zentriert: Nutzer wählen
-nur Home-Assistant-Aktuatoren aus. SillyHome Next findet Sensoren, Zustände und
-Kontext automatisch, wertet die vorhandene Historie aus und hält passende
-lokale Modelle autonom aktuell. Es gibt keinen Regel-, Trigger-, Sensor- oder
-YAML-Konfigurationsschritt.
+Modern, lokal-first und datenschutzfreundliches Smart-Home-Intelligenzsystem für Home Assistant.
 
 ## Motivation
 TheSillyHome zeigte die Idee: statt statischer Regeln das Zuhause aus Verhaltensmustern verstehen. Diese Architektur modernisiert den Ansatz in Richtung Explainable AI, hybride Intelligenzebenen und langlebige Wartbarkeit.
@@ -17,109 +9,56 @@ TheSillyHome zeigte die Idee: statt statischer Regeln das Zuhause aus Verhaltens
 - Home Assistant und Sensoren/Aktoren verstehen
 - Historie auswerten und Gewohnheiten erkennen
 - Vorhersagen erstellen und erklären
-- Persönliches Verhalten pro Aktor lernen und zukünftige Handlungen vorhersagen
+- Automationen vorschlagen und direkt generieren
 - Lokal-first ohne Cloudpflicht
 - Erweiterbar, testbar, dokumentiert
 
-## Quickstart
-1. Python-Venv anlegen und Abhängigkeiten installieren:
+## Lokaler Quickstart
+
+Voraussetzung ist Python 3.11 oder neuer.
+
 ```bash
 python -m venv .venv
-source .venv/bin/activate
-pip install -e ".[dev]"
-```
-
-2. Konfiguration aus `.env.example` übernehmen und anpassen:
-```bash
+. .venv/bin/activate
+python -m pip install --upgrade pip
+python -m pip install -e ".[dev]"
 cp .env.example .env
 ```
 
-3. API starten:
+In `.env` müssen für echte Home-Assistant-Daten diese Werte gesetzt werden:
+
+```bash
+SILLYHOME_HA_URL=http://homeassistant.local:8123
+SILLYHOME_HA_TOKEN=<long-lived-access-token>
+```
+
+Alternativ werden aus Kompatibilitätsgründen auch `HA_URL` und `HA_TOKEN` gelesen.
+Tokens bleiben lokal und dürfen nicht committed, geloggt oder in Issues kopiert werden.
+
+API starten:
+
 ```bash
 uvicorn app.main:app --reload
 ```
 
-4. Erreichbar unter:
-- `http://127.0.0.1:8000/` - lokales Dashboard
-- `http://127.0.0.1:8000/health` - Health-Check
-- `http://127.0.0.1:8000/docs/` - OpenAPI-Dokumentation
-- `http://127.0.0.1:8000/v1/entities` - Home-Assistant-Entities
-- `http://127.0.0.1:8000/v1/discovery` - klassifizierte, filterbare Entities
-- `http://127.0.0.1:8000/v1/history` - normalisierte numerische Zeitreihen
-- `http://127.0.0.1:8000/v1/actuators/discovery` - unterstützte Aktuatoren für den aktor-zentrierten Workflow
-- `POST http://127.0.0.1:8000/v1/actuators` - Aktor freigeben; Kontextzuordnung und Modell-Lebenszyklus starten automatisch
-- `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/evaluate` - Shadow-Vorhersage aktualisieren
-- `POST http://127.0.0.1:8000/v1/actuators/{entity_id}/activation` - autonomes Schalten pro Aktor freigeben oder stoppen
-- `POST http://127.0.0.1:8000/v1/actuators/reconciliation/run` - globale Reconciliation manuell anstoßen
-- `http://127.0.0.1:8000/ml/health` - Registry-/Serving-Health
-- `POST http://127.0.0.1:8000/ml/retrain` - Modell-Metadaten aktualisieren
-- `POST http://127.0.0.1:8000/ml/evaluate` - MAE/RMSE/Coverage berechnen
-
-Ohne vollständige HA-Konfiguration liefert `/v1/entities` bewusst `503`.
-
-### Docker Compose
+Nützliche Checks:
 
 ```bash
-cp .env.example .env
-docker compose up --build -d
-curl --fail http://127.0.0.1:8000/health
+curl http://127.0.0.1:8000/health
+curl http://127.0.0.1:8000/v1/entities
 ```
 
-Compose veröffentlicht die API standardmäßig nur auf `127.0.0.1`. Für Zugriff aus
-dem Netz muss ein authentifizierender Reverse Proxy vorgeschaltet werden.
+Die interaktive API-Dokumentation liegt unter `http://127.0.0.1:8000/docs`.
 
-### ENV-Konfiguration (`.env.example`)
-- `SILLYHOME_HA_URL` – Basis-URL deiner Home-Assistant-Instanz (z. B. `http://homeassistant.local:8123`)
-- `SILLYHOME_HA_TOKEN` – Long-Lived Access Token eines dedizierten HA-Benutzers mit minimalen Rechten
-- `SILLYHOME_MODEL_STORE` – Verzeichnis für persistierte Modell-Metadaten
-- `SILLYHOME_ACTUATOR_STORE` – Verzeichnis für persistente Aktor-Zuordnungen und Reconciliation-Status
-- `SILLYHOME_HISTORY_DAYS` – Trainingsfenster für HA-History (1 bis 31 Tage)
-- `SILLYHOME_MIN_TRAINING_POINTS` – Mindestanzahl nutzbarer numerischer Messpunkte vor einem Modelltraining
-- `SILLYHOME_RETRAIN_STALE_HOURS` – Staleness-Grenze für automatisches Retraining
-- `SILLYHOME_RECONCILE_INTERVAL_SECONDS` – Intervall für sichere periodische Reconciliation
-- `SILLYHOME_MIN_BEHAVIOR_ACTIONS` – Mindestzahl gelernter Handlungen vor einer Freigabe
-- `SILLYHOME_PREDICTION_CONFIDENCE` – Mindestkonfidenz für autonomes Schalten
-- `SILLYHOME_PREDICTION_WINDOW_MINUTES` – Zeitfenster um gelernte Handlungsmuster
-- `SILLYHOME_PREDICTION_INTERVAL_SECONDS` – Intervall für Shadow-/Aktiv-Vorhersagen
-- `SILLYHOME_EXECUTION_COOLDOWN_SECONDS` – Mindestabstand zwischen eigenen Schaltungen
-- `SILLYHOME_TIMEZONE` – lokale Zeitzone für Tages- und Wochenmuster
+## Qualität
 
-Niemals Administrator-Tokens oder Passwörter eintragen. `.env` gehört nicht ins
-Versionskontrollsystem.
+Vor jedem Pull Request lokal laufen lassen:
 
-### Home-Assistant-Add-on
-
-Das Repository ist zugleich ein Home-Assistant-Add-on-Repository. In Home Assistant
-unter **Einstellungen → Add-ons → Add-on-Shop → Repositories** diese URL eintragen:
-
-`http://192.168.6.31:3000/pino/sillyhome-next`
-
-Danach **SillyHome Next** installieren und starten. Das Dashboard wird per Ingress
-geöffnet. Dort werden ausschließlich erlaubte Aktoren ausgewählt; Kontext- und
-Lernentscheidungen erfolgen automatisch.
-
-### Normaler Workflow
-1. Im Dashboard einen Aktor auswählen, zum Beispiel `light.abstellkammer`.
-2. SillyHome Next bewertet automatisch Messwerte, Anwesenheit, Bewegung,
-   Bereiche, Gerätebeziehungen und weitere HA-Kontexte.
-3. Das System verwendet selbstständig die beste verfügbare Zuordnung.
-   Niedrige Sicherheit bleibt als Diagnose sichtbar, verlangt aber keine
-   manuelle Konfiguration.
-4. Sobald genügend Historie vorhanden ist, trainiert und aktualisiert das
-   System das lokale Modell automatisch.
-5. Vorhersagen laufen zunächst ausschließlich im Shadow-Modus.
-6. Erst nach ausdrücklicher Freigabe pro Aktor werden hochkonfidente,
-   erlaubte Zustände geschaltet. Eigene Schaltungen und erkannte
-   HA-Automationen werden nicht als Nutzerhandlungen zurückgelernt.
-
-Vor einem Update sollte in Home Assistant unter **Einstellungen → System → Backups**
-eine Teil-Sicherung des Add-ons erstellt werden. Zur Wiederherstellung das gewünschte
-Backup öffnen, **SillyHome Next** auswählen und wiederherstellen. Der erste produktive
-Teststand `v0.3.0` wurde als HA-Backup `7df0fca0` gesichert.
-
-### Tests
 ```bash
-pytest
+pytest -q
 ruff check .
-mypy
+mypy app tests
 ```
+
+Der Gitea-Actions-Workflow in `.gitea/workflows/quality.yml` führt dieselben Checks für
+Pushes und Pull Requests aus.

addon/Dockerfile

@@ -1,23 +0,0 @@
-FROM python:3.13-slim
-
-ENV PYTHONDONTWRITEBYTECODE=1 \
-    PYTHONUNBUFFERED=1 \
-    PIP_NO_CACHE_DIR=1
-
-# The add-on version changes for every release. Copying its config before the
-# clone makes Docker invalidate the application layer instead of reusing old code.
-COPY config.yaml /tmp/addon-config.yaml
-
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends git \
-    && git clone --depth 1 --branch main \
-       http://192.168.6.31:3000/pino/sillyhome-next.git /app \
-    && python -m pip install --upgrade pip \
-    && python -m pip install /app \
-    && rm -rf /var/lib/apt/lists/* /app/.git /tmp/addon-config.yaml
-
-COPY run.sh /run.sh
-RUN chmod 0755 /run.sh
-
-EXPOSE 8000
-CMD ["/run.sh"]

addon/config.yaml

@@ -1,21 +0,0 @@
-name: SillyHome Next
-version: "0.6.1"
-slug: sillyhome_next
-description: Lernt automatisch aus deinem Verhalten und steuert freigegebene Aktoren
-url: http://192.168.6.31:3000/pino/sillyhome-next
-arch:
-  - amd64
-startup: application
-boot: auto
-init: false
-ingress: true
-ingress_port: 8000
-panel_title: SillyHome Next
-panel_icon: mdi:home-analytics
-panel_admin: true
-homeassistant_api: true
-hassio_api: false
-auth_api: false
-map:
-  - type: addon_config
-    read_only: false

addon/run.sh

@@ -1,25 +0,0 @@
-#!/bin/sh
-set -eu
-
-export SILLYHOME_HA_URL="${SILLYHOME_HA_URL:-http://supervisor/core}"
-export SILLYHOME_HA_TOKEN="${SILLYHOME_HA_TOKEN:-${SUPERVISOR_TOKEN:-}}"
-export SILLYHOME_MODEL_STORE=/data/models
-export SILLYHOME_AUTOMATION_STORE=/data/automations
-export SILLYHOME_ACTUATOR_STORE=/data/actuators
-
-if [ -f /data/options.json ]; then
-  export SILLYHOME_HISTORY_DAYS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("history_days", 14))')"
-  export SILLYHOME_MIN_TRAINING_POINTS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("min_training_points", 24))')"
-  export SILLYHOME_RETRAIN_STALE_HOURS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("retrain_stale_hours", 24))')"
-  export SILLYHOME_RECONCILE_INTERVAL_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("reconcile_interval_seconds", 900))')"
-  export SILLYHOME_MIN_BEHAVIOR_ACTIONS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("min_behavior_actions", 3))')"
-  export SILLYHOME_PREDICTION_CONFIDENCE="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_confidence", 0.82))')"
-  export SILLYHOME_PREDICTION_WINDOW_MINUTES="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_window_minutes", 30))')"
-  export SILLYHOME_PREDICTION_INTERVAL_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("prediction_interval_seconds", 60))')"
-  export SILLYHOME_EXECUTION_COOLDOWN_SECONDS="$(python -c 'import json; print(json.load(open("/data/options.json")).get("execution_cooldown_seconds", 900))')"
-  export SILLYHOME_TIMEZONE="$(python -c 'import json; print(json.load(open("/data/options.json")).get("timezone", "Europe/Berlin"))')"
-fi
-
-mkdir -p "$SILLYHOME_MODEL_STORE" "$SILLYHOME_AUTOMATION_STORE" "$SILLYHOME_ACTUATOR_STORE"
-exec uvicorn app.main:app --app-dir /app --host 0.0.0.0 --port 8000 \
-  --proxy-headers --forwarded-allow-ips='*'

app/actuators/__init__.py

@@ -1,27 +0,0 @@
-from app.actuators.lifecycle import (
-    ActuatorReconciliationService,
-)
-from app.actuators.models import (
-    ActuatorRecord,
-    AssignmentCandidate,
-    AssignmentSelection,
-    LifecycleAuditEntry,
-    LifecycleStatus,
-    ManualOverride,
-    ReconciliationState,
-    model_id_for_actuator,
-)
-from app.actuators.store import ActuatorStore
-
-__all__ = [
-    "ActuatorReconciliationService",
-    "ActuatorRecord",
-    "ActuatorStore",
-    "AssignmentCandidate",
-    "AssignmentSelection",
-    "LifecycleAuditEntry",
-    "LifecycleStatus",
-    "ManualOverride",
-    "ReconciliationState",
-    "model_id_for_actuator",
-]

app/actuators/lifecycle.py

@@ -1,601 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import logging
-import re
-from collections.abc import Iterable
-from datetime import datetime, timedelta, timezone
-
-from app.actuators.models import (
-    ActuatorRecord,
-    AssignmentCandidate,
-    AssignmentSelection,
-    AssignmentSource,
-    LifecycleAuditEntry,
-    LifecycleStatus,
-    ModelLifecycleState,
-    ReconciliationState,
-    model_id_for_actuator,
-)
-from app.actuators.store import ActuatorStore
-from app.config import Settings
-from app.ha.discovery import DiscoveredEntity, EntityRole
-from app.ha.history import EntityHistorySeries, NumericHistoryPoint
-from app.ha.models import HaEntitySummary
-from app.ha.reader import HaReader
-from app.ml.feature_store import FeatureVector
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.retraining import retrain_model
-from app.ml.training import TrainedArtifact
-
-logger = logging.getLogger(__name__)
-
-_TOKEN_PATTERN = re.compile(r"[a-z0-9]+", re.IGNORECASE)
-_STOPWORDS = frozenset(
-    {
-        "actuator",
-        "battery",
-        "bin",
-        "binary",
-        "brightness",
-        "current",
-        "door",
-        "energy",
-        "entity",
-        "humidity",
-        "illuminance",
-        "light",
-        "licht",
-        "lichtschalter",
-        "power",
-        "sensor",
-        "state",
-        "switch",
-        "temperature",
-        "value",
-    }
-)
-_NUMERIC_AUTO_ACCEPT_SCORE = 0.82
-_NUMERIC_AUTO_ACCEPT_MIN_SCORE = 0.5
-_NUMERIC_MIN_MARGIN = 0.18
-_CONTEXT_AUTO_ACCEPT_SCORE = 0.78
-_CONTEXT_AUTO_ACCEPT_MIN_SCORE = 0.3
-_MAX_CONTEXT_SELECTIONS = 5
-_AUDIT_LIMIT = 20
-
-
-class ActuatorReconciliationService:
-    def __init__(
-        self,
-        *,
-        ha_reader: HaReader,
-        store: ActuatorStore,
-        registry: ModelRegistry,
-        settings: Settings,
-    ) -> None:
-        self._ha_reader = ha_reader
-        self._store = store
-        self._registry = registry
-        self._settings = settings
-
-    def list_configured(self) -> list[ActuatorRecord]:
-        return self._store.list()
-
-    def configure_actuator(self, actuator_entity_id: str, *, enabled: bool = True) -> ActuatorRecord:
-        self._store.configure(actuator_entity_id, enabled=enabled)
-        return self.reconcile_actuator(actuator_entity_id, trigger="configuration")
-
-    def get_actuator(self, actuator_entity_id: str) -> ActuatorRecord:
-        return self._store.get(actuator_entity_id)
-
-    def delete_actuator(self, actuator_entity_id: str) -> None:
-        model_id = model_id_for_actuator(actuator_entity_id)
-        self._registry.archive(model_id)
-        self._store.delete(actuator_entity_id)
-
-    def reconcile_all(self, trigger: str = "manual") -> ReconciliationState:
-        state = self._store.load_reconciliation_state().model_copy(
-            update={
-                "running": True,
-                "last_started_at": datetime.now(timezone.utc),
-                "last_trigger": trigger,
-            }
-        )
-        self._store.save_reconciliation_state(state)
-        records = self._store.list()
-        for record in records:
-            self.reconcile_actuator(record.actuator_entity_id, trigger=trigger)
-        self._archive_orphan_models({model_id_for_actuator(record.actuator_entity_id) for record in records})
-        refreshed = self._store.list()
-        summary = ReconciliationState(
-            last_started_at=state.last_started_at,
-            last_completed_at=datetime.now(timezone.utc),
-            last_trigger=trigger,
-            running=False,
-            configured_actuators=len(refreshed),
-            review_required=sum(1 for record in refreshed if record.assignment.review_required),
-            trained_models=sum(
-                1 for record in refreshed if record.lifecycle.status is LifecycleStatus.TRAINED
-            ),
-            last_summary=(
-                f"{len(refreshed)} Aktuatoren geprüft, "
-                f"{sum(1 for record in refreshed if record.assignment.review_required)} "
-                "mit niedriger Zuordnungssicherheit."
-            ),
-        )
-        self._store.save_reconciliation_state(summary)
-        return summary
-
-    def reconcile_actuator(self, actuator_entity_id: str, trigger: str = "manual") -> ActuatorRecord:
-        now = datetime.now(timezone.utc)
-        record = self._store.get(actuator_entity_id)
-        entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
-        discovered = {entity.entity_id: entity for entity in self._ha_reader.discover()}
-        actuator = entities.get(actuator_entity_id)
-        descriptor = discovered.get(actuator_entity_id)
-        lifecycle = record.lifecycle.model_copy(update={"last_reconciled_at": now})
-
-        if not record.enabled:
-            lifecycle = self._archive_state(
-                lifecycle,
-                "Aktuator ist deaktiviert; Modell bleibt archiviert.",
-                now=now,
-            )
-            updated = record.model_copy(
-                update={
-                    "assignment": AssignmentSelection(
-                        selected_numeric_entity_id=None,
-                        selected_context_entity_ids=[],
-                        source=AssignmentSource.NONE,
-                        confidence=0.0,
-                        review_required=False,
-                        reason="Aktuator ist deaktiviert.",
-                    ),
-                    "numeric_candidates": [],
-                    "context_candidates": [],
-                    "lifecycle": lifecycle,
-                    "updated_at": now,
-                }
-            )
-            return self._store.upsert(updated)
-
-        if actuator is None or descriptor is None or descriptor.role is not EntityRole.ACTUATOR:
-            lifecycle = self._archive_state(
-                lifecycle,
-                "Aktuator ist in Home Assistant nicht mehr als Aktor vorhanden.",
-                now=now,
-                status=LifecycleStatus.ORPHANED,
-            )
-            updated = record.model_copy(
-                update={
-                    "assignment": AssignmentSelection(
-                        selected_numeric_entity_id=None,
-                        selected_context_entity_ids=[],
-                        source=AssignmentSource.NONE,
-                        confidence=0.0,
-                        review_required=True,
-                        reason="Aktuator fehlt oder ist kein unterstützter Aktor mehr.",
-                    ),
-                    "numeric_candidates": [],
-                    "context_candidates": [],
-                    "lifecycle": lifecycle,
-                    "updated_at": now,
-                }
-            )
-            return self._store.upsert(updated)
-
-        numeric_candidates = self._rank_candidates(
-            actuator=actuator,
-            candidates=_filter_candidates(entities, discovered, {EntityRole.MEASUREMENT}),
-            context=False,
-        )
-        context_candidates = self._rank_candidates(
-            actuator=actuator,
-            candidates=_filter_candidates(
-                entities,
-                discovered,
-                {EntityRole.BINARY_CONTEXT, EntityRole.CONTEXT},
-            ),
-            context=True,
-        )
-        assignment = self._select_assignment(
-            actuator=actuator,
-            numeric_candidates=numeric_candidates,
-            context_candidates=context_candidates,
-        )
-        lifecycle = self._reconcile_lifecycle(
-            actuator=actuator,
-            assignment=assignment,
-            lifecycle=lifecycle,
-            now=now,
-        )
-        updated = record.model_copy(
-            update={
-                "assignment": assignment,
-                "manual_override": None,
-                "numeric_candidates": numeric_candidates,
-                "context_candidates": context_candidates,
-                "lifecycle": lifecycle,
-                "updated_at": now,
-            }
-        )
-        self._store.upsert(updated)
-        logger.info(
-            "Actuator %s reconciled via %s -> %s",
-            actuator_entity_id,
-            trigger,
-            lifecycle.status,
-        )
-        return updated
-
-    def _select_assignment(
-        self,
-        *,
-        actuator: HaEntitySummary,
-        numeric_candidates: list[AssignmentCandidate],
-        context_candidates: list[AssignmentCandidate],
-    ) -> AssignmentSelection:
-        top_numeric = next(
-            (candidate for candidate in numeric_candidates if candidate.auto_accepted),
-            None,
-        )
-        accepted_contexts = [
-            candidate
-            for candidate in context_candidates
-            if candidate.auto_accepted
-        ][: _MAX_CONTEXT_SELECTIONS]
-        top_contexts = [candidate.entity_id for candidate in accepted_contexts]
-        if top_numeric is None:
-            if accepted_contexts:
-                return AssignmentSelection(
-                    selected_numeric_entity_id=None,
-                    selected_context_entity_ids=top_contexts,
-                    source=AssignmentSource.AUTOMATIC,
-                    confidence=max(candidate.confidence for candidate in accepted_contexts),
-                    review_required=False,
-                    reason=(
-                        "Passender Schaltkontext automatisch erkannt. Für diese "
-                        "Verhaltensvorhersage ist kein numerischer Sensor erforderlich."
-                    ),
-                )
-            return AssignmentSelection(
-                selected_numeric_entity_id=None,
-                selected_context_entity_ids=top_contexts,
-                source=AssignmentSource.NONE,
-                confidence=0.0,
-                review_required=True,
-                reason=(
-                    f"Für {display_name(actuator)} ist noch kein nutzbarer numerischer "
-                    "Kontext verfügbar. Die Zuordnung wird automatisch erneut geprüft."
-                ),
-            )
-
-        return AssignmentSelection(
-            selected_numeric_entity_id=top_numeric.entity_id,
-            selected_context_entity_ids=top_contexts,
-            source=AssignmentSource.AUTOMATIC,
-            confidence=top_numeric.confidence,
-            review_required=not top_numeric.auto_accepted,
-            reason=(
-                "Kontext automatisch und eindeutig zugeordnet."
-                if top_numeric.auto_accepted
-                else "Besten verfügbaren Kontext automatisch mit niedriger Sicherheit zugeordnet."
-            ),
-        )
-
-    def _reconcile_lifecycle(
-        self,
-        *,
-        actuator: HaEntitySummary,
-        assignment: AssignmentSelection,
-        lifecycle: ModelLifecycleState,
-        now: datetime,
-    ) -> ModelLifecycleState:
-        model_id = lifecycle.model_id
-        if assignment.selected_numeric_entity_id is None:
-            return self._archive_state(
-                lifecycle,
-                "Ohne numerische Sensorzuordnung wird kein Modell aktiv gehalten.",
-                now=now,
-            )
-        sensor_id = assignment.selected_numeric_entity_id
-        series = self._read_history(sensor_id, now)
-        points = series.points if series is not None else []
-        if len(points) < self._settings.min_training_points:
-            return self._with_audit(
-                lifecycle.model_copy(
-                    update={
-                        "status": LifecycleStatus.PENDING_HISTORY,
-                        "last_reconciled_at": now,
-                        "reason": (
-                            f"{len(points)} von mindestens {self._settings.min_training_points} "
-                            f"Messpunkten für {sensor_id} vorhanden."
-                        ),
-                        "next_action": "Historie wird automatisch weiter gesammelt.",
-                        "last_history_point_count": len(points),
-                    }
-                ),
-                action="history_wait",
-                reason=(
-                    f"Training für {display_name(actuator)} verschoben: zu wenig numerische Historie."
-                ),
-                now=now,
-            )
-
-        signature = _history_signature(sensor_id, points)
-        artifact = self._registry.get_optional(model_id)
-        needs_retrain = artifact is None
-        retrain_reason = "Noch kein Modell vorhanden."
-        if artifact is not None:
-            valid, reason = _artifact_valid_for_sensor(artifact, sensor_id)
-            if not valid:
-                self._registry.archive(model_id)
-                needs_retrain = True
-                retrain_reason = reason
-            elif lifecycle.last_history_signature != signature:
-                needs_retrain = True
-                retrain_reason = "Historie hat sich seit dem letzten Training materiell geändert."
-            elif lifecycle.last_trained_at is None or (
-                now - lifecycle.last_trained_at
-            ) >= timedelta(hours=self._settings.retrain_stale_hours):
-                needs_retrain = True
-                retrain_reason = "Modell gilt als veraltet und wird präventiv neu trainiert."
-
-        if needs_retrain:
-            vectors = [FeatureVector(sensor_id=sensor_id, values={"value": point.value}) for point in points]
-            result = retrain_model(self._registry, model_id, vectors)
-            return self._with_audit(
-                lifecycle.model_copy(
-                    update={
-                        "status": LifecycleStatus.TRAINED,
-                        "last_reconciled_at": now,
-                        "last_trained_at": now,
-                        "last_history_signature": signature,
-                        "last_history_point_count": len(points),
-                        "reason": retrain_reason,
-                        "next_action": "Neue Daten automatisch überwachen und nachtrainieren.",
-                    }
-                ),
-                action="retrained" if result.replaced else "trained",
-                reason=f"{retrain_reason} Modell {model_id} aktualisiert.",
-                now=now,
-            )
-
-        return self._with_audit(
-            lifecycle.model_copy(
-                update={
-                    "status": LifecycleStatus.TRAINED,
-                    "last_reconciled_at": now,
-                    "last_history_signature": signature,
-                    "last_history_point_count": len(points),
-                    "reason": "Modell ist aktuell und passt zur automatischen Kontextzuordnung.",
-                    "next_action": "Neue Historie automatisch auswerten.",
-                }
-            ),
-            action="kept",
-            reason=f"Modell {model_id} blieb unverändert.",
-            now=now,
-        )
-
-    def _read_history(self, sensor_id: str, now: datetime) -> EntityHistorySeries | None:
-        start = now - timedelta(days=self._settings.history_days)
-        history = list(self._ha_reader.read_history([sensor_id], start, now))
-        for series in history:
-            if series.entity_id == sensor_id:
-                return series
-        return None
-
-    def _archive_orphan_models(self, configured_model_ids: set[str]) -> None:
-        for artifact in self._registry.list_models():
-            if not artifact.artifact_id.startswith("actuator."):
-                continue
-            if artifact.artifact_id not in configured_model_ids:
-                self._registry.archive(artifact.artifact_id)
-
-    def _archive_state(
-        self,
-        lifecycle: ModelLifecycleState,
-        reason: str,
-        *,
-        now: datetime,
-        status: LifecycleStatus = LifecycleStatus.ARCHIVED,
-    ) -> ModelLifecycleState:
-        self._registry.archive(lifecycle.model_id)
-        return self._with_audit(
-            lifecycle.model_copy(
-                update={
-                    "status": status,
-                    "last_reconciled_at": now,
-                    "reason": reason,
-                    "next_action": "Bei neuen Home-Assistant-Daten automatisch erneut zuordnen.",
-                }
-            ),
-            action="archived",
-            reason=reason,
-            now=now,
-        )
-
-    def _rank_candidates(
-        self,
-        *,
-        actuator: HaEntitySummary,
-        candidates: Iterable[tuple[HaEntitySummary, DiscoveredEntity]],
-        context: bool,
-    ) -> list[AssignmentCandidate]:
-        scored: list[AssignmentCandidate] = []
-        all_scores: list[float] = []
-        for entity, discovered in candidates:
-            score, evidence = _score_candidate(actuator, entity, discovered.role, context=context)
-            if score <= 0:
-                continue
-            all_scores.append(score)
-            scored.append(
-                AssignmentCandidate(
-                    entity_id=entity.entity_id,
-                    domain=entity.domain,
-                    role=discovered.role,
-                    device_class=entity.device_class,
-                    state_class=entity.state_class,
-                    unit_of_measurement=entity.unit_of_measurement,
-                    friendly_name=entity.friendly_name,
-                    area_name=entity.area_name,
-                    device_name=entity.device_name,
-                    score=score,
-                    confidence=0.0,
-                    evidence=evidence,
-                )
-            )
-        if not scored:
-            return []
-        highest = max(all_scores)
-        sorted_candidates = sorted(scored, key=lambda item: (-item.score, item.entity_id))
-        second_score = sorted_candidates[1].score if len(sorted_candidates) > 1 else 0.0
-        for index, candidate in enumerate(sorted_candidates):
-            confidence = candidate.score / highest if highest else 0.0
-            margin = candidate.score - second_score if index == 0 else 0.0
-            auto_score = _CONTEXT_AUTO_ACCEPT_SCORE if context else _NUMERIC_AUTO_ACCEPT_SCORE
-            minimum_score = (
-                _CONTEXT_AUTO_ACCEPT_MIN_SCORE
-                if context
-                else _NUMERIC_AUTO_ACCEPT_MIN_SCORE
-            )
-            auto_accepted = (
-                candidate.score >= minimum_score
-                and confidence >= auto_score
-                and (context or margin >= _NUMERIC_MIN_MARGIN)
-            )
-            sorted_candidates[index] = candidate.model_copy(
-                update={
-                    "confidence": round(confidence, 4),
-                    "auto_accepted": auto_accepted,
-                }
-            )
-        return sorted_candidates
-
-    @staticmethod
-    def _with_audit(
-        lifecycle: ModelLifecycleState,
-        *,
-        action: str,
-        reason: str,
-        now: datetime,
-    ) -> ModelLifecycleState:
-        audit = list(lifecycle.audit)
-        entry = LifecycleAuditEntry(at=now, action=action, reason=reason)
-        if not audit or audit[-1].action != action or audit[-1].reason != reason:
-            audit.append(entry)
-        if len(audit) > _AUDIT_LIMIT:
-            audit = audit[-_AUDIT_LIMIT:]
-        return lifecycle.model_copy(update={"audit": audit})
-
-
-def display_name(entity: HaEntitySummary) -> str:
-    return entity.friendly_name or entity.device_name or entity.entity_id
-
-
-def _filter_candidates(
-    entities: dict[str, HaEntitySummary],
-    discovered: dict[str, DiscoveredEntity],
-    roles: set[EntityRole],
-) -> list[tuple[HaEntitySummary, DiscoveredEntity]]:
-    result: list[tuple[HaEntitySummary, DiscoveredEntity]] = []
-    for entity_id, summary in entities.items():
-        candidate = discovered.get(entity_id)
-        if candidate is None or candidate.role not in roles:
-            continue
-        result.append((summary, candidate))
-    return result
-
-
-def _score_candidate(
-    actuator: HaEntitySummary,
-    entity: HaEntitySummary,
-    role: EntityRole,
-    *,
-    context: bool,
-) -> tuple[float, list[str]]:
-    evidence: list[str] = []
-    score = 0.0
-    actuator_tokens = _metadata_tokens(actuator)
-    entity_tokens = _metadata_tokens(entity)
-    overlap = sorted(actuator_tokens.intersection(entity_tokens))
-    if overlap:
-        score += min(0.4, 0.1 * len(overlap))
-        evidence.append(f"Gemeinsame Tokens: {', '.join(overlap[:4])}")
-    if actuator.area_name and entity.area_name and actuator.area_name == entity.area_name:
-        score += 0.35
-        evidence.append(f"Gleicher Bereich: {actuator.area_name}")
-    if actuator.device_id and entity.device_id and actuator.device_id == entity.device_id:
-        score += 0.2
-        evidence.append("Gleiche Home-Assistant-Geräte-ID")
-    if actuator.device_name and entity.device_name and actuator.device_name == entity.device_name:
-        score += 0.15
-        evidence.append(f"Gleicher Gerätename: {actuator.device_name}")
-    if actuator.friendly_name and entity.friendly_name and actuator.friendly_name == entity.friendly_name:
-        score += 0.1
-        evidence.append("Gleicher Friendly Name")
-    preferred_device_classes = _preferred_device_classes(actuator.domain, context=context)
-    if entity.device_class in preferred_device_classes:
-        score += 0.2
-        evidence.append(f"Passende device_class: {entity.device_class}")
-    if not context and actuator.domain == "light" and entity.device_class == "illuminance":
-        score += 0.2
-        evidence.append("Beleuchtungsstärke wird für Lichtaktoren bevorzugt.")
-    if not context and entity.unit_of_measurement is not None:
-        score += 0.05
-        evidence.append(f"Numerische Einheit vorhanden: {entity.unit_of_measurement}")
-    if context and role is EntityRole.BINARY_CONTEXT:
-        score += 0.05
-        evidence.append("Binärer Kontextsensor bevorzugt für Zusatzkontext.")
-    return round(min(score, 1.0), 4), evidence
-
-
-def _preferred_device_classes(domain: str, *, context: bool) -> frozenset[str]:
-    if context:
-        return frozenset({"door", "garage_door", "motion", "occupancy", "opening", "presence"})
-    mapping = {
-        "climate": {"temperature", "humidity", "power"},
-        "cover": {"illuminance", "temperature", "wind_speed"},
-        "fan": {"temperature", "humidity", "power"},
-        "humidifier": {"humidity", "temperature", "power"},
-        "light": {"illuminance", "power", "energy"},
-        "switch": {"power", "energy", "current"},
-        "valve": {"temperature", "pressure", "humidity"},
-    }
-    return frozenset(mapping.get(domain, {"power", "energy", "temperature"}))
-
-
-def _metadata_tokens(entity: HaEntitySummary) -> set[str]:
-    raw_values = [
-        entity.entity_id,
-        entity.friendly_name,
-        entity.area_name,
-        entity.device_name,
-    ]
-    tokens: set[str] = set()
-    for value in raw_values:
-        if value is None:
-            continue
-        for token in _TOKEN_PATTERN.findall(value.lower().replace("_", " ")):
-            if len(token) < 3 or token in _STOPWORDS:
-                continue
-            tokens.add(token)
-    return tokens
-
-
-def _history_signature(sensor_id: str, points: list[NumericHistoryPoint]) -> str:
-    digest = hashlib.sha256()
-    digest.update(sensor_id.encode("utf-8"))
-    for point in points:
-        digest.update(point.timestamp.isoformat().encode("utf-8"))
-        digest.update(f"{point.value:.6f}".encode("utf-8"))
-    return digest.hexdigest()
-
-
-def _artifact_valid_for_sensor(artifact: TrainedArtifact, sensor_id: str) -> tuple[bool, str]:
-    if sensor_id not in artifact.supported_sensors:
-        return False, "Vorhandenes Modell passt nicht mehr zur aktuellen Sensorzuordnung."
-    feature_models = artifact.feature_models.get(sensor_id, {})
-    if "value" not in feature_models:
-        return False, "Vorhandenes Modell enthält kein numerisches Trainingsmerkmal 'value'."
-    return True, "Modell ist kompatibel."

app/actuators/models.py

@@ -1,157 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from enum import StrEnum
-
-from pydantic import BaseModel, Field
-
-from app.ha.discovery import EntityRole
-
-
-class AssignmentSource(StrEnum):
-    NONE = "none"
-    AUTOMATIC = "automatic"
-    MANUAL = "manual"
-
-
-class LifecycleStatus(StrEnum):
-    PENDING_ASSIGNMENT = "pending_assignment"
-    REVIEW_REQUIRED = "review_required"
-    PENDING_HISTORY = "pending_history"
-    TRAINED = "trained"
-    STALE = "stale"
-    INVALID = "invalid"
-    ORPHANED = "orphaned"
-    ARCHIVED = "archived"
-
-
-class BehaviorMode(StrEnum):
-    SHADOW = "shadow"
-    ACTIVE = "active"
-    PAUSED = "paused"
-
-
-class BehaviorStatus(StrEnum):
-    COLLECTING = "collecting"
-    TRAINED = "trained"
-    BLOCKED = "blocked"
-
-
-class AssignmentCandidate(BaseModel):
-    entity_id: str
-    domain: str
-    role: EntityRole
-    device_class: str | None = None
-    state_class: str | None = None
-    unit_of_measurement: str | None = None
-    friendly_name: str | None = None
-    area_name: str | None = None
-    device_name: str | None = None
-    score: float = Field(ge=0.0)
-    confidence: float = Field(ge=0.0, le=1.0)
-    auto_accepted: bool = False
-    evidence: list[str] = Field(default_factory=list)
-
-
-class AssignmentSelection(BaseModel):
-    selected_numeric_entity_id: str | None = None
-    selected_context_entity_ids: list[str] = Field(default_factory=list)
-    source: AssignmentSource = AssignmentSource.NONE
-    confidence: float = Field(default=0.0, ge=0.0, le=1.0)
-    review_required: bool = True
-    reason: str = "Noch keine Zuordnung vorhanden."
-
-
-class ManualOverride(BaseModel):
-    numeric_entity_id: str | None = None
-    context_entity_ids: list[str] = Field(default_factory=list)
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    note: str | None = None
-
-
-class LifecycleAuditEntry(BaseModel):
-    at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    action: str = Field(min_length=1, max_length=120)
-    reason: str = Field(min_length=1, max_length=500)
-
-
-class ModelLifecycleState(BaseModel):
-    model_id: str
-    status: LifecycleStatus = LifecycleStatus.PENDING_ASSIGNMENT
-    last_reconciled_at: datetime | None = None
-    last_trained_at: datetime | None = None
-    last_history_signature: str | None = None
-    last_history_point_count: int = Field(default=0, ge=0)
-    reason: str = "Noch keine Trainingsdaten ausgewertet."
-    next_action: str = "Aktor auswählen; Kontext und Historie werden automatisch geprüft."
-    audit: list[LifecycleAuditEntry] = Field(default_factory=list)
-
-
-class BehaviorPattern(BaseModel):
-    target_state: str = Field(min_length=1, max_length=100)
-    minute_of_day: int = Field(ge=0, le=1439)
-    weekday: int = Field(ge=0, le=6)
-    context_states: dict[str, str] = Field(default_factory=dict)
-    trigger_entity_id: str | None = None
-    trigger_from_state: str | None = None
-    trigger_to_state: str | None = None
-    source: str = Field(default="observed", max_length=40)
-    weight: float = Field(default=1.0, ge=0.1, le=1.0)
-    observed_at: datetime
-
-
-class BehaviorPrediction(BaseModel):
-    target_state: str
-    confidence: float = Field(ge=0.0, le=1.0)
-    generated_at: datetime
-    reason: str
-    matching_patterns: int = Field(default=0, ge=0)
-    executed: bool = False
-
-
-class ExecutionEvent(BaseModel):
-    target_state: str
-    executed_at: datetime
-
-
-class BehaviorState(BaseModel):
-    mode: BehaviorMode = BehaviorMode.SHADOW
-    status: BehaviorStatus = BehaviorStatus.COLLECTING
-    approved_at: datetime | None = None
-    sample_count: int = Field(default=0, ge=0)
-    high_confidence_sample_count: int = Field(default=0, ge=0)
-    patterns: list[BehaviorPattern] = Field(default_factory=list)
-    prediction: BehaviorPrediction | None = None
-    last_trained_at: datetime | None = None
-    last_evaluated_at: datetime | None = None
-    last_executed_at: datetime | None = None
-    execution_events: list[ExecutionEvent] = Field(default_factory=list)
-    reason: str = "Historische Aktorhandlungen werden analysiert."
-
-
-class ActuatorRecord(BaseModel):
-    actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
-    enabled: bool = True
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    assignment: AssignmentSelection = Field(default_factory=AssignmentSelection)
-    manual_override: ManualOverride | None = None
-    numeric_candidates: list[AssignmentCandidate] = Field(default_factory=list)
-    context_candidates: list[AssignmentCandidate] = Field(default_factory=list)
-    lifecycle: ModelLifecycleState
-    behavior: BehaviorState = Field(default_factory=BehaviorState)
-
-
-class ReconciliationState(BaseModel):
-    last_started_at: datetime | None = None
-    last_completed_at: datetime | None = None
-    last_trigger: str | None = None
-    running: bool = False
-    configured_actuators: int = Field(default=0, ge=0)
-    review_required: int = Field(default=0, ge=0)
-    trained_models: int = Field(default=0, ge=0)
-    last_summary: str = "Noch keine Reconciliation ausgeführt."
-
-
-def model_id_for_actuator(actuator_entity_id: str) -> str:
-    return f"actuator.{actuator_entity_id}"

app/actuators/store.py

@@ -1,116 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from datetime import datetime, timezone
-from pathlib import Path
-from threading import RLock
-
-from app.actuators.models import (
-    ActuatorRecord,
-    LifecycleStatus,
-    ModelLifecycleState,
-    ReconciliationState,
-    model_id_for_actuator,
-)
-
-
-class ActuatorStore:
-    def __init__(self, root: str | Path) -> None:
-        self._root = Path(root).resolve()
-        self._actuators_root = self._root / "actuators"
-        self._actuators_root.mkdir(parents=True, exist_ok=True)
-        self._lock = RLock()
-        self._reconciliation_state_path = self._root / "reconciliation_state.json"
-
-    def list(self) -> list[ActuatorRecord]:
-        with self._lock:
-            return [self._load(path) for path in sorted(self._actuators_root.glob("*.json"))]
-
-    def get(self, actuator_entity_id: str) -> ActuatorRecord:
-        with self._lock:
-            target = self._target(actuator_entity_id)
-            if not target.exists():
-                raise KeyError("Aktuator-Konfiguration nicht gefunden.")
-            return self._load(target)
-
-    def upsert(self, record: ActuatorRecord) -> ActuatorRecord:
-        with self._lock:
-            self._persist(record)
-            return record
-
-    def configure(self, actuator_entity_id: str, *, enabled: bool = True) -> ActuatorRecord:
-        with self._lock:
-            target = self._target(actuator_entity_id)
-            if target.exists():
-                record = self._load(target)
-                updated = record.model_copy(
-                    update={
-                        "enabled": enabled,
-                        "updated_at": datetime.now(timezone.utc),
-                    }
-                )
-                self._persist(updated)
-                return updated
-            record = ActuatorRecord(
-                actuator_entity_id=actuator_entity_id,
-                enabled=enabled,
-                lifecycle=ModelLifecycleState(
-                    model_id=model_id_for_actuator(actuator_entity_id),
-                    status=LifecycleStatus.PENDING_ASSIGNMENT,
-                ),
-            )
-            self._persist(record)
-            return record
-
-    def delete(self, actuator_entity_id: str) -> None:
-        with self._lock:
-            target = self._target(actuator_entity_id)
-            if target.exists():
-                target.unlink()
-
-    def load_reconciliation_state(self) -> ReconciliationState:
-        with self._lock:
-            if not self._reconciliation_state_path.exists():
-                return ReconciliationState()
-            try:
-                return ReconciliationState.model_validate_json(
-                    self._reconciliation_state_path.read_text(encoding="utf-8")
-                )
-            except ValueError as exc:
-                raise ValueError("Ungültiger Reconciliation-Status.") from exc
-
-    def save_reconciliation_state(self, state: ReconciliationState) -> ReconciliationState:
-        with self._lock:
-            self._persist_reconciliation_state(state)
-            return state
-
-    def _target(self, actuator_entity_id: str) -> Path:
-        if "." not in actuator_entity_id:
-            raise ValueError("Ungültige actuator_entity_id.")
-        safe_name = actuator_entity_id.replace(".", "__")
-        return self._actuators_root / f"{safe_name}.json"
-
-    def _persist(self, record: ActuatorRecord) -> None:
-        target = self._target(record.actuator_entity_id)
-        temporary = target.with_suffix(".json.tmp")
-        temporary.write_text(
-            json.dumps(record.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
-            encoding="utf-8",
-        )
-        os.replace(temporary, target)
-
-    def _persist_reconciliation_state(self, state: ReconciliationState) -> None:
-        temporary = self._reconciliation_state_path.with_suffix(".json.tmp")
-        temporary.write_text(
-            json.dumps(state.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
-            encoding="utf-8",
-        )
-        os.replace(temporary, self._reconciliation_state_path)
-
-    @staticmethod
-    def _load(path: Path) -> ActuatorRecord:
-        try:
-            return ActuatorRecord.model_validate_json(path.read_text(encoding="utf-8"))
-        except ValueError as exc:
-            raise ValueError(f"Ungültige Aktuator-Konfiguration: {path.name}") from exc

app/api/v1/actuators.py

@@ -1,145 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter, Depends, HTTPException, Query, Request, status
-from pydantic import BaseModel, Field
-
-from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import ActuatorRecord, ReconciliationState
-from app.actuators.store import ActuatorStore
-from app.behavior.engine import BehaviorEngine
-from app.dependencies import get_ha_reader
-from app.ha.discovery import EntityRole
-from app.ha.models import HaEntitySummary
-from app.ha.reader import HaReader
-
-router = APIRouter(prefix="/v1/actuators", tags=["actuators"])
-
-
-class ConfigureActuatorRequest(BaseModel):
-    actuator_entity_id: str = Field(pattern=r"^[a-z0-9_]+\.[a-z0-9_]+$")
-    enabled: bool = True
-
-
-class ActivationRequest(BaseModel):
-    active: bool
-
-
-@router.get("/discovery", response_model=list[HaEntitySummary])
-def discover_actuators(ha_reader: HaReader = Depends(get_ha_reader)) -> list[HaEntitySummary]:
-    entities = {entity.entity_id: entity for entity in ha_reader.read_entities()}
-    discovered = ha_reader.discover()
-    actuator_ids = sorted(
-        entity.entity_id for entity in discovered if entity.role is EntityRole.ACTUATOR
-    )
-    return [entities[entity_id] for entity_id in actuator_ids if entity_id in entities]
-
-
-@router.get("", response_model=list[ActuatorRecord])
-def list_configured(request: Request) -> list[ActuatorRecord]:
-    return _service(request).list_configured()
-
-
-@router.post("", response_model=ActuatorRecord, status_code=201)
-def configure(payload: ConfigureActuatorRequest, request: Request) -> ActuatorRecord:
-    try:
-        record = _service(request).configure_actuator(
-            payload.actuator_entity_id,
-            enabled=payload.enabled,
-        )
-        _behavior(request).train(record.actuator_entity_id)
-        return _behavior(request).evaluate(record.actuator_entity_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-
-@router.get("/{actuator_entity_id}", response_model=ActuatorRecord)
-def get_actuator(actuator_entity_id: str, request: Request) -> ActuatorRecord:
-    try:
-        return _service(request).get_actuator(actuator_entity_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-
-@router.delete("/{actuator_entity_id}", status_code=204)
-def delete_actuator(actuator_entity_id: str, request: Request) -> None:
-    _service(request).delete_actuator(actuator_entity_id)
-
-
-@router.post("/{actuator_entity_id}/reconcile", response_model=ActuatorRecord)
-def reconcile_actuator(
-    actuator_entity_id: str,
-    request: Request,
-) -> ActuatorRecord:
-    try:
-        _service(request).reconcile_actuator(actuator_entity_id, trigger="manual")
-        _behavior(request).train(actuator_entity_id)
-        return _behavior(request).evaluate(actuator_entity_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-
-@router.post("/{actuator_entity_id}/evaluate", response_model=ActuatorRecord)
-def evaluate_actuator(
-    actuator_entity_id: str,
-    request: Request,
-) -> ActuatorRecord:
-    try:
-        return _behavior(request).evaluate(actuator_entity_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-
-
-@router.post("/{actuator_entity_id}/activation", response_model=ActuatorRecord)
-def set_activation(
-    actuator_entity_id: str,
-    payload: ActivationRequest,
-    request: Request,
-) -> ActuatorRecord:
-    try:
-        return _behavior(request).set_active(actuator_entity_id, active=payload.active)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except ValueError as exc:
-        raise HTTPException(status_code=409, detail=str(exc)) from exc
-
-
-@router.get("/reconciliation/state", response_model=ReconciliationState)
-def get_reconciliation_state(request: Request) -> ReconciliationState:
-    store = getattr(request.app.state, "actuator_store", None)
-    if not isinstance(store, ActuatorStore):
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Actuator Store nicht initialisiert.",
-        )
-    return store.load_reconciliation_state()
-
-
-@router.post("/reconciliation/run", response_model=ReconciliationState)
-def run_reconciliation(
-    request: Request,
-    trigger: str = Query(default="manual", pattern=r"^[a-z0-9_-]{1,32}$"),
-) -> ReconciliationState:
-    state = _service(request).reconcile_all(trigger=trigger)
-    _behavior(request).train_all()
-    _behavior(request).evaluate_all()
-    return state
-
-
-def _service(request: Request) -> ActuatorReconciliationService:
-    service = getattr(request.app.state, "actuator_service", None)
-    if not isinstance(service, ActuatorReconciliationService):
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Actuator-Reconciliation nicht initialisiert.",
-        )
-    return service
-
-
-def _behavior(request: Request) -> BehaviorEngine:
-    engine = getattr(request.app.state, "behavior_engine", None)
-    if not isinstance(engine, BehaviorEngine):
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Verhaltenslernen ist nicht initialisiert.",
-        )
-    return engine

app/api/v1/automations.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from fastapi import APIRouter, HTTPException, Request, Response, status
-
-from app.automations.models import (
-    AutomationProposal,
-    ProposalDecision,
-    ProposalStatus,
-)
-from app.automations.store import AutomationStore
-
-router = APIRouter(prefix="/v1/automations", tags=["automations"])
-
-
-@router.post("/proposals", response_model=AutomationProposal, status_code=201)
-def create_proposal(payload: AutomationProposal, request: Request) -> AutomationProposal:
-    if payload.trigger.above is None and payload.trigger.below is None:
-        raise HTTPException(status_code=422, detail="Trigger benötigt above oder below.")
-    return _store(request).create(payload.model_copy(update={"status": ProposalStatus.DRAFT}))
-
-
-@router.get("/proposals", response_model=list[AutomationProposal])
-def list_proposals(request: Request) -> list[AutomationProposal]:
-    return _store(request).list()
-
-
-@router.post("/proposals/{proposal_id}/approve", response_model=AutomationProposal)
-def approve(
-    proposal_id: str,
-    payload: ProposalDecision,
-    request: Request,
-) -> AutomationProposal:
-    return _decide(request, proposal_id, ProposalStatus.APPROVED, payload.expected_revision)
-
-
-@router.post("/proposals/{proposal_id}/reject", response_model=AutomationProposal)
-def reject(
-    proposal_id: str,
-    payload: ProposalDecision,
-    request: Request,
-) -> AutomationProposal:
-    return _decide(request, proposal_id, ProposalStatus.REJECTED, payload.expected_revision)
-
-
-@router.get("/proposals/{proposal_id}/yaml")
-def export_yaml(proposal_id: str, request: Request) -> Response:
-    try:
-        content = _store(request).export_yaml(proposal_id)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except ValueError as exc:
-        raise HTTPException(status_code=409, detail=str(exc)) from exc
-    return Response(content=content, media_type="application/yaml")
-
-
-def _decide(
-    request: Request,
-    proposal_id: str,
-    decision: ProposalStatus,
-    expected_revision: int,
-) -> AutomationProposal:
-    try:
-        return _store(request).decide(proposal_id, decision, expected_revision)
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail=str(exc)) from exc
-    except ValueError as exc:
-        raise HTTPException(status_code=409, detail=str(exc)) from exc
-
-
-def _store(request: Request) -> AutomationStore:
-    store = getattr(request.app.state, "automation_store", None)
-    if not isinstance(store, AutomationStore):
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Automation Store nicht initialisiert.",
-        )
-    return store

app/api/v1/entities.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
-from datetime import datetime
-from typing import List
+from collections.abc import Sequence
 
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends
 
 from app.dependencies import get_ha_reader
-from app.ha.discovery import DiscoveredEntity
-from app.ha.history import EntityHistorySeries
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 
@@ -18,47 +15,7 @@ router = APIRouter(prefix="/v1", tags=["entities"])
     "/entities",
     summary="Home-Assistant-Entities auflisten",
     description="Gibt eine kompakte Zusammenfassung aller erreichbaren HA-Entitäten zurück.",
-    response_model=List[HaEntitySummary],
+    response_model=list[HaEntitySummary],
 )
-def list_entities(ha_reader: HaReader = Depends(get_ha_reader)) -> List[HaEntitySummary]:
-    return list(ha_reader.read_entities())
-
-
-@router.get(
-    "/discovery",
-    summary="Home-Assistant-Entities klassifizieren",
-    description="Klassifiziert Entities nach Lernrelevanz, Kontextquelle und Aktor-Rolle.",
-    response_model=List[DiscoveredEntity],
-)
-def discovery(
-    domain: List[str] | None = Query(default=None),
-    learnable: bool | None = None,
-    ha_reader: HaReader = Depends(get_ha_reader),
-) -> List[DiscoveredEntity]:
-    return list(
-        ha_reader.discover(
-            domains=set(domain) if domain else None,
-            learnable=learnable,
-        )
-    )
-
-
-@router.get(
-    "/history",
-    summary="Numerische Home-Assistant-Historie lesen",
-    description="Lädt und normalisiert numerische Zustände ausgewählter Entities.",
-    response_model=List[EntityHistorySeries],
-)
-def history(
-    entity_id: List[str] = Query(),
-    start_time: datetime = Query(),
-    end_time: datetime = Query(),
-    ha_reader: HaReader = Depends(get_ha_reader),
-) -> List[EntityHistorySeries]:
-    try:
-        return list(ha_reader.read_history(entity_id, start_time, end_time))
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=str(exc),
-        ) from exc
+def list_entities(reader: HaReader = Depends(get_ha_reader)) -> Sequence[HaEntitySummary]:
+    return reader.read_entities()

app/automations/__init__.py

@@ -1,3 +0,0 @@
-from app.automations.store import AutomationStore
-
-__all__ = ["AutomationStore"]

app/automations/models.py

@@ -1,41 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from enum import StrEnum
-from uuid import uuid4
-
-from pydantic import BaseModel, Field
-
-
-class ProposalStatus(StrEnum):
-    DRAFT = "draft"
-    APPROVED = "approved"
-    REJECTED = "rejected"
-
-
-class NumericStateTrigger(BaseModel):
-    entity_id: str = Field(pattern=r"^sensor\.[a-z0-9_]+$")
-    above: float | None = None
-    below: float | None = None
-
-
-class ServiceAction(BaseModel):
-    service: str = Field(pattern=r"^(light|switch|climate|fan|cover)\.[a-z0-9_]+$")
-    entity_id: str = Field(pattern=r"^(light|switch|climate|fan|cover)\.[a-z0-9_]+$")
-    data: dict[str, str | int | float | bool] = Field(default_factory=dict)
-
-
-class AutomationProposal(BaseModel):
-    proposal_id: str = Field(default_factory=lambda: uuid4().hex)
-    alias: str = Field(min_length=1, max_length=120)
-    description: str = Field(min_length=1, max_length=500)
-    trigger: NumericStateTrigger
-    action: ServiceAction
-    status: ProposalStatus = ProposalStatus.DRAFT
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    revision: int = 1
-
-
-class ProposalDecision(BaseModel):
-    expected_revision: int = Field(ge=1)

app/automations/store.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from datetime import datetime, timezone
-from pathlib import Path
-from threading import RLock
-
-from app.automations.models import AutomationProposal, ProposalStatus
-
-
-class AutomationStore:
-    def __init__(self, root: str | Path) -> None:
-        self._root = Path(root).resolve()
-        self._root.mkdir(parents=True, exist_ok=True)
-        self._lock = RLock()
-
-    def create(self, proposal: AutomationProposal) -> AutomationProposal:
-        with self._lock:
-            target = self._target(proposal.proposal_id)
-            if target.exists():
-                raise ValueError("Automation-Vorschlag existiert bereits.")
-            self._persist(proposal)
-        return proposal
-
-    def list(self) -> list[AutomationProposal]:
-        with self._lock:
-            return [self._load(path) for path in sorted(self._root.glob("*.json"))]
-
-    def get(self, proposal_id: str) -> AutomationProposal:
-        with self._lock:
-            target = self._target(proposal_id)
-            if not target.exists():
-                raise KeyError("Automation-Vorschlag nicht gefunden.")
-            return self._load(target)
-
-    def decide(
-        self,
-        proposal_id: str,
-        status: ProposalStatus,
-        expected_revision: int,
-    ) -> AutomationProposal:
-        if status is ProposalStatus.DRAFT:
-            raise ValueError("Entscheidung darf nicht auf draft gesetzt werden.")
-        with self._lock:
-            proposal = self.get(proposal_id)
-            if proposal.revision != expected_revision:
-                raise ValueError("Revision stimmt nicht mit dem aktuellen Vorschlag überein.")
-            if proposal.status is not ProposalStatus.DRAFT:
-                raise ValueError("Über den Vorschlag wurde bereits entschieden.")
-            updated = proposal.model_copy(
-                update={
-                    "status": status,
-                    "updated_at": datetime.now(timezone.utc),
-                    "revision": proposal.revision + 1,
-                }
-            )
-            self._persist(updated)
-            return updated
-
-    def export_yaml(self, proposal_id: str) -> str:
-        proposal = self.get(proposal_id)
-        if proposal.status is not ProposalStatus.APPROVED:
-            raise ValueError("Nur freigegebene Vorschläge dürfen exportiert werden.")
-        trigger_lines = [
-            "trigger:",
-            "  - platform: numeric_state",
-            f"    entity_id: {proposal.trigger.entity_id}",
-        ]
-        if proposal.trigger.above is not None:
-            trigger_lines.append(f"    above: {proposal.trigger.above}")
-        if proposal.trigger.below is not None:
-            trigger_lines.append(f"    below: {proposal.trigger.below}")
-        action_lines = [
-            "action:",
-            f"  - service: {proposal.action.service}",
-            "    target:",
-            f"      entity_id: {proposal.action.entity_id}",
-        ]
-        if proposal.action.data:
-            action_lines.append("    data:")
-            action_lines.extend(
-                f"      {key}: {_yaml_scalar(value)}"
-                for key, value in sorted(proposal.action.data.items())
-            )
-        return "\n".join(
-            [
-                f"alias: {_yaml_scalar(proposal.alias)}",
-                f"description: {_yaml_scalar(proposal.description)}",
-                *trigger_lines,
-                *action_lines,
-                "mode: single",
-                "",
-            ]
-        )
-
-    def _target(self, proposal_id: str) -> Path:
-        if len(proposal_id) != 32 or not proposal_id.isalnum():
-            raise ValueError("Ungültige proposal_id.")
-        return self._root / f"{proposal_id}.json"
-
-    def _persist(self, proposal: AutomationProposal) -> None:
-        target = self._target(proposal.proposal_id)
-        temporary = target.with_suffix(".json.tmp")
-        temporary.write_text(
-            json.dumps(proposal.model_dump(mode="json"), ensure_ascii=True, sort_keys=True) + "\n",
-            encoding="utf-8",
-        )
-        os.replace(temporary, target)
-
-    @staticmethod
-    def _load(path: Path) -> AutomationProposal:
-        try:
-            return AutomationProposal.model_validate_json(path.read_text(encoding="utf-8"))
-        except ValueError as exc:
-            raise ValueError(f"Ungültiger Automation-Vorschlag: {path.name}") from exc
-
-
-def _yaml_scalar(value: str | int | float | bool) -> str:
-    if isinstance(value, bool):
-        return "true" if value else "false"
-    if isinstance(value, (int, float)):
-        return str(value)
-    return json.dumps(value, ensure_ascii=True)

app/behavior/__init__.py

@@ -1 +0,0 @@
-"""Learning and prediction for actuator behavior."""

app/behavior/engine.py

@@ -1,566 +0,0 @@
-from __future__ import annotations
-
-import logging
-from datetime import datetime, timedelta, timezone
-from zoneinfo import ZoneInfo
-
-from app.actuators.models import (
-    ActuatorRecord,
-    BehaviorMode,
-    BehaviorPattern,
-    BehaviorPrediction,
-    BehaviorState,
-    BehaviorStatus,
-    ExecutionEvent,
-)
-from app.actuators.store import ActuatorStore
-from app.config import Settings
-from app.ha.exceptions import HaClientError
-from app.ha.history import LogbookEntry, StateHistoryPoint, StateHistorySeries
-from app.ha.reader import HaReader
-
-_MAX_PATTERNS = 500
-_MAX_EXECUTION_EVENTS = 100
-_ACTION_LOGBOOK_TOLERANCE = timedelta(seconds=10)
-_CONTEXT_TRIGGER_TOLERANCE = timedelta(seconds=3)
-_OWN_ACTION_TOLERANCE = timedelta(seconds=20)
-_SAFE_ACTIVE_DOMAINS = frozenset({"cover", "fan", "humidifier", "light", "switch"})
-_AUTOMATION_CONTEXT_DOMAINS = frozenset({"automation", "script"})
-logger = logging.getLogger(__name__)
-
-
-class BehaviorEngine:
-    def __init__(
-        self,
-        *,
-        ha_reader: HaReader,
-        store: ActuatorStore,
-        settings: Settings,
-    ) -> None:
-        self._ha_reader = ha_reader
-        self._store = store
-        self._settings = settings
-
-    def train_all(self) -> list[ActuatorRecord]:
-        results: list[ActuatorRecord] = []
-        for record in self._store.list():
-            try:
-                results.append(self.train(record.actuator_entity_id))
-            except Exception:
-                logger.exception("Behavior training failed for %s", record.actuator_entity_id)
-                results.append(record)
-        return results
-
-    def train(self, actuator_entity_id: str) -> ActuatorRecord:
-        record = self._store.get(actuator_entity_id)
-        now = datetime.now(timezone.utc)
-        raw_context_ids = list(
-            dict.fromkeys(
-                [
-                    record.assignment.selected_numeric_entity_id,
-                    *record.assignment.selected_context_entity_ids,
-                ]
-            )
-        )
-        context_ids = [
-            entity_id for entity_id in raw_context_ids if isinstance(entity_id, str)
-        ]
-        if not context_ids:
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "status": BehaviorStatus.COLLECTING,
-                        "last_trained_at": now,
-                        "reason": "Noch kein geeigneter Kontext für Verhaltenslernen vorhanden.",
-                    }
-                ),
-            )
-
-        start = now - timedelta(days=self._settings.history_days)
-        history_ids = [actuator_entity_id, *context_ids]
-        try:
-            history = {
-                series.entity_id: series
-                for series in self._ha_reader.read_state_history(history_ids, start, now)
-            }
-        except (HaClientError, ValueError) as exc:
-            logger.warning("Behavior history unavailable for %s: %s", actuator_entity_id, exc)
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "status": BehaviorStatus.BLOCKED,
-                        "last_trained_at": now,
-                        "reason": f"Home-Assistant-Historie konnte nicht gelesen werden: {exc}",
-                    }
-                ),
-            )
-        actuator_history = history.get(actuator_entity_id)
-        if actuator_history is None or len(actuator_history.points) < 2:
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "status": BehaviorStatus.COLLECTING,
-                        "sample_count": 0,
-                        "high_confidence_sample_count": 0,
-                        "patterns": [],
-                        "last_trained_at": now,
-                        "reason": "Noch keine historischen Aktorhandlungen gefunden.",
-                    }
-                ),
-            )
-
-        try:
-            logbook = list(self._ha_reader.read_logbook(actuator_entity_id, start, now))
-        except (HaClientError, ValueError) as exc:
-            logger.warning("Logbook unavailable for %s: %s", actuator_entity_id, exc)
-            logbook = []
-        patterns = self._build_patterns(
-            actuator_history=actuator_history,
-            context_history=history,
-            context_ids=context_ids,
-            logbook=logbook,
-            own_executions=record.behavior.execution_events,
-        )
-        high_confidence = sum(1 for pattern in patterns if pattern.source == "user")
-        status = (
-            BehaviorStatus.TRAINED
-            if len(patterns) >= self._settings.min_behavior_actions
-            else BehaviorStatus.COLLECTING
-        )
-        reason = (
-            f"{len(patterns)} Handlungen mit automatisch erfasstem Kontext gelernt."
-            if status is BehaviorStatus.TRAINED
-            else (
-                f"{len(patterns)} von mindestens {self._settings.min_behavior_actions} "
-                "benötigten Handlungen gelernt."
-            )
-        )
-        behavior = record.behavior.model_copy(
-            update={
-                "status": status,
-                "sample_count": len(patterns),
-                "high_confidence_sample_count": high_confidence,
-                "patterns": patterns[-_MAX_PATTERNS:],
-                "last_trained_at": now,
-                "reason": reason,
-            }
-        )
-        return self._save_behavior(record, behavior)
-
-    def evaluate_all(self) -> list[ActuatorRecord]:
-        results: list[ActuatorRecord] = []
-        for record in self._store.list():
-            try:
-                results.append(self.evaluate(record.actuator_entity_id))
-            except Exception:
-                logger.exception("Behavior evaluation failed for %s", record.actuator_entity_id)
-                results.append(record)
-        return results
-
-    def evaluate(self, actuator_entity_id: str) -> ActuatorRecord:
-        record = self._store.get(actuator_entity_id)
-        now = datetime.now(timezone.utc)
-        try:
-            entities = {entity.entity_id: entity for entity in self._ha_reader.read_entities()}
-        except HaClientError as exc:
-            logger.warning("Current HA state unavailable for %s: %s", actuator_entity_id, exc)
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "last_evaluated_at": now,
-                        "prediction": None,
-                        "reason": f"Aktueller Home-Assistant-Zustand ist nicht verfügbar: {exc}",
-                    }
-                ),
-            )
-        actuator = entities.get(actuator_entity_id)
-        if actuator is None:
-            return self._save_behavior(
-                record,
-                record.behavior.model_copy(
-                    update={
-                        "last_evaluated_at": now,
-                        "prediction": None,
-                        "reason": "Aktor ist aktuell nicht in Home Assistant verfügbar.",
-                    }
-                ),
-            )
-        current_context = {
-            entity_id: entities[entity_id].state
-            for entity_id in (
-                [
-                    record.assignment.selected_numeric_entity_id,
-                    *record.assignment.selected_context_entity_ids,
-                ]
-            )
-            if entity_id and entity_id in entities and entities[entity_id].state is not None
-        }
-        current_context_changed_at = {
-            entity_id: entities[entity_id].last_changed
-            for entity_id in current_context
-        }
-        prediction = predict_behavior(
-            record.behavior.patterns,
-            current_context=current_context,
-            current_context_changed_at=current_context_changed_at,
-            now=now,
-            min_support=self._settings.min_behavior_actions,
-            window_minutes=self._settings.prediction_window_minutes,
-            causal_window_seconds=self._settings.prediction_interval_seconds * 2,
-            timezone_name=self._settings.timezone,
-        )
-        behavior = record.behavior.model_copy(
-            update={
-                "last_evaluated_at": now,
-                "prediction": prediction,
-                "reason": (
-                    prediction.reason
-                    if prediction is not None
-                    else "Aktuell ist kein gelerntes Handlungsmuster fällig."
-                ),
-            }
-        )
-        if (
-            prediction is not None
-            and behavior.mode is BehaviorMode.ACTIVE
-            and prediction.confidence >= self._settings.prediction_confidence
-            and actuator.state != prediction.target_state
-            and self._cooldown_elapsed(behavior, now)
-        ):
-            domain = actuator_entity_id.split(".", 1)[0]
-            service = service_for_state(domain, prediction.target_state)
-            if service is not None:
-                try:
-                    self._ha_reader.call_service(
-                        domain,
-                        service,
-                        {"entity_id": actuator_entity_id},
-                    )
-                except (HaClientError, ValueError) as exc:
-                    logger.error(
-                        "Predicted action failed for %s: %s",
-                        actuator_entity_id,
-                        exc,
-                    )
-                    behavior = behavior.model_copy(
-                        update={
-                            "reason": f"Vorhersage wurde aus Sicherheitsgründen nicht ausgeführt: {exc}"
-                        }
-                    )
-                    return self._save_behavior(record, behavior)
-                event = ExecutionEvent(
-                    target_state=prediction.target_state,
-                    executed_at=now,
-                )
-                behavior = behavior.model_copy(
-                    update={
-                        "prediction": prediction.model_copy(update={"executed": True}),
-                        "last_executed_at": now,
-                        "execution_events": [
-                            *behavior.execution_events,
-                            event,
-                        ][-_MAX_EXECUTION_EVENTS:],
-                        "reason": (
-                            f"Vorhersage mit {prediction.confidence:.0%} Sicherheit ausgeführt."
-                        ),
-                    }
-                )
-            else:
-                behavior = behavior.model_copy(
-                    update={
-                        "reason": (
-                            f"Der vorhergesagte Zustand {prediction.target_state!r} "
-                            "ist für autonomes Schalten nicht freigegeben."
-                        )
-                    }
-                )
-        return self._save_behavior(record, behavior)
-
-    def set_active(self, actuator_entity_id: str, *, active: bool) -> ActuatorRecord:
-        record = self._store.get(actuator_entity_id)
-        now = datetime.now(timezone.utc)
-        if active:
-            domain = actuator_entity_id.split(".", 1)[0]
-            if domain not in _SAFE_ACTIVE_DOMAINS:
-                raise ValueError(
-                    f"Automatisches Schalten ist für die Domain {domain} nicht freigegeben."
-                )
-            if record.behavior.status is not BehaviorStatus.TRAINED:
-                raise ValueError("Das Verhaltensmodell hat noch nicht genügend Handlungen gelernt.")
-            if (
-                record.behavior.high_confidence_sample_count
-                < self._settings.min_behavior_actions
-            ):
-                raise ValueError(
-                    "Für die Freigabe fehlen noch eindeutig dir zugeordnete Handlungen. "
-                    "Bediene den Aktor einige Male über Home Assistant."
-                )
-            mode = BehaviorMode.ACTIVE
-            approved_at = now
-            reason = "Autonomes Lernen und Schalten wurde ausdrücklich freigegeben."
-        else:
-            mode = BehaviorMode.SHADOW
-            approved_at = None
-            reason = "Shadow-Modus aktiv; Vorhersagen werden nicht ausgeführt."
-        behavior = record.behavior.model_copy(
-            update={
-                "mode": mode,
-                "approved_at": approved_at,
-                "reason": reason,
-            }
-        )
-        return self._save_behavior(record, behavior)
-
-    def _build_patterns(
-        self,
-        *,
-        actuator_history: StateHistorySeries,
-        context_history: dict[str, StateHistorySeries],
-        context_ids: list[str],
-        logbook: list[LogbookEntry],
-        own_executions: list[ExecutionEvent],
-    ) -> list[BehaviorPattern]:
-        patterns: list[BehaviorPattern] = []
-        previous_state = actuator_history.points[0].state
-        for point in actuator_history.points[1:]:
-            if point.state == previous_state:
-                continue
-            previous_state = point.state
-            if _matches_own_execution(point, own_executions):
-                continue
-            source, weight = _action_source(point, logbook)
-            trigger = _recent_context_transition(
-                context_history,
-                context_ids,
-                point.timestamp,
-            )
-            if source == "automation" and trigger is None:
-                continue
-            contexts = {
-                entity_id: state
-                for entity_id in context_ids
-                if (state := _state_at(context_history.get(entity_id), point.timestamp)) is not None
-            }
-            local = point.timestamp.astimezone(ZoneInfo(self._settings.timezone))
-            patterns.append(
-                BehaviorPattern(
-                    target_state=point.state,
-                    minute_of_day=local.hour * 60 + local.minute,
-                    weekday=local.weekday(),
-                    context_states=contexts,
-                    trigger_entity_id=trigger[0] if trigger else None,
-                    trigger_from_state=trigger[1] if trigger else None,
-                    trigger_to_state=trigger[2] if trigger else None,
-                    source=source,
-                    weight=weight,
-                    observed_at=point.timestamp,
-                )
-            )
-        return patterns
-
-    def _cooldown_elapsed(self, behavior: BehaviorState, now: datetime) -> bool:
-        return behavior.last_executed_at is None or (
-            now - behavior.last_executed_at
-        ) >= timedelta(seconds=self._settings.execution_cooldown_seconds)
-
-    def _save_behavior(
-        self,
-        record: ActuatorRecord,
-        behavior: BehaviorState,
-    ) -> ActuatorRecord:
-        updated = record.model_copy(
-            update={
-                "behavior": behavior,
-                "updated_at": datetime.now(timezone.utc),
-            }
-        )
-        return self._store.upsert(updated)
-
-
-def predict_behavior(
-    patterns: list[BehaviorPattern],
-    *,
-    current_context: dict[str, str | None],
-    now: datetime,
-    min_support: int,
-    window_minutes: int,
-    current_context_changed_at: dict[str, datetime | None] | None = None,
-    causal_window_seconds: int = 120,
-    timezone_name: str = "Europe/Berlin",
-) -> BehaviorPrediction | None:
-    if not patterns:
-        return None
-    local = now.astimezone(ZoneInfo(timezone_name))
-    minute_of_day = local.hour * 60 + local.minute
-    changed_at = current_context_changed_at or {}
-    by_state: dict[str, list[float]] = {}
-    causal_support_by_state: dict[str, int] = {}
-    for pattern in patterns:
-        if pattern.trigger_entity_id and pattern.trigger_to_state:
-            trigger_changed_at = changed_at.get(pattern.trigger_entity_id)
-            trigger_age = (
-                (now - trigger_changed_at).total_seconds()
-                if trigger_changed_at is not None
-                else None
-            )
-            if not (
-                current_context.get(pattern.trigger_entity_id)
-                == pattern.trigger_to_state
-                and trigger_age is not None
-                and 0 <= trigger_age <= causal_window_seconds
-            ):
-                continue
-            comparable = [
-                (entity_id, expected)
-                for entity_id, expected in pattern.context_states.items()
-                if entity_id in current_context
-            ]
-            context_score = (
-                sum(
-                    current_context[entity_id] == expected
-                    for entity_id, expected in comparable
-                )
-                / len(comparable)
-                if comparable
-                else 0.5
-            )
-            score = pattern.weight * (0.85 + 0.15 * context_score)
-            by_state.setdefault(pattern.target_state, []).append(score)
-            causal_support_by_state[pattern.target_state] = (
-                causal_support_by_state.get(pattern.target_state, 0) + 1
-            )
-            continue
-        distance = _circular_minute_distance(minute_of_day, pattern.minute_of_day)
-        if distance > window_minutes:
-            continue
-        time_score = 1.0 - (distance / max(window_minutes, 1))
-        weekday_score = (
-            1.0
-            if local.weekday() == pattern.weekday
-            else 0.5
-            if (local.weekday() >= 5) == (pattern.weekday >= 5)
-            else 0.0
-        )
-        comparable = [
-            (entity_id, expected)
-            for entity_id, expected in pattern.context_states.items()
-            if entity_id in current_context
-        ]
-        context_score = (
-            sum(current_context[entity_id] == expected for entity_id, expected in comparable)
-            / len(comparable)
-            if comparable
-            else 0.5
-        )
-        score = pattern.weight * (
-            0.45 * time_score + 0.45 * context_score + 0.10 * weekday_score
-        )
-        by_state.setdefault(pattern.target_state, []).append(score)
-    if not by_state:
-        return None
-    target_state, scores = max(
-        by_state.items(),
-        key=lambda item: (sum(item[1]), len(item[1]), item[0]),
-    )
-    support = len(scores)
-    causal_support = causal_support_by_state.get(target_state, 0)
-    confidence = min(1.0, (sum(scores) / support) * min(1.0, support / min_support))
-    if confidence <= 0:
-        return None
-    return BehaviorPrediction(
-        target_state=target_state,
-        confidence=round(confidence, 4),
-        generated_at=now,
-        matching_patterns=support,
-        reason=(
-            (
-                f"{causal_support} historische Handlungen folgten demselben "
-                "frischen Sensorwechsel."
-            )
-            if causal_support
-            else f"{support} ähnliche Handlungsmuster passen zu Zeit und aktuellem Kontext."
-        ),
-    )
-
-
-def service_for_state(domain: str, target_state: str) -> str | None:
-    if domain in {"fan", "humidifier", "light", "switch"}:
-        return {"on": "turn_on", "off": "turn_off"}.get(target_state)
-    if domain == "cover":
-        return {"open": "open_cover", "closed": "close_cover"}.get(target_state)
-    return None
-
-
-def _state_at(series: StateHistorySeries | None, timestamp: datetime) -> str | None:
-    if series is None:
-        return None
-    state: str | None = None
-    for point in series.points:
-        if point.timestamp > timestamp:
-            break
-        state = point.state
-    return state
-
-
-def _action_source(
-    point: StateHistoryPoint,
-    logbook: list[LogbookEntry],
-) -> tuple[str, float]:
-    nearest = min(
-        logbook,
-        key=lambda item: abs(item.timestamp - point.timestamp),
-        default=None,
-    )
-    if nearest is None or abs(nearest.timestamp - point.timestamp) > _ACTION_LOGBOOK_TOLERANCE:
-        return "physical_or_unknown", 0.7
-    if nearest.context_user_id:
-        return "user", 1.0
-    if nearest.context_domain in _AUTOMATION_CONTEXT_DOMAINS:
-        return "automation", 0.1
-    return "physical_or_unknown", 0.7
-
-
-def _matches_own_execution(
-    point: StateHistoryPoint,
-    own_executions: list[ExecutionEvent],
-) -> bool:
-    return any(
-        event.target_state == point.state
-        and abs(event.executed_at - point.timestamp) <= _OWN_ACTION_TOLERANCE
-        for event in own_executions
-    )
-
-
-def _recent_context_transition(
-    history: dict[str, StateHistorySeries],
-    context_ids: list[str],
-    timestamp: datetime,
-) -> tuple[str, str, str] | None:
-    nearest: tuple[timedelta, str, str, str] | None = None
-    for entity_id in context_ids:
-        series = history.get(entity_id)
-        if series is None:
-            continue
-        previous_state: str | None = None
-        for point in series.points:
-            if point.timestamp > timestamp:
-                break
-            if previous_state is not None and point.state != previous_state:
-                age = timestamp - point.timestamp
-                if age <= _CONTEXT_TRIGGER_TOLERANCE and (
-                    nearest is None or age < nearest[0]
-                ):
-                    nearest = (age, entity_id, previous_state, point.state)
-            previous_state = point.state
-    if nearest is None:
-        return None
-    return nearest[1], nearest[2], nearest[3]
-
-
-def _circular_minute_distance(left: int, right: int) -> int:
-    direct = abs(left - right)
-    return min(direct, 1440 - direct)

app/config.py

@@ -8,19 +8,6 @@ from dataclasses import dataclass
 class Settings:
     ha_url: str | None = None
     ha_token: str | None = None
-    model_store: str = ".model_store"
-    automation_store: str = ".automation_store"
-    actuator_store: str = ".actuator_store"
-    history_days: int = 14
-    min_training_points: int = 24
-    retrain_stale_hours: int = 24
-    reconcile_interval_seconds: int = 900
-    min_behavior_actions: int = 3
-    prediction_confidence: float = 0.82
-    prediction_window_minutes: int = 30
-    prediction_interval_seconds: int = 60
-    execution_cooldown_seconds: int = 900
-    timezone: str = "Europe/Berlin"
 
     @property
     def ha_configured(self) -> bool:
@@ -31,28 +18,4 @@ def load_settings() -> Settings:
     return Settings(
         ha_url=os.getenv("SILLYHOME_HA_URL") or os.getenv("HA_URL"),
         ha_token=os.getenv("SILLYHOME_HA_TOKEN") or os.getenv("HA_TOKEN"),
-        model_store=os.getenv("SILLYHOME_MODEL_STORE", ".model_store"),
-        automation_store=os.getenv("SILLYHOME_AUTOMATION_STORE", ".automation_store"),
-        actuator_store=os.getenv("SILLYHOME_ACTUATOR_STORE", ".actuator_store"),
-        history_days=max(1, min(31, int(os.getenv("SILLYHOME_HISTORY_DAYS", "14")))),
-        min_training_points=max(2, int(os.getenv("SILLYHOME_MIN_TRAINING_POINTS", "24"))),
-        retrain_stale_hours=max(1, int(os.getenv("SILLYHOME_RETRAIN_STALE_HOURS", "24"))),
-        reconcile_interval_seconds=max(
-            60, int(os.getenv("SILLYHOME_RECONCILE_INTERVAL_SECONDS", "900"))
-        ),
-        min_behavior_actions=max(2, int(os.getenv("SILLYHOME_MIN_BEHAVIOR_ACTIONS", "3"))),
-        prediction_confidence=max(
-            0.5,
-            min(0.99, float(os.getenv("SILLYHOME_PREDICTION_CONFIDENCE", "0.82"))),
-        ),
-        prediction_window_minutes=max(
-            5, min(120, int(os.getenv("SILLYHOME_PREDICTION_WINDOW_MINUTES", "30")))
-        ),
-        prediction_interval_seconds=max(
-            30, int(os.getenv("SILLYHOME_PREDICTION_INTERVAL_SECONDS", "60"))
-        ),
-        execution_cooldown_seconds=max(
-            60, int(os.getenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "900"))
-        ),
-        timezone=os.getenv("SILLYHOME_TIMEZONE", "Europe/Berlin"),
     )

app/core/exceptions.py

@@ -1,20 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from fastapi import FastAPI, Request
-
-from app.ha.exceptions import HaAuthError, HaClientError, HaHttpError
-
-
-def register_exception_handlers(app: FastAPI) -> None:
-    @app.exception_handler(HaClientError)
-    async def handle_ha_client_error(request: Request, exc: HaClientError) -> Any:  # pragma: no cover - einfacher Wrapper
-        if isinstance(exc, HaAuthError):
-            return {"detail": "Ungültige Authentifizierung gegenüber Home Assistant."}
-        if isinstance(exc, HaHttpError):
-            return {
-                "detail": "Home Assistant meldet einen Fehler.",
-                "upstream_status": exc.status_code,
-            }
-        return {"detail": str(exc)}

app/ha/client.py

@@ -2,11 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from datetime import datetime
-import json
-import re
 from typing import Any
-from urllib.parse import quote
 
 import requests
 
@@ -19,10 +15,6 @@ from app.ha.exceptions import (
 
 logger = logging.getLogger(__name__)
 
-_ENTITY_ID_PATTERN = re.compile(r"^[a-z0-9_]+\.[a-z0-9_]+$")
-_SERVICE_PART_PATTERN = re.compile(r"^[a-z0-9_]+$")
-_MAX_HISTORY_SECONDS = 31 * 24 * 60 * 60
-
 
 @dataclass(frozen=True)
 class HaClientSettings:
@@ -40,258 +32,36 @@ class HaClient:
             "Content-Type": "application/json",
         })
 
-    def close(self) -> None:
-        self._session.close()
-
-    def list_entities(self) -> list[dict[str, object]]:
-        payload = self._get_json("/api/states")
-        if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError(
-                "Antwort von Home Assistant hat unerwartetes Format."
-            )
-        return payload
-
-    def get_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[object]:
-        if not entity_ids:
-            raise ValueError("Mindestens eine entity_id ist erforderlich.")
-        if len(entity_ids) > 100:
-            raise ValueError("Es können höchstens 100 Entities abgefragt werden.")
-        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
-            raise ValueError("entity_id enthält ein ungültiges Format.")
-        if start_time.tzinfo is None or end_time.tzinfo is None:
-            raise ValueError("start_time und end_time müssen eine Zeitzone enthalten.")
-        if end_time <= start_time:
-            raise ValueError("end_time muss nach start_time liegen.")
-        if (end_time - start_time).total_seconds() > _MAX_HISTORY_SECONDS:
-            raise ValueError("History-Abfragen sind auf 31 Tage begrenzt.")
-
-        start = quote(start_time.isoformat(), safe=":+")
-        payload = self._get_json(
-            f"/api/history/period/{start}",
-            params={
-                "filter_entity_id": ",".join(entity_ids),
-                "end_time": end_time.isoformat(),
-                "minimal_response": "1",
-                "no_attributes": "1",
-            },
-        )
-        if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError(
-                "History-Antwort von Home Assistant hat unerwartetes Format."
-            )
-        return payload
-
-    def get_logbook(
-        self,
-        entity_id: str,
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[object]:
-        self._validate_period([entity_id], start_time, end_time)
-        start = quote(start_time.isoformat(), safe=":+")
-        payload = self._get_json(
-            f"/api/logbook/{start}",
-            params={
-                "entity": entity_id,
-                "end_time": end_time.isoformat(),
-            },
-        )
-        if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError(
-                "Logbook-Antwort von Home Assistant hat unerwartetes Format."
-            )
-        return payload
-
-    def call_service(
-        self,
-        domain: str,
-        service: str,
-        service_data: dict[str, object],
-    ) -> list[object]:
-        if not _SERVICE_PART_PATTERN.fullmatch(domain):
-            raise ValueError("Ungültige Service-Domain.")
-        if not _SERVICE_PART_PATTERN.fullmatch(service):
-            raise ValueError("Ungültiger Service-Name.")
-        payload = self._post_json(f"/api/services/{domain}/{service}", service_data)
-        if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError(
-                "Service-Antwort von Home Assistant hat unerwartetes Format."
-            )
-        return payload
-
-    def list_entity_metadata(self, entity_ids: list[str]) -> dict[str, dict[str, str | None]]:
-        if not entity_ids:
-            return {}
-        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
-            raise ValueError("entity_id enthält ein ungültiges Format.")
-        template = _metadata_template(entity_ids)
-        rendered = self._post_text("/api/template", {"template": template})
-        try:
-            payload = json.loads(rendered)
-        except json.JSONDecodeError as exc:
-            raise HaUnexpectedPayloadError("Entity-Metadaten konnten nicht gelesen werden.") from exc
-        if not isinstance(payload, list):
-            raise HaUnexpectedPayloadError("Entity-Metadaten haben ein unerwartetes Format.")
-        result: dict[str, dict[str, str | None]] = {}
-        for item in payload:
-            if not isinstance(item, dict):
-                raise HaUnexpectedPayloadError("Entity-Metadaten haben ein unerwartetes Format.")
-            entity_id = item.get("entity_id")
-            if not isinstance(entity_id, str) or "." not in entity_id:
-                raise HaUnexpectedPayloadError("Entity-Metadaten enthalten ungültige entity_id.")
-            result[entity_id] = {
-                key: _optional_string(item.get(key))
-                for key in ("area_id", "area_name", "device_id", "device_name")
-            }
-        return result
-
-    def _get_json(
-        self,
-        path: str,
-        *,
-        params: dict[str, str] | None = None,
-    ) -> object:
+    def list_entities(self) -> list[dict[str, Any]]:
         try:
             response = self._session.get(
-                f"{self._settings.url.rstrip('/')}{path}",
-                params=params,
+                f"{self._settings.url}/api/states",
                 timeout=self._settings.timeout_seconds,
             )
         except requests.Timeout as exc:
-            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
+            raise HaTimeoutError("Home Assistant request timed out.") from exc
         except requests.RequestException as exc:
-            raise HaHttpError(
-                getattr(getattr(exc, "response", None), "status_code", 502),
-                "Netzwerkfehler beim Zugriff auf Home Assistant.",
-            ) from exc
+            raise HaHttpError(status_code=502, message="Home Assistant request failed.") from exc
 
-        if response.status_code in (401, 403):
+        if response.status_code in {401, 403}:
             raise HaAuthError(
-                response.status_code,
-                "Authentifizierung bei Home Assistant fehlgeschlagen.",
+                status_code=response.status_code,
+                message="Home Assistant authentication failed.",
             )
 
         try:
             response.raise_for_status()
         except requests.HTTPError as exc:
             raise HaHttpError(
-                response.status_code,
-                "Home Assistant meldet einen Fehler.",
+                status_code=response.status_code,
+                message="Home Assistant returned an HTTP error.",
             ) from exc
 
         try:
             payload = response.json()
         except ValueError as exc:
-            raise HaUnexpectedPayloadError(
-                "Antwort von Home Assistant ist kein gültiges JSON."
-            ) from exc
+            raise HaUnexpectedPayloadError("Home Assistant returned invalid JSON.") from exc
 
+        if not isinstance(payload, list):
+            raise HaUnexpectedPayloadError("Home Assistant states response must be a list.")
         return payload
-
-    def _post_json(self, path: str, payload: Any) -> object:
-        try:
-            response = self._session.post(
-                f"{self._settings.url.rstrip('/')}{path}",
-                json=payload,
-                timeout=self._settings.timeout_seconds,
-            )
-        except requests.Timeout as exc:
-            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
-        except requests.RequestException as exc:
-            raise HaHttpError(
-                getattr(getattr(exc, "response", None), "status_code", 502),
-                "Netzwerkfehler beim Zugriff auf Home Assistant.",
-            ) from exc
-        if response.status_code in (401, 403):
-            raise HaAuthError(
-                response.status_code,
-                "Authentifizierung bei Home Assistant fehlgeschlagen.",
-            )
-        try:
-            response.raise_for_status()
-        except requests.HTTPError as exc:
-            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
-        try:
-            return response.json()
-        except ValueError as exc:
-            raise HaUnexpectedPayloadError(
-                "Antwort von Home Assistant ist kein gültiges JSON."
-            ) from exc
-
-    def _post_text(self, path: str, payload: dict[str, str]) -> str:
-        try:
-            response = self._session.post(
-                f"{self._settings.url.rstrip('/')}{path}",
-                json=payload,
-                timeout=self._settings.timeout_seconds,
-            )
-        except requests.Timeout as exc:
-            raise HaTimeoutError("Zeitüberschreitung beim Zugriff auf Home Assistant.") from exc
-        except requests.RequestException as exc:
-            raise HaHttpError(
-                getattr(getattr(exc, "response", None), "status_code", 502),
-                "Netzwerkfehler beim Zugriff auf Home Assistant.",
-            ) from exc
-
-        if response.status_code in (401, 403):
-            raise HaAuthError(
-                response.status_code,
-                "Authentifizierung bei Home Assistant fehlgeschlagen.",
-            )
-        try:
-            response.raise_for_status()
-        except requests.HTTPError as exc:
-            raise HaHttpError(response.status_code, "Home Assistant meldet einen Fehler.") from exc
-        return response.text
-
-    @staticmethod
-    def _validate_period(
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> None:
-        if not entity_ids:
-            raise ValueError("Mindestens eine entity_id ist erforderlich.")
-        if len(entity_ids) > 100:
-            raise ValueError("Es können höchstens 100 Entities abgefragt werden.")
-        if any(not _ENTITY_ID_PATTERN.fullmatch(entity_id) for entity_id in entity_ids):
-            raise ValueError("entity_id enthält ein ungültiges Format.")
-        if start_time.tzinfo is None or end_time.tzinfo is None:
-            raise ValueError("start_time und end_time müssen eine Zeitzone enthalten.")
-        if end_time <= start_time:
-            raise ValueError("end_time muss nach start_time liegen.")
-        if (end_time - start_time).total_seconds() > _MAX_HISTORY_SECONDS:
-            raise ValueError("History-Abfragen sind auf 31 Tage begrenzt.")
-
-
-def _metadata_template(entity_ids: list[str]) -> str:
-    ids = json.dumps(entity_ids, ensure_ascii=True)
-    return (
-        "{% set ids = "
-        f"{ids}"
-        " %}["
-        "{% for entity_id in ids %}"
-        "{% set device = device_id(entity_id) %}"
-        "{{ "
-        "{"
-        "\"entity_id\": entity_id,"
-        "\"area_id\": area_id(entity_id),"
-        "\"area_name\": area_name(entity_id),"
-        "\"device_id\": device,"
-        "\"device_name\": device_attr(device, 'name') if device else none"
-        "}"
-        " | tojson }}"
-        "{% if not loop.last %},{% endif %}"
-        "{% endfor %}]"
-    )
-
-
-def _optional_string(value: object) -> str | None:
-    if value is None or value == "":
-        return None
-    return str(value)

app/ha/discovery.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-from enum import StrEnum
-
-from pydantic import BaseModel
-
-from app.ha.models import HaEntitySummary
-
-
-class EntityRole(StrEnum):
-    MEASUREMENT = "measurement"
-    BINARY_CONTEXT = "binary_context"
-    CONTEXT = "context"
-    ACTUATOR = "actuator"
-    UNSUPPORTED = "unsupported"
-
-
-class DiscoveredEntity(BaseModel):
-    entity_id: str
-    domain: str
-    device_class: str | None = None
-    state_class: str | None = None
-    unit_of_measurement: str | None = None
-    role: EntityRole
-    learnable: bool
-    reason: str
-
-
-_MEASUREMENT_CLASSES = frozenset({
-    "apparent_power",
-    "atmospheric_pressure",
-    "battery",
-    "carbon_dioxide",
-    "carbon_monoxide",
-    "current",
-    "distance",
-    "duration",
-    "energy",
-    "frequency",
-    "gas",
-    "humidity",
-    "illuminance",
-    "moisture",
-    "monetary",
-    "nitrogen_dioxide",
-    "nitrogen_monoxide",
-    "nitrous_oxide",
-    "ozone",
-    "pm1",
-    "pm10",
-    "pm25",
-    "power",
-    "precipitation",
-    "pressure",
-    "reactive_power",
-    "signal_strength",
-    "sound_pressure",
-    "speed",
-    "sulphur_dioxide",
-    "temperature",
-    "volatile_organic_compounds",
-    "voltage",
-    "volume",
-    "volume_flow_rate",
-    "water",
-    "weight",
-    "wind_speed",
-})
-_BINARY_CONTEXT_CLASSES = frozenset({
-    "door",
-    "garage_door",
-    "lock",
-    "motion",
-    "occupancy",
-    "opening",
-    "presence",
-    "problem",
-    "safety",
-    "smoke",
-    "sound",
-    "vibration",
-    "window",
-})
-_ACTUATOR_DOMAINS = frozenset({
-    "button",
-    "climate",
-    "cover",
-    "fan",
-    "humidifier",
-    "light",
-    "lock",
-    "scene",
-    "select",
-    "siren",
-    "switch",
-    "valve",
-})
-_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "sun", "weather", "zone"})
-_LEARNABLE_CONTEXT_DOMAINS = frozenset({"device_tracker", "person", "weather"})
-_NUMERIC_STATE_CLASSES = frozenset({"measurement", "total", "total_increasing"})
-
-
-def classify_entity(entity: HaEntitySummary) -> DiscoveredEntity:
-    if entity.domain == "sensor" and (
-        entity.state_class in _NUMERIC_STATE_CLASSES
-        or entity.device_class in _MEASUREMENT_CLASSES
-        or entity.unit_of_measurement is not None
-    ):
-        return _result(
-            entity,
-            EntityRole.MEASUREMENT,
-            learnable=True,
-            reason="Numerischer Messsensor für Zeitreihen und Training.",
-        )
-
-    if entity.domain == "binary_sensor" and entity.device_class in _BINARY_CONTEXT_CLASSES:
-        return _result(
-            entity,
-            EntityRole.BINARY_CONTEXT,
-            learnable=True,
-            reason="Binärer Kontextsensor für Zustands- und Anwesenheitsmuster.",
-        )
-
-    if entity.domain in _CONTEXT_DOMAINS:
-        learnable = entity.domain in _LEARNABLE_CONTEXT_DOMAINS
-        return _result(
-            entity,
-            EntityRole.CONTEXT,
-            learnable=learnable,
-            reason=(
-                "Kontextquelle für Training und Erklärungen."
-                if learnable
-                else "Kontextquelle ohne direkte Trainingsfreigabe."
-            ),
-        )
-
-    if entity.domain in _ACTUATOR_DOMAINS:
-        return _result(
-            entity,
-            EntityRole.ACTUATOR,
-            learnable=False,
-            reason="Aktor ist ein mögliches Automationsziel, aber kein Trainingssensor.",
-        )
-
-    return _result(
-        entity,
-        EntityRole.UNSUPPORTED,
-        learnable=False,
-        reason="Entity-Typ ist noch nicht für Lernen oder Automationen klassifiziert.",
-    )
-
-
-def discover_entities(
-    entities: list[HaEntitySummary],
-    domains: set[str] | None = None,
-    learnable: bool | None = None,
-) -> list[DiscoveredEntity]:
-    normalized_domains = {domain.strip().lower() for domain in domains or set() if domain.strip()}
-    discovered = [classify_entity(entity) for entity in entities]
-    return [
-        entity
-        for entity in discovered
-        if (not normalized_domains or entity.domain in normalized_domains)
-        and (learnable is None or entity.learnable is learnable)
-    ]
-
-
-def _result(
-    entity: HaEntitySummary,
-    role: EntityRole,
-    *,
-    learnable: bool,
-    reason: str,
-) -> DiscoveredEntity:
-    return DiscoveredEntity(
-        entity_id=entity.entity_id,
-        domain=entity.domain,
-        device_class=entity.device_class,
-        state_class=entity.state_class,
-        unit_of_measurement=entity.unit_of_measurement,
-        role=role,
-        learnable=learnable,
-        reason=reason,
-    )

app/ha/exceptions.py

@@ -2,34 +2,26 @@ from __future__ import annotations
 
 
 class HaClientError(Exception):
-    """Basisklasse für HA-Client-Fehler."""
+    """Base class for Home Assistant integration failures."""
 
-    public_detail: str | None = None
+    public_detail = "Home Assistant is currently unavailable."
 
 
 class HaTimeoutError(HaClientError):
-    """Zeitüberschreitung bei Request an Home Assistant."""
-
     public_detail = "Home Assistant request timed out."
 
 
 class HaHttpError(HaClientError):
-    """Nicht erfolgreicher HTTP-Statuscode."""
+    public_detail = "Home Assistant returned an error."
 
-    public_detail = "Home Assistant request failed."
-
-    def __init__(self, status_code: int, message: str = "") -> None:
-        super().__init__(message)
+    def __init__(self, status_code: int, message: str | None = None) -> None:
+        super().__init__(message or self.public_detail)
         self.status_code = status_code
 
 
 class HaAuthError(HaHttpError):
-    """Authentifizierung oder Berechtigung fehlgeschlagen."""
-
     public_detail = "Home Assistant authentication failed."
 
 
 class HaUnexpectedPayloadError(HaClientError):
-    """Antwort hat nicht das erwartete Format."""
-
-    public_detail = "Home Assistant returned an unexpected payload."
+    public_detail = "Home Assistant returned an unexpected response."

app/ha/history.py

@@ -1,178 +0,0 @@
-from __future__ import annotations
-
-import math
-from datetime import datetime
-
-from pydantic import BaseModel
-
-from app.ha.exceptions import HaUnexpectedPayloadError
-
-
-class NumericHistoryPoint(BaseModel):
-    timestamp: datetime
-    value: float
-
-
-class EntityHistorySeries(BaseModel):
-    entity_id: str
-    points: list[NumericHistoryPoint]
-
-
-class StateHistoryPoint(BaseModel):
-    timestamp: datetime
-    state: str
-
-
-class StateHistorySeries(BaseModel):
-    entity_id: str
-    points: list[StateHistoryPoint]
-
-
-class LogbookEntry(BaseModel):
-    entity_id: str
-    timestamp: datetime
-    message: str = ""
-    context_user_id: str | None = None
-    context_domain: str | None = None
-    context_service: str | None = None
-
-
-def normalize_history_payload(payload: object) -> list[EntityHistorySeries]:
-    if not isinstance(payload, list):
-        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
-
-    normalized: list[EntityHistorySeries] = []
-    for raw_series in payload:
-        if not isinstance(raw_series, list):
-            raise HaUnexpectedPayloadError("History-Serie muss eine Liste sein.")
-        series = _normalize_series(raw_series)
-        if series is not None:
-            normalized.append(series)
-
-    return sorted(normalized, key=lambda item: item.entity_id)
-
-
-def normalize_state_history_payload(payload: object) -> list[StateHistorySeries]:
-    if not isinstance(payload, list):
-        raise HaUnexpectedPayloadError("History-Payload muss eine Liste sein.")
-    normalized: list[StateHistorySeries] = []
-    for raw_series in payload:
-        if not isinstance(raw_series, list):
-            raise HaUnexpectedPayloadError("History-Serie muss eine Liste sein.")
-        entity_id: str | None = None
-        points: list[StateHistoryPoint] = []
-        for raw_entry in raw_series:
-            if not isinstance(raw_entry, dict):
-                raise HaUnexpectedPayloadError("History-Eintrag muss ein Objekt sein.")
-            raw_entity_id = raw_entry.get("entity_id")
-            if raw_entity_id is not None:
-                if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
-                    raise HaUnexpectedPayloadError(
-                        "History-Eintrag enthält ungültige entity_id."
-                    )
-                if entity_id is not None and entity_id != raw_entity_id:
-                    raise HaUnexpectedPayloadError("History-Serie enthält mehrere Entities.")
-                entity_id = raw_entity_id
-            raw_state = raw_entry.get("state")
-            if not isinstance(raw_state, str) or raw_state in {"unknown", "unavailable"}:
-                continue
-            if entity_id is None:
-                raise HaUnexpectedPayloadError("History-Serie enthält keine entity_id.")
-            timestamp = _parse_timestamp(
-                raw_entry.get("last_changed") or raw_entry.get("last_updated")
-            )
-            if not points or points[-1].state != raw_state:
-                points.append(StateHistoryPoint(timestamp=timestamp, state=raw_state))
-        if entity_id is not None and points:
-            points.sort(key=lambda point: point.timestamp)
-            normalized.append(StateHistorySeries(entity_id=entity_id, points=points))
-    return sorted(normalized, key=lambda item: item.entity_id)
-
-
-def normalize_logbook_payload(payload: object, entity_id: str) -> list[LogbookEntry]:
-    if not isinstance(payload, list):
-        raise HaUnexpectedPayloadError("Logbook-Payload muss eine Liste sein.")
-    entries: list[LogbookEntry] = []
-    for raw_entry in payload:
-        if not isinstance(raw_entry, dict):
-            raise HaUnexpectedPayloadError("Logbook-Eintrag muss ein Objekt sein.")
-        raw_entity_id = raw_entry.get("entity_id")
-        if raw_entity_id != entity_id:
-            continue
-        entries.append(
-            LogbookEntry(
-                entity_id=entity_id,
-                timestamp=_parse_timestamp(raw_entry.get("when")),
-                message=str(raw_entry.get("message") or ""),
-                context_user_id=_optional_string(raw_entry.get("context_user_id")),
-                context_domain=_optional_string(
-                    raw_entry.get("context_domain") or raw_entry.get("domain")
-                ),
-                context_service=_optional_string(raw_entry.get("context_service")),
-            )
-        )
-    return sorted(entries, key=lambda item: item.timestamp)
-
-
-def _normalize_series(raw_series: list[object]) -> EntityHistorySeries | None:
-    entity_id: str | None = None
-    points: list[NumericHistoryPoint] = []
-
-    for raw_entry in raw_series:
-        if not isinstance(raw_entry, dict):
-            raise HaUnexpectedPayloadError("History-Eintrag muss ein Objekt sein.")
-
-        raw_entity_id = raw_entry.get("entity_id")
-        if raw_entity_id is not None:
-            if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
-                raise HaUnexpectedPayloadError("History-Eintrag enthält ungültige entity_id.")
-            if entity_id is not None and entity_id != raw_entity_id:
-                raise HaUnexpectedPayloadError("History-Serie enthält mehrere Entities.")
-            entity_id = raw_entity_id
-
-        raw_state = raw_entry.get("state")
-        value = _finite_float(raw_state)
-        if value is None:
-            continue
-        if entity_id is None:
-            raise HaUnexpectedPayloadError("History-Serie enthält keine entity_id.")
-
-        raw_timestamp = raw_entry.get("last_changed") or raw_entry.get("last_updated")
-        timestamp = _parse_timestamp(raw_timestamp)
-        points.append(NumericHistoryPoint(timestamp=timestamp, value=value))
-
-    if entity_id is None or not points:
-        return None
-
-    points.sort(key=lambda point: point.timestamp)
-    return EntityHistorySeries(entity_id=entity_id, points=points)
-
-
-def _finite_float(value: object) -> float | None:
-    if isinstance(value, bool) or value is None:
-        return None
-    if not isinstance(value, (str, int, float)):
-        return None
-    try:
-        converted = float(value)
-    except (TypeError, ValueError):
-        return None
-    return converted if math.isfinite(converted) else None
-
-
-def _parse_timestamp(value: object) -> datetime:
-    if not isinstance(value, str):
-        raise HaUnexpectedPayloadError("Numerischer History-Eintrag enthält keinen Zeitstempel.")
-    try:
-        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError as exc:
-        raise HaUnexpectedPayloadError("History-Eintrag enthält ungültigen Zeitstempel.") from exc
-    if parsed.tzinfo is None:
-        raise HaUnexpectedPayloadError("History-Zeitstempel muss eine Zeitzone enthalten.")
-    return parsed
-
-
-def _optional_string(value: object) -> str | None:
-    if value is None or value == "":
-        return None
-    return str(value)

app/ha/models.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from datetime import datetime
-
 from pydantic import BaseModel
 
 
@@ -16,13 +14,6 @@ class HaState(BaseModel):
 class HaEntitySummary(BaseModel):
     entity_id: str
     domain: str
-    state: str | None = None
-    last_changed: datetime | None = None
     state_class: str | None = None
     device_class: str | None = None
     unit_of_measurement: str | None = None
-    friendly_name: str | None = None
-    area_id: str | None = None
-    area_name: str | None = None
-    device_id: str | None = None
-    device_name: str | None = None

app/ha/reader.py

@@ -1,26 +1,11 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from datetime import datetime
 from typing import Any
-import logging
-
-from app.ha.exceptions import HaClientError
 
 from app.ha.client import HaClient
-from app.ha.discovery import DiscoveredEntity, discover_entities
-from app.ha.history import (
-    EntityHistorySeries,
-    LogbookEntry,
-    StateHistorySeries,
-    normalize_history_payload,
-    normalize_logbook_payload,
-    normalize_state_history_payload,
-)
 from app.ha.models import HaEntitySummary
 
-logger = logging.getLogger(__name__)
-
 
 class HaReader:
     def __init__(self, client: HaClient) -> None:
@@ -28,102 +13,27 @@ class HaReader:
 
     def read_entities(self) -> Sequence[HaEntitySummary]:
         entities = self._client.list_entities()
-        entity_ids = [
-            raw_entity_id
-            for item in entities
-            if isinstance((raw_entity_id := item.get("entity_id")), str) and "." in raw_entity_id
-        ]
-        try:
-            metadata_by_entity = self._client.list_entity_metadata(entity_ids)
-        except (HaClientError, ValueError) as exc:
-            logger.warning("HA metadata enrichment skipped: %s", exc)
-            metadata_by_entity = {}
         summaries: list[HaEntitySummary] = []
         for item in entities:
-            raw_entity_id = item.get("entity_id")
-            if not isinstance(raw_entity_id, str) or "." not in raw_entity_id:
+            entity_id = item.get("entity_id", "")
+            if "." not in entity_id:
                 continue
-            entity_id = raw_entity_id
             domain = entity_id.split(".", 1)[0]
             raw_attributes = item.get("attributes") or {}
             attributes: dict[str, Any] = raw_attributes if isinstance(raw_attributes, dict) else {}
-            metadata = metadata_by_entity.get(entity_id, {})
             summaries.append(
                 HaEntitySummary(
                     entity_id=entity_id,
                     domain=domain,
-                    state=_optional_str(item.get("state")),
-                    last_changed=_optional_datetime(item.get("last_changed")),
                     state_class=_optional_str(attributes.get("state_class")),
                     device_class=_optional_str(attributes.get("device_class")),
                     unit_of_measurement=_optional_str(attributes.get("unit_of_measurement")),
-                    friendly_name=_optional_str(attributes.get("friendly_name")),
-                    area_id=_optional_str(metadata.get("area_id") or attributes.get("area_id")),
-                    area_name=_optional_str(metadata.get("area_name") or attributes.get("area_name")),
-                    device_id=_optional_str(metadata.get("device_id") or attributes.get("device_id")),
-                    device_name=_optional_str(
-                        metadata.get("device_name")
-                        or attributes.get("device_name")
-                        or attributes.get("device")
-                    ),
                 )
             )
         return summaries
 
-    def discover(
-        self,
-        domains: set[str] | None = None,
-        learnable: bool | None = None,
-    ) -> Sequence[DiscoveredEntity]:
-        return discover_entities(list(self.read_entities()), domains=domains, learnable=learnable)
-
-    def read_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> Sequence[EntityHistorySeries]:
-        payload = self._client.get_history(entity_ids, start_time, end_time)
-        return normalize_history_payload(payload)
-
-    def read_state_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> Sequence[StateHistorySeries]:
-        payload = self._client.get_history(entity_ids, start_time, end_time)
-        return normalize_state_history_payload(payload)
-
-    def read_logbook(
-        self,
-        entity_id: str,
-        start_time: datetime,
-        end_time: datetime,
-    ) -> Sequence[LogbookEntry]:
-        payload = self._client.get_logbook(entity_id, start_time, end_time)
-        return normalize_logbook_payload(payload, entity_id)
-
-    def call_service(
-        self,
-        domain: str,
-        service: str,
-        service_data: dict[str, object],
-    ) -> Sequence[object]:
-        return self._client.call_service(domain, service, service_data)
-
 
 def _optional_str(value: object) -> str | None:
     if value is None or value == "":
         return None
     return str(value)
-
-
-def _optional_datetime(value: object) -> datetime | None:
-    if not isinstance(value, str) or not value:
-        return None
-    try:
-        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-    return parsed if parsed.tzinfo is not None else None

app/main.py

@@ -1,93 +1,40 @@
-import asyncio
-from contextlib import asynccontextmanager, suppress
 from collections.abc import AsyncIterator
-from pathlib import Path
-from typing import cast
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
 
-from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.store import ActuatorStore
-from app.api.v1.actuators import router as actuators_router
 from app.api.v1.entities import router as entities_router
-from app.behavior.engine import BehaviorEngine
 from app.config import load_settings
 from app.core.exception_handlers import register_exception_handlers
 from app.ha.client import HaClient, HaClientSettings
 from app.ha.reader import HaReader
-from app.ml.registry.model_registry import ModelRegistry
-from backend.routes.ml import init_ml_routes
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
-    settings = app.state.settings
-    client: HaClient | None = None
-    reconcile_task: asyncio.Task[None] | None = None
-    prediction_task: asyncio.Task[None] | None = None
-    app.state.registry = ModelRegistry(settings.model_store)
-    app.state.actuator_store = ActuatorStore(settings.actuator_store)
-    if hasattr(app.state, "ha_reader"):
-        del app.state.ha_reader
-    if hasattr(app.state, "actuator_service"):
-        del app.state.actuator_service
-    if hasattr(app.state, "behavior_engine"):
-        del app.state.behavior_engine
+    settings = load_settings()
+    app.state.settings = settings
     if settings.ha_configured:
         client = HaClient(
             settings=HaClientSettings(
-                url=cast(str, settings.ha_url),
-                token=cast(str, settings.ha_token),
+                url=settings.ha_url or "",
+                token=settings.ha_token or "",
             )
         )
         app.state.ha_reader = HaReader(client=client)
-        app.state.actuator_service = ActuatorReconciliationService(
-            ha_reader=app.state.ha_reader,
-            store=app.state.actuator_store,
-            registry=app.state.registry,
-            settings=settings,
-        )
-        app.state.behavior_engine = BehaviorEngine(
-            ha_reader=app.state.ha_reader,
-            store=app.state.actuator_store,
-            settings=settings,
-        )
-        await asyncio.to_thread(app.state.actuator_service.reconcile_all, "startup")
-        await asyncio.to_thread(app.state.behavior_engine.train_all)
-        await asyncio.to_thread(app.state.behavior_engine.evaluate_all)
-        reconcile_task = asyncio.create_task(_periodic_reconciliation(app))
-        prediction_task = asyncio.create_task(_periodic_prediction(app))
-    try:
-        yield
-    finally:
-        if reconcile_task is not None:
-            reconcile_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await reconcile_task
-        if prediction_task is not None:
-            prediction_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await prediction_task
-        if client is not None:
-            client.close()
+    yield
 
 
 app = FastAPI(
     title="SillyHome Next API",
     description="Lokales Smart-Home-Intelligenzsystem für Home Assistant.",
-    version="0.5.2",
+    version="0.1.0",
     lifespan=lifespan,
 )
-app.state.settings = load_settings()
-register_exception_handlers(app)
-app.include_router(entities_router)
-app.include_router(actuators_router)
-init_ml_routes(app, model_store=app.state.settings.model_store)
 
-STATIC_DIR = Path(__file__).with_name("static")
-app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+register_exception_handlers(app)
+
+app.include_router(entities_router)
 
 
 @app.get("/health")
@@ -96,26 +43,5 @@ def health() -> dict[str, str]:
 
 
 @app.get("/")
-def root() -> FileResponse:
-    return FileResponse(STATIC_DIR / "index.html")
-
-
-async def _periodic_reconciliation(app: FastAPI) -> None:
-    while True:
-        await asyncio.sleep(app.state.settings.reconcile_interval_seconds)
-        service = getattr(app.state, "actuator_service", None)
-        if not isinstance(service, ActuatorReconciliationService):
-            continue
-        await asyncio.to_thread(service.reconcile_all, "scheduled")
-        engine = getattr(app.state, "behavior_engine", None)
-        if isinstance(engine, BehaviorEngine):
-            await asyncio.to_thread(engine.train_all)
-
-
-async def _periodic_prediction(app: FastAPI) -> None:
-    while True:
-        await asyncio.sleep(app.state.settings.prediction_interval_seconds)
-        engine = getattr(app.state, "behavior_engine", None)
-        if not isinstance(engine, BehaviorEngine):
-            continue
-        await asyncio.to_thread(engine.evaluate_all)
+def root() -> dict[str, str]:
+    return {"service": "sillyhome-next", "docs": "/docs"}

app/ml/__init__.py

@@ -1,20 +0,0 @@
-
-"""Machine-Learning-Grundbausteine für SillyHome Next."""
-__all__ = [
-    "FeatureStore",
-    "FeatureVector",
-    "FeatureModel",
-    "FeatureExplanation",
-    "PredictionResult",
-    "Predictor",
-    "RetrainingResult",
-    "RetrainingService",
-    "TrainedArtifact",
-    "TrainingPipeline",
-    "retrain_model",
-]
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.explanation import FeatureExplanation
-from app.ml.predictor import PredictionResult, Predictor
-from app.ml.retraining import RetrainingResult, RetrainingService, retrain_model
-from app.ml.training import FeatureModel, TrainedArtifact, TrainingPipeline

app/ml/evaluation.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import logging
-import math
-from collections.abc import Sequence
-from dataclasses import dataclass
-
-from app.ml.feature_store import FeatureVector
-from app.ml.predictor import Predictor
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.training import TrainingPipeline
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class Metric:
-    name: str
-    value: float
-    threshold: float | None = None
-
-
-@dataclass
-class EvalReport:
-    artifact_id: str
-    sample_size: int
-    metrics: list[Metric]
-
-
-class Evaluator:
-    def __init__(
-        self,
-        pipeline: TrainingPipeline | None = None,
-        registry: ModelRegistry | None = None,
-    ) -> None:
-        if isinstance(pipeline, ModelRegistry) and registry is None:
-            registry = pipeline
-            pipeline = None
-        if pipeline is None and registry is None:
-            raise ValueError("Evaluator erfordert TrainingPipeline oder ModelRegistry.")
-        self._pipeline = pipeline
-        self._registry = registry
-        self._predictor = Predictor(pipeline=pipeline, registry=registry)
-
-    def evaluate(self, artifact_id: str, samples: Sequence[FeatureVector]) -> EvalReport:
-        try:
-            if self._registry is not None:
-                self._registry.load_artifact(artifact_id)
-            elif self._pipeline is not None:
-                self._pipeline.export(artifact_id)
-        except KeyError as exc:
-            raise ValueError("Kein trainiertes Modell für Evaluation vorhanden.") from exc
-
-        absolute_errors: list[float] = []
-        squared_errors: list[float] = []
-        for sample in samples:
-            try:
-                prediction = self._predictor.predict(artifact_id, sample)
-            except ValueError:
-                continue
-            for feature_name, predicted in prediction.predictions.items():
-                actual = float(sample.values[feature_name])
-                error = predicted - actual
-                absolute_errors.append(abs(error))
-                squared_errors.append(error**2)
-
-        sample_size = len(absolute_errors)
-        mae = sum(absolute_errors) / sample_size if sample_size else 0.0
-        rmse = math.sqrt(sum(squared_errors) / sample_size) if sample_size else 0.0
-        expected_values = sum(len(sample.values) for sample in samples)
-        coverage = sample_size / expected_values if expected_values else 0.0
-
-        report = EvalReport(
-            artifact_id=artifact_id,
-            sample_size=sample_size,
-            metrics=[
-                Metric(name="mae", value=mae),
-                Metric(name="rmse", value=rmse),
-                Metric(name="coverage", value=coverage, threshold=0.8),
-            ],
-        )
-        logger.info(
-            "Evaluation %s -> mae=%.4f, rmse=%.4f, coverage=%.2f",
-            artifact_id,
-            mae,
-            rmse,
-            coverage,
-        )
-        return report

app/ml/explanation.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from app.ml.training import FeatureModel
-
-
-@dataclass(frozen=True)
-class FeatureExplanation:
-    feature: str
-    current_value: float
-    predicted_value: float
-    change: float
-    direction: str
-    sample_count: int
-    historical_mean: float
-    historical_range: tuple[float, float]
-    standard_deviation: float
-    trend_per_step: float
-    confidence: float
-    summary: str
-
-
-def explain_feature(
-    feature_name: str,
-    current_value: float,
-    predicted_value: float,
-    model: FeatureModel,
-) -> FeatureExplanation:
-    change = predicted_value - current_value
-    direction = _direction(change)
-    summary = (
-        f"{feature_name}: {direction}; Prognose {predicted_value:.3f} "
-        f"aus aktuellem Wert {current_value:.3f} und Trend {model.slope:+.3f}. "
-        f"Basis: {model.sample_count} Messwerte, Mittelwert {model.mean:.3f}, "
-        f"Confidence {model.confidence:.0%}."
-    )
-    return FeatureExplanation(
-        feature=feature_name,
-        current_value=current_value,
-        predicted_value=predicted_value,
-        change=change,
-        direction=direction,
-        sample_count=model.sample_count,
-        historical_mean=model.mean,
-        historical_range=(model.minimum, model.maximum),
-        standard_deviation=model.standard_deviation,
-        trend_per_step=model.slope,
-        confidence=model.confidence,
-        summary=summary,
-    )
-
-
-def _direction(change: float) -> str:
-    if abs(change) < 1e-12:
-        return "stabil"
-    return "steigend" if change > 0 else "fallend"

app/ml/feature_store.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from collections.abc import Iterable
-from dataclasses import dataclass
-
-
-@dataclass(frozen=True)
-class FeatureVector:
-    sensor_id: str
-    values: dict[str, float]
-    label: str | None = None
-
-
-class FeatureStore:
-    def __init__(self) -> None:
-        self._vectors: dict[str, list[FeatureVector]] = defaultdict(list)
-
-    def add(self, vector: FeatureVector) -> None:
-        self._vectors[vector.sensor_id].append(vector)
-
-    def add_batch(self, vectors: Iterable[FeatureVector]) -> None:
-        for vector in vectors:
-            self.add(vector)
-
-    def latest(self, sensor_id: str) -> FeatureVector | None:
-        series = self._vectors.get(sensor_id)
-        return series[-1] if series else None
-
-    def all(self) -> list[FeatureVector]:
-        return [vector for vectors in self._vectors.values() for vector in vectors]

app/ml/predictor.py

@@ -1,102 +0,0 @@
-from __future__ import annotations
-
-import logging
-import math
-from dataclasses import dataclass
-from typing import Sequence
-
-from app.ml.explanation import FeatureExplanation, explain_feature
-from app.ml.feature_store import FeatureVector
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.training import TrainedArtifact, TrainingPipeline
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class PredictionResult:
-    artifact_id: str
-    sensor_id: str
-    predictions: dict[str, float]
-    confidence: float
-    model_type: str
-    explanations: dict[str, FeatureExplanation]
-
-
-class Predictor:
-    def __init__(
-        self,
-        pipeline: TrainingPipeline | None = None,
-        registry: ModelRegistry | None = None,
-    ) -> None:
-        if isinstance(pipeline, ModelRegistry) and registry is None:
-            registry = pipeline
-            pipeline = None
-        if pipeline is None and registry is None:
-            raise ValueError("Predictor erfordert TrainingPipeline oder ModelRegistry.")
-        self._pipeline = pipeline
-        self._registry = registry
-
-    def predict(self, artifact_id: str, entity: FeatureVector) -> PredictionResult:
-        artifact = self._get_artifact(artifact_id)
-        if entity.sensor_id not in artifact.supported_sensors:
-            raise ValueError(
-                f"Sensor '{entity.sensor_id}' wird vom Modell '{artifact_id}' nicht unterstützt."
-            )
-        sensor_models = artifact.feature_models.get(entity.sensor_id, {})
-        if not sensor_models:
-            raise ValueError(f"Modell '{artifact_id}' enthält keine statistischen Parameter.")
-
-        feature_names = sorted(set(sensor_models).intersection(entity.values))
-        if not feature_names:
-            raise ValueError(
-                f"Keine Eingabemerkmale werden vom Modell '{artifact_id}' unterstützt."
-            )
-
-        predictions: dict[str, float] = {}
-        explanations: dict[str, FeatureExplanation] = {}
-        confidences: list[float] = []
-        for feature_name in feature_names:
-            model = sensor_models[feature_name]
-            current_value = float(entity.values[feature_name])
-            if not math.isfinite(current_value):
-                raise ValueError("Vorhersagewerte müssen endlich sein.")
-            predicted_value = model.forecast(current_value)
-            predictions[feature_name] = predicted_value
-            explanations[feature_name] = explain_feature(
-                feature_name,
-                current_value,
-                predicted_value,
-                model,
-            )
-            confidences.append(model.confidence)
-
-        return PredictionResult(
-            artifact_id=artifact_id,
-            sensor_id=entity.sensor_id,
-            predictions=predictions,
-            confidence=sum(confidences) / len(confidences),
-            model_type=artifact.model_type,
-            explanations=explanations,
-        )
-
-    def predict_batch(
-        self,
-        artifact_id: str,
-        entities: Sequence[FeatureVector],
-    ) -> list[PredictionResult]:
-        return [self.predict(artifact_id, entity) for entity in entities]
-
-    @staticmethod
-    def default_artifact(pipeline: TrainingPipeline) -> TrainedArtifact:
-        artifacts = list(pipeline._artifacts)
-        if not artifacts:
-            raise ValueError("Kein trainiertes Modell gefunden.")
-        return pipeline.export(artifacts[-1])
-
-    def _get_artifact(self, artifact_id: str) -> TrainedArtifact:
-        if self._registry is not None:
-            return self._registry.load_artifact(artifact_id)
-        if self._pipeline is not None:
-            return self._pipeline.export(artifact_id)
-        raise RuntimeError("Predictor nicht initialisiert.")

app/ml/registry/__init__.py

@@ -1,3 +0,0 @@
-from .model_registry import ModelRegistry
-
-__all__ = ["ModelRegistry"]

app/ml/registry/model_registry.py

@@ -1,181 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import math
-import os
-from pathlib import Path
-import re
-from threading import RLock
-from collections.abc import Iterable
-
-from app.ml.training import FeatureModel, TrainedArtifact
-
-logger = logging.getLogger(__name__)
-
-_ARTIFACT_ID_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
-
-
-class ModelRegistry:
-    def __init__(self, root: str | Path) -> None:
-        self._root = Path(root).resolve()
-        self._root.mkdir(parents=True, exist_ok=True)
-        self._archive_root = self._root / "archive"
-        self._archive_root.mkdir(parents=True, exist_ok=True)
-        self._artifacts: dict[str, TrainedArtifact] = {}
-        self._lock = RLock()
-        self._load_existing()
-
-    def register(self, artifact: TrainedArtifact) -> TrainedArtifact:
-        registered, _ = self.register_with_status(artifact)
-        return registered
-
-    def register_with_status(self, artifact: TrainedArtifact) -> tuple[TrainedArtifact, bool]:
-        self._validate_artifact_id(artifact.artifact_id)
-        with self._lock:
-            replaced = artifact.artifact_id in self._artifacts
-            self._persist(artifact)
-            self._artifacts[artifact.artifact_id] = artifact
-        return artifact, replaced
-
-    def load_artifact(self, artifact_id: str) -> TrainedArtifact:
-        self._validate_artifact_id(artifact_id)
-        with self._lock:
-            if artifact_id not in self._artifacts:
-                raise KeyError(f"Artifact '{artifact_id}' nicht registriert.")
-            return self._artifacts[artifact_id]
-
-    def get_optional(self, artifact_id: str) -> TrainedArtifact | None:
-        self._validate_artifact_id(artifact_id)
-        with self._lock:
-            return self._artifacts.get(artifact_id)
-
-    def list_models(self) -> Iterable[TrainedArtifact]:
-        with self._lock:
-            return [self._artifacts[key] for key in sorted(self._artifacts)]
-
-    def archive(self, artifact_id: str) -> bool:
-        self._validate_artifact_id(artifact_id)
-        with self._lock:
-            artifact = self._artifacts.pop(artifact_id, None)
-            source = self._root / f"{artifact_id}.json"
-            if not source.exists():
-                return artifact is not None
-            target = self._archive_root / f"{artifact_id}.json"
-            os.replace(source, target)
-            logger.info("Modell archiviert: %s", target)
-            return True
-
-    def _load_existing(self) -> None:
-        for source in sorted(self._root.glob("*.json")):
-            try:
-                raw = json.loads(source.read_text(encoding="utf-8"))
-                artifact_id = raw["artifact_id"]
-                supported_sensors = raw["supported_sensors"]
-                model_type = raw.get("model_type", "metadata")
-                raw_feature_models = raw.get("feature_models", {})
-                if not isinstance(artifact_id, str) or not isinstance(supported_sensors, list):
-                    raise ValueError("invalid artifact structure")
-                if not isinstance(model_type, str):
-                    raise ValueError("model_type must be a string")
-                self._validate_artifact_id(artifact_id)
-                if source.name != f"{artifact_id}.json":
-                    raise ValueError("artifact id does not match filename")
-                if not all(isinstance(sensor, str) for sensor in supported_sensors):
-                    raise ValueError("supported_sensors must contain strings")
-                feature_models = _deserialize_feature_models(raw_feature_models)
-            except (KeyError, TypeError, ValueError, json.JSONDecodeError) as exc:
-                raise ValueError(f"Ungültiges Modell-Artefakt: {source.name}") from exc
-
-            self._artifacts[artifact_id] = TrainedArtifact(
-                artifact_id=artifact_id,
-                supported_sensors=tuple(supported_sensors),
-                feature_models=feature_models,
-                model_type=model_type,
-            )
-
-    def _persist(self, artifact: TrainedArtifact) -> None:
-        target = self._root / f"{artifact.artifact_id}.json"
-        temporary = target.with_suffix(".json.tmp")
-        payload = {
-            "artifact_id": artifact.artifact_id,
-            "supported_sensors": list(artifact.supported_sensors),
-            "model_type": artifact.model_type,
-            "feature_models": {
-                sensor_id: {
-                    feature_name: {
-                        "sample_count": model.sample_count,
-                        "mean": model.mean,
-                        "standard_deviation": model.standard_deviation,
-                        "minimum": model.minimum,
-                        "maximum": model.maximum,
-                        "slope": model.slope,
-                        "intercept": model.intercept,
-                    }
-                    for feature_name, model in sorted(models.items())
-                }
-                for sensor_id, models in sorted(artifact.feature_models.items())
-            },
-        }
-        temporary.write_text(
-            json.dumps(payload, ensure_ascii=True, sort_keys=True) + "\n",
-            encoding="utf-8",
-        )
-        os.replace(temporary, target)
-        logger.info("Modell gespeichert: %s", target)
-
-    @staticmethod
-    def _validate_artifact_id(artifact_id: str) -> None:
-        if not _ARTIFACT_ID_PATTERN.fullmatch(artifact_id) or ".." in artifact_id:
-            raise ValueError(
-                "artifact_id darf nur Buchstaben, Ziffern, Punkt, Unterstrich "
-                "und Bindestrich enthalten."
-            )
-
-
-def _deserialize_feature_models(raw: object) -> dict[str, dict[str, FeatureModel]]:
-    if not isinstance(raw, dict):
-        raise ValueError("feature_models must be an object")
-
-    result: dict[str, dict[str, FeatureModel]] = {}
-    for sensor_id, raw_features in raw.items():
-        if not isinstance(sensor_id, str) or not isinstance(raw_features, dict):
-            raise ValueError("invalid sensor feature models")
-        features: dict[str, FeatureModel] = {}
-        for feature_name, raw_model in raw_features.items():
-            if not isinstance(feature_name, str) or not isinstance(raw_model, dict):
-                raise ValueError("invalid feature model")
-            sample_count = raw_model.get("sample_count")
-            if not isinstance(sample_count, int) or isinstance(sample_count, bool) or sample_count < 1:
-                raise ValueError("sample_count must be a positive integer")
-            values = {
-                key: _finite_number(raw_model.get(key))
-                for key in (
-                    "mean",
-                    "standard_deviation",
-                    "minimum",
-                    "maximum",
-                    "slope",
-                    "intercept",
-                )
-            }
-            features[feature_name] = FeatureModel(
-                sample_count=sample_count,
-                mean=values["mean"],
-                standard_deviation=values["standard_deviation"],
-                minimum=values["minimum"],
-                maximum=values["maximum"],
-                slope=values["slope"],
-                intercept=values["intercept"],
-            )
-        result[sensor_id] = features
-    return result
-
-
-def _finite_number(value: object) -> float:
-    if not isinstance(value, (int, float)) or isinstance(value, bool):
-        raise ValueError("feature model values must be finite numbers")
-    converted = float(value)
-    if not math.isfinite(converted):
-        raise ValueError("feature model values must be finite numbers")
-    return converted

app/ml/retraining.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.training import TrainedArtifact, TrainingPipeline
-
-
-@dataclass(frozen=True)
-class RetrainingResult:
-    artifact: TrainedArtifact
-    replaced: bool
-
-
-class RetrainingService:
-    """Runs one retraining cycle without owning scheduling or background threads."""
-
-    def __init__(self, registry: ModelRegistry) -> None:
-        self._registry = registry
-
-    def retrain(
-        self,
-        artifact_id: str,
-        vectors: Iterable[FeatureVector],
-    ) -> RetrainingResult:
-        store = FeatureStore()
-        store.add_batch(vectors)
-        pipeline = TrainingPipeline(store)
-        artifact = pipeline.run(artifact_id)
-        _, replaced = self._registry.register_with_status(artifact)
-        return RetrainingResult(artifact=artifact, replaced=replaced)
-
-
-def retrain_model(
-    registry: ModelRegistry,
-    artifact_id: str,
-    vectors: Iterable[FeatureVector],
-) -> RetrainingResult:
-    """Scheduler-compatible entry point for exactly one retraining run."""
-
-    return RetrainingService(registry).retrain(artifact_id, vectors)

app/ml/training.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-import logging
-import math
-from collections import defaultdict
-from dataclasses import dataclass, field
-
-from app.ml.feature_store import FeatureStore
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class FeatureModel:
-    sample_count: int
-    mean: float
-    standard_deviation: float
-    minimum: float
-    maximum: float
-    slope: float
-    intercept: float
-
-    def forecast(self, current_value: float | None = None) -> float:
-        if current_value is not None:
-            return current_value + self.slope
-        return self.intercept + self.slope * self.sample_count
-
-    @property
-    def confidence(self) -> float:
-        sample_score = self.sample_count / (self.sample_count + 2)
-        scale = abs(self.mean) if abs(self.mean) > 1e-9 else 1.0
-        stability_score = 1.0 / (1.0 + self.standard_deviation / scale)
-        return min(0.99, max(0.05, sample_score * stability_score))
-
-
-@dataclass(frozen=True)
-class TrainedArtifact:
-    artifact_id: str
-    supported_sensors: tuple[str, ...]
-    feature_models: dict[str, dict[str, FeatureModel]] = field(default_factory=dict)
-    model_type: str = "statistical_baseline"
-
-
-class TrainingPipeline:
-    def __init__(self, store: FeatureStore) -> None:
-        self._store = store
-        self._artifacts: dict[str, TrainedArtifact] = {}
-
-    def run(self, artifact_id: str) -> TrainedArtifact:
-        vectors = self._store.all()
-        if not vectors:
-            raise ValueError("FeatureStore enthält keine Trainingsdaten.")
-
-        samples: dict[str, dict[str, list[float]]] = defaultdict(lambda: defaultdict(list))
-        for vector in vectors:
-            for feature_name, raw_value in vector.values.items():
-                value = float(raw_value)
-                if math.isfinite(value):
-                    samples[vector.sensor_id][feature_name].append(value)
-
-        feature_models = {
-            sensor_id: {
-                feature_name: _fit_feature(values)
-                for feature_name, values in sorted(features.items())
-                if values
-            }
-            for sensor_id, features in sorted(samples.items())
-        }
-        feature_models = {
-            sensor_id: models for sensor_id, models in feature_models.items() if models
-        }
-        if not feature_models:
-            raise ValueError("Trainingsdaten enthalten keine endlichen numerischen Werte.")
-
-        sensors = tuple(feature_models)
-        artifact = TrainedArtifact(
-            artifact_id=artifact_id,
-            supported_sensors=sensors,
-            feature_models=feature_models,
-        )
-        self._artifacts[artifact_id] = artifact
-        logger.info("Training abgeschlossen für %s mit %d Sensoren", artifact_id, len(sensors))
-        return artifact
-
-    def export(self, artifact_id: str) -> TrainedArtifact:
-        if artifact_id not in self._artifacts:
-            raise KeyError(f"Artifact '{artifact_id}' nicht gefunden.")
-        return self._artifacts[artifact_id]
-
-
-def _fit_feature(values: list[float]) -> FeatureModel:
-    sample_count = len(values)
-    mean = sum(values) / sample_count
-    variance = sum((value - mean) ** 2 for value in values) / sample_count
-    standard_deviation = math.sqrt(variance)
-
-    if sample_count == 1:
-        slope = 0.0
-        intercept = mean
-    else:
-        x_mean = (sample_count - 1) / 2
-        denominator = sum((index - x_mean) ** 2 for index in range(sample_count))
-        numerator = sum(
-            (index - x_mean) * (value - mean) for index, value in enumerate(values)
-        )
-        slope = numerator / denominator
-        intercept = mean - slope * x_mean
-
-    return FeatureModel(
-        sample_count=sample_count,
-        mean=mean,
-        standard_deviation=standard_deviation,
-        minimum=min(values),
-        maximum=max(values),
-        slope=slope,
-        intercept=intercept,
-    )

app/rules/heating.py

@@ -6,29 +6,26 @@ from app.ha.models import HaEntitySummary
 from app.rules.recommender import Rule
 
 
+HEATING_SENSOR_DEVICE_CLASSES = frozenset({"temperature", "humidity"})
+HEATING_BINARY_SENSOR_DEVICE_CLASSES = frozenset({"occupancy", "presence"})
+
+
 class HeatingRule(Rule):
-    """Heizungsregel: Nur auf heizungsrelevante Entitäten reagieren.
-
-    Triggert bei:
-    - `climate`-Entitäten direkt
-    - `sensor` mit `device_class` in {temperature, humidity}
-    - `binary_sensor` mit `device_class` in {occupancy, presence}
-
-    Alle anderen Domains/Device-Klassen bleiben ohne Effekt.
-    """
-
-    HEATING_SENSOR_CLASSES: frozenset[str] = frozenset({"temperature", "humidity"})
-    HEATING_PRESENCE_CLASSES: frozenset[str] = frozenset({"occupancy", "presence"})
-
     def matches(self, entities: Sequence[HaEntitySummary]) -> bool:
-        for item in entities:
-            if item.domain == "climate":
+        for entity in entities:
+            if entity.domain == "climate":
                 return True
-            if item.domain == "sensor" and item.device_class in self.HEATING_SENSOR_CLASSES:
+            if (
+                entity.domain == "sensor"
+                and entity.device_class in HEATING_SENSOR_DEVICE_CLASSES
+            ):
                 return True
-            if item.domain == "binary_sensor" and item.device_class in self.HEATING_PRESENCE_CLASSES:
+            if (
+                entity.domain == "binary_sensor"
+                and entity.device_class in HEATING_BINARY_SENSOR_DEVICE_CLASSES
+            ):
                 return True
         return False
 
     def recommendation(self, entities: Sequence[HaEntitySummary]) -> str:
-        return "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
+        return "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."

app/static/index.html

@@ -1,346 +0,0 @@
-<!doctype html>
-<html lang="de">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <title>SillyHome Next</title>
-  <style>
-    :root { color-scheme: dark; font-family: system-ui, sans-serif; background: #10151c; color: #eaf1f8; }
-    body { margin: 0; }
-    header { padding: 22px; background: linear-gradient(135deg,#142b3a,#193f36); }
-    h1,h2,h3 { margin: 0 0 12px; }
-    header p { margin: 5px 0; color: #c3d1dc; }
-    main { display: grid; grid-template-columns: repeat(auto-fit,minmax(320px,1fr)); gap: 14px; padding: 14px; }
-    section { background: #18212b; border: 1px solid #2d3a47; border-radius: 12px; padding: 16px; }
-    .wide { grid-column: 1 / -1; }
-    .steps { display:grid; grid-template-columns:repeat(auto-fit,minmax(220px,1fr)); gap:12px; }
-    .step { background:#111a23; border:1px solid #31404d; border-radius:10px; padding:14px; }
-    .step-number { display:inline-grid; place-items:center; width:28px; height:28px; border-radius:50%; background:#23715b; font-weight:700; margin-bottom:8px; }
-    .step p { margin:5px 0; }
-    .ok { color: #66dfa9; }
-    .warn { color: #f3c969; }
-    .bad { color: #ff8f8f; }
-    label { display: block; margin: 9px 0 4px; color: #b9c9d6; }
-    select,button { box-sizing: border-box; width: 100%; border-radius: 7px; border: 1px solid #3b4b5b; padding: 10px; background: #101820; color: #fff; }
-    button { margin-top: 10px; background: #23715b; border: 0; font-weight: 700; cursor: pointer; }
-    button.secondary { background: #37495c; }
-    button.danger { background: #7b3434; }
-    table { width: 100%; border-collapse: collapse; font-size: .92rem; }
-    td,th { padding: 8px; border-bottom: 1px solid #2d3a47; text-align: left; vertical-align: top; }
-    ul { margin: 8px 0; padding-left: 18px; }
-    .notice { border-left: 4px solid #66dfa9; padding-left: 10px; }
-    .grid-two { display:grid; grid-template-columns:repeat(auto-fit,minmax(240px,1fr)); gap:12px; }
-    .chips { display:flex; flex-wrap:wrap; gap:6px; margin-top:8px; }
-    .chip { padding:4px 8px; border-radius:999px; background:#22303c; border:1px solid #31404d; font-size:.85rem; }
-    .muted { color:#9fb0be; }
-  </style>
-</head>
-<body>
-<header>
-  <h1>SillyHome Next</h1>
-  <p>Hier wählst du nur Geräte aus, deren Bedienung SillyHome lernen soll. Sensoren, Zusammenhänge und Modelle werden automatisch verwaltet.</p>
-  <p class="notice">Sicherer Start: Zuerst wird nur beobachtet und vorhergesagt. Ohne deine spätere Freigabe wird nichts geschaltet.</p>
-</header>
-<main>
-  <section class="wide">
-    <h2>So gehst du vor</h2>
-    <div class="steps">
-      <div class="step">
-        <span class="step-number">1</span>
-        <h3>Aktor auswählen</h3>
-        <p><strong>Wo?</strong> Unten im Feld „Gerät auswählen“.</p>
-        <p><strong>Was passiert?</strong> SillyHome ordnet Raum, Sensoren, Zustände und vorhandene Historie automatisch zu.</p>
-      </div>
-      <div class="step">
-        <span class="step-number">2</span>
-        <h3>Wie gewohnt bedienen</h3>
-        <p><strong>Wo?</strong> Weiterhin in Home Assistant, an Schaltern oder über deine bisherigen Bedienwege.</p>
-        <p><strong>Was passiert?</strong> SillyHome lernt deine Handlungen und zeigt Vorhersagen an, schaltet aber noch nicht selbst.</p>
-      </div>
-      <div class="step">
-        <span class="step-number">3</span>
-        <h3>Später freigeben</h3>
-        <p><strong>Wo?</strong> In den Details des ausgewählten Geräts, sobald genug Verhalten gelernt wurde.</p>
-        <p><strong>Was passiert?</strong> Erst dann darf SillyHome passende Vorhersagen automatisch ausführen. Die Freigabe kann jederzeit gestoppt werden.</p>
-      </div>
-    </div>
-  </section>
-
-  <section>
-    <h2>Systemstatus</h2>
-    <p class="muted">Zeigt, ob Verbindung, Lernsystem und automatische Prüfungen funktionieren. Hier musst du normalerweise nichts einstellen.</p>
-    <div id="status">Prüfung läuft ...</div>
-    <div class="chips" id="status-chips"></div>
-    <button class="secondary" onclick="loadOverview()">Status aktualisieren</button>
-  </section>
-
-  <section>
-    <h2>1. Gerät zum Lernen auswählen</h2>
-    <p class="muted">Wähle eine Lampe, einen Rollladen oder einen anderen unterstützten Aktor. Du wählst keine Sensoren und erstellst keine Regeln.</p>
-    <label for="actuator-select">Gerät aus Home Assistant</label>
-    <select id="actuator-select"></select>
-    <button onclick="configureActuator()">Gerät hinzufügen und Beobachtung starten</button>
-    <p id="actuator-config-result" class="muted">Noch kein Aktor ausgewählt.</p>
-  </section>
-
-  <section class="wide">
-    <h2>2. Beobachtete Geräte</h2>
-    <p class="muted">Öffne „Details“, um Lernfortschritt, aktuelle Vorhersage und den automatisch gefundenen Kontext zu sehen.</p>
-    <div id="configured-actuators">Noch nicht geladen.</div>
-  </section>
-
-  <section class="wide">
-    <h2>3. Lernfortschritt und Freigabe</h2>
-    <p class="muted">Die Freigabe erscheint erst, wenn genug eindeutig zugeordnete Handlungen gelernt wurden. Vorher bleibt das Gerät sicher im Beobachtungsmodus.</p>
-    <div id="actuator-detail" class="muted">Öffne bei einem beobachteten Gerät die Details.</div>
-  </section>
-</main>
-<script>
-const escapeHtml = value => String(value ?? "")
-  .replaceAll("&", "&amp;")
-  .replaceAll("<", "&lt;")
-  .replaceAll(">", "&gt;")
-  .replaceAll('"', "&quot;")
-  .replaceAll("'", "&#039;");
-let currentActuatorId = null;
-
-async function api(path, options = {}) {
-  const response = await fetch(path, {headers: {"Content-Type": "application/json"}, ...options});
-  const body = response.status === 204 ? null : await response.json().catch(() => ({}));
-  if (!response.ok) throw new Error(body?.detail || `${response.status} ${response.statusText}`);
-  return body;
-}
-
-function lifecycleLabel(record) {
-  if (record.behavior.status === "trained") return "Kontext erkannt";
-  const labels = {
-    trained: "lernt",
-    pending_history: "sammelt Historie",
-    pending_assignment: "sucht Kontext",
-    review_required: "geringe Zuordnungssicherheit",
-    archived: "wartet auf Kontext",
-    orphaned: "Aktor nicht gefunden",
-  };
-  return labels[record.lifecycle.status] || record.lifecycle.status;
-}
-
-function statusClass(record) {
-  if (record.behavior.status === "trained") return "ok";
-  if (record.lifecycle.status === "trained") return "ok";
-  if (["pending_history", "pending_assignment", "archived"].includes(record.lifecycle.status)) return "warn";
-  return "bad";
-}
-
-function behaviorLabel(record) {
-  if (record.behavior.mode === "active") return "aktiv freigegeben";
-  if (record.behavior.status === "trained") return "Shadow-Vorhersage";
-  if (record.behavior.status === "blocked") return "Lernen blockiert";
-  return "sammelt Handlungen";
-}
-
-async function loadOverview() {
-  const status = document.getElementById("status");
-  const chips = document.getElementById("status-chips");
-  try {
-    const [health, ml, reconciliation, actuators] = await Promise.all([
-      api("health"),
-      api("ml/health"),
-      api("v1/actuators/reconciliation/state"),
-      api("v1/actuators"),
-    ]);
-    status.innerHTML = `<p class="ok">System bereit</p><p>Letzte automatische Prüfung: ${escapeHtml(reconciliation.last_completed_at || "noch nie")}</p>`;
-    chips.innerHTML = [
-      `<span class="chip">API: ${escapeHtml(health.status)}</span>`,
-      `<span class="chip">Lernsystem: ${escapeHtml(ml.status)}</span>`,
-      `<span class="chip">Aktoren: ${actuators.length}</span>`,
-      `<span class="chip">Lernbereite Geräte: ${reconciliation.trained_models}</span>`,
-    ].join("");
-  } catch (error) {
-    status.innerHTML = `<p class="bad">${escapeHtml(error.message)}</p>`;
-    chips.innerHTML = "";
-  }
-  await Promise.all([loadActuatorDiscovery(), loadConfiguredActuators()]);
-}
-
-async function loadActuatorDiscovery() {
-  const select = document.getElementById("actuator-select");
-  try {
-    const [available, configured] = await Promise.all([
-      api("v1/actuators/discovery"),
-      api("v1/actuators"),
-    ]);
-    const configuredIds = new Set(configured.map(record => record.actuator_entity_id));
-    const choices = available.filter(entity => !configuredIds.has(entity.entity_id));
-    select.innerHTML = choices.length
-      ? choices.map(entity => `<option value="${escapeHtml(entity.entity_id)}">${escapeHtml(entity.friendly_name || entity.entity_id)}${entity.area_name ? ` (${escapeHtml(entity.area_name)})` : ""}</option>`).join("")
-      : "<option value=''>Alle erkannten Aktoren sind ausgewählt</option>";
-  } catch (error) {
-    select.innerHTML = `<option value="">${escapeHtml(error.message)}</option>`;
-  }
-}
-
-async function configureActuator() {
-  const actuatorId = document.getElementById("actuator-select").value;
-  const result = document.getElementById("actuator-config-result");
-  if (!actuatorId) return;
-  result.textContent = "Kontext wird automatisch analysiert ...";
-  try {
-    const record = await api("v1/actuators", {
-      method: "POST",
-      body: JSON.stringify({actuator_entity_id: actuatorId}),
-    });
-    currentActuatorId = record.actuator_entity_id;
-    result.textContent = `${record.actuator_entity_id}: ${lifecycleLabel(record)}.`;
-    await loadOverview();
-    await showActuator(record.actuator_entity_id);
-  } catch (error) {
-    result.textContent = error.message;
-  }
-}
-
-async function loadConfiguredActuators() {
-  const box = document.getElementById("configured-actuators");
-  try {
-    const rows = await api("v1/actuators");
-    box.innerHTML = rows.length ? `
-      <table>
-        <tr><th>Gerät</th><th>Lernstatus</th><th>Gelernte Handlungen</th><th>Letzte Vorhersage</th><th>Aktionen</th></tr>
-        ${rows.map(record => `
-          <tr>
-            <td>${escapeHtml(record.actuator_entity_id)}</td>
-            <td class="${record.behavior.status === "trained" ? "ok" : "warn"}">${escapeHtml(behaviorLabel(record))}</td>
-            <td>${record.behavior.sample_count}</td>
-            <td>${record.behavior.prediction
-              ? `${escapeHtml(record.behavior.prediction.target_state)} (${Math.round(record.behavior.prediction.confidence * 100)} %)`
-              : "-"}</td>
-            <td>
-              <button onclick="showActuator('${escapeHtml(record.actuator_entity_id)}')">Details</button>
-              <button class="danger" onclick="removeActuator('${escapeHtml(record.actuator_entity_id)}')">Entfernen</button>
-            </td>
-          </tr>
-        `).join("")}
-      </table>` : "<p>Noch keine Aktoren ausgewählt.</p>";
-  } catch (error) {
-    box.textContent = error.message;
-  }
-}
-
-async function showActuator(actuatorId, evaluationMessage = "") {
-  currentActuatorId = actuatorId;
-  const box = document.getElementById("actuator-detail");
-  try {
-    const record = await api(`v1/actuators/${encodeURIComponent(actuatorId)}`);
-    const contexts = [
-      record.assignment.selected_numeric_entity_id,
-      ...record.assignment.selected_context_entity_ids,
-    ].filter(Boolean);
-    const evidence = [...record.numeric_candidates, ...record.context_candidates]
-      .filter(candidate => contexts.includes(candidate.entity_id))
-      .map(candidate => `<li><strong>${escapeHtml(candidate.friendly_name || candidate.entity_id)}</strong>: ${candidate.evidence.map(escapeHtml).join(", ") || "statistisch relevanter Kandidat"}</li>`)
-      .join("");
-    const prediction = record.behavior.prediction;
-    const requiredUserActions = 3;
-    const learnedAutomationActions = record.behavior.patterns.filter(
-      pattern => pattern.source === "automation",
-    ).length;
-    const missingUserActions = Math.max(
-      0,
-      requiredUserActions - record.behavior.high_confidence_sample_count,
-    );
-    const activationButton = record.behavior.mode === "active"
-      ? `<button class="danger" onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', false)">Autonomes Schalten stoppen</button>`
-      : record.behavior.status === "trained" && missingUserActions === 0
-        ? `<button onclick="setActivation('${escapeHtml(record.actuator_entity_id)}', true)">Lernen und Schalten freigeben</button>`
-        : record.behavior.status === "trained"
-          ? `<p class='muted'>Freigabe noch gesperrt: ${missingUserActions} eindeutig manuelle Bedienung${missingUserActions === 1 ? "" : "en"} fehlen. Bediene das Licht dafür direkt über Home Assistant.</p>`
-          : "<p class='muted'>Freigabe wird möglich, sobald genügend Handlungen gelernt wurden.</p>";
-    box.innerHTML = `
-      <div class="grid-two">
-        <div>
-          <h3>${escapeHtml(record.actuator_entity_id)}</h3>
-          <p><strong>Status:</strong> <span class="${statusClass(record)}">${escapeHtml(lifecycleLabel(record))}</span></p>
-          <p><strong>Kontextzuordnung:</strong> automatisch erledigt</p>
-          <p><strong>Zuordnungssicherheit:</strong> ${Math.round(record.assignment.confidence * 100)} %</p>
-          <p class="muted">Dieser Wert beschreibt, wie sicher Raum, Sensoren und Zustände zu diesem Gerät passen.</p>
-          <p><strong>Ergebnis:</strong> ${escapeHtml(record.assignment.reason)}</p>
-        </div>
-        <div>
-          <h3>Lernfortschritt</h3>
-          <p><strong>Betriebsart:</strong> ${escapeHtml(behaviorLabel(record))}</p>
-          <p><strong>Gelernte Handlungen:</strong> ${record.behavior.sample_count}</p>
-          <p><strong>Davon eindeutig Benutzer:</strong> ${record.behavior.high_confidence_sample_count}</p>
-          <p><strong>Davon erkannte HA-Automationen:</strong> ${learnedAutomationActions}</p>
-          <p><strong>Letztes Training:</strong> ${escapeHtml(record.behavior.last_trained_at || "noch nicht")}</p>
-          <p><strong>Was noch passiert:</strong> ${escapeHtml(record.behavior.reason)}</p>
-          ${activationButton}
-          <button class="secondary" onclick="evaluateActuator('${escapeHtml(record.actuator_entity_id)}')">Aktuelle Situation auswerten</button>
-          <p class="muted">Die Prüfung simuliert keinen Sensorwechsel und schaltet keinen Aktor.</p>
-          ${evaluationMessage ? `<p class="ok">${escapeHtml(evaluationMessage)}</p>` : ""}
-        </div>
-      </div>
-      <h3>Was SillyHome aktuell vorhersagt</h3>
-      ${prediction
-        ? `<p><strong>${escapeHtml(prediction.target_state)}</strong> mit ${Math.round(prediction.confidence * 100)} % Sicherheit. ${escapeHtml(prediction.reason)} ${prediction.executed ? "<span class='ok'>Ausgeführt.</span>" : "<span class='muted'>Nicht ausgeführt.</span>"}</p>`
-        : "<p class='muted'>Aktuell ist kein gelerntes Handlungsmuster fällig.</p>"}
-      <h3>Welche Zusammenhänge automatisch verwendet werden</h3>
-      ${evidence ? `<ul>${evidence}</ul>` : "<p class='warn'>Noch kein geeigneter Kontext erkannt. SillyHome prüft bei neuen HA-Daten erneut.</p>"}
-    `;
-  } catch (error) {
-    box.textContent = error.message;
-  }
-}
-
-async function evaluateActuator(actuatorId) {
-  try {
-    const record = await api(
-      `v1/actuators/${encodeURIComponent(actuatorId)}/evaluate`,
-      {method: "POST"},
-    );
-    const checkedAt = new Date(
-      record.behavior.last_evaluated_at || Date.now(),
-    ).toLocaleString("de-DE");
-    const message = record.behavior.prediction
-      ? `Prüfung ${checkedAt}: ${record.behavior.prediction.target_state} mit ${Math.round(record.behavior.prediction.confidence * 100)} % vorhergesagt.`
-      : `Prüfung ${checkedAt}: Kein frischer passender Sensorwechsel erkannt; aktuell ist keine Aktion fällig.`;
-    await loadConfiguredActuators();
-    await showActuator(actuatorId, message);
-  } catch (error) {
-    alert(error.message);
-  }
-}
-
-async function setActivation(actuatorId, active) {
-  const question = active
-    ? `${actuatorId} wirklich für autonomes Lernen und Schalten freigeben?`
-    : `${actuatorId} wieder in den Shadow-Modus setzen?`;
-  if (!confirm(question)) return;
-  try {
-    await api(`v1/actuators/${encodeURIComponent(actuatorId)}/activation`, {
-      method: "POST",
-      body: JSON.stringify({active}),
-    });
-    await loadConfiguredActuators();
-    await showActuator(actuatorId);
-  } catch (error) {
-    alert(error.message);
-  }
-}
-
-async function removeActuator(actuatorId) {
-  if (!confirm(`${actuatorId} aus SillyHome entfernen?`)) return;
-  try {
-    await api(`v1/actuators/${encodeURIComponent(actuatorId)}`, {method: "DELETE"});
-    if (currentActuatorId === actuatorId) {
-      currentActuatorId = null;
-      document.getElementById("actuator-detail").textContent = "Öffne bei einem beobachteten Gerät die Details.";
-    }
-    await loadOverview();
-  } catch (error) {
-    alert(error.message);
-  }
-}
-
-loadOverview();
-</script>
-</body>
-</html>

backend/__init__.py

@@ -1 +0,0 @@
-"""Secondary application entry points for SillyHome Next."""

backend/app.py

@@ -1,43 +0,0 @@
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI
-from starlette.datastructures import State
-
-from backend.routes.ml import init_ml_routes
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.training import TrainingPipeline
-from app.ml.feature_store import FeatureStore, FeatureVector
-
-
-@asynccontextmanager
-async def lifespan(application: FastAPI) -> AsyncIterator[None]:
-    application.state.registry = ModelRegistry(application.state.model_store)
-    _seed_default_model(application.state)
-    yield
-
-
-def create_app() -> FastAPI:
-    application = FastAPI(title="SillyHome Next ML", lifespan=lifespan)
-    init_ml_routes(application)
-    return application
-
-
-def _seed_default_model(state: State) -> None:
-    registry = getattr(state, "registry", None)
-    if registry is None:
-        registry = ModelRegistry(".model_store")
-        state.registry = registry
-
-    if list(registry.list_models()):
-        return
-
-    store = FeatureStore()
-    store.add(FeatureVector(sensor_id="sensor.front_door", values={"contact": 1.0}))
-    store.add(FeatureVector(sensor_id="sensor.living_room", values={"temperature": 21.0}))
-    pipeline = TrainingPipeline(store)
-    artifact = pipeline.run("default")
-    registry.register(artifact)
-
-
-app = create_app()

backend/routes/__init__.py

@@ -1 +0,0 @@
-"""API route modules."""

backend/routes/ml.py

@@ -1,253 +0,0 @@
-from __future__ import annotations
-
-import logging
-from datetime import datetime, timezone
-from collections.abc import Sequence
-
-from fastapi import APIRouter, FastAPI, HTTPException, Request, status
-from pydantic import BaseModel, Field
-
-from app.ml.evaluation import Evaluator
-from app.ml.feature_store import FeatureVector
-from app.ml.predictor import Predictor
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.retraining import retrain_model
-
-logger = logging.getLogger(__name__)
-
-router = APIRouter(prefix="/ml", tags=["ml"])
-
-
-class HealthResponse(BaseModel):
-    status: str
-    updated_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-
-
-class PredictRequest(BaseModel):
-    model_id: str = Field(..., alias="modelId")
-    sensor_id: str
-    values: dict[str, float]
-
-
-class PredictResponse(BaseModel):
-    model_id: str
-    sensor_id: str
-    predictions: dict[str, float]
-    confidence: float
-    model_type: str
-    explanations: dict[str, "FeatureExplanationResponse"]
-
-
-class FeatureExplanationResponse(BaseModel):
-    feature: str
-    current_value: float
-    predicted_value: float
-    change: float
-    direction: str
-    sample_count: int
-    historical_mean: float
-    historical_range: tuple[float, float]
-    standard_deviation: float
-    trend_per_step: float
-    confidence: float
-    summary: str
-
-
-class BatchRequest(BaseModel):
-    requests: Sequence[PredictRequest]
-
-
-class BatchResponse(BaseModel):
-    predictions: Sequence[PredictResponse]
-
-
-class ModelsResponse(BaseModel):
-    models: list[str]
-
-
-class TrainingSample(BaseModel):
-    sensor_id: str = Field(min_length=1)
-    values: dict[str, float]
-    label: str | None = None
-
-
-class RetrainRequest(BaseModel):
-    model_id: str = Field(..., alias="modelId", min_length=1, max_length=128)
-    samples: list[TrainingSample] = Field(min_length=1)
-
-
-class RetrainResponse(BaseModel):
-    model_id: str
-    supported_sensors: list[str]
-    trained_features: int
-    model_type: str
-    replaced: bool
-
-
-class EvaluateRequest(BaseModel):
-    model_id: str = Field(..., alias="modelId", min_length=1, max_length=128)
-    samples: list[TrainingSample] = Field(min_length=1)
-
-
-class MetricResponse(BaseModel):
-    name: str
-    value: float
-    threshold: float | None = None
-
-
-class EvaluateResponse(BaseModel):
-    model_id: str
-    sample_size: int
-    metrics: list[MetricResponse]
-
-
-@router.get("/health", response_model=HealthResponse, status_code=200)
-def health() -> HealthResponse:
-    return HealthResponse(status="ok")
-
-
-@router.get("/models", response_model=ModelsResponse, status_code=200)
-def list_models(request: Request) -> ModelsResponse:
-    registry = _require_registry(request)
-    models = [artifact.artifact_id for artifact in registry.list_models()]
-    return ModelsResponse(models=models)
-
-
-@router.post("/retrain", response_model=RetrainResponse, status_code=200)
-def retrain(payload: RetrainRequest, request: Request) -> RetrainResponse:
-    registry = _require_registry(request)
-    vectors = [
-        FeatureVector(
-            sensor_id=sample.sensor_id,
-            values=sample.values,
-            label=sample.label,
-        )
-        for sample in payload.samples
-    ]
-    try:
-        result = retrain_model(registry, payload.model_id, vectors)
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=str(exc),
-        ) from exc
-    return RetrainResponse(
-        model_id=result.artifact.artifact_id,
-        supported_sensors=list(result.artifact.supported_sensors),
-        trained_features=sum(
-            len(feature_models)
-            for feature_models in result.artifact.feature_models.values()
-        ),
-        model_type=result.artifact.model_type,
-        replaced=result.replaced,
-    )
-
-
-@router.post("/evaluate", response_model=EvaluateResponse, status_code=200)
-def evaluate(payload: EvaluateRequest, request: Request) -> EvaluateResponse:
-    registry = _require_registry(request)
-    vectors = [
-        FeatureVector(
-            sensor_id=sample.sensor_id,
-            values=sample.values,
-            label=sample.label,
-        )
-        for sample in payload.samples
-    ]
-    try:
-        report = Evaluator(registry=registry).evaluate(payload.model_id, vectors)
-    except ValueError as exc:
-        try:
-            registry.load_artifact(payload.model_id)
-        except KeyError:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=str(exc),
-            ) from exc
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=str(exc),
-        ) from exc
-    return EvaluateResponse(
-        model_id=report.artifact_id,
-        sample_size=report.sample_size,
-        metrics=[
-            MetricResponse(name=metric.name, value=metric.value, threshold=metric.threshold)
-            for metric in report.metrics
-        ],
-    )
-
-
-@router.post("/predict", response_model=PredictResponse, status_code=200)
-def predict(payload: PredictRequest, request: Request) -> PredictResponse:
-    registry = _require_registry(request)
-    predictor = Predictor(registry=registry)
-    vector = FeatureVector(sensor_id=payload.sensor_id, values=payload.values)
-    try:
-        prediction = predictor.predict(payload.model_id, vector)
-    except KeyError as exc:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
-    except ValueError as exc:
-        raise HTTPException(
-            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-            detail=str(exc),
-        ) from exc
-    return PredictResponse(
-        model_id=payload.model_id,
-        sensor_id=payload.sensor_id,
-        predictions=prediction.predictions,
-        confidence=prediction.confidence,
-        model_type=prediction.model_type,
-        explanations={
-            name: FeatureExplanationResponse(**explanation.__dict__)
-            for name, explanation in prediction.explanations.items()
-        },
-    )
-
-
-@router.post("/batch", response_model=BatchResponse, status_code=200)
-def predict_batch(payload: BatchRequest, request: Request) -> BatchResponse:
-    registry = _require_registry(request)
-    predictor = Predictor(registry=registry)
-    responses: list[PredictResponse] = []
-    for item in payload.requests:
-        vector = FeatureVector(sensor_id=item.sensor_id, values=item.values)
-        try:
-            prediction = predictor.predict(item.model_id, vector)
-        except KeyError as exc:
-            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
-        except ValueError as exc:
-            raise HTTPException(
-                status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
-                detail=str(exc),
-            ) from exc
-        responses.append(
-            PredictResponse(
-                model_id=item.model_id,
-                sensor_id=item.sensor_id,
-                predictions=prediction.predictions,
-                confidence=prediction.confidence,
-                model_type=prediction.model_type,
-                explanations={
-                    name: FeatureExplanationResponse(**explanation.__dict__)
-                    for name, explanation in prediction.explanations.items()
-                },
-            )
-        )
-    return BatchResponse(predictions=responses)
-
-
-def _require_registry(request: Request) -> ModelRegistry:
-    registry = getattr(request.app.state, "registry", None)
-    if not isinstance(registry, ModelRegistry):
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="ML registry nicht initialisiert.",
-        )
-    return registry
-
-
-def init_ml_routes(app: FastAPI, model_store: str = ".model_store") -> None:
-    app.state.model_store = model_store
-    app.include_router(router)
-    logger.info("ML routes registered")

docker-compose.yml

@@ -1,39 +0,0 @@
-services:
-  api:
-    build: .
-    ports:
-      - "127.0.0.1:8000:8000"
-    env_file:
-      - path: .env
-        required: false
-    environment:
-      SILLYHOME_MODEL_STORE: /app/data/models
-      SILLYHOME_AUTOMATION_STORE: /app/data/automations
-      SILLYHOME_ACTUATOR_STORE: /app/data/actuators
-      SILLYHOME_HISTORY_DAYS: 14
-      SILLYHOME_MIN_TRAINING_POINTS: 24
-      SILLYHOME_RETRAIN_STALE_HOURS: 24
-      SILLYHOME_RECONCILE_INTERVAL_SECONDS: 900
-      SILLYHOME_MIN_BEHAVIOR_ACTIONS: 3
-      SILLYHOME_PREDICTION_CONFIDENCE: 0.82
-      SILLYHOME_PREDICTION_WINDOW_MINUTES: 30
-      SILLYHOME_PREDICTION_INTERVAL_SECONDS: 60
-      SILLYHOME_EXECUTION_COOLDOWN_SECONDS: 900
-      SILLYHOME_TIMEZONE: Europe/Berlin
-    volumes:
-      - model-data:/app/data/models
-      - automation-data:/app/data/automations
-      - actuator-data:/app/data/actuators
-    read_only: true
-    tmpfs:
-      - /tmp
-    security_opt:
-      - no-new-privileges:true
-    cap_drop:
-      - ALL
-    restart: unless-stopped
-
-volumes:
-  model-data:
-  automation-data:
-  actuator-data:

docs/automations.md

@@ -1,6 +0,0 @@
-# Keine manuell erzeugten Automationen
-
-Seit `v0.5.0` erstellt SillyHome Next keine YAML-Automationen und bietet keinen
-Regel- oder Trigger-Editor mehr an. Der produktive Ablauf besteht aus
-Aktorauswahl, automatischem Verhaltenslernen, Shadow-Vorhersage und einer
-separaten Ausführungsfreigabe pro Aktor.

docs/ha_data.md

@@ -1,52 +0,0 @@
-# Home-Assistant-Datenpipeline
-
-SillyHome Next trennt aktuelle Entity-Metadaten, Discovery und historische
-Messwerte. Dadurch gelangen nur klassifizierte, geeignete Daten in spätere
-Trainings- und Erklärungsprozesse.
-
-## Entity Discovery
-
-`GET /v1/discovery` klassifiziert Home-Assistant-Entities in:
-
-- `measurement`: numerische Messsensoren, für Training geeignet
-- `binary_context`: binäre Kontextsensoren wie Bewegung oder Anwesenheit
-- `context`: Personen-, Wetter- und Standortkontext
-- `actuator`: mögliche Automationsziele, nicht als Trainingssensor verwendet
-- `unsupported`: noch nicht klassifizierte Entity-Typen
-
-Zusätzlich reichert `HaReader` verfügbare Metadaten wie `friendly_name`,
-Bereich und Gerät aus Home Assistant an. Für die aktor-zentrierte Zuordnung
-nutzt SillyHome Next bevorzugt:
-
-- `area_id` und `area_name`
-- `device_id` und `device_name`
-- Friendly Names und Entity-ID-Tokens
-- Domain und `device_class`
-
-Optionale Query-Parameter:
-
-- `domain=sensor` kann mehrfach angegeben werden
-- `learnable=true|false` filtert nach Trainingsrelevanz
-
-## Historische Daten
-
-Historische Zustände werden über Home Assistants
-`/api/history/period/<start>`-Schnittstelle geladen. Abfragen verlangen:
-
-- mindestens eine Entity-ID, maximal 100
-- zeitzonenbehaftete Start- und Endzeit
-- ein Enddatum nach dem Startdatum
-- maximal 31 Tage pro Abfrage
-
-Die Normalisierung übernimmt nur endliche numerische Zustände. `unknown`,
-`unavailable`, nichtnumerische Werte, `NaN` und unendliche Werte werden nicht
-als Trainingsdaten verwendet. Ergebnisse werden je Entity chronologisch
-sortiert. Binäre Kontext-Entities werden bewusst nicht in numerische
-Trainingsreihen konvertiert.
-
-## Datenschutz und Betrieb
-
-Die Daten bleiben lokal. Home-Assistant-Tokens gehören ausschließlich in die
-Umgebungskonfiguration und dürfen nicht protokolliert oder versioniert werden.
-Die API sollte nur lokal oder hinter einem authentifizierenden Reverse Proxy
-erreichbar sein.

docs/ml_api.md

@@ -1,229 +0,0 @@
-# ML-Serving-API
-
-Diese Dokumentation beschreibt die REST-Endpunkte der aktuellen
-Modell-Artefakt-, Vorhersage- und aktor-zentrierten Lifecycle-Schnittstelle.
-
-Das Serving verwendet ein lokal trainiertes statistisches Baseline-Modell.
-
-## Basis-URL
-
-- Standard: `http://127.0.0.1:8000/ml`
-- Health: `/health`
-- Modelle: `/models`
-- Retraining: `/retrain`
-- Evaluation: `/evaluate`
-- Einzelvorhersage: `/predict`
-- Batchvorhersage: `/batch`
-
-Die aktor-zentrierte API liegt unter `/v1/actuators`.
-
-Der Standard-Start erfolgt über `uvicorn app.main:app`, danach stehen HA- und
-ML-Routen in derselben Anwendung bereit.
-
-## Endpoints
-
-### `GET /ml/health`
-
-Health-Check der ML-Services.
-
-**Beispielantwort**
-```json
-{
-  "status": "ok",
-  "updated_at": "2026-06-11T12:00:00Z"
-}
-```
-
-### `GET /ml/models`
-
-Listet alle registrierten Modell-Artefakte auf.
-
-**Beispielantwort**
-```json
-{
-  "models": ["default"]
-}
-```
-
-### `POST /ml/predict`
-
-Einzelne Vorhersage für einen Sensor.
-
-**Request**
-```json
-{
-  "modelId": "default",
-  "sensor_id": "sensor.kitchen",
-  "values": {"temperature": 21.0}
-}
-```
-
-**Antwort**
-```json
-{
-  "model_id": "default",
-  "sensor_id": "sensor.kitchen",
-  "predictions": {"temperature": 21.4},
-  "confidence": 0.78,
-  "model_type": "statistical_baseline",
-  "explanations": {
-    "temperature": {
-      "direction": "steigend",
-      "change": 0.4,
-      "sample_count": 24,
-      "historical_mean": 20.7,
-      "trend_per_step": 0.4,
-      "summary": "temperature: steigend; Prognose ..."
-    }
-  }
-}
-```
-
-Die Erklärung nennt pro Merkmal den aktuellen und prognostizierten Wert,
-Richtung, Veränderung, Datenbasis, historischen Bereich, Streuung, Trend und
-Confidence. Sie wird deterministisch aus den gespeicherten Modellparametern
-erzeugt.
-
-### `POST /ml/retrain`
-
-Trainiert die Artefakt-Metadaten aus neuen Sensordaten. Existiert `modelId`
-bereits, wird das Artefakt atomisch ersetzt und beim nächsten Prozessstart aus
-dem Modellverzeichnis geladen.
-
-**Request**
-```json
-{
-  "modelId": "home-model",
-  "samples": [
-    {
-      "sensor_id": "sensor.kitchen",
-      "values": {"temperature": 21.0},
-      "label": "occupied"
-    }
-  ]
-}
-```
-
-**Antwort**
-```json
-{
-  "model_id": "home-model",
-  "supported_sensors": ["sensor.kitchen"],
-  "trained_features": 1,
-  "model_type": "statistical_baseline",
-  "replaced": false
-}
-```
-
-### `POST /ml/evaluate`
-
-Vergleicht Modellvorhersagen mit Validierungsdaten und liefert MAE, RMSE und
-Coverage. Der Request verwendet dasselbe Sample-Format wie `/ml/retrain`.
-
-### `POST /ml/batch`
-
-Batch-Vorhersage für mehrere Sensorwerte.
-
-**Request**
-```json
-{
-  "requests": [
-    {
-      "modelId": "default",
-      "sensor_id": "sensor.kitchen",
-      "values": {"temperature": 21.0}
-    },
-    {
-      "modelId": "default",
-      "sensor_id": "sensor.bedroom",
-      "values": {"temperature": 18.5}
-    }
-  ]
-}
-```
-
-**Antwort**
-```json
-{
-  "predictions": [
-    {
-      "model_id": "default",
-      "sensor_id": "sensor.kitchen",
-      "predictions": {"temperature": 21.4},
-      "confidence": 0.78,
-      "model_type": "statistical_baseline"
-    },
-    {
-      "model_id": "default",
-      "sensor_id": "sensor.bedroom",
-      "predictions": {"temperature": 18.3},
-      "confidence": 0.74,
-      "model_type": "statistical_baseline"
-    }
-  ]
-}
-```
-
-## Fehlerfälle
-
-- `404 Not Found`: Modell nicht registriert.
-- `422 Unprocessable Content`: Sensor wird vom Modell nicht unterstützt oder Eingabe ist ungültig.
-- `503 Service Unavailable`: Registry ist nicht initialisiert.
-
-## Aktuator-zentrierte API
-
-### `GET /v1/actuators/discovery`
-
-Listet unterstützte Aktuatoren mit angereicherter HA-Metadatenbasis.
-
-### `POST /v1/actuators`
-
-Registriert einen Aktor. Das System ermittelt passende Messwerte und
-Kontext-Entities vollständig automatisch, trainiert bei ausreichender Historie
-ein Modell und liefert Zuordnung, Confidence, Evidenz und Lifecycle-Status zur
-Diagnose zurück.
-
-**Request**
-```json
-{
-  "actuator_entity_id": "light.abstellkammer",
-  "enabled": true
-}
-```
-
-### `POST /v1/actuators/reconciliation/run`
-
-Führt eine sichere globale Reconciliation aus. Die periodische Add-on-Schleife
-ruft denselben idempotenten Ablauf auf, startet aber keine Services in Home
-Assistant.
-
-### `POST /v1/actuators/{actuator_entity_id}/evaluate`
-
-Erstellt aus aktuellem Kontext eine neue Shadow- oder Aktiv-Vorhersage. Im
-Shadow-Modus wird niemals geschaltet.
-
-### `POST /v1/actuators/{actuator_entity_id}/activation`
-
-```json
-{"active": true}
-```
-
-Aktiviert autonomes Schalten erst nach ausreichendem Training und nur für
-erlaubte Aktor-Domains. Mit `false` wird der Aktor sofort wieder in den
-Shadow-Modus versetzt.
-
-## Betrieb
-
-Die produktive App lädt Artefakte aus `SILLYHOME_MODEL_STORE`. Aktor- und
-Reconciliation-Zustände liegen atomisch in
-`SILLYHOME_ACTUATOR_STORE`. Neue Artefakte werden über `/ml/retrain`,
-`RetrainingService` oder den aktor-zentrierten Lifecycle registriert. Die API
-sollte nur in einem vertrauenswürdigen Netz oder hinter einem
-authentifizierenden Reverse Proxy erreichbar sein.
-
-## Verweise
-
-- `app/ml/predictor.py`
-- `app/ml/retraining.py`
-- `app/ml/registry/model_registry.py`
-- `backend/routes/ml.py`

docs/ml_training.md

@@ -1,51 +0,0 @@
-# Verhaltenslernen und Vorhersage
-
-Seit `v0.5.0` ist der produktive Lernpfad aktor-zentriert. Nutzer wählen nur
-einen Aktor; Sensoren, Kontext und Modelle werden automatisch verwaltet.
-
-## Datengrundlage
-
-Für jeden Aktor lädt SillyHome Next:
-
-- dessen Zustandswechsel aus der Home-Assistant-Historie
-- Logbook-Einträge zur Herkunft der Handlung
-- automatisch zugeordnete Mess- und Kontext-Entities
-- deren Zustand zum Zeitpunkt der Handlung
-
-Eindeutig einem Home-Assistant-Benutzer zugeordnete Handlungen erhalten das
-höchste Gewicht. Erkannte Automations- und Script-Aktionen werden verworfen.
-Physische oder nicht eindeutig zuordenbare Bedienungen dürfen das
-Shadow-Modell ergänzen, reichen allein aber nicht zur Aktivierung.
-
-## Modell
-
-Das lokale Modell speichert pro beobachteter Handlung:
-
-- Zielzustand
-- lokale Tageszeit
-- Wochentag
-- Kontextzustände
-- Herkunft und Gewicht
-
-Eine Vorhersage bewertet zeitliche Nähe, Wochentagsmuster und aktuellen
-Kontext. Mehrere passende historische Handlungen erhöhen die Confidence.
-
-## Betriebsstufen
-
-1. `collecting`: Noch nicht genügend Handlungen vorhanden.
-2. `shadow`: Modell ist trainiert; Vorhersagen werden angezeigt, aber nicht ausgeführt.
-3. `active`: Nutzer hat den Aktor ausdrücklich freigegeben.
-
-Die Aktivierung verlangt genügend eindeutig einem Benutzer zugeordnete
-Handlungen. Ausgeführt werden nur erlaubte Zustände reversibler Domains:
-`light`, `switch`, `fan`, `humidifier` und `cover`.
-
-## Schutzmechanismen
-
-- explizite Freigabe pro Aktor
-- konfigurierbare Mindestkonfidenz
-- Cooldown zwischen Schaltungen
-- keine Ausführung bei bereits erreichtem Zielzustand
-- keine Ausführung unbekannter Zustände oder riskanter Domains
-- eigene Schaltungen werden beim nächsten Training herausgefiltert
-- bekannte Automation-/Script-Aktionen werden nicht als Nutzerverhalten gelernt

pyproject.toml

@@ -1,10 +1,6 @@
-[build-system]
-requires = ["setuptools>=69"]
-build-backend = "setuptools.build_meta"
-
 [project]
 name = "sillyhome-next"
-version = "0.5.2"
+version = "0.1.0"
 description = "Lokales Smart-Home-Intelligenzsystem für Home Assistant"
 requires-python = ">=3.11"
 dependencies = [
@@ -28,10 +24,6 @@ addopts = "-q"
 
 [tool.mypy]
 strict = true
-files = ["app", "backend", "tests"]
-
-[tool.setuptools.packages.find]
-include = ["app*", "backend*"]
 
 [tool.ruff]
 line-length = 100

repository.yaml

@@ -1,3 +0,0 @@
-name: SillyHome Next Add-ons
-url: http://192.168.6.31:3000/pino/sillyhome-next
-maintainer: Pino

tests/actuators/test_actuator_store.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from app.actuators.models import ReconciliationState
-from app.actuators.store import ActuatorStore
-
-
-def test_actuator_store_persists_record_and_reconciliation_state(tmp_path: Path) -> None:
-    store = ActuatorStore(tmp_path)
-    store.configure("light.abstellkammer")
-    state = ReconciliationState(last_summary="ok", configured_actuators=1)
-
-    store.save_reconciliation_state(state)
-
-    restarted = ActuatorStore(tmp_path)
-    assert restarted.get("light.abstellkammer").actuator_entity_id == "light.abstellkammer"
-    assert restarted.load_reconciliation_state().last_summary == "ok"

tests/actuators/test_lifecycle.py

@@ -1,293 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.models import (
-    AssignmentSource,
-    LifecycleStatus,
-    ManualOverride,
-    model_id_for_actuator,
-)
-from app.actuators.store import ActuatorStore
-from app.config import Settings
-from app.ha.discovery import DiscoveredEntity
-from app.ha.discovery import discover_entities
-from app.ha.history import EntityHistorySeries, NumericHistoryPoint
-from app.ha.models import HaEntitySummary
-from app.ha.reader import HaReader
-from app.ml.registry.model_registry import ModelRegistry
-
-
-class FakeActuatorReader(HaReader):
-    def __init__(
-        self,
-        entities: list[HaEntitySummary],
-        history_by_entity: dict[str, list[NumericHistoryPoint]],
-    ) -> None:
-        self._entities = entities
-        self._history_by_entity = history_by_entity
-
-    def read_entities(self) -> list[HaEntitySummary]:
-        return list(self._entities)
-
-    def discover(
-        self,
-        domains: set[str] | None = None,
-        learnable: bool | None = None,
-    ) -> list[DiscoveredEntity]:
-        return discover_entities(self._entities, domains=domains, learnable=learnable)
-
-    def read_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[EntityHistorySeries]:
-        series: list[EntityHistorySeries] = []
-        for entity_id in entity_ids:
-            points = [
-                point
-                for point in self._history_by_entity.get(entity_id, [])
-                if start_time <= point.timestamp <= end_time
-            ]
-            if points:
-                series.append(EntityHistorySeries(entity_id=entity_id, points=points))
-        return series
-
-
-def _points(count: int, start: datetime, value: float) -> list[NumericHistoryPoint]:
-    return [
-        NumericHistoryPoint(timestamp=start + timedelta(hours=index), value=value + index)
-        for index in range(count)
-    ]
-
-
-def _service(
-    tmp_path: Path,
-    entities: list[HaEntitySummary],
-    history_by_entity: dict[str, list[NumericHistoryPoint]],
-) -> ActuatorReconciliationService:
-    return ActuatorReconciliationService(
-        ha_reader=FakeActuatorReader(entities, history_by_entity),
-        store=ActuatorStore(tmp_path / "actuators"),
-        registry=ModelRegistry(tmp_path / "models"),
-        settings=Settings(
-            ha_url="http://ha.local",
-            ha_token="token",
-            model_store=str(tmp_path / "models"),
-            automation_store=str(tmp_path / "automations"),
-            actuator_store=str(tmp_path / "actuators"),
-            history_days=14,
-            min_training_points=5,
-            retrain_stale_hours=24,
-            reconcile_interval_seconds=900,
-        ),
-    )
-
-
-def test_reconciliation_auto_assigns_and_trains_numeric_model(tmp_path: Path) -> None:
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    entities = [
-        HaEntitySummary(
-            entity_id="light.abstellkammer",
-            domain="light",
-            friendly_name="Abstellkammer Licht",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.abstellkammer_illuminance",
-            domain="sensor",
-            device_class="illuminance",
-            state_class="measurement",
-            unit_of_measurement="lx",
-            friendly_name="Abstellkammer Helligkeit",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="binary_sensor.abstellkammer_motion",
-            domain="binary_sensor",
-            device_class="motion",
-            friendly_name="Abstellkammer Bewegung",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.kitchen_temperature",
-            domain="sensor",
-            device_class="temperature",
-            state_class="measurement",
-            unit_of_measurement="°C",
-            friendly_name="Kueche Temperatur",
-            area_name="Kueche",
-        ),
-    ]
-    service = _service(
-        tmp_path,
-        entities,
-        {
-            "sensor.abstellkammer_illuminance": _points(8, start, 10.0),
-            "sensor.kitchen_temperature": _points(8, start, 18.0),
-        },
-    )
-
-    record = service.configure_actuator("light.abstellkammer")
-
-    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_illuminance"
-    assert record.assignment.selected_context_entity_ids == ["binary_sensor.abstellkammer_motion"]
-    assert record.assignment.review_required is False
-    assert record.lifecycle.status is LifecycleStatus.TRAINED
-    artifact = service._registry.load_artifact(model_id_for_actuator("light.abstellkammer"))
-    assert artifact.supported_sensors == ("sensor.abstellkammer_illuminance",)
-    assert "binary_sensor.abstellkammer_motion" not in artifact.supported_sensors
-
-
-def test_reconciliation_rejects_ambiguous_numeric_mapping(tmp_path: Path) -> None:
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    entities = [
-        HaEntitySummary(
-            entity_id="switch.garage_pump",
-            domain="switch",
-            friendly_name="Garage Pumpe",
-            area_name="Garage",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.garage_power",
-            domain="sensor",
-            device_class="power",
-            state_class="measurement",
-            unit_of_measurement="W",
-            friendly_name="Garage Leistung",
-            area_name="Garage",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.garage_energy",
-            domain="sensor",
-            device_class="energy",
-            state_class="measurement",
-            unit_of_measurement="kWh",
-            friendly_name="Garage Energie",
-            area_name="Garage",
-        ),
-    ]
-    service = _service(
-        tmp_path,
-        entities,
-        {
-            "sensor.garage_power": _points(8, start, 10.0),
-            "sensor.garage_energy": _points(8, start, 11.0),
-        },
-    )
-
-    record = service.configure_actuator("switch.garage_pump")
-
-    assert record.assignment.review_required is True
-    assert record.assignment.selected_numeric_entity_id is None
-    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
-
-
-def test_reconciliation_does_not_cross_assign_other_room_light_energy(
-    tmp_path: Path,
-) -> None:
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    entities = [
-        HaEntitySummary(
-            entity_id=(
-                "light.lichtschalter_abstellraum_"
-                "lichtschalter_abstellraum_s1"
-            ),
-            domain="light",
-            friendly_name="Licht Abstellraum",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.licht_badezimmer_energy",
-            domain="sensor",
-            device_class="energy",
-            state_class="total_increasing",
-            unit_of_measurement="kWh",
-            friendly_name="Lichtschalter_Badezimmer Licht Badezimmer energy",
-        ),
-        HaEntitySummary(
-            entity_id="binary_sensor.abstellraum_ture",
-            domain="binary_sensor",
-            device_class="door",
-            friendly_name="Abstellraum Türe",
-        ),
-        HaEntitySummary(
-            entity_id="binary_sensor.briefkasten_open",
-            domain="binary_sensor",
-            device_class="opening",
-            friendly_name="Briefkasten open",
-        ),
-    ]
-    service = _service(
-        tmp_path,
-        entities,
-        {"sensor.licht_badezimmer_energy": _points(8, start, 1.0)},
-    )
-
-    record = service.configure_actuator(
-        "light.lichtschalter_abstellraum_lichtschalter_abstellraum_s1"
-    )
-
-    assert record.assignment.selected_numeric_entity_id is None
-    assert record.assignment.selected_context_entity_ids == [
-        "binary_sensor.abstellraum_ture"
-    ]
-    assert record.assignment.source is AssignmentSource.AUTOMATIC
-    assert record.assignment.confidence == 1.0
-    assert record.assignment.review_required is False
-    assert record.lifecycle.status is LifecycleStatus.ARCHIVED
-
-
-def test_legacy_manual_override_is_cleared_and_automatic_mapping_wins(tmp_path: Path) -> None:
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    entities = [
-        HaEntitySummary(
-            entity_id="light.abstellkammer",
-            domain="light",
-            friendly_name="Abstellkammer Licht",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.abstellkammer_illuminance",
-            domain="sensor",
-            device_class="illuminance",
-            state_class="measurement",
-            unit_of_measurement="lx",
-            friendly_name="Abstellkammer Helligkeit",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.abstellkammer_power",
-            domain="sensor",
-            device_class="power",
-            state_class="measurement",
-            unit_of_measurement="W",
-            friendly_name="Abstellkammer Leistung",
-            area_name="Abstellkammer",
-        ),
-    ]
-    history = {
-        "sensor.abstellkammer_illuminance": _points(8, start, 10.0),
-        "sensor.abstellkammer_power": _points(8, start, 30.0),
-    }
-    service = _service(tmp_path, entities, history)
-    configured = service.configure_actuator("light.abstellkammer")
-    legacy = configured.model_copy(
-        update={
-            "manual_override": ManualOverride(
-                numeric_entity_id="sensor.abstellkammer_power",
-                context_entity_ids=[],
-                note="Alte manuelle Zuordnung",
-            )
-        }
-    )
-    service._store.upsert(legacy)
-
-    restarted = _service(tmp_path, entities, history)
-    record = restarted.reconcile_actuator("light.abstellkammer")
-
-    assert record.assignment.selected_numeric_entity_id == "sensor.abstellkammer_illuminance"
-    assert record.assignment.source.value == "automatic"
-    assert record.manual_override is None

tests/api/test_actuators.py

@@ -1,186 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta
-from pathlib import Path
-
-from fastapi.testclient import TestClient
-
-from app.actuators.lifecycle import ActuatorReconciliationService
-from app.actuators.store import ActuatorStore
-from app.behavior.engine import BehaviorEngine
-from app.config import Settings
-from app.ha.discovery import DiscoveredEntity
-from app.ha.discovery import discover_entities
-from app.ha.history import (
-    EntityHistorySeries,
-    LogbookEntry,
-    NumericHistoryPoint,
-    StateHistorySeries,
-)
-from app.ha.models import HaEntitySummary
-from app.ha.reader import HaReader
-from app.main import app
-from app.ml.registry.model_registry import ModelRegistry
-
-
-class FakeHaReader(HaReader):
-    def __init__(self, entities: list[HaEntitySummary], history: dict[str, list[float]]) -> None:
-        self._entities = entities
-        self._history = history
-
-    def read_entities(self) -> list[HaEntitySummary]:
-        return list(self._entities)
-
-    def discover(
-        self,
-        domains: set[str] | None = None,
-        learnable: bool | None = None,
-    ) -> list[DiscoveredEntity]:
-        return discover_entities(self._entities, domains=domains, learnable=learnable)
-
-    def read_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[EntityHistorySeries]:
-        base = start_time
-        return [
-            EntityHistorySeries(
-                entity_id=entity_id,
-                points=[
-                    NumericHistoryPoint(
-                        timestamp=base + timedelta(hours=index),
-                        value=value,
-                    )
-                    for index, value in enumerate(self._history.get(entity_id, []))
-                ],
-            )
-            for entity_id in entity_ids
-            if entity_id in self._history
-        ]
-
-    def read_state_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[StateHistorySeries]:
-        return []
-
-    def read_logbook(
-        self,
-        entity_id: str,
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[LogbookEntry]:
-        return []
-
-    def call_service(
-        self,
-        domain: str,
-        service: str,
-        service_data: dict[str, object],
-    ) -> list[object]:
-        return []
-
-
-def _install_service(tmp_path: Path) -> None:
-    entities = [
-        HaEntitySummary(
-            entity_id="light.abstellkammer",
-            domain="light",
-            friendly_name="Abstellkammer Licht",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="sensor.abstellkammer_illuminance",
-            domain="sensor",
-            device_class="illuminance",
-            state_class="measurement",
-            unit_of_measurement="lx",
-            friendly_name="Abstellkammer Helligkeit",
-            area_name="Abstellkammer",
-        ),
-        HaEntitySummary(
-            entity_id="binary_sensor.abstellkammer_motion",
-            domain="binary_sensor",
-            device_class="motion",
-            friendly_name="Abstellkammer Bewegung",
-            area_name="Abstellkammer",
-        ),
-    ]
-    settings = Settings(
-        ha_url="http://ha.local",
-        ha_token="token",
-        model_store=str(tmp_path / "models"),
-        automation_store=str(tmp_path / "automations"),
-        actuator_store=str(tmp_path / "actuators"),
-        history_days=14,
-        min_training_points=5,
-        retrain_stale_hours=24,
-        reconcile_interval_seconds=900,
-    )
-    app.state.registry = ModelRegistry(tmp_path / "models")
-    app.state.actuator_store = ActuatorStore(tmp_path / "actuators")
-    app.state.ha_reader = FakeHaReader(
-        entities,
-        {"sensor.abstellkammer_illuminance": [10, 11, 12, 13, 14, 15]},
-    )
-    app.state.actuator_service = ActuatorReconciliationService(
-        ha_reader=app.state.ha_reader,
-        store=app.state.actuator_store,
-        registry=app.state.registry,
-        settings=settings,
-    )
-    app.state.behavior_engine = BehaviorEngine(
-        ha_reader=app.state.ha_reader,
-        store=app.state.actuator_store,
-        settings=settings,
-    )
-
-
-def test_actuator_api_configures_reconciles_and_removes(tmp_path: Path) -> None:
-    with TestClient(app) as client:
-        _install_service(tmp_path)
-
-        created = client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
-        assert created.status_code == 201
-        assert created.json()["assignment"]["selected_numeric_entity_id"] == (
-            "sensor.abstellkammer_illuminance"
-        )
-
-        listed = client.get("/v1/actuators")
-        assert listed.status_code == 200
-        assert listed.json()[0]["lifecycle"]["status"] == "trained"
-        assert listed.json()[0]["behavior"]["mode"] == "shadow"
-
-        evaluation = client.post("/v1/actuators/light.abstellkammer/evaluate")
-        assert evaluation.status_code == 200
-
-        premature_activation = client.post(
-            "/v1/actuators/light.abstellkammer/activation",
-            json={"active": True},
-        )
-        assert premature_activation.status_code == 409
-
-        reconciliation = client.post("/v1/actuators/reconciliation/run")
-        assert reconciliation.status_code == 200
-        assert reconciliation.json()["trained_models"] == 1
-
-        removed = client.delete("/v1/actuators/light.abstellkammer")
-        assert removed.status_code == 204
-        assert client.get("/v1/actuators").json() == []
-
-
-def test_manual_override_endpoint_is_not_exposed(tmp_path: Path) -> None:
-    with TestClient(app) as client:
-        _install_service(tmp_path)
-        client.post("/v1/actuators", json={"actuator_entity_id": "light.abstellkammer"})
-
-        response = client.post(
-            "/v1/actuators/light.abstellkammer/override",
-            json={"numeric_entity_id": "sensor.abstellkammer_illuminance"},
-        )
-
-    assert response.status_code == 404

tests/api/test_automations.py

@@ -1,17 +0,0 @@
-from fastapi.testclient import TestClient
-
-from app.main import app
-
-
-def test_automation_api_is_not_exposed() -> None:
-    with TestClient(app) as client:
-        response = client.post(
-            "/v1/automations/proposals",
-            json={
-                "alias": "Nicht mehr verfügbar",
-                "trigger": {"entity_id": "sensor.hall_illuminance", "below": 10},
-                "action": {"service": "light.turn_on", "entity_id": "light.hall"},
-            },
-        )
-
-    assert response.status_code == 404

tests/api/test_entities.py

@@ -1,11 +1,8 @@
 from collections.abc import Sequence
-from datetime import datetime
 
 from fastapi.testclient import TestClient
 
 from app.ha.exceptions import HaTimeoutError
-from app.ha.discovery import DiscoveredEntity, EntityRole
-from app.ha.history import EntityHistorySeries, NumericHistoryPoint
 from app.ha.models import HaEntitySummary
 from app.ha.reader import HaReader
 from app.main import app
@@ -18,38 +15,6 @@ class FakeHaReader(HaReader):
     def read_entities(self) -> Sequence[HaEntitySummary]:
         return [HaEntitySummary(entity_id="sensor.temperature", domain="sensor")]
 
-    def discover(
-        self,
-        domains: set[str] | None = None,
-        learnable: bool | None = None,
-    ) -> Sequence[DiscoveredEntity]:
-        result = DiscoveredEntity(
-            entity_id="sensor.temperature",
-            domain="sensor",
-            device_class="temperature",
-            role=EntityRole.MEASUREMENT,
-            learnable=True,
-            reason="Numerischer Messsensor für Zeitreihen und Training.",
-        )
-        if domains and result.domain not in domains:
-            return []
-        if learnable is not None and result.learnable is not learnable:
-            return []
-        return [result]
-
-    def read_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> Sequence[EntityHistorySeries]:
-        return [
-            EntityHistorySeries(
-                entity_id=entity_ids[0],
-                points=[NumericHistoryPoint(timestamp=start_time, value=21.5)],
-            )
-        ]
-
 
 class TimeoutHaReader(HaReader):
     def __init__(self) -> None:
@@ -73,24 +38,19 @@ def test_entities_returns_reader_data() -> None:
     assert response.status_code == 200
     assert response.json() == [
         {
-                "entity_id": "sensor.temperature",
-                "domain": "sensor",
-                "state": None,
-                "last_changed": None,
-                "state_class": None,
+            "entity_id": "sensor.temperature",
+            "domain": "sensor",
+            "state_class": None,
             "device_class": None,
             "unit_of_measurement": None,
-            "friendly_name": None,
-            "area_id": None,
-            "area_name": None,
-            "device_id": None,
-            "device_name": None,
         }
     ]
 
 
 def test_entities_returns_503_without_home_assistant_config() -> None:
     with TestClient(app) as client:
+        if hasattr(app.state, "ha_reader"):
+            delattr(app.state, "ha_reader")
         response = client.get("/v1/entities")
     assert response.status_code == 503
 
@@ -101,44 +61,3 @@ def test_entities_maps_ha_errors_without_leaking_details() -> None:
         response = client.get("/v1/entities")
     assert response.status_code == 504
     assert response.json() == {"detail": "Home Assistant request timed out."}
-
-
-def test_discovery_filters_entities() -> None:
-    with TestClient(app) as client:
-        app.state.ha_reader = FakeHaReader()
-        response = client.get("/v1/discovery?domain=sensor&learnable=true")
-
-    assert response.status_code == 200
-    assert response.json() == [
-        {
-            "entity_id": "sensor.temperature",
-            "domain": "sensor",
-            "device_class": "temperature",
-            "state_class": None,
-            "unit_of_measurement": None,
-            "role": "measurement",
-            "learnable": True,
-            "reason": "Numerischer Messsensor für Zeitreihen und Training.",
-        }
-    ]
-
-
-def test_history_returns_normalized_series() -> None:
-    with TestClient(app) as client:
-        app.state.ha_reader = FakeHaReader()
-        response = client.get(
-            "/v1/history",
-            params=[
-                ("entity_id", "sensor.temperature"),
-                ("start_time", "2026-06-01T00:00:00Z"),
-                ("end_time", "2026-06-02T00:00:00Z"),
-            ],
-        )
-
-    assert response.status_code == 200
-    assert response.json() == [
-        {
-            "entity_id": "sensor.temperature",
-            "points": [{"timestamp": "2026-06-01T00:00:00Z", "value": 21.5}],
-        }
-    ]

tests/api/test_ml_routes.py

@@ -1,184 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from fastapi.testclient import TestClient
-
-from app.main import app
-
-
-def test_ml_routes_are_exposed_by_production_app() -> None:
-    with TestClient(app) as client:
-        health = client.get("/ml/health")
-        models = client.get("/ml/models")
-
-    assert health.status_code == 200
-    assert models.status_code == 200
-    assert isinstance(models.json()["models"], list)
-
-
-def test_unknown_model_returns_404() -> None:
-    with TestClient(app) as client:
-        response = client.post(
-            "/ml/predict",
-            json={
-                "modelId": "missing",
-                "sensor_id": "sensor.kitchen",
-                "values": {"temperature": 21.0},
-            },
-        )
-
-    assert response.status_code == 404
-
-
-def test_unsupported_sensor_returns_422(tmp_path: Path) -> None:
-    from app.ml.registry.model_registry import ModelRegistry
-    from app.ml.training import TrainedArtifact
-
-    registry = ModelRegistry(tmp_path)
-    registry.register(TrainedArtifact("default", ("sensor.kitchen",)))
-
-    with TestClient(app) as client:
-        app.state.registry = registry
-        response = client.post(
-            "/ml/predict",
-            json={
-                "modelId": "default",
-                "sensor_id": "sensor.unknown",
-                "values": {"temperature": 21.0},
-            },
-        )
-
-    assert response.status_code == 422
-
-
-def test_retrain_creates_and_replaces_persisted_model(tmp_path: Path) -> None:
-    from app.ml.registry.model_registry import ModelRegistry
-
-    registry = ModelRegistry(tmp_path)
-    with TestClient(app) as client:
-        app.state.registry = registry
-        created = client.post(
-            "/ml/retrain",
-            json={
-                "modelId": "home-model",
-                "samples": [
-                    {
-                        "sensor_id": "sensor.kitchen",
-                        "values": {"temperature": 21.0},
-                    }
-                ],
-            },
-        )
-        replaced = client.post(
-            "/ml/retrain",
-            json={
-                "modelId": "home-model",
-                "samples": [
-                    {
-                        "sensor_id": "sensor.bedroom",
-                        "values": {"temperature": 18.0},
-                    }
-                ],
-            },
-        )
-
-    assert created.status_code == 200
-    assert created.json() == {
-        "model_id": "home-model",
-        "supported_sensors": ["sensor.kitchen"],
-        "trained_features": 1,
-        "model_type": "statistical_baseline",
-        "replaced": False,
-    }
-    assert replaced.status_code == 200
-    assert replaced.json() == {
-        "model_id": "home-model",
-        "supported_sensors": ["sensor.bedroom"],
-        "trained_features": 1,
-        "model_type": "statistical_baseline",
-        "replaced": True,
-    }
-    restarted = ModelRegistry(tmp_path)
-    assert restarted.load_artifact("home-model").supported_sensors == ("sensor.bedroom",)
-
-
-def test_retrain_rejects_empty_samples() -> None:
-    with TestClient(app) as client:
-        response = client.post(
-            "/ml/retrain",
-            json={"modelId": "home-model", "samples": []},
-        )
-
-    assert response.status_code == 422
-
-
-def test_predict_returns_numeric_forecast_and_confidence(tmp_path: Path) -> None:
-    from app.ml.feature_store import FeatureStore, FeatureVector
-    from app.ml.registry.model_registry import ModelRegistry
-    from app.ml.training import TrainingPipeline
-
-    store = FeatureStore()
-    store.add_batch(
-        [
-            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
-            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
-        ]
-    )
-    registry = ModelRegistry(tmp_path)
-    registry.register(TrainingPipeline(store).run("home-model"))
-
-    with TestClient(app) as client:
-        app.state.registry = registry
-        response = client.post(
-            "/ml/predict",
-            json={
-                "modelId": "home-model",
-                "sensor_id": "sensor.kitchen",
-                "values": {"temperature": 21.0},
-            },
-        )
-
-    assert response.status_code == 200
-    assert response.json()["predictions"] == {"temperature": 22.0}
-    assert 0.0 < response.json()["confidence"] <= 1.0
-    assert response.json()["model_type"] == "statistical_baseline"
-    explanation = response.json()["explanations"]["temperature"]
-    assert explanation["direction"] == "steigend"
-    assert explanation["change"] == 1.0
-    assert explanation["sample_count"] == 2
-
-
-def test_evaluate_returns_real_error_metrics(tmp_path: Path) -> None:
-    from app.ml.feature_store import FeatureStore, FeatureVector
-    from app.ml.registry.model_registry import ModelRegistry
-    from app.ml.training import TrainingPipeline
-
-    store = FeatureStore()
-    store.add_batch(
-        [
-            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
-            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
-        ]
-    )
-    registry = ModelRegistry(tmp_path)
-    registry.register(TrainingPipeline(store).run("home-model"))
-
-    with TestClient(app) as client:
-        app.state.registry = registry
-        response = client.post(
-            "/ml/evaluate",
-            json={
-                "modelId": "home-model",
-                "samples": [
-                    {
-                        "sensor_id": "sensor.kitchen",
-                        "values": {"temperature": 21.0},
-                    }
-                ],
-            },
-        )
-
-    assert response.status_code == 200
-    metrics = {metric["name"]: metric["value"] for metric in response.json()["metrics"]}
-    assert metrics == {"mae": 1.0, "rmse": 1.0, "coverage": 1.0}

tests/automations/test_store.py

@@ -1,53 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from app.automations.models import (
-    AutomationProposal,
-    NumericStateTrigger,
-    ProposalStatus,
-    ServiceAction,
-)
-from app.automations.store import AutomationStore
-
-
-def proposal() -> AutomationProposal:
-    return AutomationProposal(
-        alias="Wohnzimmer bei Kälte heizen",
-        description="Aktiviert den Heizmodus unter 18 Grad.",
-        trigger=NumericStateTrigger(entity_id="sensor.living_room_temperature", below=18.0),
-        action=ServiceAction(
-            service="climate.set_temperature",
-            entity_id="climate.living_room",
-            data={"temperature": 21.0},
-        ),
-    )
-
-
-def test_store_persists_approval_and_exports_yaml(tmp_path: Path) -> None:
-    store = AutomationStore(tmp_path)
-    created = store.create(proposal())
-    approved = store.decide(created.proposal_id, ProposalStatus.APPROVED, 1)
-    yaml = AutomationStore(tmp_path).export_yaml(created.proposal_id)
-    assert approved.status is ProposalStatus.APPROVED
-    assert approved.revision == 2
-    assert "platform: numeric_state" in yaml
-    assert "service: climate.set_temperature" in yaml
-    assert "temperature: 21.0" in yaml
-
-
-def test_store_requires_approval_and_current_revision(tmp_path: Path) -> None:
-    store = AutomationStore(tmp_path)
-    created = store.create(proposal())
-    with pytest.raises(ValueError, match="freigegebene"):
-        store.export_yaml(created.proposal_id)
-    with pytest.raises(ValueError, match="Revision"):
-        store.decide(created.proposal_id, ProposalStatus.APPROVED, 2)
-
-
-def test_store_allows_only_one_decision(tmp_path: Path) -> None:
-    store = AutomationStore(tmp_path)
-    created = store.create(proposal())
-    store.decide(created.proposal_id, ProposalStatus.REJECTED, 1)
-    with pytest.raises(ValueError, match="bereits entschieden"):
-        store.decide(created.proposal_id, ProposalStatus.APPROVED, 2)

tests/behavior/test_engine.py

@@ -1,416 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-import pytest
-
-from app.actuators.models import BehaviorMode, BehaviorPattern, BehaviorStatus
-from app.actuators.store import ActuatorStore
-from app.behavior.engine import BehaviorEngine, predict_behavior, service_for_state
-from app.config import Settings
-from app.ha.history import (
-    LogbookEntry,
-    StateHistoryPoint,
-    StateHistorySeries,
-)
-from app.ha.models import HaEntitySummary
-from app.ha.reader import HaReader
-
-
-class FakeBehaviorReader(HaReader):
-    def __init__(
-        self,
-        *,
-        entities: list[HaEntitySummary],
-        history: list[StateHistorySeries],
-        logbook: list[LogbookEntry],
-    ) -> None:
-        self.entities = entities
-        self.history = history
-        self.logbook = logbook
-        self.service_calls: list[tuple[str, str, dict[str, object]]] = []
-
-    def read_entities(self) -> list[HaEntitySummary]:
-        return list(self.entities)
-
-    def read_state_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[StateHistorySeries]:
-        return [series for series in self.history if series.entity_id in entity_ids]
-
-    def read_logbook(
-        self,
-        entity_id: str,
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[LogbookEntry]:
-        return [entry for entry in self.logbook if entry.entity_id == entity_id]
-
-    def call_service(
-        self,
-        domain: str,
-        service: str,
-        service_data: dict[str, object],
-    ) -> list[object]:
-        self.service_calls.append((domain, service, service_data))
-        return []
-
-
-def _settings(tmp_path: Path) -> Settings:
-    return Settings(
-        actuator_store=str(tmp_path / "actuators"),
-        model_store=str(tmp_path / "models"),
-        automation_store=str(tmp_path / "automations"),
-        history_days=14,
-        min_behavior_actions=3,
-        prediction_confidence=0.8,
-        prediction_window_minutes=30,
-        execution_cooldown_seconds=900,
-        timezone="Europe/Berlin",
-    )
-
-
-def _reader(now: datetime) -> FakeBehaviorReader:
-    actuator_points: list[StateHistoryPoint] = []
-    logbook: list[LogbookEntry] = []
-    for days_ago in (3, 2, 1):
-        action_at = now - timedelta(days=days_ago)
-        actuator_points.extend(
-            [
-                StateHistoryPoint(timestamp=action_at - timedelta(minutes=1), state="off"),
-                StateHistoryPoint(timestamp=action_at, state="on"),
-                StateHistoryPoint(timestamp=action_at + timedelta(hours=6), state="off"),
-            ]
-        )
-        logbook.extend(
-            [
-                LogbookEntry(
-                    entity_id="light.office",
-                    timestamp=action_at,
-                    message="turned on",
-                    context_user_id="user-1",
-                ),
-                LogbookEntry(
-                    entity_id="light.office",
-                    timestamp=action_at + timedelta(hours=6),
-                    message="turned off",
-                    context_domain="automation",
-                    context_service="trigger",
-                ),
-            ]
-        )
-    actuator_points.sort(key=lambda point: point.timestamp)
-    context_points = [
-        StateHistoryPoint(timestamp=now - timedelta(days=7), state="on"),
-    ]
-    return FakeBehaviorReader(
-        entities=[
-            HaEntitySummary(entity_id="light.office", domain="light", state="off"),
-            HaEntitySummary(
-                entity_id="binary_sensor.office_presence",
-                domain="binary_sensor",
-                state="on",
-            ),
-        ],
-        history=[
-            StateHistorySeries(entity_id="light.office", points=actuator_points),
-            StateHistorySeries(
-                entity_id="binary_sensor.office_presence",
-                points=context_points,
-            ),
-        ],
-        logbook=logbook,
-    )
-
-
-def _engine(tmp_path: Path, now: datetime) -> tuple[BehaviorEngine, FakeBehaviorReader]:
-    settings = _settings(tmp_path)
-    store = ActuatorStore(settings.actuator_store)
-    record = store.configure("light.office")
-    store.upsert(
-        record.model_copy(
-            update={
-                "assignment": record.assignment.model_copy(
-                    update={
-                        "selected_context_entity_ids": [
-                            "binary_sensor.office_presence"
-                        ],
-                    }
-                )
-            }
-        )
-    )
-    reader = _reader(now)
-    return (
-        BehaviorEngine(ha_reader=reader, store=store, settings=settings),
-        reader,
-    )
-
-
-def test_engine_trains_predicts_in_shadow_and_executes_only_after_approval(
-    tmp_path: Path,
-) -> None:
-    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
-    engine, reader = _engine(tmp_path, now)
-
-    trained = engine.train("light.office")
-    shadow = engine.evaluate("light.office")
-
-    assert trained.behavior.status is BehaviorStatus.TRAINED
-    assert trained.behavior.sample_count == 3
-    assert trained.behavior.high_confidence_sample_count == 3
-    assert shadow.behavior.mode is BehaviorMode.SHADOW
-    assert shadow.behavior.prediction is not None
-    assert shadow.behavior.prediction.target_state == "on"
-    assert reader.service_calls == []
-
-    engine.set_active("light.office", active=True)
-    active = engine.evaluate("light.office")
-
-    assert active.behavior.mode is BehaviorMode.ACTIVE
-    assert active.behavior.prediction is not None
-    assert active.behavior.prediction.executed is True
-    assert reader.service_calls == [
-        ("light", "turn_on", {"entity_id": "light.office"})
-    ]
-
-
-def test_engine_excludes_known_automation_actions(tmp_path: Path) -> None:
-    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
-    engine, _ = _engine(tmp_path, now)
-
-    trained = engine.train("light.office")
-
-    assert {pattern.target_state for pattern in trained.behavior.patterns} == {"on"}
-    assert {pattern.source for pattern in trained.behavior.patterns} == {"user"}
-
-
-def test_engine_learns_causal_automation_for_shadow_without_user_credit(
-    tmp_path: Path,
-) -> None:
-    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
-    actuator_points: list[StateHistoryPoint] = []
-    door_points: list[StateHistoryPoint] = []
-    logbook: list[LogbookEntry] = []
-    for days_ago in (3, 2, 1):
-        action_at = now - timedelta(days=days_ago)
-        actuator_points.extend(
-            [
-                StateHistoryPoint(
-                    timestamp=action_at - timedelta(minutes=1),
-                    state="off",
-                ),
-                StateHistoryPoint(timestamp=action_at, state="on"),
-            ]
-        )
-        door_points.extend(
-            [
-                StateHistoryPoint(
-                    timestamp=action_at - timedelta(minutes=1),
-                    state="off",
-                ),
-                StateHistoryPoint(
-                    timestamp=action_at - timedelta(seconds=1),
-                    state="on",
-                ),
-            ]
-        )
-        logbook.append(
-            LogbookEntry(
-                entity_id="light.storage",
-                timestamp=action_at,
-                message="turned on",
-                context_domain="automation",
-                context_service="trigger",
-            )
-        )
-    actuator_points.sort(key=lambda point: point.timestamp)
-    door_points.sort(key=lambda point: point.timestamp)
-    settings = _settings(tmp_path)
-    store = ActuatorStore(settings.actuator_store)
-    record = store.configure("light.storage")
-    store.upsert(
-        record.model_copy(
-            update={
-                "assignment": record.assignment.model_copy(
-                    update={
-                        "selected_context_entity_ids": [
-                            "binary_sensor.storage_door"
-                        ],
-                    }
-                )
-            }
-        )
-    )
-    reader = FakeBehaviorReader(
-        entities=[],
-        history=[
-            StateHistorySeries(
-                entity_id="light.storage",
-                points=actuator_points,
-            ),
-            StateHistorySeries(
-                entity_id="binary_sensor.storage_door",
-                points=door_points,
-            ),
-        ],
-        logbook=logbook,
-    )
-    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
-
-    trained = engine.train("light.storage")
-    automation_patterns = [
-        pattern
-        for pattern in trained.behavior.patterns
-        if pattern.source == "automation"
-    ]
-
-    assert len(automation_patterns) == 3
-    assert trained.behavior.high_confidence_sample_count == 0
-    assert {
-        (
-            pattern.trigger_entity_id,
-            pattern.trigger_from_state,
-            pattern.trigger_to_state,
-        )
-        for pattern in automation_patterns
-    } == {("binary_sensor.storage_door", "off", "on")}
-
-
-def test_active_mode_rejects_unsafe_domains(tmp_path: Path) -> None:
-    settings = _settings(tmp_path)
-    store = ActuatorStore(settings.actuator_store)
-    record = store.configure("lock.front_door")
-    store.upsert(
-        record.model_copy(
-            update={
-                "behavior": record.behavior.model_copy(
-                    update={"status": BehaviorStatus.TRAINED}
-                )
-            }
-        )
-    )
-    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
-    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
-
-    with pytest.raises(ValueError, match="nicht freigegeben"):
-        engine.set_active("lock.front_door", active=True)
-
-
-def test_active_mode_requires_user_attributed_actions(tmp_path: Path) -> None:
-    settings = _settings(tmp_path)
-    store = ActuatorStore(settings.actuator_store)
-    record = store.configure("light.office")
-    store.upsert(
-        record.model_copy(
-            update={
-                "behavior": record.behavior.model_copy(
-                    update={
-                        "status": BehaviorStatus.TRAINED,
-                        "sample_count": 3,
-                        "high_confidence_sample_count": 0,
-                    }
-                )
-            }
-        )
-    )
-    reader = FakeBehaviorReader(entities=[], history=[], logbook=[])
-    engine = BehaviorEngine(ha_reader=reader, store=store, settings=settings)
-
-    with pytest.raises(ValueError, match="eindeutig dir zugeordnete"):
-        engine.set_active("light.office", active=True)
-
-
-@pytest.mark.parametrize(
-    ("domain", "state", "service"),
-    [
-        ("light", "on", "turn_on"),
-        ("switch", "off", "turn_off"),
-        ("cover", "open", "open_cover"),
-        ("cover", "closed", "close_cover"),
-        ("lock", "unlocked", None),
-    ],
-)
-def test_service_for_state_is_strictly_allowlisted(
-    domain: str,
-    state: str,
-    service: str | None,
-) -> None:
-    assert service_for_state(domain, state) == service
-
-
-def test_prediction_requires_temporal_support() -> None:
-    assert predict_behavior(
-        [],
-        current_context={},
-        now=datetime.now(timezone.utc),
-        min_support=3,
-        window_minutes=30,
-    ) is None
-
-
-def test_prediction_uses_fresh_causal_context_transition_outside_time_window() -> None:
-    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
-    patterns = [
-        BehaviorPattern(
-            target_state="on",
-            minute_of_day=60,
-            weekday=0,
-            context_states={"binary_sensor.storage_door": "on"},
-            trigger_entity_id="binary_sensor.storage_door",
-            trigger_from_state="off",
-            trigger_to_state="on",
-            source="automation",
-            weight=0.7,
-            observed_at=now - timedelta(days=days_ago),
-        )
-        for days_ago in (3, 2, 1)
-    ]
-
-    prediction = predict_behavior(
-        patterns,
-        current_context={"binary_sensor.storage_door": "on"},
-        current_context_changed_at={
-            "binary_sensor.storage_door": now - timedelta(seconds=10)
-        },
-        now=now,
-        min_support=3,
-        window_minutes=30,
-    )
-
-    assert prediction is not None
-    assert prediction.target_state == "on"
-    assert prediction.matching_patterns == 3
-    assert prediction.confidence == 0.7
-    assert "frischen Sensorwechsel" in prediction.reason
-
-
-def test_prediction_ignores_stale_causal_context_state() -> None:
-    now = datetime.now(timezone.utc).replace(second=0, microsecond=0)
-    pattern = BehaviorPattern(
-        target_state="on",
-        minute_of_day=60,
-        weekday=0,
-        context_states={"binary_sensor.storage_door": "on"},
-        trigger_entity_id="binary_sensor.storage_door",
-        trigger_from_state="off",
-        trigger_to_state="on",
-        source="automation",
-        weight=0.7,
-        observed_at=now - timedelta(days=1),
-    )
-
-    assert predict_behavior(
-        [pattern],
-        current_context={"binary_sensor.storage_door": "on"},
-        current_context_changed_at={
-            "binary_sensor.storage_door": now - timedelta(minutes=5)
-        },
-        now=now,
-        min_support=1,
-        window_minutes=30,
-    ) is None

tests/ha/test_discovery.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from app.ha.discovery import EntityRole, classify_entity, discover_entities
-from app.ha.models import HaEntitySummary
-
-
-@pytest.mark.parametrize(
-    ("entity", "role", "learnable"),
-    [
-        (
-            HaEntitySummary(
-                entity_id="sensor.temperature",
-                domain="sensor",
-                device_class="temperature",
-                state_class="measurement",
-                unit_of_measurement="°C",
-            ),
-            EntityRole.MEASUREMENT,
-            True,
-        ),
-        (
-            HaEntitySummary(
-                entity_id="binary_sensor.motion",
-                domain="binary_sensor",
-                device_class="motion",
-            ),
-            EntityRole.BINARY_CONTEXT,
-            True,
-        ),
-        (
-            HaEntitySummary(entity_id="person.simon", domain="person"),
-            EntityRole.CONTEXT,
-            True,
-        ),
-        (
-            HaEntitySummary(entity_id="light.living_room", domain="light"),
-            EntityRole.ACTUATOR,
-            False,
-        ),
-        (
-            HaEntitySummary(entity_id="camera.driveway", domain="camera"),
-            EntityRole.UNSUPPORTED,
-            False,
-        ),
-    ],
-)
-def test_classify_entity(
-    entity: HaEntitySummary,
-    role: EntityRole,
-    learnable: bool,
-) -> None:
-    result = classify_entity(entity)
-    assert result.role is role
-    assert result.learnable is learnable
-
-
-def test_discovery_filters_domain_and_learnable() -> None:
-    entities = [
-        HaEntitySummary(
-            entity_id="sensor.temperature",
-            domain="sensor",
-            device_class="temperature",
-        ),
-        HaEntitySummary(entity_id="sensor.status", domain="sensor"),
-        HaEntitySummary(
-            entity_id="binary_sensor.motion",
-            domain="binary_sensor",
-            device_class="motion",
-        ),
-    ]
-
-    result = discover_entities(entities, domains={" SENSOR "}, learnable=True)
-
-    assert [item.entity_id for item in result] == ["sensor.temperature"]

tests/ha/test_ha_client.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
 from unittest.mock import Mock
 
 import pytest
@@ -16,7 +15,7 @@ from app.ha.exceptions import (
 
 
 def _client_with_response(response: Mock) -> HaClient:
-    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
+    client = HaClient(HaClientSettings(url="http://ha.local", token="secret-token"))
     client._session.get = Mock(return_value=response)  # type: ignore[method-assign]
     return client
 
@@ -33,12 +32,14 @@ def _response(status_code: int = 200, payload: object | None = None) -> Mock:
 def test_list_entities_returns_home_assistant_payload() -> None:
     payload = [{"entity_id": "sensor.temperature", "state": "21"}]
     client = _client_with_response(_response(payload=payload))
+
     assert client.list_entities() == payload
 
 
 def test_list_entities_maps_timeout() -> None:
-    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
-    client._session.get = Mock(side_effect=requests.Timeout("timed out"))  # type: ignore[method-assign]
+    client = HaClient(HaClientSettings(url="http://ha.local", token="secret-token"))
+    client._session.get = Mock(side_effect=requests.Timeout("secret-token"))  # type: ignore[method-assign]
+
     with pytest.raises(HaTimeoutError):
         client.list_entities()
 
@@ -46,15 +47,19 @@ def test_list_entities_maps_timeout() -> None:
 @pytest.mark.parametrize("status_code", [401, 403])
 def test_list_entities_maps_auth_errors(status_code: int) -> None:
     client = _client_with_response(_response(status_code=status_code))
+
     with pytest.raises(HaAuthError) as exc_info:
         client.list_entities()
+
     assert exc_info.value.status_code == status_code
 
 
 def test_list_entities_maps_http_errors() -> None:
     client = _client_with_response(_response(status_code=500))
+
     with pytest.raises(HaHttpError) as exc_info:
         client.list_entities()
+
     assert exc_info.value.status_code == 500
 
 
@@ -62,116 +67,13 @@ def test_list_entities_rejects_invalid_json() -> None:
     response = _response()
     response.json.side_effect = ValueError("not json")
     client = _client_with_response(response)
+
     with pytest.raises(HaUnexpectedPayloadError):
         client.list_entities()
 
 
 def test_list_entities_rejects_non_list_payload() -> None:
     client = _client_with_response(_response(payload={"entity_id": "sensor.temperature"}))
+
     with pytest.raises(HaUnexpectedPayloadError):
         client.list_entities()
-
-
-def test_get_history_calls_home_assistant_history_api() -> None:
-    response = _response(payload=[[{"entity_id": "sensor.temperature", "state": "21.0"}]])
-    client = _client_with_response(response)
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
-
-    payload = client.get_history(["sensor.temperature"], start, end)
-
-    assert payload == [[{"entity_id": "sensor.temperature", "state": "21.0"}]]
-    client._session.get.assert_called_once()  # type: ignore[attr-defined]
-    call = client._session.get.call_args  # type: ignore[attr-defined]
-    assert "/api/history/period/2026-06-01T00:00:00+00:00" in call.args[0]
-    assert call.kwargs["params"]["filter_entity_id"] == "sensor.temperature"
-    assert call.kwargs["params"]["end_time"] == "2026-06-02T00:00:00+00:00"
-
-
-def test_list_entity_metadata_calls_template_api() -> None:
-    response = _response()
-    response.text = (
-        '[{"entity_id":"sensor.temperature","area_name":"Kueche","device_name":"Thermometer"}]'
-    )
-    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
-    client._session.post = Mock(return_value=response)  # type: ignore[method-assign]
-
-    metadata = client.list_entity_metadata(["sensor.temperature"])
-
-    assert metadata == {
-        "sensor.temperature": {
-            "area_id": None,
-            "area_name": "Kueche",
-            "device_id": None,
-            "device_name": "Thermometer",
-        }
-    }
-
-
-def test_get_logbook_filters_entity_and_period() -> None:
-    response = _response(payload=[{"entity_id": "light.office"}])
-    client = _client_with_response(response)
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
-
-    payload = client.get_logbook("light.office", start, end)
-
-    assert payload == [{"entity_id": "light.office"}]
-    call = client._session.get.call_args  # type: ignore[attr-defined]
-    assert "/api/logbook/2026-06-01T00:00:00+00:00" in call.args[0]
-    assert call.kwargs["params"]["entity"] == "light.office"
-
-
-def test_call_service_posts_to_home_assistant() -> None:
-    response = _response(payload=[])
-    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
-    client._session.post = Mock(return_value=response)  # type: ignore[method-assign]
-
-    result = client.call_service("light", "turn_on", {"entity_id": "light.office"})
-
-    assert result == []
-    client._session.post.assert_called_once_with(
-        "http://ha.local/api/services/light/turn_on",
-        json={"entity_id": "light.office"},
-        timeout=10,
-    )
-
-
-@pytest.mark.parametrize(
-    ("entity_ids", "start", "end"),
-    [
-        (
-            [],
-            datetime(2026, 6, 1, tzinfo=timezone.utc),
-            datetime(2026, 6, 2, tzinfo=timezone.utc),
-        ),
-        (
-            ["sensor.temperature"],
-            datetime(2026, 6, 1),
-            datetime(2026, 6, 2, tzinfo=timezone.utc),
-        ),
-        (
-            ["sensor.temperature"],
-            datetime(2026, 6, 2, tzinfo=timezone.utc),
-            datetime(2026, 6, 1, tzinfo=timezone.utc),
-        ),
-        (
-            ["invalid entity"],
-            datetime(2026, 6, 1, tzinfo=timezone.utc),
-            datetime(2026, 6, 2, tzinfo=timezone.utc),
-        ),
-        (
-            ["sensor.temperature"],
-            datetime(2026, 5, 1, tzinfo=timezone.utc),
-            datetime(2026, 6, 2, tzinfo=timezone.utc),
-        ),
-    ],
-)
-def test_get_history_validates_request(
-    entity_ids: list[str],
-    start: datetime,
-    end: datetime,
-) -> None:
-    client = HaClient(HaClientSettings(url="http://ha.local", token="test-token"))
-    with pytest.raises(ValueError):
-        client.get_history(entity_ids, start, end)

tests/ha/test_ha_reader.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from datetime import datetime, timezone
-
 from app.ha.client import HaClient, HaClientSettings
 from app.ha.reader import HaReader
 
@@ -15,7 +13,6 @@ class FakeHaClient(HaClient):
             {
                 "entity_id": "sensor.temperature",
                 "state": "21.5",
-                "last_changed": "2026-06-14T12:00:00+00:00",
                 "attributes": {
                     "state_class": "measurement",
                     "device_class": "temperature",
@@ -29,55 +26,6 @@ class FakeHaClient(HaClient):
             },
         ]
 
-    def get_history(
-        self,
-        entity_ids: list[str],
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[object]:
-        return [
-            [
-                {
-                    "entity_id": entity_ids[0],
-                    "state": "21.5",
-                    "last_changed": start_time.isoformat(),
-                }
-            ]
-        ]
-
-    def list_entity_metadata(self, entity_ids: list[str]) -> dict[str, dict[str, str | None]]:
-        return {
-            "sensor.temperature": {
-                "area_id": "kitchen",
-                "area_name": "Kueche",
-                "device_id": "device-1",
-                "device_name": "Thermometer",
-            }
-        }
-
-    def get_logbook(
-        self,
-        entity_id: str,
-        start_time: datetime,
-        end_time: datetime,
-    ) -> list[object]:
-        return [
-            {
-                "entity_id": entity_id,
-                "when": start_time.isoformat(),
-                "message": "turned on",
-                "context_user_id": "user-1",
-            }
-        ]
-
-    def call_service(
-        self,
-        domain: str,
-        service: str,
-        service_data: dict[str, object],
-    ) -> list[object]:
-        return []
-
 
 def test_ha_reader_returns_summaries() -> None:
     reader = HaReader(FakeHaClient())
@@ -87,41 +35,3 @@ def test_ha_reader_returns_summaries() -> None:
     assert domains == {"sensor", "light"}
     sensor = next(item for item in summaries if item.entity_id == "sensor.temperature")
     assert sensor.unit_of_measurement == "°C"
-    assert sensor.state == "21.5"
-    assert sensor.last_changed == datetime(2026, 6, 14, 12, 0, tzinfo=timezone.utc)
-    assert sensor.area_name == "Kueche"
-    assert sensor.device_name == "Thermometer"
-
-
-def test_ha_reader_discovers_learnable_sensors() -> None:
-    reader = HaReader(FakeHaClient())
-
-    discovered = reader.discover(learnable=True)
-
-    assert [entity.entity_id for entity in discovered] == ["sensor.temperature"]
-
-
-def test_ha_reader_normalizes_history() -> None:
-    reader = HaReader(FakeHaClient())
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-
-    history = reader.read_history(
-        ["sensor.temperature"],
-        start,
-        datetime(2026, 6, 2, tzinfo=timezone.utc),
-    )
-
-    assert history[0].entity_id == "sensor.temperature"
-    assert history[0].points[0].value == 21.5
-
-
-def test_ha_reader_normalizes_state_history_and_logbook() -> None:
-    reader = HaReader(FakeHaClient())
-    start = datetime(2026, 6, 1, tzinfo=timezone.utc)
-    end = datetime(2026, 6, 2, tzinfo=timezone.utc)
-
-    history = reader.read_state_history(["light.living_room"], start, end)
-    logbook = reader.read_logbook("light.living_room", start, end)
-
-    assert history[0].points[0].state == "21.5"
-    assert logbook[0].context_user_id == "user-1"

tests/ha/test_history.py

@@ -1,139 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timezone
-
-import pytest
-
-from app.ha.exceptions import HaUnexpectedPayloadError
-from app.ha.history import (
-    normalize_history_payload,
-    normalize_logbook_payload,
-    normalize_state_history_payload,
-)
-
-
-def test_normalize_history_payload_groups_and_sorts_numeric_states() -> None:
-    payload = [
-        [
-            {
-                "entity_id": "sensor.temperature",
-                "state": "22.5",
-                "last_changed": "2026-06-01T12:15:00+00:00",
-            },
-            {
-                "state": "21.0",
-                "last_changed": "2026-06-01T12:00:00Z",
-            },
-        ],
-        [
-            {
-                "entity_id": "sensor.humidity",
-                "state": 45,
-                "last_updated": "2026-06-01T12:00:00+00:00",
-            }
-        ],
-    ]
-
-    result = normalize_history_payload(payload)
-
-    assert [series.entity_id for series in result] == [
-        "sensor.humidity",
-        "sensor.temperature",
-    ]
-    temperature = result[1]
-    assert [point.value for point in temperature.points] == [21.0, 22.5]
-    assert temperature.points[0].timestamp == datetime(
-        2026, 6, 1, 12, 0, tzinfo=timezone.utc
-    )
-
-
-def test_normalize_history_payload_skips_non_numeric_and_non_finite_states() -> None:
-    payload = [
-        [
-            {
-                "entity_id": "sensor.temperature",
-                "state": state,
-                "last_changed": "2026-06-01T12:00:00+00:00",
-            }
-            for state in ("unknown", "unavailable", "nan", "inf", "-inf", True, None)
-        ]
-    ]
-
-    assert normalize_history_payload(payload) == []
-
-
-@pytest.mark.parametrize(
-    "payload",
-    [
-        {},
-        [{}],
-        [["invalid"]],
-        [[{"entity_id": "invalid", "state": "21", "last_changed": "2026-06-01"}]],
-        [[{"entity_id": "sensor.a", "state": "21", "last_changed": "invalid"}]],
-        [[{"state": "21", "last_changed": "2026-06-01T12:00:00+00:00"}]],
-        [
-            [
-                {
-                    "entity_id": "sensor.a",
-                    "state": "21",
-                    "last_changed": "2026-06-01T12:00:00+00:00",
-                },
-                {
-                    "entity_id": "sensor.b",
-                    "state": "22",
-                    "last_changed": "2026-06-01T12:01:00+00:00",
-                },
-            ]
-        ],
-    ],
-)
-def test_normalize_history_payload_rejects_malformed_structure(payload: object) -> None:
-    with pytest.raises(HaUnexpectedPayloadError):
-        normalize_history_payload(payload)
-
-
-def test_normalize_history_payload_accepts_empty_series() -> None:
-    assert normalize_history_payload([[]]) == []
-
-
-def test_normalize_state_history_keeps_categorical_changes() -> None:
-    result = normalize_state_history_payload(
-        [
-            [
-                {
-                    "entity_id": "light.office",
-                    "state": "off",
-                    "last_changed": "2026-06-01T08:00:00+00:00",
-                },
-                {
-                    "state": "on",
-                    "last_changed": "2026-06-01T08:05:00+00:00",
-                },
-                {
-                    "state": "on",
-                    "last_changed": "2026-06-01T08:06:00+00:00",
-                },
-            ]
-        ]
-    )
-
-    assert [point.state for point in result[0].points] == ["off", "on"]
-
-
-def test_normalize_logbook_preserves_action_origin() -> None:
-    result = normalize_logbook_payload(
-        [
-            {
-                "entity_id": "light.office",
-                "when": "2026-06-01T08:05:00+00:00",
-                "message": "turned on",
-                "context_user_id": "user-1",
-                "context_domain": "light",
-                "context_service": "turn_on",
-            }
-        ],
-        "light.office",
-    )
-
-    assert result[0].context_user_id == "user-1"
-    assert result[0].context_service == "turn_on"

tests/ml/test_evaluation.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from app.ml.evaluation import Evaluator
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.training import TrainingPipeline
-
-
-def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
-
-
-def evaluator_factory() -> Evaluator:
-    store = FeatureStore()
-    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
-    pipeline = TrainingPipeline(store)
-    pipeline.run("artifact_v1")
-    return Evaluator(pipeline)
-
-
-def test_evaluate_returns_report_with_metrics() -> None:
-    evaluator = evaluator_factory()
-    report = evaluator.evaluate(
-        "artifact_v1",
-        [
-            _vector("sensor.kitchen", 21.0),
-            _vector("sensor.bedroom", 18.5),
-        ],
-    )
-    assert report.artifact_id == "artifact_v1"
-    assert report.sample_size == 2
-    assert {metric.name for metric in report.metrics} == {"mae", "rmse", "coverage"}
-    assert next(metric.value for metric in report.metrics if metric.name == "coverage") == 1.0
-    assert next(metric.value for metric in report.metrics if metric.name == "mae") == 0.0
-
-
-def test_evaluate_without_training_raises_value_error() -> None:
-    evaluator = Evaluator(TrainingPipeline(FeatureStore()))
-    with pytest.raises(ValueError):
-        evaluator.evaluate("artifact_v1", [])
-
-
-def test_coverage_counts_only_supported_sensor_features() -> None:
-    evaluator = evaluator_factory()
-    report = evaluator.evaluate(
-        "artifact_v1",
-        [
-            _vector("sensor.kitchen", 21.0),
-            FeatureVector(sensor_id="sensor.kitchen", values={"humidity": 50.0}),
-            _vector("sensor.kitchen_extra", 20.0),
-        ],
-    )
-
-    metrics = {metric.name: metric.value for metric in report.metrics}
-    assert metrics["coverage"] == pytest.approx(1 / 3)

tests/ml/test_explanation.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from app.ml.explanation import explain_feature
-from app.ml.training import FeatureModel
-
-
-def _model(slope: float) -> FeatureModel:
-    return FeatureModel(
-        sample_count=4,
-        mean=20.0,
-        standard_deviation=1.0,
-        minimum=18.0,
-        maximum=22.0,
-        slope=slope,
-        intercept=18.5,
-    )
-
-
-def test_explain_feature_describes_rising_forecast() -> None:
-    explanation = explain_feature("temperature", 21.0, 21.5, _model(0.5))
-
-    assert explanation.direction == "steigend"
-    assert explanation.change == 0.5
-    assert explanation.historical_range == (18.0, 22.0)
-    assert "4 Messwerte" in explanation.summary
-    assert "Trend +0.500" in explanation.summary
-
-
-def test_explain_feature_describes_stable_and_falling_forecasts() -> None:
-    stable = explain_feature("humidity", 50.0, 50.0, _model(0.0))
-    falling = explain_feature("temperature", 21.0, 20.5, _model(-0.5))
-
-    assert stable.direction == "stabil"
-    assert falling.direction == "fallend"

tests/ml/test_feature_store.py

@@ -1,46 +0,0 @@
-from __future__ import annotations
-
-from app.ml.feature_store import FeatureStore, FeatureVector
-
-
-def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
-
-
-def test_append_and_latest_returns_last_vector() -> None:
-    store = FeatureStore()
-    vectors = [_vector("sensor.living_room", 20.0), _vector("sensor.living_room", 21.5)]
-    for item in vectors:
-        store.add(item)
-    assert store.latest("sensor.living_room") == vectors[-1]
-
-
-def test_latest_returns_none_when_empty() -> None:
-    store = FeatureStore()
-    assert store.latest("sensor.living_room") is None
-
-
-def test_add_batch_appends_all_vectors() -> None:
-    store = FeatureStore()
-    vectors = [
-        _vector("sensor.kitchen", 19.0),
-        _vector("sensor.kitchen", 20.0),
-        _vector("sensor.bathroom", 23.5),
-    ]
-    store.add_batch(vectors)
-    assert len(store.all()) == 3
-    latest = store.latest("sensor.kitchen")
-    assert latest is not None
-    assert latest.values["temperature"] == 20.0
-
-
-def test_different_sensors_are_stored_independently() -> None:
-    store = FeatureStore()
-    store.add(_vector("sensor.living_room", 21.0))
-    store.add(_vector("sensor.bedroom", 18.5))
-    living_room = store.latest("sensor.living_room")
-    bedroom = store.latest("sensor.bedroom")
-    assert living_room is not None
-    assert bedroom is not None
-    assert living_room.values["temperature"] == 21.0
-    assert bedroom.values["temperature"] == 18.5

tests/ml/test_model_registry.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import pytest
-
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.training import TrainedArtifact
-
-
-def test_registry_loads_persisted_artifacts_after_restart(tmp_path: Path) -> None:
-    registry = ModelRegistry(tmp_path)
-    artifact = TrainedArtifact("model-v1", ("sensor.kitchen", "sensor.bedroom"))
-    registry.register(artifact)
-
-    restarted = ModelRegistry(tmp_path)
-
-    assert restarted.load_artifact("model-v1") == artifact
-
-
-def test_registry_persists_statistical_parameters(tmp_path: Path) -> None:
-    from app.ml.feature_store import FeatureStore, FeatureVector
-    from app.ml.training import TrainingPipeline
-
-    store = FeatureStore()
-    store.add_batch(
-        [
-            FeatureVector("sensor.kitchen", {"temperature": 19.0}),
-            FeatureVector("sensor.kitchen", {"temperature": 20.0}),
-        ]
-    )
-    artifact = TrainingPipeline(store).run("model-v1")
-
-    ModelRegistry(tmp_path).register(artifact)
-
-    assert ModelRegistry(tmp_path).load_artifact("model-v1") == artifact
-
-
-def test_registry_replaces_persisted_artifact_after_restart(tmp_path: Path) -> None:
-    registry = ModelRegistry(tmp_path)
-    registry.register(TrainedArtifact("model-v1", ("sensor.kitchen",)))
-    replacement = TrainedArtifact("model-v1", ("sensor.bedroom",))
-
-    registry.register(replacement)
-
-    assert registry.load_artifact("model-v1") == replacement
-    assert ModelRegistry(tmp_path).load_artifact("model-v1") == replacement
-
-
-@pytest.mark.parametrize("artifact_id", ["../escape", "nested/model", "..", ""])
-def test_registry_rejects_unsafe_artifact_ids(tmp_path: Path, artifact_id: str) -> None:
-    registry = ModelRegistry(tmp_path)
-
-    with pytest.raises(ValueError):
-        registry.register(TrainedArtifact(artifact_id, ("sensor.kitchen",)))
-
-    assert list(tmp_path.parent.glob("escape.json")) == []
-
-
-def test_registry_rejects_corrupt_persisted_artifact(tmp_path: Path) -> None:
-    (tmp_path / "broken.json").write_text(
-        json.dumps({"artifact_id": "../broken", "supported_sensors": []}),
-        encoding="utf-8",
-    )
-
-    with pytest.raises(ValueError, match="broken.json"):
-        ModelRegistry(tmp_path)

tests/ml/test_predictor.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.predictor import Predictor
-from app.ml.training import TrainingPipeline
-
-
-def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
-
-
-def predictor() -> Predictor:
-    store = FeatureStore()
-    store.add_batch(
-        [
-            _vector("sensor.kitchen", 19.0),
-            _vector("sensor.kitchen", 20.0),
-            _vector("sensor.bedroom", 18.5),
-        ]
-    )
-    pipeline = TrainingPipeline(store)
-    pipeline.run("artifact_v1")
-    return Predictor(pipeline)
-
-
-def test_predict_returns_statistical_forecast() -> None:
-    p = predictor()
-    result = p.predict("artifact_v1", _vector("sensor.kitchen", 21.0))
-    assert result.artifact_id == "artifact_v1"
-    assert result.sensor_id == "sensor.kitchen"
-    assert result.predictions == {"temperature": 22.0}
-    assert 0.0 < result.confidence <= 1.0
-    assert result.model_type == "statistical_baseline"
-    explanation = result.explanations["temperature"]
-    assert explanation.direction == "steigend"
-    assert explanation.current_value == 21.0
-    assert explanation.predicted_value == 22.0
-    assert explanation.sample_count == 2
-
-
-def test_predict_rejects_unknown_sensor() -> None:
-    p = predictor()
-    with pytest.raises(ValueError):
-        p.predict("artifact_v1", _vector("sensor.unknown", 10.0))
-
-
-def test_predict_batch_matches_single_calls() -> None:
-    p = predictor()
-    entities = [_vector("sensor.kitchen", 21.0), _vector("sensor.bedroom", 19.0)]
-    assert p.predict_batch("artifact_v1", entities) == [
-        p.predict("artifact_v1", item) for item in entities
-    ]
-
-
-def test_default_artifact_returns_last_registered() -> None:
-    store = FeatureStore()
-    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
-    pipeline = TrainingPipeline(store)
-    pipeline.run("first")
-    pipeline.run("second")
-    assert Predictor.default_artifact(pipeline).artifact_id == "second"

tests/ml/test_retraining.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from app.ml.feature_store import FeatureVector
-from app.ml.registry.model_registry import ModelRegistry
-from app.ml.retraining import RetrainingService, retrain_model
-
-
-def _vector(sensor_id: str) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": 21.0})
-
-
-def test_retraining_registers_new_artifact(tmp_path: Path) -> None:
-    registry = ModelRegistry(tmp_path)
-
-    result = retrain_model(registry, "home-model", [_vector("sensor.kitchen")])
-
-    assert result.replaced is False
-    assert registry.load_artifact("home-model") == result.artifact
-
-
-def test_retraining_replaces_existing_artifact(tmp_path: Path) -> None:
-    registry = ModelRegistry(tmp_path)
-    service = RetrainingService(registry)
-    service.retrain("home-model", [_vector("sensor.kitchen")])
-
-    result = service.retrain("home-model", [_vector("sensor.bedroom")])
-
-    assert result.replaced is True
-    assert result.artifact.supported_sensors == ("sensor.bedroom",)
-    assert ModelRegistry(tmp_path).load_artifact("home-model") == result.artifact
-
-
-def test_retraining_rejects_empty_training_data(tmp_path: Path) -> None:
-    with pytest.raises(ValueError, match="keine Trainingsdaten"):
-        retrain_model(ModelRegistry(tmp_path), "home-model", [])

tests/ml/test_training.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.training import TrainingPipeline
-
-
-def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
-
-
-def store_with_data() -> TrainingPipeline:
-    store = FeatureStore()
-    store.add_batch(
-        [
-            _vector("sensor.kitchen", 19.0),
-            _vector("sensor.kitchen", 20.0),
-            _vector("sensor.bedroom", 18.5),
-        ]
-    )
-    return TrainingPipeline(store)
-
-
-def test_run_returns_trained_artifact() -> None:
-    pipeline = store_with_data()
-    artifact = pipeline.run("artifact_v1")
-    assert artifact.artifact_id == "artifact_v1"
-    assert artifact.supported_sensors == ("sensor.bedroom", "sensor.kitchen")
-    kitchen = artifact.feature_models["sensor.kitchen"]["temperature"]
-    assert kitchen.sample_count == 2
-    assert kitchen.mean == 19.5
-    assert kitchen.slope == 1.0
-    assert kitchen.forecast() == 21.0
-
-
-def test_run_without_data_raises_value_error() -> None:
-    pipeline = TrainingPipeline(FeatureStore())
-    with pytest.raises(ValueError):
-        pipeline.run("artifact_v1")
-
-
-def test_export_returns_registered_artifact() -> None:
-    pipeline = store_with_data()
-    pipeline.run("artifact_v1")
-    exported = pipeline.export("artifact_v1")
-    assert exported == pipeline.export("artifact_v1")
-
-
-def test_export_missing_artifact_raises_key_error() -> None:
-    pipeline = store_with_data()
-    with pytest.raises(KeyError):
-        pipeline.export("artifact_v1")

tests/ml/test_training_evaluation.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from app.ml.evaluation import Evaluator, EvalReport, Metric
-from app.ml.feature_store import FeatureStore, FeatureVector
-from app.ml.training import TrainingPipeline
-
-
-def _vector(sensor_id: str, temperature: float, label: str | None = None) -> FeatureVector:
-    return FeatureVector(sensor_id=sensor_id, values={"temperature": temperature}, label=label)
-
-
-def test_end_to_end_training_then_evaluation() -> None:
-    store = FeatureStore()
-    store.add_batch([_vector("sensor.kitchen", 19.0), _vector("sensor.bedroom", 18.5)])
-    pipeline = TrainingPipeline(store)
-    artifact = pipeline.run("artifact_v1")
-
-    evaluator = Evaluator(pipeline)
-    samples = [
-        _vector("sensor.kitchen", 21.0),
-        _vector("sensor.bedroom", 18.5),
-    ]
-    report = evaluator.evaluate(artifact.artifact_id, samples)
-    assert isinstance(report, EvalReport)
-    assert report.sample_size == len(samples)
-    assert any(metric.name == "coverage" for metric in report.metrics)
-
-
-def test_metric_helpers_are_serializable() -> None:
-    metric = Metric(name="mae", value=0.85, threshold=1.0)
-    assert metric.name == "mae"
-    assert metric.value == 0.85
-    assert metric.threshold == 1.0

tests/rules/test_heating.py

@@ -1,64 +1,48 @@
 from __future__ import annotations
 
-import pytest
-
 from app.ha.models import HaEntitySummary
 from app.rules.heating import HeatingRule
+from app.rules.recommender import Recommender
 
 
-def _entity(entity_id: str, domain: str, device_class: str | None = None) -> HaEntitySummary:
-    return HaEntitySummary(entity_id=entity_id, domain=domain, device_class=device_class)
+def _sensor(entity_id: str, device_class: str | None = None) -> HaEntitySummary:
+    return HaEntitySummary(entity_id=entity_id, domain="sensor", device_class=device_class)
 
 
-# --- positive cases --------------------------------------------------------
-@pytest.mark.parametrize(
-    "entity",
-    [
-        _entity("climate.living_room", "climate"),
-        _entity("sensor.temperature_living", "sensor", "temperature"),
-        _entity("sensor.humidity_bathroom", "sensor", "humidity"),
-        _entity("binary_sensor.living_room_occupancy", "binary_sensor", "occupancy"),
-        _entity("binary_sensor.entrance_presence", "binary_sensor", "presence"),
-    ],
-    ids=lambda e: e.entity_id,
-)
-def test_heating_rule_triggers_for_relevant_entities(entity: HaEntitySummary) -> None:
+def _binary_sensor(entity_id: str, device_class: str | None = None) -> HaEntitySummary:
+    return HaEntitySummary(
+        entity_id=entity_id,
+        domain="binary_sensor",
+        device_class=device_class,
+    )
+
+
+def _climate(entity_id: str) -> HaEntitySummary:
+    return HaEntitySummary(entity_id=entity_id, domain="climate")
+
+
+def test_heating_rule_triggers() -> None:
     rule = HeatingRule()
-    assert rule.matches([entity]) is True
+    assert rule.matches([_climate("climate.living_room")])
+    assert rule.matches([_sensor("sensor.temperature_living", device_class="temperature")])
+    assert rule.matches([_sensor("sensor.humidity_bath", device_class="humidity")])
+    assert rule.matches([_binary_sensor("binary_sensor.occupancy_living", "occupancy")])
+    assert rule.matches([_binary_sensor("binary_sensor.presence_entry", "presence")])
 
 
-# --- negative cases -------------------------------------------------------
-@pytest.mark.parametrize(
-    "entity",
-    [
-        _entity("sensor.power_consumption", "sensor", "power"),
-        _entity("sensor.door", "sensor", "door"),
-        _entity("sensor.energy", "sensor", "energy"),
-        _entity("binary_sensor.door_window", "binary_sensor", "door"),
-        _entity("binary_sensor.motion", "binary_sensor", "motion"),
-        _entity("light.living_room", "light"),
-        _entity("switch.plug", "switch"),
-        _entity("sensor.some_random", "sensor"),
-        _entity("binary_sensor.some_binary", "binary_sensor"),
-    ],
-    ids=lambda e: e.entity_id,
-)
-def test_heating_rule_ignores_non_heating_entities(entity: HaEntitySummary) -> None:
+def test_heating_rule_ignores_non_relevant_sensors() -> None:
     rule = HeatingRule()
-    assert rule.matches([entity]) is False
+    assert not rule.matches([_sensor("sensor.temperature_living")])
+    assert not rule.matches([_sensor("sensor.power", device_class="power")])
+    assert not rule.matches([_sensor("sensor.voltage", device_class="voltage")])
+    assert not rule.matches([_sensor("sensor.door", device_class="door")])
+    assert not rule.matches([_sensor("sensor.window", device_class="window")])
+    assert not rule.matches([_sensor("sensor.light", device_class="illuminance")])
+    assert not rule.matches([_binary_sensor("binary_sensor.window", device_class="window")])
 
 
-def test_heating_rule_mixed_list_returns_true() -> None:
-    rule = HeatingRule()
-    entities = [
-        _entity("sensor.power", "sensor", "power"),
-        _entity("climate.living_room", "climate"),
-        _entity("light.ceiling", "light"),
+def test_recommender_uses_rule() -> None:
+    recommender = Recommender(rules=[HeatingRule()])
+    assert recommender.run([_climate("climate.living_room")]) == [
+        "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
     ]
-    assert rule.matches(entities) is True
-
-
-def test_heating_rule_recommendation_is_stable() -> None:
-    rule = HeatingRule()
-    expected = "Prüfe Heizungsregelung: Aktiviere energiesparenden Modus bei Abwesenheit."
-    assert rule.recommendation([_entity("climate.living_room", "climate")]) == expected

tests/test_addon_config.py

@@ -1,18 +0,0 @@
-from pathlib import Path
-
-
-def test_addon_does_not_expose_internal_learning_parameters() -> None:
-    config = Path("addon/config.yaml").read_text(encoding="utf-8")
-
-    assert "\noptions:" not in config
-    assert "\nschema:" not in config
-    assert "prediction_confidence" not in config
-    assert "execution_cooldown_seconds" not in config
-
-
-def test_addon_version_invalidates_application_build_layer() -> None:
-    dockerfile = Path("addon/Dockerfile").read_text(encoding="utf-8")
-
-    config_copy = dockerfile.index("COPY config.yaml /tmp/addon-config.yaml")
-    repository_clone = dockerfile.index("git clone --depth 1 --branch main")
-    assert config_copy < repository_clone

tests/test_config.py

@@ -1,42 +0,0 @@
-from __future__ import annotations
-
-from pytest import MonkeyPatch
-
-from app.config import load_settings
-
-
-def test_load_settings_reads_documented_environment(monkeypatch: MonkeyPatch) -> None:
-    monkeypatch.setenv("SILLYHOME_HA_URL", "http://ha.local:8123")
-    monkeypatch.setenv("SILLYHOME_HA_TOKEN", "secret")
-    monkeypatch.setenv("SILLYHOME_MODEL_STORE", "/tmp/models")
-    monkeypatch.setenv("SILLYHOME_AUTOMATION_STORE", "/tmp/automations")
-    monkeypatch.setenv("SILLYHOME_ACTUATOR_STORE", "/tmp/actuators")
-    monkeypatch.setenv("SILLYHOME_HISTORY_DAYS", "7")
-    monkeypatch.setenv("SILLYHOME_MIN_TRAINING_POINTS", "12")
-    monkeypatch.setenv("SILLYHOME_RETRAIN_STALE_HOURS", "48")
-    monkeypatch.setenv("SILLYHOME_RECONCILE_INTERVAL_SECONDS", "600")
-    monkeypatch.setenv("SILLYHOME_MIN_BEHAVIOR_ACTIONS", "4")
-    monkeypatch.setenv("SILLYHOME_PREDICTION_CONFIDENCE", "0.9")
-    monkeypatch.setenv("SILLYHOME_PREDICTION_WINDOW_MINUTES", "20")
-    monkeypatch.setenv("SILLYHOME_PREDICTION_INTERVAL_SECONDS", "45")
-    monkeypatch.setenv("SILLYHOME_EXECUTION_COOLDOWN_SECONDS", "1200")
-    monkeypatch.setenv("SILLYHOME_TIMEZONE", "Europe/Berlin")
-
-    settings = load_settings()
-
-    assert settings.ha_url == "http://ha.local:8123"
-    assert settings.ha_token == "secret"
-    assert settings.model_store == "/tmp/models"
-    assert settings.automation_store == "/tmp/automations"
-    assert settings.actuator_store == "/tmp/actuators"
-    assert settings.history_days == 7
-    assert settings.min_training_points == 12
-    assert settings.retrain_stale_hours == 48
-    assert settings.reconcile_interval_seconds == 600
-    assert settings.min_behavior_actions == 4
-    assert settings.prediction_confidence == 0.9
-    assert settings.prediction_window_minutes == 20
-    assert settings.prediction_interval_seconds == 45
-    assert settings.execution_cooldown_seconds == 1200
-    assert settings.timezone == "Europe/Berlin"
-    assert settings.ha_configured

tests/test_dashboard.py

@@ -1,26 +0,0 @@
-from fastapi.testclient import TestClient
-
-from app.main import app
-
-
-def test_dashboard_is_served_at_root() -> None:
-    with TestClient(app) as client:
-        response = client.get("/")
-
-    assert response.status_code == 200
-    assert "SillyHome Next" in response.text
-    assert "So gehst du vor" in response.text
-    assert "Gerät zum Lernen auswählen" in response.text
-    assert "Wie gewohnt bedienen" in response.text
-    assert "Ohne deine spätere Freigabe wird nichts geschaltet" in response.text
-    assert "Du wählst keine Sensoren und erstellst keine Regeln" in response.text
-    assert "Freigabe noch gesperrt" in response.text
-    assert "Bediene das Licht dafür direkt über Home Assistant" in response.text
-    assert "Davon erkannte HA-Automationen" in response.text
-    assert "Aktuelle Situation auswerten" in response.text
-    assert "Die Prüfung simuliert keinen Sensorwechsel" in response.text
-    assert "Kein frischer passender Sensorwechsel erkannt" in response.text
-    assert "Vorhersage jetzt prüfen" not in response.text
-    assert 'record.behavior.status === "trained" && missingUserActions === 0' in response.text
-    assert "Automation-Entwurf" not in response.text
-    assert "Manuelle Overrides" not in response.text