boxwart: Update-Verlauf zeigt das echte Ergebnis je Baustein, festgehaltene Bausteine sichtbar

Der Verlauf las bisher nur den Hermes-Cron-Status ("Skript lief") und zeigte die
Laeufe vom 06. und 13.09. als "durchgelaufen", obwohl dort zurueckgerollt und
festgehalten wurde; ein abgebrochener Lauf stand als "laeuft" da. Jetzt kommt der
Verlauf aus dem Meldeprotokoll (~/mc2-notify.log), also aus dem, was autoupdate.sh
selbst je Baustein meldet.

Festgehaltene Bausteine (Pin-Register) werden zum Waechter-Hinweis mit Knopf
"Freigeben", auf der Updates-Seite markiert und in der Updates-Lampe gezaehlt.
Hermes zeigt seine laufende Version und die Zahl der neuen Aenderungen.

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

backend/services/maintenance.py

@@ -11,6 +11,7 @@ import re
 import subprocess
 import time
 from datetime import datetime
+from pathlib import Path
 
 import httpx
 import psutil
@@ -513,6 +514,16 @@ def _summarize_hermes_commits(commits: list[dict]) -> dict:
     return _summarize_release("hermes", commits[0]["hash"] if commits else "", context, subjects)
 
 
+def _hermes_version(path: str) -> str | None:
+    """Versionsnummer aus der pyproject.toml des Hermes-Checkouts (z. B. „0.21.3“)."""
+    try:
+        text = (Path(path) / "pyproject.toml").read_text(encoding="utf-8")
+    except OSError:
+        return None
+    m = re.search(r'^version\s*=\s*"([^"]+)"', text, re.MULTILINE)
+    return m.group(1) if m else None
+
+
 def hermes_update_details() -> dict:
     """Commits, die ein Hermes-Update einspielen würde (HEAD..origin/<branch>) + LLM-Zusammenfassung."""
     info: dict = {"kind": "hermes", "branch": None, "behind": 0, "commits": []}
@@ -536,6 +547,7 @@ def hermes_update_details() -> dict:
                 commits.append({"hash": parts[0], "subject": parts[1], "when": parts[2]})
         info["commits"] = commits
         info["behind"] = len(commits)
+        info["installed_version"] = _hermes_version(path)
         if commits:
             info.update(_summarize_hermes_commits(commits))
     except Exception as exc:

backend/services/update_verlauf.py

