UMBAU v3 P3a handgebaut: SSE-Eventstrom /api/events (Invalidation-Bus)

User-Entscheid 15.07. abends: P3-Worker-Jobs abgebrochen (22 Anlaeufe,
0 Ergebnisse) - 'du bearbeitest sie ein letztes Mal manuell'.

P3a KOMPLETT: backend/routers/events.py streamt SSE; ein Sammler prueft
alle 3 s billige Fingerabdruecke (Briefkasten-Cursor, Queue-Status,
Auftragsbuch-/Reminder-mtimes) und schickt bei Aenderung 'invalidate'
mit den React-Query-Keys. frontend/src/lib/events.ts haelt EIN
EventSource, invalidiert gezielt und entspannt die vier gedeckten
Poller x5 (relax() in queries.ts); reisst der Strom, reconnectet
EventSource selbst und die UI pollt wie bisher. Live-Graphen bleiben
bewusst beim Polling (aendern sich jede Sekunde).

P3b (TanStack Router) BEWUSST NICHT umgesetzt: Hash-Navigation liefert
Deep-Links + Zuruecktaste bereits; Router-Migration = hohes Regressions-
risiko ueber alle Views bei minimalem Gewinn fuer 1-Nutzer-LAN (gleiche
Logik wie das React-bleibt-Verdikt in UMBAUPLAN 3b).
P3c (OpenAPI-Typen) VERTAGT: ohne Pydantic-response_models liefert der
Generator leere Typen - Voraussetzung ist erst das Backend-Typing
(eigene, klein geschnittene Karten-Serie).

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

backend/app.py

