fix: Restore all files lost during destructive rebase

A previous `git pull --rebase origin main` dropped 177 local commits,
losing 3400+ files across admin-v2, backend, studio-v2, website,
klausur-service, and many other services. The partial restore attempt
(660295e2) only recovered some files.

This commit restores all missing files from pre-rebase ref 98933f5e
while preserving post-rebase additions (night-scheduler, night-mode UI,
NightModeWidget dashboard integration).

Restored features include:
- AI Module Sidebar (FAB), OCR Labeling, OCR Compare
- GPU Dashboard, RAG Pipeline, Magic Help
- Klausur-Korrektur (8 files), Abitur-Archiv (5+ files)
- Companion, Zeugnisse-Crawler, Screen Flow
- Full backend, studio-v2, website, klausur-service
- All compliance SDKs, agent-core, voice-service
- CI/CD configs, documentation, scripts

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

backend/classroom/services/persistence.py

@@ -0,0 +1,131 @@
+"""
+Classroom API - Database Persistence Service
+
+Handles hybrid storage: In-Memory + PostgreSQL for sessions.
+"""
+
+import logging
+from typing import Dict, Optional
+
+from fastapi import HTTPException
+
+from classroom_engine import LessonSession, LessonPhase
+
+logger = logging.getLogger(__name__)
+
+# Database imports (Feature f22)
+try:
+    from classroom_engine.database import get_db, init_db, SessionLocal
+    from classroom_engine.repository import SessionRepository
+    DB_ENABLED = True
+except ImportError:
+    DB_ENABLED = False
+    SessionLocal = None
+    logger.warning("Classroom DB not available, using in-memory storage only")
+
+
+# === Hybrid Storage: In-Memory + DB (Feature f22) ===
+# In-Memory fuer schnellen Zugriff, DB fuer Persistenz
+
+sessions: Dict[str, LessonSession] = {}
+_db_initialized = False
+
+
+def init_db_if_needed():
+    """Initialisiert DB und laedt aktive Sessions beim ersten Aufruf."""
+    global _db_initialized
+    if _db_initialized or not DB_ENABLED:
+        return
+
+    try:
+        init_db()
+        load_active_sessions_from_db()
+        _db_initialized = True
+        logger.info("Classroom DB initialized, loaded active sessions")
+    except Exception as e:
+        logger.error(f"Failed to initialize Classroom DB: {e}")
+
+
+def load_active_sessions_from_db():
+    """Laedt alle aktiven Sessions aus der DB in den Memory-Cache."""
+    if not DB_ENABLED:
+        return
+
+    try:
+        db = SessionLocal()
+        repo = SessionRepository(db)
+
+        # Lade alle nicht-beendeten Sessions
+        from classroom_engine.db_models import LessonSessionDB, LessonPhaseEnum
+        active_db_sessions = db.query(LessonSessionDB).filter(
+            LessonSessionDB.current_phase != LessonPhaseEnum.ENDED
+        ).all()
+
+        for db_session in active_db_sessions:
+            session = repo.to_dataclass(db_session)
+            sessions[session.session_id] = session
+            logger.info(f"Loaded session {session.session_id} from DB")
+
+        db.close()
+    except Exception as e:
+        logger.error(f"Failed to load sessions from DB: {e}")
+
+
+def persist_session(session: LessonSession):
+    """Speichert/aktualisiert Session in der DB."""
+    if not DB_ENABLED:
+        return
+
+    try:
+        db = SessionLocal()
+        repo = SessionRepository(db)
+
+        existing = repo.get_by_id(session.session_id)
+        if existing:
+            repo.update(session)
+        else:
+            repo.create(session)
+
+        db.close()
+    except Exception as e:
+        logger.error(f"Failed to persist session {session.session_id}: {e}")
+
+
+def get_session_or_404(session_id: str) -> LessonSession:
+    """Holt eine Session oder wirft 404. Prueft auch DB bei Cache-Miss."""
+    init_db_if_needed()
+
+    session = sessions.get(session_id)
+    if session:
+        return session
+
+    # Feature f22: Bei Cache-Miss aus DB laden
+    if DB_ENABLED:
+        try:
+            db = SessionLocal()
+            repo = SessionRepository(db)
+            db_session = repo.get_by_id(session_id)
+            if db_session:
+                session = repo.to_dataclass(db_session)
+                sessions[session.session_id] = session  # In Cache laden
+                db.close()
+                return session
+            db.close()
+        except Exception as e:
+            logger.error(f"Failed to load session {session_id} from DB: {e}")
+
+    raise HTTPException(status_code=404, detail="Session nicht gefunden")
+
+
+def delete_session_from_db(session_id: str):
+    """Loescht Session aus der DB."""
+    if not DB_ENABLED:
+        return
+
+    try:
+        db = SessionLocal()
+        repo = SessionRepository(db)
+        repo.delete(session_id)
+        db.close()
+    except Exception as e:
+        logger.error(f"Failed to delete session {session_id} from DB: {e}")