@@ -0,0 +1,231 @@
+"""
+Update-Verlauf und festgehaltene Bausteine (Box-Wart, Umbau 09/2026).
+
+Was ein Update-Lauf wirklich gebracht hat, steht nicht im Hermes-Cron-Status — der sagt nur
+„Skript lief". Die Wahrheit ist das, was deploy/autoupdate.sh am Ende meldet: eine Zeile je
+Baustein („255 → 256 eingespielt", „zurückgerollt + GEPINNT" …). notify.sh schreibt jede
+Meldung mit Zeitstempel in ~/mc2-notify.log; der Verlauf wird von dort gelesen, nur lesend.
+
+Das Pin-Register (/srv/models/mc2-pins.json) führt autoupdate.sh: Besteht ein Update den Check
+nicht, wird zurückgerollt und der Baustein festgehalten — künftige Sonntage überspringen ihn.
+Vom 06. bis 17.09.2026 hat das niemand gesehen, die Box bekam elf Tage keine Updates. Darum
+zeigt der Wächter jeden festgehaltenen Baustein als Hinweis, und hier lässt er sich freigeben.
+"""
+
+import json
+import os
+import re
+import threading
+from datetime import datetime
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+LOCAL_TZ = ZoneInfo(os.environ.get("MC_LOCAL_TZ", "Europe/Berlin"))
+NOTIFY_LOG = Path(os.environ.get("MC_NOTIFY_LOG", str(Path.home() / "mc2-notify.log")))
+PINS_FILE = Path(os.environ.get("MC_PINS_FILE", "/srv/models/mc2-pins.json"))
+LESE_MAX = 3_000_000          # Bytes vom Ende des Protokolls — reicht für Monate
+LAUF_LUECKE_S = 45 * 60       # Meldungen mit größerem Abstand gehören zu verschiedenen Läufen
+
+NAMEN = {"swap": "llama-swap", "engine": "Motor (llama.cpp)", "hermes": "Hermes"}
+FREIGEGEBEN_TEXT = "Freigegeben. Der nächste Sonntags-Lauf versucht das Update erneut."
+
+# So heißen die Bausteine in den Meldungen von autoupdate.sh → kurzer Name fürs Cockpit.
+_BAUSTEIN_IM_TEXT = (
+    (re.compile(r"Router \(llama-swap\)"), "llama-swap"),
+    (re.compile(r"Engine \(llama\.cpp\)"), "Motor"),
+    (re.compile(r"Hermes(-Agent)?\b"), "Hermes"),
+)
+
+# Kopfzeile eines Protokolleintrags (notify.sh): Zeitstempel, Zustellweg, Nachricht.
+_EINTRAG = re.compile(
+    r"^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) "
+    r"(?:OK telegram|QUEUED für Morgen-Digest|FALLBACK \(.*?\)): ?(.*)$")
+
+_ZUSAMMENFASSUNG = re.compile(r"Wochenpflege der Box ist durch")
+_UPDATE_MELDUNG = re.compile(
+    r"^(KRITISCH: )?(Router \(llama-swap\)|Engine \(llama\.cpp\)|Hermes-Agent|Hermes)[ -](aktualisiert|Update)"
+    r"|^Auto-Update abgebrochen|^Sonntags-Update")
+_NEUSTART = re.compile(r"^Die Box startet jetzt neu|^Neustart (NICHT|verschoben|FEHLGESCHLAGEN)")
+
+# Einordnung einer Ergebniszeile. Reihenfolge zählt: „zurückgerollt + GEPINNT“ ist ein Rückbau,
+# „Check fehlgeschlagen“ ist offen und kein Stack-Schaden.
+_EINORDNUNG = (
+    ("fehler", re.compile(r"kritisch", re.IGNORECASE)),
+    ("zurueckgerollt", re.compile(r"zurückgerollt", re.IGNORECASE)),
+    ("festgehalten", re.compile(r"gepinnt", re.IGNORECASE)),
+    ("offen", re.compile(r"wartet|unklar|check fehlgeschlagen|job-start|nicht ausgefuehrt|verschoben",
+                         re.IGNORECASE)),
+    ("fehler", re.compile(r"fehlgeschlagen|abgebrochen|ausgefallen|mit fehler", re.IGNORECASE)),
+    ("neustart", re.compile(r"startet jetzt neu", re.IGNORECASE)),
+    ("eingespielt", re.compile(r"eingespielt|aktualisiert|repariert", re.IGNORECASE)),
+    ("aktuell", re.compile(r"aktuell", re.IGNORECASE)),
+)
+STUFE_DER_ZEILE = {"fehler": "rot", "zurueckgerollt": "gelb", "festgehalten": "gelb", "offen": "gelb",
+                   "neustart": "info", "eingespielt": "gruen", "aktuell": "grau"}
+_RANG = {"rot": 4, "gelb": 3, "gruen": 2, "info": 1, "grau": 0}
+
+_cache_lock = threading.Lock()
+_cache: dict = {"schluessel": None, "laeufe": []}
+
+
+# --- Protokoll lesen ----------------------------------------------------------------
+
+def eintraege(text: str) -> list[tuple[datetime, str]]:
+    """Protokoll → (Zeitpunkt, Nachricht). Zeilen ohne Zeitstempel gehören zur Nachricht davor
+    (mehrzeilige Meldungen wie die Wochen-Zusammenfassung oder die Nachrichten-Übersicht)."""
+    ergebnis: list[tuple[datetime, str]] = []
+    for zeile in text.splitlines():
+        if m := _EINTRAG.match(zeile):
+            try:
+                zeit = datetime.strptime(m.group(1), "%Y-%m-%d %H:%M:%S").replace(tzinfo=LOCAL_TZ)
+            except ValueError:
+                continue
+            ergebnis.append((zeit, m.group(2)))
+        elif ergebnis:
+            zeit, bisher = ergebnis[-1]
+            ergebnis[-1] = (zeit, f"{bisher}\n{zeile}")
+    return ergebnis
+
+
+def _einordnen(text: str) -> str:
+    return next((art for art, muster in _EINORDNUNG if muster.search(text)), "offen")
+
+
+def _baustein_aus(text: str) -> str:
+    return next((name for muster, name in _BAUSTEIN_IM_TEXT if muster.search(text)), "Update-Lauf")
+
+
+def _lesbar(text: str) -> str:
+    """Meldungstext fürs Cockpit: Fachwörter der Skripte in Alltagssprache."""
+    text = re.sub(r"\s*\+\s*GEPINNT", " und festgehalten", text)
+    text = re.sub(r"gepinnt, übersprungen", "festgehalten, übersprungen", text, flags=re.IGNORECASE)
+    text = text.replace("GEPINNT", "festgehalten").replace("FEHLGESCHLAGEN", "fehlgeschlagen")
+    text = re.sub(r"\b(\d+) Commits\b", r"\1 Änderungen", text)
+    return text.strip()[:240]
+
+
+def _zeile(baustein: str, text: str) -> dict:
+    ergebnis = _einordnen(text)
+    return {"baustein": baustein, "ergebnis": ergebnis, "stufe": STUFE_DER_ZEILE[ergebnis], "text": _lesbar(text)}
+
+
+def _lauf(gruppe: list[tuple[datetime, str]]) -> dict:
+    zusammenfassung = next((t for _, t in reversed(gruppe) if _ZUSAMMENFASSUNG.search(t)), None)
+    zeilen: list[dict] = []
+    if zusammenfassung:
+        for z in zusammenfassung.splitlines()[1:]:
+            if m := re.match(r"^\s*•\s*(.+?):\s*(.+)$", z):
+                zeilen.append(_zeile(_baustein_aus(m.group(1)), m.group(2)))
+    for _, text in gruppe:
+        erste = text.splitlines()[0] if text else ""
+        if _NEUSTART.search(erste):
+            zeilen.append(_zeile("Neustart", erste))
+        elif erste.startswith(("Sonntags-Update", "Auto-Update abgebrochen")):
+            zeilen.append(_zeile("Update-Lauf", erste))
+        elif not zusammenfassung and _UPDATE_MELDUNG.search(erste):
+            # Ohne Abschlussmeldung (Lauf abgebrochen) sind die Einzelmeldungen alles, was es gibt.
+            zeilen.append(_zeile(_baustein_aus(erste), re.sub(r"^KRITISCH:\s*", "Kritisch: ", erste)))
+
+    stufe = max((z["stufe"] for z in zeilen), key=lambda s: _RANG[s], default="grau")
+    arten = {z["ergebnis"] for z in zeilen}
+    if stufe == "rot":
+        titel = "Fehler"
+    elif stufe == "gelb":
+        titel = ("Zurückgerollt" if "zurueckgerollt" in arten
+                 else "Festgehalten" if "festgehalten" in arten else "Unvollständig")
+    elif stufe == "gruen":
+        titel = "Eingespielt"
+    elif stufe == "info":
+        titel = "Neu gestartet"
+    else:
+        titel = "Alles aktuell"
+    start, ende = gruppe[0][0], gruppe[-1][0]
+    sonntag = start.weekday() == 6 and 4 <= start.hour < 6
+    return {"start": start.isoformat(), "ende": ende.isoformat(),
+            "anlass": "Updates am Sonntag" if sonntag else "Update von Hand",
+            "stufe": stufe, "titel": titel, "zeilen": zeilen}
+
+
+def laeufe_aus(text: str) -> list[dict]:
+    """Alle Update-Läufe im Protokolltext, neueste zuerst."""
+    relevant = [(z, t) for z, t in eintraege(text)
+                if _ZUSAMMENFASSUNG.search(t) or _UPDATE_MELDUNG.search(t.splitlines()[0] if t else "")
+                or _NEUSTART.search(t.splitlines()[0] if t else "")]
+    gruppen: list[list[tuple[datetime, str]]] = []
+    for eintrag in relevant:
+        if gruppen and (eintrag[0] - gruppen[-1][-1][0]).total_seconds() <= LAUF_LUECKE_S:
+            gruppen[-1].append(eintrag)
+        else:
+            gruppen.append([eintrag])
+    # Ein Neustart allein ist kein Update-Lauf (z. B. von Hand ausgelöst).
+    laeufe = [_lauf(g) for g in gruppen if any(not _NEUSTART.search(t.splitlines()[0]) for _, t in g)]
+    return list(reversed(laeufe))
+
+
+def _protokoll_ende() -> str:
+    try:
+        with NOTIFY_LOG.open("rb") as f:
+            f.seek(0, os.SEEK_END)
+            groesse = f.tell()
+            f.seek(max(0, groesse - LESE_MAX))
+            roh = f.read()
+    except OSError:
+        return ""
+    text = roh.decode("utf-8", errors="replace")
+    if groesse > LESE_MAX:
+        text = text.split("\n", 1)[-1]   # angeschnittene erste Zeile verwerfen
+    return text
+
+
+def laeufe(anzahl: int = 8) -> list[dict]:
+    """Die letzten Update-Läufe (neueste zuerst). Neu gelesen nur, wenn das Protokoll wuchs."""
+    try:
+        st = NOTIFY_LOG.stat()
+        schluessel = (st.st_mtime_ns, st.st_size)
+    except OSError:
+        return []
+    with _cache_lock:
+        if _cache["schluessel"] != schluessel:
+            _cache["laeufe"] = laeufe_aus(_protokoll_ende())
+            _cache["schluessel"] = schluessel
+        return _cache["laeufe"][:anzahl]
+
+
+# --- Festgehaltene Bausteine (Pin-Register von autoupdate.sh) -----------------------
+
+def _pins_lesen() -> dict:
+    try:
+        daten = json.loads(PINS_FILE.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return daten if isinstance(daten, dict) else {}
+
+
+def festgehalten() -> list[dict]:
+    """Bausteine, die der Sonntags-Lauf nach einem gescheiterten Update überspringt."""
+    ergebnis = []
+    for baustein, eintrag in _pins_lesen().items():
+        if not (isinstance(eintrag, dict) and eintrag.get("pinned")):
+            continue
+        datum = str(eintrag.get("datum") or "")
+        m = re.fullmatch(r"\d{4}-(\d{2})-(\d{2})", datum)
+        seit = f"{m.group(2)}.{m.group(1)}." if m else (datum or "?")
+        ergebnis.append({"baustein": baustein, "name": NAMEN.get(baustein, baustein),
+                         "version": str(eintrag.get("version") or "?"), "seit": seit,
+                         "grund": _lesbar(str(eintrag.get("grund") or ""))})
+    return ergebnis
+
+
+def freigeben(baustein: str) -> bool:
+    """Pin lösen (atomar schreiben). False, wenn der Baustein gar nicht festgehalten war."""
+    daten = _pins_lesen()
+    if baustein not in daten:
+        return False
+    daten.pop(baustein)
+    tmp = PINS_FILE.with_suffix(".tmp")
+    try:
+        tmp.write_text(json.dumps(daten, ensure_ascii=False, indent=2), encoding="utf-8")
+        os.replace(tmp, PINS_FILE)
+    except OSError:
+        return False
+    return True

backend/services/waechter.py

@@ -10,6 +10,7 @@ gesehen. Dieser Wächter schaut deshalb breiter hin:
   • Hermes-Jobs  Status der Cron-Jobs + Werkzeugfehler im letzten Lauf (errors.log)
   • Kern         Engine, Hirn, Hermes, Hör-Dienst, MC2, Gateway antworten per HTTP
   • Platte       Füllstand des Modell-Laufwerks
+  • Updates      Bausteine, die der Sonntags-Lauf nach einem Fehlschlag festhält
 
 Jeder Befund wird zum Hinweis mit Stufe (rot = jetzt, gelb = bei Gelegenheit), Beginn und
 Knöpfen. Einfaches behebt er selbst (User-Entscheid 23.09.): Ein ABGESTÜRZTER Dienst
@@ -43,7 +44,7 @@ import httpx
 import psutil
 from config import HERMES_API_KEY, HERMES_API_URL, HERMES_HOME, MODELS_DIR, VOICE_SERVICE_URL
 
-from services import announce, llamaswap, maintenance
+from services import announce, llamaswap, maintenance, update_verlauf
 
 log = logging.getLogger(__name__)
 
@@ -246,28 +247,6 @@ def _letzter_lauf(job_id: str) -> dict | None:
     return {"status": row[0], "started_at": row[1], "finished_at": row[2], "error": row[3]}
 
 
-def update_laeufe(anzahl: int = 8) -> list[dict]:
-    """Letzte Läufe aller Update-Jobs (Name enthält „update“), neueste zuerst."""
-    ids = {str(j.get("id")): str(j.get("name", "")) for j in _hermes_jobs()
-           if "update" in str(j.get("name", "")).lower()}
-    if not ids or not HERMES_EXEC_DB.exists():
-        return []
-    platz = ",".join("?" * len(ids))
-    try:
-        con = sqlite3.connect(f"file:{HERMES_EXEC_DB}?mode=ro", uri=True, timeout=2)
-        try:
-            rows = con.execute(
-                f"select job_id, status, started_at, finished_at, error from executions "
-                f"where job_id in ({platz}) order by started_at desc limit ?",
-                (*ids, anzahl)).fetchall()
-        finally:
-            con.close()
-    except sqlite3.Error:
-        return []
-    return [{"job": ids.get(r[0], r[0]), "status": r[1], "start": r[2], "ende": r[3],
-             "fehler": (r[4] or None)} for r in rows]
-
-
 def werkzeugfehler_im_lauf(zeilen: list[str], job_id: str, start_iso: str) -> tuple[int, str]:
     """Zählt 'Tool X returned error'-Zeilen eines Laufs in errors.log. Hermes markiert jede
     Zeile mit [cron_<job>_<JJJJMMTT>_<HHMMSS>]; der Tag des Laufstarts reicht zur Zuordnung."""
@@ -389,7 +368,20 @@ def pruefe_platte() -> list[Befund]:
                    quelle="platte", sofort=True)]
 
 