@@ -1,172 +1,174 @@
-"""
-Mission Control 2.0 — dünner FastAPI-Einstieg.
-
-Hängt die Router ein, liefert (in Prod) das gebaute React-Frontend aus und
-setzt eine no-cache-Middleware. Im Dev läuft das Frontend über den Vite-Dev-
-Server (proxyt /api hierher), daher CORS für localhost offen.
-"""
-
-import asyncio
-import logging
-import os
-from contextlib import asynccontextmanager
-from typing import Any, AsyncGenerator, Awaitable, Callable
-
-import httpx
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-from starlette.requests import Request
-
-from config import FRONTEND_DIST, V1_UPSTREAM, VERSION
-from routers import (
-    agent,
-    auftragsbuch,
-    chronik,
-    connect,
-    console,
-    eigenleben,
-    gateway_proxy,
-    health,
-    hermes_ui,
-    ideen,
-    maintenance,
-    memory,
-    models,
-    routing,
-    system,
-    voice,
-    wissen,
-    zeitmaschine,
-)
-from routers import reminders as reminders_router
-from services import memory as memory_svc
-from services import reminders, sentry, warmer
-
-# Zentrales Logging — Level via MC_LOG_LEVEL (INFO default). Eine Konfiguration
-# für alle Module (logging.getLogger(__name__)).
-logging.basicConfig(
-    level=os.environ.get("MC_LOG_LEVEL", "INFO").upper(),
-    format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
-)
-log = logging.getLogger(__name__)
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-    """Hintergrund-Tasks an den App-Lebenszyklus binden: Re-Warm-Wächter fürs Agent-Hirn
-    + Health-Wächter (meldet Ausfälle/Erholung in den Lucy-Briefkasten und auf Telegram)."""
-    tasks: list[asyncio.Task[Any]] = []
-    if warmer.ENABLED:
-        tasks.append(asyncio.create_task(warmer.rewarm_loop()))
-        log.info(
-            "Hirn-Re-Warm-Wächter aktiv (Intervall %ss, Hirn dynamisch aus Hermes-Config)",
-            warmer.INTERVAL,
-        )
-    if sentry.ENABLED:
-        tasks.append(asyncio.create_task(sentry.sentry_loop()))
-    tasks.append(asyncio.create_task(reminders.reminders_loop()))
-    if memory_svc.AUTO_DEDUPE_ENABLED:
-        tasks.append(asyncio.create_task(memory_svc.auto_dedupe_loop()))
-        log.info(
-            "Mem0-Auto-Dedupe aktiv (alle %ss, Schwelle %s)",
-            memory_svc.AUTO_DEDUPE_INTERVAL,
-            memory_svc.AUTO_DEDUPE_THRESHOLD,
-        )
-    # Geteilter HTTP-Client zur lokalen Engine: Keep-Alive/Connection-Pooling statt neuer Client
-    # pro /v1-Anfrage (spart Sockets/TIME_WAIT unter parallelen Agent-Strömen von Zed/Kilo).
-    app.state.gw_client = httpx.AsyncClient(
-        timeout=httpx.Timeout(connect=10.0, read=None, write=None, pool=10.0),
-        limits=httpx.Limits(max_keepalive_connections=100, max_connections=200),
-    )
-    try:
-        yield
-    finally:
-        for task in tasks:
-            _ = task.cancel()
-        await app.state.gw_client.aclose()
-
-
-app = FastAPI(title="Mission Control 2.0", version=VERSION, lifespan=lifespan)
-
-# Dev: Vite-Dev-Server (5173) ruft das Backend per /api auf.
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.middleware("http")
-async def no_cache(
-    request: Request, call_next: Callable[[Request], Awaitable[httpx.Response]]
-) -> httpx.Response:
-    resp = await call_next(request)
-    if request.url.path.startswith("/api"):
-        resp.headers["Cache-Control"] = "no-cache"
-    return resp
-
-
-app.include_router(health.router)
-app.include_router(models.router)
-app.include_router(routing.router)
-app.include_router(system.router)
-app.include_router(connect.router)
-app.include_router(memory.router)
-app.include_router(agent.router)
-app.include_router(
-    voice.router
-)  # Sprache: STT/TTS-Proxy + Hermes-Agent-Chat (Voice-Tab)
-app.include_router(
-    reminders_router.router
-)  # Erinnerungen/Routinen (A3) — feuern in den Briefkasten
-# /v1-Datenpfad: Nach dem Gateway-Auszug (UMBAU v3 P1) läuft der eigentliche Gateway als
-# eigener Prozess (mc2-gateway, Loopback :9010) — MC2 reicht /v1 dann nur roh durch, damit
-# LAN-Clients (IDE-Lane) weiter über :9001 kommen. Ohne MC_V1_UPSTREAM (vor dem ersten
-# Deploy der neuen Unit / nach Rollback) bedient MC2 /v1 wie bisher selbst.
-if V1_UPSTREAM:
-    from routers import gateway_forward
-    app.include_router(gateway_forward.router)  # dünner Roh-Weiterleiter → mc2-gateway
-else:
-    app.include_router(gateway_proxy.router)  # OpenAI-kompatibler /v1-Gateway (model:auto)
-app.include_router(maintenance.router)
-app.include_router(auftragsbuch.router)   # Vorschlags-Inbox (Mensch-Gate als Klick)
-app.include_router(ideen.router)          # Ideen-Queue (natives Hermes-Kanban) — Tür der Zentrale
-app.include_router(chronik.router)        # Timeline der autonomen Taten (Announce-Store)
-app.include_router(eigenleben.router)     # „Von allein": Skills + Vorschlags-Bilanz der Box
-app.include_router(wissen.router)         # Wissens-Vault (Traum-Notizen) read-only
-app.include_router(zeitmaschine.router)   # Snapshots ansehen + Ein-Klick-Restore (detached)
-app.include_router(
-    console.router
-)  # Box-Konsole (ttyd) same-origin durchreichen — VOR dem SPA-Catch-all
-app.include_router(
-    hermes_ui.router
-)  # Eingebaute Hermes-Web-GUI (hermes serve) same-origin unter /hermes-ui/ — VOR dem SPA-Catch-all
-
-
-# Prod: gebautes Frontend ausliefern (falls vorhanden). SPA-Fallback auf index.html.
-if FRONTEND_DIST.exists():
-    app.mount("/assets", StaticFiles(directory=FRONTEND_DIST / "assets"), name="assets")
-
-    _DIST_ROOT = FRONTEND_DIST.resolve()
-
-    @app.get("/{full_path:path}")
-    def spa(full_path: str):
-        # Datei direkt aus FRONTEND_DIST ausliefern (manifest.webmanifest, favicon.ico, …) — aber
-        # NUR innerhalb des dist-Ordners: Pfad auflösen + Traversal (../, absolute Pfade) hart raus.
-        try:
-            target = (FRONTEND_DIST / full_path).resolve()
-            if target.is_relative_to(_DIST_ROOT) and target.is_file():
-                return FileResponse(target)
-        except (ValueError, OSError):
-            pass
-
-        index = FRONTEND_DIST / "index.html"
-        if index.exists():
-            # index.html nie cachen → Browser zieht nach jedem Deploy das aktuelle (gehashte) Bundle.
-            return FileResponse(
-                index, headers={"Cache-Control": "no-cache, must-revalidate"}
-            )
-        return {"detail": "frontend not built"}
+"""
+Mission Control 2.0 — dünner FastAPI-Einstieg.
+
+Hängt die Router ein, liefert (in Prod) das gebaute React-Frontend aus und
+setzt eine no-cache-Middleware. Im Dev läuft das Frontend über den Vite-Dev-
+Server (proxyt /api hierher), daher CORS für localhost offen.
+"""
+
+import asyncio
+import logging
+import os
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Awaitable, Callable
+
+import httpx
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from starlette.requests import Request
+
+from config import FRONTEND_DIST, V1_UPSTREAM, VERSION
+from routers import (
+    agent,
+    auftragsbuch,
+    chronik,
+    connect,
+    console,
+    eigenleben,
+    events,
+    gateway_proxy,
+    health,
+    hermes_ui,
+    ideen,
+    maintenance,
+    memory,
+    models,
+    routing,
+    system,
+    voice,
+    wissen,
+    zeitmaschine,
+)
+from routers import reminders as reminders_router
+from services import memory as memory_svc
+from services import reminders, sentry, warmer
+
+# Zentrales Logging — Level via MC_LOG_LEVEL (INFO default). Eine Konfiguration
+# für alle Module (logging.getLogger(__name__)).
+logging.basicConfig(
+    level=os.environ.get("MC_LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+)
+log = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Hintergrund-Tasks an den App-Lebenszyklus binden: Re-Warm-Wächter fürs Agent-Hirn
+    + Health-Wächter (meldet Ausfälle/Erholung in den Lucy-Briefkasten und auf Telegram)."""
+    tasks: list[asyncio.Task[Any]] = []
+    if warmer.ENABLED:
+        tasks.append(asyncio.create_task(warmer.rewarm_loop()))
+        log.info(
+            "Hirn-Re-Warm-Wächter aktiv (Intervall %ss, Hirn dynamisch aus Hermes-Config)",
+            warmer.INTERVAL,
+        )
+    if sentry.ENABLED:
+        tasks.append(asyncio.create_task(sentry.sentry_loop()))
+    tasks.append(asyncio.create_task(reminders.reminders_loop()))
+    if memory_svc.AUTO_DEDUPE_ENABLED:
+        tasks.append(asyncio.create_task(memory_svc.auto_dedupe_loop()))
+        log.info(
+            "Mem0-Auto-Dedupe aktiv (alle %ss, Schwelle %s)",
+            memory_svc.AUTO_DEDUPE_INTERVAL,
+            memory_svc.AUTO_DEDUPE_THRESHOLD,
+        )
+    # Geteilter HTTP-Client zur lokalen Engine: Keep-Alive/Connection-Pooling statt neuer Client
+    # pro /v1-Anfrage (spart Sockets/TIME_WAIT unter parallelen Agent-Strömen von Zed/Kilo).
+    app.state.gw_client = httpx.AsyncClient(
+        timeout=httpx.Timeout(connect=10.0, read=None, write=None, pool=10.0),
+        limits=httpx.Limits(max_keepalive_connections=100, max_connections=200),
+    )
+    try:
+        yield
+    finally:
+        for task in tasks:
+            _ = task.cancel()
+        await app.state.gw_client.aclose()
+
+
+app = FastAPI(title="Mission Control 2.0", version=VERSION, lifespan=lifespan)
+
+# Dev: Vite-Dev-Server (5173) ruft das Backend per /api auf.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.middleware("http")
+async def no_cache(
+    request: Request, call_next: Callable[[Request], Awaitable[httpx.Response]]
+) -> httpx.Response:
+    resp = await call_next(request)
+    if request.url.path.startswith("/api"):
+        resp.headers["Cache-Control"] = "no-cache"
+    return resp
+
+
+app.include_router(health.router)
+app.include_router(models.router)
+app.include_router(routing.router)
+app.include_router(system.router)
+app.include_router(connect.router)
+app.include_router(memory.router)
+app.include_router(agent.router)
+app.include_router(
+    voice.router
+)  # Sprache: STT/TTS-Proxy + Hermes-Agent-Chat (Voice-Tab)
+app.include_router(
+    reminders_router.router
+)  # Erinnerungen/Routinen (A3) — feuern in den Briefkasten
+# /v1-Datenpfad: Nach dem Gateway-Auszug (UMBAU v3 P1) läuft der eigentliche Gateway als
+# eigener Prozess (mc2-gateway, Loopback :9010) — MC2 reicht /v1 dann nur roh durch, damit
+# LAN-Clients (IDE-Lane) weiter über :9001 kommen. Ohne MC_V1_UPSTREAM (vor dem ersten
+# Deploy der neuen Unit / nach Rollback) bedient MC2 /v1 wie bisher selbst.
+if V1_UPSTREAM:
+    from routers import gateway_forward
+    app.include_router(gateway_forward.router)  # dünner Roh-Weiterleiter → mc2-gateway
+else:
+    app.include_router(gateway_proxy.router)  # OpenAI-kompatibler /v1-Gateway (model:auto)
+app.include_router(maintenance.router)
+app.include_router(auftragsbuch.router)   # Vorschlags-Inbox (Mensch-Gate als Klick)
+app.include_router(ideen.router)          # Ideen-Queue (natives Hermes-Kanban) — Tür der Zentrale
+app.include_router(chronik.router)        # Timeline der autonomen Taten (Announce-Store)
+app.include_router(eigenleben.router)     # „Von allein": Skills + Vorschlags-Bilanz der Box
+app.include_router(events.router)         # SSE-Eventstrom /api/events (P3a) — Invalidation-Bus
+app.include_router(wissen.router)         # Wissens-Vault (Traum-Notizen) read-only
+app.include_router(zeitmaschine.router)   # Snapshots ansehen + Ein-Klick-Restore (detached)
+app.include_router(
+    console.router
+)  # Box-Konsole (ttyd) same-origin durchreichen — VOR dem SPA-Catch-all
+app.include_router(
+    hermes_ui.router
+)  # Eingebaute Hermes-Web-GUI (hermes serve) same-origin unter /hermes-ui/ — VOR dem SPA-Catch-all
+
+
+# Prod: gebautes Frontend ausliefern (falls vorhanden). SPA-Fallback auf index.html.
+if FRONTEND_DIST.exists():
+    app.mount("/assets", StaticFiles(directory=FRONTEND_DIST / "assets"), name="assets")
+
+    _DIST_ROOT = FRONTEND_DIST.resolve()
+
+    @app.get("/{full_path:path}")
+    def spa(full_path: str):
+        # Datei direkt aus FRONTEND_DIST ausliefern (manifest.webmanifest, favicon.ico, …) — aber
+        # NUR innerhalb des dist-Ordners: Pfad auflösen + Traversal (../, absolute Pfade) hart raus.
+        try:
+            target = (FRONTEND_DIST / full_path).resolve()
+            if target.is_relative_to(_DIST_ROOT) and target.is_file():
+                return FileResponse(target)
+        except (ValueError, OSError):
+            pass
+
+        index = FRONTEND_DIST / "index.html"
+        if index.exists():
+            # index.html nie cachen → Browser zieht nach jedem Deploy das aktuelle (gehashte) Bundle.
+            return FileResponse(
+                index, headers={"Cache-Control": "no-cache, must-revalidate"}
+            )
+        return {"detail": "frontend not built"}

backend/routers/events.py

@@ -0,0 +1,89 @@
+"""SSE-Eventstrom (UMBAU v3 P3a) — ein Kanal sagt der Zentrale, WANN neu laden lohnt.
+
+GET /api/events liefert Server-Sent Events. Ein Sammler prüft alle paar Sekunden
+billige Fingerabdrücke der ereignishaften Quellen (Briefkasten/Chronik, Ideen-Queue,
+Auftragsbuch, Erinnerungen) und schickt NUR bei Änderung ein `invalidate`-Event mit
+den React-Query-Keys. Die Wahrheit bleibt in den bestehenden Endpunkten — der Strom
+ist ein reiner Invalidation-Bus, kein zweites Zustandsmodell.
+
+Frontend-Gegenstück: frontend/src/lib/events.ts (EventSource, invalidiert die Caches,
+entspannt die Fallback-Poller ×5, solange der Strom steht; reißt er ab, reconnectet
+EventSource selbst und bis dahin pollt die UI wie bisher). Live-Metriken (CPU/Token-
+Graphen) laufen bewusst NICHT hierüber — die ändern sich jede Sekunde, da ist Polling
+das richtige Werkzeug.
+
+Handgebaut 15.07. abends (User-Entscheid: „ihr brecht die Jobs ab, du baust es ein
+letztes Mal manuell") — die autonomen P3-Worker bissen sich an der Aufgabe fest.
+"""
+
+import asyncio
+import json
+import logging
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from fastapi.responses import StreamingResponse
+
+from config import MODELS_DIR
+
+log = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api")
+
+TICK_S = 3.0        # Prüf-Takt des Sammlers (nur Fingerabdrücke, kein Neuberechnen)
+KEEPALIVE_S = 20.0  # Kommentar-Ping, damit Proxies/Browser die Verbindung halten
+
+
+def _mtime(p: Path) -> float:
+    try:
+        return p.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
+def _fingerprints() -> dict[str, object]:
+    """Billige Änderungs-Signale je Quelle → React-Query-Key. Fehler einer Quelle
+    dürfen den Strom nie reißen (dann bleibt ihr Abdruck einfach stehen)."""
+    fp: dict[str, object] = {}
+    try:  # Briefkasten trägt Chronik UND Kontext-Limit-Warnungen — in-process, spottbillig
+        from services import announce
+        fp["chronik"] = announce.list_after(None)["latest"]
+    except Exception:
+        pass
+    try:  # Queue: (id,status)-Paare; list_queue cached selbst ~15 s, der Tick kostet nichts
+        from services import ideen
+        d = ideen.list_queue()
+        fp["ideen"] = json.dumps([(i.get("id"), i.get("status")) for i in d.get("items") or []])
+    except Exception:
+        pass
+    # Auftragsbuch (Annahme-Status + Karten-Meldungen) & Erinnerungen: Datei-mtimes
+    fp["auftragsbuch"] = (_mtime(MODELS_DIR / "mc2-auftragsbuch.json"),
+                          _mtime(MODELS_DIR / "mc2-announce-branches.json"))
+    fp["reminders"] = _mtime(MODELS_DIR / "mc2-reminders.json")
+    return fp
+
+
+@router.get("/events")
+async def events(request: Request) -> StreamingResponse:
+    async def strom():
+        # Der Client hat beim Verbinden frisch geladen — Basislinie ohne Event setzen.
+        alt = _fingerprints()
+        yield ": verbunden\n\n"
+        seit_ping = 0.0
+        while True:
+            if await request.is_disconnected():
+                return
+            await asyncio.sleep(TICK_S)
+            seit_ping += TICK_S
+            neu = _fingerprints()
+            keys = [k for k, v in neu.items() if k in alt and v != alt[k]]
+            alt.update(neu)
+            if keys:
+                yield f"event: invalidate\ndata: {json.dumps({'keys': keys})}\n\n"
+                seit_ping = 0.0
+            elif seit_ping >= KEEPALIVE_S:
+                yield ": ping\n\n"
+                seit_ping = 0.0
+
+    return StreamingResponse(strom(), media_type="text/event-stream",
+                             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})