-PRUEFUNGEN = (pruefe_dienste, pruefe_timer_dienste, pruefe_hermes_jobs, pruefe_kern, pruefe_platte)
+def pruefe_festgehalten() -> list[Befund]:
+    """Festgehaltene Bausteine (Pin-Register von autoupdate.sh). Vom 06. bis 17.09.2026 hielt
+    die Box Motor und Hermes fest, ohne dass es jemand sah — elf Tage ohne Updates."""
+    return [Befund(id=f"pin:{p['baustein']}", stufe="gelb",
+                   titel=f"{p['name']} bekommt keine Updates mehr",
+                   text=(f"Seit {p['seit']} auf {p['version']} festgehalten: {p['grund']}. "
+                         "Der Sonntags-Lauf überspringt ihn, bis du ihn freigibst."),
+                   quelle="updates", sofort=True,
+                   aktionen=[_aktion("freigeben", "Freigeben", baustein=p["baustein"])])
+            for p in update_verlauf.festgehalten()]
+
+
+PRUEFUNGEN = (pruefe_dienste, pruefe_timer_dienste, pruefe_hermes_jobs, pruefe_kern, pruefe_platte,
+              pruefe_festgehalten)
 
 
 # --- Zustand, Takt, Selbstreparatur -----------------------------------------------
@@ -564,6 +556,10 @@ def fuehre_aktion_aus(hinweis_id: str, aktion_id: str) -> dict:
         if aktion.get("job"):
             return _job_protokoll(aktion["job"])
         return maintenance.logs(aktion["dienst"], lines=120)
+    if aktion_id == "freigeben":
+        if not update_verlauf.freigeben(aktion["baustein"]):
+            return {"ok": False, "detail": "Der Baustein war schon freigegeben."}
+        return {"ok": True, "text": update_verlauf.FREIGEGEBEN_TEXT}
     if aktion_id == "job-wiederholen":
         try:
             r = subprocess.run(["hermes", "cron", "run", aktion["job"]],