feat: two-pass deskew with wider angle range and residual correction

- Increase iterative deskew coarse_range from ±2° to ±5° to handle
  heavily skewed scans
- New deskew_two_pass(): runs iterative projection first, then
  word-alignment on the corrected image to detect/fix residual skew
  (applied when residual ≥ 0.3°)
- OCR pipeline API auto_deskew now uses deskew_two_pass by default
- Vocab worksheet _run_ocr_pipeline_for_page uses deskew_two_pass
- Deskew result now includes angle_residual and two_pass_debug

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

.claude/CLAUDE.md

@@ -6,22 +6,31 @@
 
 | Geraet | Rolle | Aufgaben |
 |--------|-------|----------|
-| **MacBook** | Client | Claude Terminal, Browser (Frontend-Tests) |
-| **Mac Mini** | Server | Docker, alle Services, Code-Ausfuehrung, Tests, Git |
+| **MacBook** | Entwicklung | Claude Terminal, Code-Entwicklung, Browser (Frontend-Tests) |
+| **Mac Mini** | Server | Docker, alle Services, Tests, Builds, Deployment |
 
-**WICHTIG:** Die Entwicklung findet vollstaendig auf dem **Mac Mini** statt!
+**WICHTIG:** Code wird direkt auf dem MacBook in diesem Repo bearbeitet. Docker und Services laufen auf dem Mac Mini.
 
-### SSH-Verbindung
+### Entwicklungsworkflow
 
 ```bash
-ssh macmini
-# Projektverzeichnis:
-cd /Users/benjaminadmin/Projekte/breakpilot-lehrer
+# 1. Code auf MacBook bearbeiten (dieses Verzeichnis)
+# 2. Committen und pushen:
+git push origin main && git push gitea main
 
-# Einzelbefehle (BEVORZUGT):
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-lehrer && <cmd>"
+# 3. Auf Mac Mini pullen und Container neu bauen:
+ssh macmini "git -C /Users/benjaminadmin/Projekte/breakpilot-lehrer pull --no-rebase origin main"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml build --no-cache <service>"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml up -d <service>"
 ```
 
+### SSH-Verbindung (fuer Docker/Tests)
+
+**WICHTIG:** `cd` in SSH-Kommandos funktioniert NICHT zuverlaessig! Stattdessen:
+- Git: `git -C /Users/benjaminadmin/Projekte/breakpilot-lehrer <cmd>`
+- Docker: `/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml <cmd>`
+- Logs: `/usr/local/bin/docker logs -f bp-lehrer-<service>`
+
 ---
 
 ## Voraussetzung
@@ -163,10 +172,10 @@ breakpilot-lehrer/
 
 ```bash
 # Lehrer-Services starten (Core muss laufen!)
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-lehrer && /usr/local/bin/docker compose up -d"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml up -d"
 
 # Einzelnen Service neu bauen
-ssh macmini "cd /Users/benjaminadmin/Projekte/breakpilot-lehrer && /usr/local/bin/docker compose build --no-cache <service>"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml build --no-cache <service>"
 
 # Logs
 ssh macmini "/usr/local/bin/docker logs -f bp-lehrer-<service>"
@@ -176,6 +185,7 @@ ssh macmini "/usr/local/bin/docker ps --filter name=bp-lehrer"
 ```
 
 **WICHTIG:** Docker-Pfad auf Mac Mini ist `/usr/local/bin/docker` (nicht im Standard-SSH-PATH).
+**WICHTIG:** Immer `-f` mit vollem Pfad zur docker-compose.yml nutzen, `cd` in SSH funktioniert nicht!
 
 ### Frontend-Entwicklung
 

.env.example

@@ -30,6 +30,23 @@ OLLAMA_VISION_MODEL=llama3.2-vision
 OLLAMA_CORRECTION_MODEL=llama3.2
 OLLAMA_TIMEOUT=120
 
+# OCR-Pipeline: LLM-Review (Schritt 6)
+# Kleine Modelle reichen fuer Zeichen-Korrekturen (0->O, 1->l, 5->S)
+# Optionen: qwen3:0.6b, qwen3:1.7b, gemma3:1b, qwen3:30b-a3b
+OLLAMA_REVIEW_MODEL=qwen3:0.6b
+# Eintraege pro Ollama-Call. Groesser = weniger HTTP-Overhead.
+OLLAMA_REVIEW_BATCH_SIZE=20
+
+# OCR-Pipeline: Engine fuer Schritt 5 (Worterkennung)
+# Optionen: auto (bevorzugt RapidOCR), rapid, tesseract,
+#           trocr-printed, trocr-handwritten, lighton
+OCR_ENGINE=auto
+
+# Klausur-HTR: Primaerem Modell fuer Handschriftenerkennung (qwen2.5vl bereits auf Mac Mini)
+OLLAMA_HTR_MODEL=qwen2.5vl:32b
+# HTR Fallback: genutzt wenn Ollama nicht erreichbar (auto-download ~340 MB)
+HTR_FALLBACK_MODEL=trocr-large
+
 # Anthropic (optional)
 ANTHROPIC_API_KEY=
 

admin-lehrer/app/(admin)/ai/agents/[agentId]/page.tsx

@@ -273,52 +273,6 @@ Dein Ziel ist die rechtzeitige Erkennung und Kommunikation relevanter Ereignisse
     createdAt: '2024-12-01T00:00:00Z',
     updatedAt: '2025-01-12T02:00:00Z'
   },
-  'compliance-advisor': {
-    id: 'compliance-advisor',
-    name: 'Compliance Advisor',
-    description: 'DSGVO/Compliance-Berater fuer SDK-Nutzer',
-    soulFile: 'compliance-advisor.soul.md',
-    soulContent: `# Compliance Advisor Agent
-
-## Identitaet
-Du bist der BreakPilot Compliance-Berater. Du hilfst Nutzern des AI Compliance SDK,
-Datenschutz- und Compliance-Fragen in verstaendlicher Sprache zu beantworten.
-Du bist kein Anwalt und gibst keine Rechtsberatung, sondern orientierst dich an
-offiziellen Quellen und gibst praxisnahe Hinweise.
-
-## Kernprinzipien
-- **Quellenbasiert**: Verweise immer auf konkrete Rechtsgrundlagen (DSGVO-Artikel, BDSG-Paragraphen)
-- **Verstaendlich**: Erklaere rechtliche Konzepte in einfacher, praxisnaher Sprache
-- **Ehrlich**: Bei Unsicherheit empfehle professionelle Rechtsberatung
-- **Kontextbewusst**: Nutze das RAG-System fuer aktuelle Rechtstexte und Leitfaeden
-- **Scope-bewusst**: Nutze alle verfuegbaren RAG-Quellen AUSSER NIBIS-Dokumenten
-
-## Kompetenzbereich
-- DSGVO Art. 1-99 + Erwaegsgruende
-- BDSG (Bundesdatenschutzgesetz)
-- AI Act (EU KI-Verordnung)
-- TTDSG, ePrivacy-Richtlinie
-- DSK-Kurzpapiere (Nr. 1-20)
-- SDM V3.0, BSI-Grundschutz, BSI-TR-03161
-- EDPB Guidelines, Bundes-/Laender-Muss-Listen
-- ISO 27001/27701 (Ueberblick)
-
-## Kommunikationsstil
-- Sachlich, aber verstaendlich
-- Deutsch als Hauptsprache
-- Strukturierte Antworten mit Quellenangabe
-- Praxisbeispiele wo hilfreich`,
-    color: '#6366f1',
-    status: 'running',
-    activeSessions: 0,
-    totalProcessed: 0,
-    avgResponseTime: 0,
-    errorRate: 0,
-    lastRestart: new Date().toISOString(),
-    version: '1.0.0',
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString()
-  },
   'orchestrator': {
     id: 'orchestrator',
     name: 'Orchestrator',

admin-lehrer/app/(admin)/ai/agents/page.tsx

@@ -94,19 +94,6 @@ const mockAgents: AgentConfig[] = [
     totalProcessed: 8934,
     avgResponseTime: 12,
     lastActivity: 'just now'
-  },
-  {
-    id: 'compliance-advisor',
-    name: 'Compliance Advisor',
-    description: 'DSGVO/Compliance-Berater fuer SDK-Nutzer',
-    soulFile: 'compliance-advisor.soul.md',
-    color: '#6366f1',
-    icon: 'message',
-    status: 'running',
-    activeSessions: 0,
-    totalProcessed: 0,
-    avgResponseTime: 0,
-    lastActivity: new Date().toISOString()
   }
 ]
 

admin-lehrer/app/(admin)/ai/gpu/page.tsx

@@ -179,7 +179,6 @@ export default function GPUInfrastructurePage() {
           databases: ['PostgreSQL (Logs)'],
         }}
         relatedPages={[
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'KI-Provider testen' },
           { name: 'Test Quality (BQAS)', href: '/ai/test-quality', description: 'Golden Suite & Tests' },
           { name: 'Magic Help', href: '/ai/magic-help', description: 'TrOCR Testing' },
         ]}

admin-lehrer/app/(admin)/ai/llm-compare/page.tsx

@@ -1,503 +0,0 @@
-'use client'
-
-/**
- * LLM Comparison Tool
- *
- * Vergleicht Antworten von verschiedenen LLM-Providern:
- * - OpenAI/ChatGPT
- * - Claude
- * - Self-hosted + Tavily
- * - Self-hosted + EduSearch
- */
-
-import { useState, useEffect, useCallback } from 'react'
-import { PagePurpose } from '@/components/common/PagePurpose'
-import { AIToolsSidebarResponsive } from '@/components/ai/AIToolsSidebar'
-
-interface LLMResponse {
-  provider: string
-  model: string
-  response: string
-  latency_ms: number
-  tokens_used?: number
-  search_results?: Array<{
-    title: string
-    url: string
-    content: string
-    score?: number
-  }>
-  error?: string
-  timestamp: string
-}
-
-interface ComparisonResult {
-  comparison_id: string
-  prompt: string
-  system_prompt?: string
-  responses: LLMResponse[]
-  created_at: string
-}
-
-const providerColors: Record<string, { bg: string; border: string; text: string }> = {
-  openai: { bg: 'bg-emerald-50', border: 'border-emerald-300', text: 'text-emerald-700' },
-  claude: { bg: 'bg-orange-50', border: 'border-orange-300', text: 'text-orange-700' },
-  selfhosted_tavily: { bg: 'bg-blue-50', border: 'border-blue-300', text: 'text-blue-700' },
-  selfhosted_edusearch: { bg: 'bg-purple-50', border: 'border-purple-300', text: 'text-purple-700' },
-}
-
-const providerLabels: Record<string, string> = {
-  openai: 'OpenAI GPT-4o-mini',
-  claude: 'Claude 3.5 Sonnet',
-  selfhosted_tavily: 'Self-hosted + Tavily',
-  selfhosted_edusearch: 'Self-hosted + EduSearch',
-}
-
-export default function LLMComparePage() {
-  // State
-  const [prompt, setPrompt] = useState('')
-  const [systemPrompt, setSystemPrompt] = useState('Du bist ein hilfreicher Assistent fuer Lehrkraefte in Deutschland.')
-
-  // Provider toggles
-  const [enableOpenAI, setEnableOpenAI] = useState(true)
-  const [enableClaude, setEnableClaude] = useState(true)
-  const [enableTavily, setEnableTavily] = useState(true)
-  const [enableEduSearch, setEnableEduSearch] = useState(true)
-
-  // Parameters
-  const [model, setModel] = useState('llama3.2:3b')
-  const [temperature, setTemperature] = useState(0.7)
-  const [maxTokens, setMaxTokens] = useState(2048)
-
-  // Results
-  const [isLoading, setIsLoading] = useState(false)
-  const [result, setResult] = useState<ComparisonResult | null>(null)
-  const [history, setHistory] = useState<ComparisonResult[]>([])
-  const [error, setError] = useState<string | null>(null)
-
-  // UI State
-  const [showSettings, setShowSettings] = useState(false)
-  const [showHistory, setShowHistory] = useState(false)
-
-  // API Base URL
-  const API_URL = process.env.NEXT_PUBLIC_LLM_GATEWAY_URL || 'http://localhost:8082'
-  const API_KEY = process.env.NEXT_PUBLIC_LLM_API_KEY || 'dev-key'
-
-  // Load history
-  const loadHistory = useCallback(async () => {
-    try {
-      const response = await fetch(`${API_URL}/v1/comparison/history?limit=20`, {
-        headers: { Authorization: `Bearer ${API_KEY}` },
-      })
-      if (response.ok) {
-        const data = await response.json()
-        setHistory(data.comparisons || [])
-      }
-    } catch (e) {
-      console.error('Failed to load history:', e)
-    }
-  }, [API_URL, API_KEY])
-
-  useEffect(() => {
-    loadHistory()
-  }, [loadHistory])
-
-  const runComparison = async () => {
-    if (!prompt.trim()) {
-      setError('Bitte geben Sie einen Prompt ein')
-      return
-    }
-
-    setIsLoading(true)
-    setError(null)
-    setResult(null)
-
-    try {
-      const response = await fetch(`${API_URL}/v1/comparison/run`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${API_KEY}`,
-        },
-        body: JSON.stringify({
-          prompt,
-          system_prompt: systemPrompt || undefined,
-          enable_openai: enableOpenAI,
-          enable_claude: enableClaude,
-          enable_selfhosted_tavily: enableTavily,
-          enable_selfhosted_edusearch: enableEduSearch,
-          selfhosted_model: model,
-          temperature,
-          max_tokens: maxTokens,
-        }),
-      })
-
-      if (!response.ok) {
-        throw new Error(`API Error: ${response.status}`)
-      }
-
-      const data = await response.json()
-      setResult(data)
-      loadHistory()
-    } catch (e) {
-      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
-    } finally {
-      setIsLoading(false)
-    }
-  }
-
-  const ResponseCard = ({ response }: { response: LLMResponse }) => {
-    const colors = providerColors[response.provider] || {
-      bg: 'bg-slate-50',
-      border: 'border-slate-300',
-      text: 'text-slate-700',
-    }
-    const label = providerLabels[response.provider] || response.provider
-
-    return (
-      <div className={`rounded-xl border-2 ${colors.border} ${colors.bg} overflow-hidden`}>
-        <div className={`px-4 py-3 border-b ${colors.border} flex items-center justify-between`}>
-          <div>
-            <h3 className={`font-semibold ${colors.text}`}>{label}</h3>
-            <p className="text-xs text-slate-500">{response.model}</p>
-          </div>
-          <div className="text-right text-xs text-slate-500">
-            <div>{response.latency_ms}ms</div>
-            {response.tokens_used && <div>{response.tokens_used} tokens</div>}
-          </div>
-        </div>
-
-        <div className="p-4">
-          {response.error ? (
-            <div className="text-red-600 text-sm">
-              <strong>Fehler:</strong> {response.error}
-            </div>
-          ) : (
-            <pre className="whitespace-pre-wrap text-sm text-slate-700 font-sans">
-              {response.response}
-            </pre>
-          )}
-        </div>
-
-        {response.search_results && response.search_results.length > 0 && (
-          <div className="px-4 pb-4">
-            <details className="text-xs">
-              <summary className="cursor-pointer text-slate-500 hover:text-slate-700">
-                {response.search_results.length} Suchergebnisse anzeigen
-              </summary>
-              <ul className="mt-2 space-y-2">
-                {response.search_results.map((sr, idx) => (
-                  <li key={idx} className="bg-white rounded p-2 border border-slate-200">
-                    <a
-                      href={sr.url}
-                      target="_blank"
-                      rel="noopener noreferrer"
-                      className="text-blue-600 hover:underline font-medium"
-                    >
-                      {sr.title || 'Untitled'}
-                    </a>
-                    <p className="text-slate-500 truncate">{sr.content}</p>
-                  </li>
-                ))}
-              </ul>
-            </details>
-          </div>
-        )}
-      </div>
-    )
-  }
-
-  return (
-    <div>
-      {/* Page Purpose */}
-      <PagePurpose
-        title="LLM Vergleich"
-        purpose="Vergleichen Sie Antworten verschiedener KI-Provider (OpenAI, Claude, Self-hosted) fuer Qualitaetssicherung. Optimieren Sie Parameter und System Prompts fuer beste Ergebnisse. Standalone-Werkzeug ohne direkten Datenfluss zur KI-Pipeline."
-        audience={['Entwickler', 'Data Scientists', 'QA']}
-        architecture={{
-          services: ['llm-gateway (Python)', 'Ollama', 'OpenAI API', 'Claude API'],
-          databases: ['PostgreSQL (History)', 'Qdrant (RAG)'],
-        }}
-        relatedPages={[
-          { name: 'Test Quality (BQAS)', href: '/ai/test-quality', description: 'Golden Suite & Synthetic Tests' },
-          { name: 'GPU Infrastruktur', href: '/ai/gpu', description: 'GPU-Ressourcen verwalten' },
-          { name: 'Agent Management', href: '/ai/agents', description: 'Multi-Agent System' },
-        ]}
-        collapsible={true}
-        defaultCollapsed={true}
-      />
-
-      {/* KI-Werkzeuge Sidebar */}
-      <AIToolsSidebarResponsive currentTool="llm-compare" />
-
-      <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
-        {/* Left Column: Input & Settings */}
-        <div className="lg:col-span-1 space-y-4">
-          {/* Prompt Input */}
-          <div className="bg-white rounded-xl border border-slate-200 p-4">
-            <h2 className="font-semibold text-slate-900 mb-3">Prompt</h2>
-
-            {/* System Prompt */}
-            <div className="mb-3">
-              <label className="block text-sm text-slate-600 mb-1">System Prompt</label>
-              <textarea
-                value={systemPrompt}
-                onChange={(e) => setSystemPrompt(e.target.value)}
-                rows={3}
-                className="w-full px-3 py-2 border border-slate-300 rounded-lg text-sm resize-none"
-                placeholder="System Prompt (optional)"
-              />
-            </div>
-
-            {/* User Prompt */}
-            <div className="mb-3">
-              <label className="block text-sm text-slate-600 mb-1">User Prompt</label>
-              <textarea
-                value={prompt}
-                onChange={(e) => setPrompt(e.target.value)}
-                rows={4}
-                className="w-full px-3 py-2 border border-slate-300 rounded-lg text-sm resize-none"
-                placeholder="z.B.: Erstelle ein Arbeitsblatt zum Thema Bruchrechnung fuer Klasse 6..."
-              />
-            </div>
-
-            {/* Provider Toggles */}
-            <div className="mb-4">
-              <label className="block text-sm text-slate-600 mb-2">Provider</label>
-              <div className="grid grid-cols-2 gap-2">
-                <label className="flex items-center gap-2 text-sm">
-                  <input
-                    type="checkbox"
-                    checked={enableOpenAI}
-                    onChange={(e) => setEnableOpenAI(e.target.checked)}
-                    className="rounded"
-                  />
-                  OpenAI
-                </label>
-                <label className="flex items-center gap-2 text-sm">
-                  <input
-                    type="checkbox"
-                    checked={enableClaude}
-                    onChange={(e) => setEnableClaude(e.target.checked)}
-                    className="rounded"
-                  />
-                  Claude
-                </label>
-                <label className="flex items-center gap-2 text-sm">
-                  <input
-                    type="checkbox"
-                    checked={enableTavily}
-                    onChange={(e) => setEnableTavily(e.target.checked)}
-                    className="rounded"
-                  />
-                  Self + Tavily
-                </label>
-                <label className="flex items-center gap-2 text-sm">
-                  <input
-                    type="checkbox"
-                    checked={enableEduSearch}
-                    onChange={(e) => setEnableEduSearch(e.target.checked)}
-                    className="rounded"
-                  />
-                  Self + EduSearch
-                </label>
-              </div>
-            </div>
-
-            {/* Run Button */}
-            <button
-              onClick={runComparison}
-              disabled={isLoading || !prompt.trim()}
-              className="w-full py-3 bg-teal-600 text-white rounded-lg font-medium hover:bg-teal-700 disabled:opacity-50 disabled:cursor-not-allowed"
-            >
-              {isLoading ? (
-                <span className="flex items-center justify-center gap-2">
-                  <svg className="animate-spin w-5 h-5" fill="none" viewBox="0 0 24 24">
-                    <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                    <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z" />
-                  </svg>
-                  Vergleiche...
-                </span>
-              ) : (
-                'Vergleich starten'
-              )}
-            </button>
-
-            {error && (
-              <div className="mt-3 p-3 bg-red-50 border border-red-200 rounded-lg text-red-700 text-sm">
-                {error}
-              </div>
-            )}
-          </div>
-
-          {/* Settings Panel */}
-          <div className="bg-white rounded-xl border border-slate-200 overflow-hidden">
-            <button
-              onClick={() => setShowSettings(!showSettings)}
-              className="w-full px-4 py-3 flex items-center justify-between hover:bg-slate-50"
-            >
-              <span className="font-semibold text-slate-900">Parameter</span>
-              <svg
-                className={`w-5 h-5 transition-transform ${showSettings ? 'rotate-180' : ''}`}
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-              </svg>
-            </button>
-
-            {showSettings && (
-              <div className="p-4 border-t border-slate-200 space-y-4">
-                <div>
-                  <label className="block text-sm text-slate-600 mb-1">Self-hosted Modell</label>
-                  <select
-                    value={model}
-                    onChange={(e) => setModel(e.target.value)}
-                    className="w-full px-3 py-2 border border-slate-300 rounded-lg text-sm"
-                  >
-                    <option value="llama3.2:3b">Llama 3.2 3B</option>
-                    <option value="llama3.1:8b">Llama 3.1 8B</option>
-                    <option value="mistral:7b">Mistral 7B</option>
-                    <option value="qwen2.5:7b">Qwen 2.5 7B</option>
-                  </select>
-                </div>
-
-                <div>
-                  <label className="block text-sm text-slate-600 mb-1">
-                    Temperature: {temperature.toFixed(2)}
-                  </label>
-                  <input
-                    type="range"
-                    min="0"
-                    max="2"
-                    step="0.1"
-                    value={temperature}
-                    onChange={(e) => setTemperature(parseFloat(e.target.value))}
-                    className="w-full"
-                  />
-                </div>
-
-                <div>
-                  <label className="block text-sm text-slate-600 mb-1">Max Tokens: {maxTokens}</label>
-                  <input
-                    type="range"
-                    min="256"
-                    max="4096"
-                    step="256"
-                    value={maxTokens}
-                    onChange={(e) => setMaxTokens(parseInt(e.target.value))}
-                    className="w-full"
-                  />
-                </div>
-              </div>
-            )}
-          </div>
-
-          {/* History Panel */}
-          <div className="bg-white rounded-xl border border-slate-200 overflow-hidden">
-            <button
-              onClick={() => setShowHistory(!showHistory)}
-              className="w-full px-4 py-3 flex items-center justify-between hover:bg-slate-50"
-            >
-              <span className="font-semibold text-slate-900">Verlauf ({history.length})</span>
-              <svg
-                className={`w-5 h-5 transition-transform ${showHistory ? 'rotate-180' : ''}`}
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-              </svg>
-            </button>
-
-            {showHistory && history.length > 0 && (
-              <div className="border-t border-slate-200 max-h-64 overflow-y-auto">
-                {history.map((h) => (
-                  <button
-                    key={h.comparison_id}
-                    onClick={() => {
-                      setResult(h)
-                      setPrompt(h.prompt)
-                      if (h.system_prompt) setSystemPrompt(h.system_prompt)
-                    }}
-                    className="w-full px-4 py-2 text-left hover:bg-slate-50 border-b border-slate-100 last:border-0"
-                  >
-                    <div className="text-sm text-slate-700 truncate">{h.prompt}</div>
-                    <div className="text-xs text-slate-400">
-                      {new Date(h.created_at).toLocaleString('de-DE')}
-                    </div>
-                  </button>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        {/* Right Column: Results */}
-        <div className="lg:col-span-2">
-          {result ? (
-            <div className="space-y-4">
-              <div className="bg-white rounded-xl border border-slate-200 p-4">
-                <div className="flex items-center justify-between">
-                  <div>
-                    <h2 className="font-semibold text-slate-900">Ergebnisse</h2>
-                    <p className="text-sm text-slate-500">ID: {result.comparison_id}</p>
-                  </div>
-                  <div className="text-sm text-slate-500">
-                    {new Date(result.created_at).toLocaleString('de-DE')}
-                  </div>
-                </div>
-                <div className="mt-2 p-3 bg-slate-50 rounded-lg">
-                  <p className="text-sm text-slate-700">{result.prompt}</p>
-                </div>
-              </div>
-
-              <div className="grid grid-cols-1 xl:grid-cols-2 gap-4">
-                {result.responses.map((response, idx) => (
-                  <ResponseCard key={`${response.provider}-${idx}`} response={response} />
-                ))}
-              </div>
-            </div>
-          ) : (
-            <div className="bg-white rounded-xl border border-slate-200 p-12 text-center">
-              <svg
-                className="w-16 h-16 mx-auto text-slate-300 mb-4"
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={1.5}
-                  d="M9 3v2m6-2v2M9 19v2m6-2v2M5 9H3m2 6H3m18-6h-2m2 6h-2M7 19h10a2 2 0 002-2V7a2 2 0 00-2-2H7a2 2 0 00-2 2v10a2 2 0 002 2zM9 9h6v6H9V9z"
-                />
-              </svg>
-              <h3 className="text-lg font-medium text-slate-700 mb-2">LLM-Vergleich starten</h3>
-              <p className="text-slate-500 max-w-md mx-auto">
-                Geben Sie einen Prompt ein und klicken Sie auf &quot;Vergleich starten&quot;, um
-                die Antworten verschiedener LLM-Provider zu vergleichen.
-              </p>
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* Info Box */}
-      <div className="mt-8 bg-teal-50 border border-teal-200 rounded-xl p-6">
-        <div className="flex items-start gap-4">
-          <svg className="w-6 h-6 text-teal-600 flex-shrink-0 mt-0.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
-          </svg>
-          <div>
-            <h3 className="font-semibold text-teal-900">Qualitaetssicherung</h3>
-            <p className="text-sm text-teal-800 mt-1">
-              Dieses Tool dient zur Qualitaetssicherung der KI-Antworten. Vergleichen Sie verschiedene Provider,
-              um die optimalen Parameter und System Prompts zu finden. Die Ergebnisse werden fuer Audits gespeichert.
-            </p>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}

admin-lehrer/app/(admin)/ai/ocr-compare/page.tsx

@@ -685,7 +685,6 @@ export default function OCRComparePage() {
           databases: ['PostgreSQL (Sessions)'],
         }}
         relatedPages={[
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'KI-Provider vergleichen' },
           { name: 'OCR-Labeling', href: '/ai/ocr-labeling', description: 'Ground Truth erstellen' },
         ]}
         collapsible={true}

admin-lehrer/app/(admin)/ai/ocr-pipeline/page.tsx

@@ -0,0 +1,550 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import { PagePurpose } from '@/components/common/PagePurpose'
+import { PipelineStepper } from '@/components/ocr-pipeline/PipelineStepper'
+import { StepDeskew } from '@/components/ocr-pipeline/StepDeskew'
+import { StepDewarp } from '@/components/ocr-pipeline/StepDewarp'
+import { StepColumnDetection } from '@/components/ocr-pipeline/StepColumnDetection'
+import { StepRowDetection } from '@/components/ocr-pipeline/StepRowDetection'
+import { StepWordRecognition } from '@/components/ocr-pipeline/StepWordRecognition'
+import { StepLlmReview } from '@/components/ocr-pipeline/StepLlmReview'
+import { StepReconstruction } from '@/components/ocr-pipeline/StepReconstruction'
+import { StepGroundTruth } from '@/components/ocr-pipeline/StepGroundTruth'
+import { PIPELINE_STEPS, DOCUMENT_CATEGORIES, type PipelineStep, type SessionListItem, type DocumentTypeResult, type DocumentCategory } from './types'
+
+const KLAUSUR_API = '/klausur-api'
+
+export default function OcrPipelinePage() {
+  const [currentStep, setCurrentStep] = useState(0)
+  const [sessionId, setSessionId] = useState<string | null>(null)
+  const [sessionName, setSessionName] = useState<string>('')
+  const [sessions, setSessions] = useState<SessionListItem[]>([])
+  const [loadingSessions, setLoadingSessions] = useState(true)
+  const [editingName, setEditingName] = useState<string | null>(null)
+  const [editNameValue, setEditNameValue] = useState('')
+  const [editingCategory, setEditingCategory] = useState<string | null>(null)
+  const [docTypeResult, setDocTypeResult] = useState<DocumentTypeResult | null>(null)
+  const [activeCategory, setActiveCategory] = useState<DocumentCategory | undefined>(undefined)
+  const [steps, setSteps] = useState<PipelineStep[]>(
+    PIPELINE_STEPS.map((s, i) => ({
+      ...s,
+      status: i === 0 ? 'active' : 'pending',
+    })),
+  )
+
+  // Load session list on mount
+  useEffect(() => {
+    loadSessions()
+  }, [])
+
+  const loadSessions = async () => {
+    setLoadingSessions(true)
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions`)
+      if (res.ok) {
+        const data = await res.json()
+        setSessions(data.sessions || [])
+      }
+    } catch (e) {
+      console.error('Failed to load sessions:', e)
+    } finally {
+      setLoadingSessions(false)
+    }
+  }
+
+  const openSession = useCallback(async (sid: string) => {
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sid}`)
+      if (!res.ok) return
+      const data = await res.json()
+
+      setSessionId(sid)
+      setSessionName(data.name || data.filename || '')
+      setActiveCategory(data.document_category || undefined)
+
+      // Restore doc type result if available
+      const savedDocType: DocumentTypeResult | null = data.doc_type_result || null
+      setDocTypeResult(savedDocType)
+
+      // Determine which step to jump to based on current_step
+      const dbStep = data.current_step || 1
+      // Steps: 1=deskew, 2=dewarp, 3=columns, ...
+      // UI steps are 0-indexed: 0=deskew, 1=dewarp, 2=columns, ...
+      const uiStep = Math.max(0, dbStep - 1)
+      const skipSteps = savedDocType?.skip_steps || []
+
+      setSteps(
+        PIPELINE_STEPS.map((s, i) => ({
+          ...s,
+          status: skipSteps.includes(s.id)
+            ? 'skipped'
+            : i < uiStep ? 'completed' : i === uiStep ? 'active' : 'pending',
+        })),
+      )
+      setCurrentStep(uiStep)
+    } catch (e) {
+      console.error('Failed to open session:', e)
+    }
+  }, [])
+
+  const deleteSession = useCallback(async (sid: string) => {
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sid}`, { method: 'DELETE' })
+      setSessions((prev) => prev.filter((s) => s.id !== sid))
+      if (sessionId === sid) {
+        setSessionId(null)
+        setCurrentStep(0)
+        setDocTypeResult(null)
+        setSteps(PIPELINE_STEPS.map((s, i) => ({ ...s, status: i === 0 ? 'active' : 'pending' })))
+      }
+    } catch (e) {
+      console.error('Failed to delete session:', e)
+    }
+  }, [sessionId])
+
+  const renameSession = useCallback(async (sid: string, newName: string) => {
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sid}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: newName }),
+      })
+      setSessions((prev) => prev.map((s) => (s.id === sid ? { ...s, name: newName } : s)))
+      if (sessionId === sid) setSessionName(newName)
+    } catch (e) {
+      console.error('Failed to rename session:', e)
+    }
+    setEditingName(null)
+  }, [sessionId])
+
+  const updateCategory = useCallback(async (sid: string, category: DocumentCategory) => {
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sid}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ document_category: category }),
+      })
+      setSessions((prev) => prev.map((s) => (s.id === sid ? { ...s, document_category: category } : s)))
+      if (sessionId === sid) setActiveCategory(category)
+    } catch (e) {
+      console.error('Failed to update category:', e)
+    }
+    setEditingCategory(null)
+  }, [sessionId])
+
+  const deleteAllSessions = useCallback(async () => {
+    if (!confirm('Alle Sessions loeschen? Dies kann nicht rueckgaengig gemacht werden.')) return
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions`, { method: 'DELETE' })
+      setSessions([])
+      setSessionId(null)
+      setCurrentStep(0)
+      setDocTypeResult(null)
+      setActiveCategory(undefined)
+      setSteps(PIPELINE_STEPS.map((s, i) => ({ ...s, status: i === 0 ? 'active' : 'pending' })))
+    } catch (e) {
+      console.error('Failed to delete all sessions:', e)
+    }
+  }, [])
+
+  const handleStepClick = (index: number) => {
+    if (index <= currentStep || steps[index].status === 'completed') {
+      setCurrentStep(index)
+    }
+  }
+
+  const goToStep = (step: number) => {
+    setCurrentStep(step)
+    setSteps((prev) =>
+      prev.map((s, i) => ({
+        ...s,
+        status: i < step ? 'completed' : i === step ? 'active' : 'pending',
+      })),
+    )
+  }
+
+  const handleNext = () => {
+    if (currentStep >= steps.length - 1) {
+      // Last step completed — return to session list
+      setSteps(PIPELINE_STEPS.map((s, i) => ({ ...s, status: i === 0 ? 'active' : 'pending' })))
+      setCurrentStep(0)
+      setSessionId(null)
+      loadSessions()
+      return
+    }
+
+    // Find the next non-skipped step
+    const skipSteps = docTypeResult?.skip_steps || []
+    let nextStep = currentStep + 1
+    while (nextStep < steps.length && skipSteps.includes(PIPELINE_STEPS[nextStep]?.id)) {
+      nextStep++
+    }
+    if (nextStep >= steps.length) nextStep = steps.length - 1
+
+    setSteps((prev) =>
+      prev.map((s, i) => {
+        if (i === currentStep) return { ...s, status: 'completed' }
+        if (i === nextStep) return { ...s, status: 'active' }
+        // Mark skipped steps between current and next
+        if (i > currentStep && i < nextStep && skipSteps.includes(PIPELINE_STEPS[i]?.id)) {
+          return { ...s, status: 'skipped' }
+        }
+        return s
+      }),
+    )
+    setCurrentStep(nextStep)
+  }
+
+  const handleDeskewComplete = (sid: string) => {
+    setSessionId(sid)
+    // Reload session list to show the new session
+    loadSessions()
+    handleNext()
+  }
+
+  const handleDewarpNext = async () => {
+    // Auto-detect document type after dewarp, then advance
+    if (sessionId) {
+      try {
+        const res = await fetch(
+          `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/detect-type`,
+          { method: 'POST' },
+        )
+        if (res.ok) {
+          const data: DocumentTypeResult = await res.json()
+          setDocTypeResult(data)
+
+          // Mark skipped steps immediately
+          const skipSteps = data.skip_steps || []
+          if (skipSteps.length > 0) {
+            setSteps((prev) =>
+              prev.map((s) =>
+                skipSteps.includes(s.id) ? { ...s, status: 'skipped' } : s,
+              ),
+            )
+          }
+        }
+      } catch (e) {
+        console.error('Doc type detection failed:', e)
+        // Not critical — continue without it
+      }
+    }
+    handleNext()
+  }
+
+  const handleDocTypeChange = (newDocType: DocumentTypeResult['doc_type']) => {
+    if (!docTypeResult) return
+
+    // Build new skip_steps based on doc type
+    let skipSteps: string[] = []
+    if (newDocType === 'full_text') {
+      skipSteps = ['columns', 'rows']
+    }
+    // vocab_table and generic_table: no skips
+
+    const updated: DocumentTypeResult = {
+      ...docTypeResult,
+      doc_type: newDocType,
+      skip_steps: skipSteps,
+      pipeline: newDocType === 'full_text' ? 'full_page' : 'cell_first',
+    }
+    setDocTypeResult(updated)
+
+    // Update step statuses
+    setSteps((prev) =>
+      prev.map((s) => {
+        if (skipSteps.includes(s.id)) return { ...s, status: 'skipped' as const }
+        if (s.status === 'skipped') return { ...s, status: 'pending' as const }
+        return s
+      }),
+    )
+  }
+
+  const handleNewSession = () => {
+    setSessionId(null)
+    setSessionName('')
+    setCurrentStep(0)
+    setDocTypeResult(null)
+    setSteps(PIPELINE_STEPS.map((s, i) => ({ ...s, status: i === 0 ? 'active' : 'pending' })))
+  }
+
+  const stepNames: Record<number, string> = {
+    1: 'Begradigung',
+    2: 'Entzerrung',
+    3: 'Spalten',
+    4: 'Zeilen',
+    5: 'Woerter',
+    6: 'Korrektur',
+    7: 'Rekonstruktion',
+    8: 'Validierung',
+  }
+
+  const reprocessFromStep = useCallback(async (uiStep: number) => {
+    if (!sessionId) return
+    const dbStep = uiStep + 1 // UI is 0-indexed, DB is 1-indexed
+    if (!confirm(`Ab Schritt ${dbStep} (${stepNames[dbStep] || '?'}) neu verarbeiten? Nachfolgende Daten werden geloescht.`)) return
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reprocess`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ from_step: dbStep }),
+      })
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}))
+        console.error('Reprocess failed:', data.detail || res.status)
+        return
+      }
+      // Reset UI steps
+      goToStep(uiStep)
+    } catch (e) {
+      console.error('Reprocess error:', e)
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId, goToStep])
+
+  const renderStep = () => {
+    switch (currentStep) {
+      case 0:
+        return <StepDeskew sessionId={sessionId} onNext={handleDeskewComplete} />
+      case 1:
+        return <StepDewarp sessionId={sessionId} onNext={handleDewarpNext} />
+      case 2:
+        return <StepColumnDetection sessionId={sessionId} onNext={handleNext} />
+      case 3:
+        return <StepRowDetection sessionId={sessionId} onNext={handleNext} />
+      case 4:
+        return <StepWordRecognition sessionId={sessionId} onNext={handleNext} goToStep={goToStep} />
+      case 5:
+        return <StepLlmReview sessionId={sessionId} onNext={handleNext} />
+      case 6:
+        return <StepReconstruction sessionId={sessionId} onNext={handleNext} />
+      case 7:
+        return <StepGroundTruth sessionId={sessionId} onNext={handleNext} />
+      default:
+        return null
+    }
+  }
+
+  return (
+    <div className="space-y-6">
+      <PagePurpose
+        title="OCR Pipeline"
+        purpose="Schrittweise Seitenrekonstruktion: Scan begradigen, Spalten erkennen, Woerter lokalisieren und die Seite Wort fuer Wort nachbauen. Ziel: 10 Vokabelseiten fehlerfrei rekonstruieren."
+        audience={['Entwickler', 'Data Scientists']}
+        architecture={{
+          services: ['klausur-service (FastAPI)', 'OpenCV', 'Tesseract'],
+          databases: ['PostgreSQL Sessions'],
+        }}
+        relatedPages={[
+          { name: 'OCR Vergleich', href: '/ai/ocr-compare', description: 'Methoden-Vergleich' },
+          { name: 'OCR-Labeling', href: '/ai/ocr-labeling', description: 'Trainingsdaten' },
+        ]}
+        defaultCollapsed
+      />
+
+      {/* Session List */}
+      <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4">
+        <div className="flex items-center justify-between mb-3">
+          <h3 className="text-sm font-medium text-gray-700 dark:text-gray-300">
+            Sessions ({sessions.length})
+          </h3>
+          <div className="flex gap-2">
+            {sessions.length > 0 && (
+              <button
+                onClick={deleteAllSessions}
+                className="text-xs px-3 py-1.5 text-red-600 hover:bg-red-50 dark:hover:bg-red-900/20 rounded-lg transition-colors"
+                title="Alle Sessions loeschen"
+              >
+                Alle loeschen
+              </button>
+            )}
+            <button
+              onClick={handleNewSession}
+              className="text-xs px-3 py-1.5 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors"
+            >
+              + Neue Session
+            </button>
+          </div>
+        </div>
+
+        {loadingSessions ? (
+          <div className="text-sm text-gray-400 py-2">Lade Sessions...</div>
+        ) : sessions.length === 0 ? (
+          <div className="text-sm text-gray-400 py-2">Noch keine Sessions vorhanden.</div>
+        ) : (
+          <div className="space-y-1.5 max-h-[320px] overflow-y-auto">
+            {sessions.map((s) => {
+              const catInfo = DOCUMENT_CATEGORIES.find(c => c.value === s.document_category)
+              return (
+                <div
+                  key={s.id}
+                  className={`relative flex items-start gap-3 px-3 py-2.5 rounded-lg text-sm transition-colors cursor-pointer ${
+                    sessionId === s.id
+                      ? 'bg-teal-50 dark:bg-teal-900/30 border border-teal-200 dark:border-teal-700'
+                      : 'hover:bg-gray-50 dark:hover:bg-gray-700/50'
+                  }`}
+                >
+                  {/* Thumbnail */}
+                  <div
+                    className="flex-shrink-0 w-12 h-12 rounded-md overflow-hidden bg-gray-100 dark:bg-gray-700"
+                    onClick={() => openSession(s.id)}
+                  >
+                    {/* eslint-disable-next-line @next/next/no-img-element */}
+                    <img
+                      src={`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${s.id}/thumbnail?size=96`}
+                      alt=""
+                      className="w-full h-full object-cover"
+                      loading="lazy"
+                      onError={(e) => { (e.target as HTMLImageElement).style.display = 'none' }}
+                    />
+                  </div>
+
+                  {/* Info */}
+                  <div className="flex-1 min-w-0" onClick={() => openSession(s.id)}>
+                    {editingName === s.id ? (
+                      <input
+                        autoFocus
+                        value={editNameValue}
+                        onChange={(e) => setEditNameValue(e.target.value)}
+                        onBlur={() => renameSession(s.id, editNameValue)}
+                        onKeyDown={(e) => {
+                          if (e.key === 'Enter') renameSession(s.id, editNameValue)
+                          if (e.key === 'Escape') setEditingName(null)
+                        }}
+                        onClick={(e) => e.stopPropagation()}
+                        className="w-full px-1 py-0.5 text-sm border rounded dark:bg-gray-700 dark:border-gray-600"
+                      />
+                    ) : (
+                      <div className="truncate font-medium text-gray-700 dark:text-gray-300">
+                        {s.name || s.filename}
+                      </div>
+                    )}
+                    {/* ID row */}
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        navigator.clipboard.writeText(s.id)
+                        const btn = e.currentTarget
+                        btn.textContent = 'Kopiert!'
+                        setTimeout(() => { btn.textContent = `ID: ${s.id.slice(0, 8)}` }, 1500)
+                      }}
+                      className="text-[10px] font-mono text-gray-400 hover:text-teal-500 transition-colors"
+                      title={`Volle ID: ${s.id} — Klick zum Kopieren`}
+                    >
+                      ID: {s.id.slice(0, 8)}
+                    </button>
+                    <div className="text-xs text-gray-400 flex gap-2 mt-0.5">
+                      <span>{new Date(s.created_at).toLocaleDateString('de-DE', { day: '2-digit', month: '2-digit', year: '2-digit', hour: '2-digit', minute: '2-digit' })}</span>
+                      <span>Schritt {s.current_step}: {stepNames[s.current_step] || '?'}</span>
+                    </div>
+                  </div>
+
+                  {/* Badges */}
+                  <div className="flex flex-col gap-1 items-end flex-shrink-0" onClick={(e) => e.stopPropagation()}>
+                    {/* Category Badge */}
+                    <button
+                      onClick={() => setEditingCategory(editingCategory === s.id ? null : s.id)}
+                      className={`text-[10px] px-1.5 py-0.5 rounded-full border transition-colors ${
+                        catInfo
+                          ? 'bg-teal-50 dark:bg-teal-900/30 border-teal-200 dark:border-teal-700 text-teal-700 dark:text-teal-300'
+                          : 'bg-gray-50 dark:bg-gray-700 border-gray-200 dark:border-gray-600 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300'
+                      }`}
+                      title="Kategorie setzen"
+                    >
+                      {catInfo ? `${catInfo.icon} ${catInfo.label}` : '+ Kategorie'}
+                    </button>
+                    {/* Doc Type Badge (read-only) */}
+                    {s.doc_type && (
+                      <span className="text-[10px] px-1.5 py-0.5 rounded-full bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 border border-gray-200 dark:border-gray-600">
+                        {s.doc_type}
+                      </span>
+                    )}
+                  </div>
+
+                  {/* Action buttons */}
+                  <div className="flex flex-col gap-0.5 flex-shrink-0">
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        setEditNameValue(s.name || s.filename)
+                        setEditingName(s.id)
+                      }}
+                      className="p-1 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300"
+                      title="Umbenennen"
+                    >
+                      <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                        <path strokeLinecap="round" strokeLinejoin="round" d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z" />
+                      </svg>
+                    </button>
+                    <button
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        if (confirm('Session loeschen?')) deleteSession(s.id)
+                      }}
+                      className="p-1 text-gray-400 hover:text-red-500"
+                      title="Loeschen"
+                    >
+                      <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+                        <path strokeLinecap="round" strokeLinejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
+                      </svg>
+                    </button>
+                  </div>
+
+                  {/* Category dropdown (inline) */}
+                  {editingCategory === s.id && (
+                    <div
+                      className="absolute right-0 top-full mt-1 z-20 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg p-2 grid grid-cols-2 gap-1 w-64"
+                      onClick={(e) => e.stopPropagation()}
+                    >
+                      {DOCUMENT_CATEGORIES.map((cat) => (
+                        <button
+                          key={cat.value}
+                          onClick={() => updateCategory(s.id, cat.value)}
+                          className={`text-xs px-2 py-1.5 rounded-md text-left transition-colors ${
+                            s.document_category === cat.value
+                              ? 'bg-teal-100 dark:bg-teal-900/40 text-teal-700 dark:text-teal-300'
+                              : 'hover:bg-gray-100 dark:hover:bg-gray-700 text-gray-600 dark:text-gray-400'
+                          }`}
+                        >
+                          {cat.icon} {cat.label}
+                        </button>
+                      ))}
+                    </div>
+                  )}
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+
+      {/* Active session info */}
+      {sessionId && sessionName && (
+        <div className="flex items-center gap-3 text-sm text-gray-500 dark:text-gray-400">
+          <span>Aktive Session: <span className="font-medium text-gray-700 dark:text-gray-300">{sessionName}</span></span>
+          {activeCategory && (() => {
+            const cat = DOCUMENT_CATEGORIES.find(c => c.value === activeCategory)
+            return cat ? <span className="text-xs px-2 py-0.5 rounded-full bg-teal-50 dark:bg-teal-900/30 border border-teal-200 dark:border-teal-700 text-teal-700 dark:text-teal-300">{cat.icon} {cat.label}</span> : null
+          })()}
+          {docTypeResult && (
+            <span className="text-xs px-2 py-0.5 rounded-full bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400 border border-gray-200 dark:border-gray-600">
+              {docTypeResult.doc_type}
+            </span>
+          )}
+        </div>
+      )}
+
+      <PipelineStepper
+        steps={steps}
+        currentStep={currentStep}
+        onStepClick={handleStepClick}
+        onReprocess={sessionId ? reprocessFromStep : undefined}
+        docTypeResult={docTypeResult}
+        onDocTypeChange={handleDocTypeChange}
+      />
+
+      <div className="min-h-[400px]">{renderStep()}</div>
+    </div>
+  )
+}

admin-lehrer/app/(admin)/ai/ocr-pipeline/types.ts

@@ -0,0 +1,295 @@
+export type PipelineStepStatus = 'pending' | 'active' | 'completed' | 'failed' | 'skipped'
+
+export interface PipelineStep {
+  id: string
+  name: string
+  icon: string
+  status: PipelineStepStatus
+}
+
+export type DocumentCategory =
+  | 'vokabelseite' | 'buchseite' | 'arbeitsblatt' | 'klausurseite'
+  | 'mathearbeit' | 'statistik' | 'zeitung' | 'formular' | 'handschrift' | 'sonstiges'
+
+export const DOCUMENT_CATEGORIES: { value: DocumentCategory; label: string; icon: string }[] = [
+  { value: 'vokabelseite', label: 'Vokabelseite', icon: '📖' },
+  { value: 'buchseite', label: 'Buchseite', icon: '📚' },
+  { value: 'arbeitsblatt', label: 'Arbeitsblatt', icon: '📝' },
+  { value: 'klausurseite', label: 'Klausurseite', icon: '📄' },
+  { value: 'mathearbeit', label: 'Mathearbeit', icon: '🔢' },
+  { value: 'statistik', label: 'Statistik', icon: '📊' },
+  { value: 'zeitung', label: 'Zeitung', icon: '📰' },
+  { value: 'formular', label: 'Formular', icon: '📋' },
+  { value: 'handschrift', label: 'Handschrift', icon: '✍️' },
+  { value: 'sonstiges', label: 'Sonstiges', icon: '📎' },
+]
+
+export interface SessionListItem {
+  id: string
+  name: string
+  filename: string
+  status: string
+  current_step: number
+  document_category?: DocumentCategory
+  doc_type?: string
+  created_at: string
+  updated_at?: string
+}
+
+export interface PipelineLogEntry {
+  step: string
+  completed_at: string
+  success: boolean
+  duration_ms?: number
+  metrics: Record<string, unknown>
+}
+
+export interface PipelineLog {
+  steps: PipelineLogEntry[]
+}
+
+export interface DocumentTypeResult {
+  doc_type: 'vocab_table' | 'full_text' | 'generic_table'
+  confidence: number
+  pipeline: 'cell_first' | 'full_page'
+  skip_steps: string[]
+  features?: Record<string, unknown>
+  duration_seconds?: number
+}
+
+export interface SessionInfo {
+  session_id: string
+  filename: string
+  name?: string
+  image_width: number
+  image_height: number
+  original_image_url: string
+  current_step?: number
+  document_category?: DocumentCategory
+  doc_type?: string
+  deskew_result?: DeskewResult
+  dewarp_result?: DewarpResult
+  column_result?: ColumnResult
+  row_result?: RowResult
+  word_result?: GridResult
+  doc_type_result?: DocumentTypeResult
+}
+
+export interface DeskewResult {
+  session_id: string
+  angle_hough: number
+  angle_word_alignment: number
+  angle_applied: number
+  method_used: 'hough' | 'word_alignment' | 'manual'
+  confidence: number
+  duration_seconds: number
+  deskewed_image_url: string
+  binarized_image_url: string
+}
+
+export interface DeskewGroundTruth {
+  is_correct: boolean
+  corrected_angle?: number
+  notes?: string
+}
+
+export interface DewarpDetection {
+  method: string
+  shear_degrees: number
+  confidence: number
+}
+
+export interface DewarpResult {
+  session_id: string
+  method_used: string
+  shear_degrees: number
+  confidence: number
+  duration_seconds: number
+  dewarped_image_url: string
+  detections?: DewarpDetection[]
+}
+
+export interface DewarpGroundTruth {
+  is_correct: boolean
+  corrected_shear?: number
+  notes?: string
+}
+
+export interface PageRegion {
+  type: 'column_en' | 'column_de' | 'column_example' | 'page_ref'
+      | 'column_marker' | 'column_text' | 'column_ignore' | 'header' | 'footer'
+  x: number
+  y: number
+  width: number
+  height: number
+  classification_confidence?: number
+  classification_method?: string
+}
+
+export interface ColumnResult {
+  columns: PageRegion[]
+  duration_seconds: number
+}
+
+export interface ColumnGroundTruth {
+  is_correct: boolean
+  corrected_columns?: PageRegion[]
+  notes?: string
+}
+
+export interface ManualColumnDivider {
+  xPercent: number  // Position in % of image width (0-100)
+}
+
+export type ColumnTypeKey = PageRegion['type']
+
+export interface RowResult {
+  rows: RowItem[]
+  summary: Record<string, number>
+  total_rows: number
+  duration_seconds: number
+}
+
+export interface RowItem {
+  index: number
+  x: number
+  y: number
+  width: number
+  height: number
+  word_count: number
+  row_type: 'content' | 'header' | 'footer'
+  gap_before: number
+}
+
+export interface RowGroundTruth {
+  is_correct: boolean
+  corrected_rows?: RowItem[]
+  notes?: string
+}
+
+export interface WordBbox {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+export interface GridCell {
+  cell_id: string          // "R03_C1"
+  row_index: number
+  col_index: number
+  col_type: string
+  text: string
+  confidence: number
+  bbox_px: WordBbox
+  bbox_pct: WordBbox
+  ocr_engine?: string
+  is_bold?: boolean
+  status?: 'pending' | 'confirmed' | 'edited' | 'skipped'
+}
+
+export interface ColumnMeta {
+  index: number
+  type: string
+  x: number
+  width: number
+}
+
+export interface GridResult {
+  cells: GridCell[]
+  grid_shape: { rows: number; cols: number; total_cells: number }
+  columns_used: ColumnMeta[]
+  layout: 'vocab' | 'generic'
+  image_width: number
+  image_height: number
+  duration_seconds: number
+  ocr_engine?: string
+  vocab_entries?: WordEntry[]   // Only when layout='vocab'
+  entries?: WordEntry[]         // Backwards compat alias for vocab_entries
+  entry_count?: number
+  summary: {
+    total_cells: number
+    non_empty_cells: number
+    low_confidence: number
+    // Only when layout='vocab':
+    total_entries?: number
+    with_english?: number
+    with_german?: number
+  }
+  llm_review?: {
+    changes: { row_index: number; field: string; old: string; new: string }[]
+    model_used: string
+    duration_ms: number
+    entries_corrected: number
+    applied_count?: number
+    applied_at?: string
+  }
+}
+
+export interface WordEntry {
+  row_index: number
+  english: string
+  german: string
+  example: string
+  source_page?: string
+  marker?: string
+  confidence: number
+  bbox: WordBbox
+  bbox_en: WordBbox | null
+  bbox_de: WordBbox | null
+  bbox_ex: WordBbox | null
+  bbox_ref?: WordBbox | null
+  bbox_marker?: WordBbox | null
+  status?: 'pending' | 'confirmed' | 'edited' | 'skipped'
+}
+
+/** @deprecated Use GridResult instead */
+export interface WordResult {
+  entries: WordEntry[]
+  entry_count: number
+  image_width: number
+  image_height: number
+  duration_seconds: number
+  ocr_engine?: string
+  summary: {
+    total_entries: number
+    with_english: number
+    with_german: number
+    low_confidence: number
+  }
+}
+
+export interface WordGroundTruth {
+  is_correct: boolean
+  corrected_entries?: WordEntry[]
+  notes?: string
+}
+
+export interface ImageRegion {
+  bbox_pct: { x: number; y: number; w: number; h: number }
+  prompt: string
+  description: string
+  image_b64: string | null
+  style: 'educational' | 'cartoon' | 'sketch' | 'clipart' | 'realistic'
+}
+
+export type ImageStyle = ImageRegion['style']
+
+export const IMAGE_STYLES: { value: ImageStyle; label: string }[] = [
+  { value: 'educational', label: 'Lehrbuch' },
+  { value: 'cartoon', label: 'Cartoon' },
+  { value: 'sketch', label: 'Skizze' },
+  { value: 'clipart', label: 'Clipart' },
+  { value: 'realistic', label: 'Realistisch' },
+]
+
+export const PIPELINE_STEPS: PipelineStep[] = [
+  { id: 'deskew', name: 'Begradigung', icon: '📐', status: 'pending' },
+  { id: 'dewarp', name: 'Entzerrung', icon: '🔧', status: 'pending' },
+  { id: 'columns', name: 'Spalten', icon: '📊', status: 'pending' },
+  { id: 'rows', name: 'Zeilen', icon: '📏', status: 'pending' },
+  { id: 'words', name: 'Woerter', icon: '🔤', status: 'pending' },
+  { id: 'llm-review', name: 'Korrektur', icon: '✏️', status: 'pending' },
+  { id: 'reconstruction', name: 'Rekonstruktion', icon: '🏗️', status: 'pending' },
+  { id: 'ground-truth', name: 'Validierung', icon: '✅', status: 'pending' },
+]

admin-lehrer/app/(admin)/ai/rag/components/ChunkBrowserQA.tsx

@@ -0,0 +1,675 @@
+'use client'
+
+import React, { useState, useEffect, useCallback, useRef } from 'react'
+import { RAG_PDF_MAPPING } from './rag-pdf-mapping'
+import { REGULATIONS_IN_RAG, REGULATION_INFO } from '../rag-constants'
+
+interface ChunkBrowserQAProps {
+  apiProxy: string
+}
+
+type RegGroupKey = 'eu_regulation' | 'eu_directive' | 'de_law' | 'at_law' | 'ch_law' | 'national_law' | 'bsi_standard' | 'eu_guideline' | 'international_standard' | 'other'
+
+const GROUP_LABELS: Record<RegGroupKey, string> = {
+  eu_regulation: 'EU Verordnungen',
+  eu_directive: 'EU Richtlinien',
+  de_law: 'DE Gesetze',
+  at_law: 'AT Gesetze',
+  ch_law: 'CH Gesetze',
+  national_law: 'Nationale Gesetze (EU)',
+  bsi_standard: 'BSI Standards',
+  eu_guideline: 'EDPB / Guidelines',
+  international_standard: 'Internationale Standards',
+  other: 'Sonstige',
+}
+
+const GROUP_ORDER: RegGroupKey[] = [
+  'eu_regulation', 'eu_directive', 'de_law', 'at_law', 'ch_law',
+  'national_law', 'bsi_standard', 'eu_guideline', 'international_standard', 'other',
+]
+
+const COLLECTIONS = [
+  'bp_compliance_gesetze',
+  'bp_compliance_ce',
+  'bp_compliance_datenschutz',
+  'bp_dsfa_corpus',
+  'bp_compliance_recht',
+  'bp_legal_templates',
+  'bp_nibis_eh',
+]
+
+export function ChunkBrowserQA({ apiProxy }: ChunkBrowserQAProps) {
+  // Filter-Sidebar
+  const [selectedRegulation, setSelectedRegulation] = useState<string | null>(null)
+  const [regulationCounts, setRegulationCounts] = useState<Record<string, number>>({})
+  const [filterSearch, setFilterSearch] = useState('')
+  const [countsLoading, setCountsLoading] = useState(false)
+
+  // Dokument-Chunks (sequenziell)
+  const [docChunks, setDocChunks] = useState<Record<string, unknown>[]>([])
+  const [docChunkIndex, setDocChunkIndex] = useState(0)
+  const [docTotalChunks, setDocTotalChunks] = useState(0)
+  const [docLoading, setDocLoading] = useState(false)
+  const docChunksRef = useRef(docChunks)
+  docChunksRef.current = docChunks
+
+  // Split-View
+  const [splitViewActive, setSplitViewActive] = useState(true)
+  const [chunksPerPage, setChunksPerPage] = useState(6)
+  const [fullscreen, setFullscreen] = useState(false)
+
+  // Collection — default to bp_compliance_ce where we have PDFs downloaded
+  const [collection, setCollection] = useState('bp_compliance_ce')
+
+  // PDF existence check
+  const [pdfExists, setPdfExists] = useState<boolean | null>(null)
+
+  // Sidebar collapsed groups
+  const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
+
+  // Build grouped regulations for sidebar
+  const regulationsInCollection = Object.entries(REGULATIONS_IN_RAG)
+    .filter(([, info]) => info.collection === collection)
+    .map(([code]) => code)
+
+  const groupedRegulations = React.useMemo(() => {
+    const groups: Record<RegGroupKey, { code: string; name: string; type: string }[]> = {
+      eu_regulation: [], eu_directive: [], de_law: [], at_law: [], ch_law: [],
+      national_law: [], bsi_standard: [], eu_guideline: [], international_standard: [], other: [],
+    }
+    for (const code of regulationsInCollection) {
+      const reg = REGULATION_INFO.find(r => r.code === code)
+      const type = (reg?.type || 'other') as RegGroupKey
+      const groupKey = type in groups ? type : 'other'
+      groups[groupKey].push({
+        code,
+        name: reg?.name || code,
+        type: reg?.type || 'unknown',
+      })
+    }
+    return groups
+  }, [regulationsInCollection.join(',')])
+
+  // Load regulation counts for current collection
+  const loadRegulationCounts = useCallback(async (col: string) => {
+    const entries = Object.entries(REGULATIONS_IN_RAG)
+      .filter(([, info]) => info.collection === col && info.qdrant_id)
+    if (entries.length === 0) return
+
+    // Build qdrant_id -> our_code mapping
+    const qdrantIdToCode: Record<string, string[]> = {}
+    for (const [code, info] of entries) {
+      if (!qdrantIdToCode[info.qdrant_id]) qdrantIdToCode[info.qdrant_id] = []
+      qdrantIdToCode[info.qdrant_id].push(code)
+    }
+    const uniqueQdrantIds = Object.keys(qdrantIdToCode)
+
+    setCountsLoading(true)
+    try {
+      const params = new URLSearchParams({
+        action: 'regulation-counts-batch',
+        collection: col,
+        qdrant_ids: uniqueQdrantIds.join(','),
+      })
+      const res = await fetch(`${apiProxy}?${params}`)
+      if (res.ok) {
+        const data = await res.json()
+        // Map qdrant_id counts back to our codes
+        const mapped: Record<string, number> = {}
+        for (const [qid, count] of Object.entries(data.counts as Record<string, number>)) {
+          const codes = qdrantIdToCode[qid] || []
+          for (const code of codes) {
+            mapped[code] = count
+          }
+        }
+        setRegulationCounts(prev => ({ ...prev, ...mapped }))
+      }
+    } catch (error) {
+      console.error('Failed to load regulation counts:', error)
+    } finally {
+      setCountsLoading(false)
+    }
+  }, [apiProxy])
+
+  // Load all chunks for a regulation (paginated scroll)
+  const loadDocumentChunks = useCallback(async (regulationCode: string) => {
+    const ragInfo = REGULATIONS_IN_RAG[regulationCode]
+    if (!ragInfo || !ragInfo.qdrant_id) return
+
+    setDocLoading(true)
+    setDocChunks([])
+    setDocChunkIndex(0)
+    setDocTotalChunks(0)
+
+    const allChunks: Record<string, unknown>[] = []
+    let offset: string | null = null
+
+    try {
+      let safety = 0
+      do {
+        const params = new URLSearchParams({
+          action: 'scroll',
+          collection: ragInfo.collection,
+          limit: '100',
+          filter_key: 'regulation_id',
+          filter_value: ragInfo.qdrant_id,
+        })
+        if (offset) params.append('offset', offset)
+
+        const res = await fetch(`${apiProxy}?${params}`)
+        if (!res.ok) break
+
+        const data = await res.json()
+        const chunks = data.chunks || []
+        allChunks.push(...chunks)
+        offset = data.next_offset || null
+        safety++
+      } while (offset && safety < 200)
+
+      // Sort by chunk_index
+      allChunks.sort((a, b) => {
+        const ai = Number(a.chunk_index ?? a.chunk_id ?? 0)
+        const bi = Number(b.chunk_index ?? b.chunk_id ?? 0)
+        return ai - bi
+      })
+
+      setDocChunks(allChunks)
+      setDocTotalChunks(allChunks.length)
+      setDocChunkIndex(0)
+    } catch (error) {
+      console.error('Failed to load document chunks:', error)
+    } finally {
+      setDocLoading(false)
+    }
+  }, [apiProxy])
+
+  // Initial load
+  useEffect(() => {
+    loadRegulationCounts(collection)
+  }, [collection, loadRegulationCounts])
+
+  // Current chunk
+  const currentChunk = docChunks[docChunkIndex] || null
+  const prevChunk = docChunkIndex > 0 ? docChunks[docChunkIndex - 1] : null
+  const nextChunk = docChunkIndex < docChunks.length - 1 ? docChunks[docChunkIndex + 1] : null
+
+  // PDF page estimation — use pages metadata if available
+  const estimatePdfPage = (chunk: Record<string, unknown> | null, chunkIdx: number): number => {
+    if (chunk) {
+      // Try pages array from payload (e.g. [7] or [7,8])
+      const pages = chunk.pages as number[] | undefined
+      if (Array.isArray(pages) && pages.length > 0) return pages[0]
+      // Try page field
+      const page = chunk.page as number | undefined
+      if (typeof page === 'number' && page > 0) return page
+    }
+    const mapping = selectedRegulation ? RAG_PDF_MAPPING[selectedRegulation] : null
+    const cpp = mapping?.chunksPerPage || chunksPerPage
+    return Math.floor(chunkIdx / cpp) + 1
+  }
+
+  const pdfPage = estimatePdfPage(currentChunk, docChunkIndex)
+  const pdfMapping = selectedRegulation ? RAG_PDF_MAPPING[selectedRegulation] : null
+  const pdfUrl = pdfMapping ? `/rag-originals/${pdfMapping.filename}#page=${pdfPage}` : null
+
+  // Check PDF existence when regulation changes
+  useEffect(() => {
+    if (!selectedRegulation) { setPdfExists(null); return }
+    const mapping = RAG_PDF_MAPPING[selectedRegulation]
+    if (!mapping) { setPdfExists(false); return }
+    const url = `/rag-originals/${mapping.filename}`
+    fetch(url, { method: 'HEAD' })
+      .then(res => setPdfExists(res.ok))
+      .catch(() => setPdfExists(false))
+  }, [selectedRegulation])
+
+  // Handlers
+  const handleSelectRegulation = (code: string) => {
+    setSelectedRegulation(code)
+    loadDocumentChunks(code)
+  }
+
+  const handleCollectionChange = (col: string) => {
+    setCollection(col)
+    setSelectedRegulation(null)
+    setDocChunks([])
+    setDocChunkIndex(0)
+    setDocTotalChunks(0)
+    setRegulationCounts({})
+  }
+
+  const handlePrev = () => {
+    if (docChunkIndex > 0) setDocChunkIndex(i => i - 1)
+  }
+
+  const handleNext = () => {
+    if (docChunkIndex < docChunks.length - 1) setDocChunkIndex(i => i + 1)
+  }
+
+  const handleKeyDown = useCallback((e: KeyboardEvent) => {
+    if (e.key === 'Escape' && fullscreen) {
+      e.preventDefault()
+      setFullscreen(false)
+    } else if (e.key === 'ArrowLeft' || e.key === 'ArrowUp') {
+      e.preventDefault()
+      setDocChunkIndex(i => Math.max(0, i - 1))
+    } else if (e.key === 'ArrowRight' || e.key === 'ArrowDown') {
+      e.preventDefault()
+      setDocChunkIndex(i => Math.min(docChunksRef.current.length - 1, i + 1))
+    }
+  }, [fullscreen])
+
+  useEffect(() => {
+    if (fullscreen || (selectedRegulation && docChunks.length > 0)) {
+      window.addEventListener('keydown', handleKeyDown)
+      return () => window.removeEventListener('keydown', handleKeyDown)
+    }
+  }, [selectedRegulation, docChunks.length, handleKeyDown, fullscreen])
+
+  const toggleGroup = (group: string) => {
+    setCollapsedGroups(prev => {
+      const next = new Set(prev)
+      if (next.has(group)) next.delete(group)
+      else next.add(group)
+      return next
+    })
+  }
+
+  // Get text content from a chunk
+  const getChunkText = (chunk: Record<string, unknown> | null): string => {
+    if (!chunk) return ''
+    return String(chunk.chunk_text || chunk.text || chunk.content || '')
+  }
+
+  // Extract structural metadata for prominent display
+  const getStructuralInfo = (chunk: Record<string, unknown> | null): { article?: string; section?: string; pages?: string } => {
+    if (!chunk) return {}
+    const result: { article?: string; section?: string; pages?: string } = {}
+    // Article / paragraph
+    const article = chunk.article || chunk.artikel || chunk.paragraph || chunk.section_title
+    if (article) result.article = String(article)
+    // Section
+    const section = chunk.section || chunk.chapter || chunk.abschnitt || chunk.kapitel
+    if (section) result.section = String(section)
+    // Pages
+    const pages = chunk.pages as number[] | undefined
+    if (Array.isArray(pages) && pages.length > 0) {
+      result.pages = pages.length === 1 ? `S. ${pages[0]}` : `S. ${pages[0]}-${pages[pages.length - 1]}`
+    } else if (chunk.page) {
+      result.pages = `S. ${chunk.page}`
+    }
+    return result
+  }
+
+  // Overlap extraction
+  const getOverlapPrev = (): string => {
+    if (!prevChunk) return ''
+    const text = getChunkText(prevChunk)
+    return text.length > 150 ? '...' + text.slice(-150) : text
+  }
+
+  const getOverlapNext = (): string => {
+    if (!nextChunk) return ''
+    const text = getChunkText(nextChunk)
+    return text.length > 150 ? text.slice(0, 150) + '...' : text
+  }
+
+  // Filter sidebar items
+  const filteredRegulations = React.useMemo(() => {
+    if (!filterSearch.trim()) return groupedRegulations
+    const term = filterSearch.toLowerCase()
+    const filtered: typeof groupedRegulations = {
+      eu_regulation: [], eu_directive: [], de_law: [], at_law: [], ch_law: [],
+      national_law: [], bsi_standard: [], eu_guideline: [], international_standard: [], other: [],
+    }
+    for (const [group, items] of Object.entries(groupedRegulations)) {
+      filtered[group as RegGroupKey] = items.filter(
+        r => r.code.toLowerCase().includes(term) || r.name.toLowerCase().includes(term)
+      )
+    }
+    return filtered
+  }, [groupedRegulations, filterSearch])
+
+  // Regulation name lookup
+  const getRegName = (code: string): string => {
+    const reg = REGULATION_INFO.find(r => r.code === code)
+    return reg?.name || code
+  }
+
+  // Important metadata keys to show prominently
+  const STRUCTURAL_KEYS = new Set([
+    'article', 'artikel', 'paragraph', 'section_title', 'section', 'chapter',
+    'abschnitt', 'kapitel', 'pages', 'page',
+  ])
+  const HIDDEN_KEYS = new Set([
+    'text', 'content', 'chunk_text', 'id', 'embedding',
+  ])
+
+  const structInfo = getStructuralInfo(currentChunk)
+
+  return (
+    <div
+      className={`flex flex-col ${fullscreen ? 'fixed inset-0 z-50 bg-slate-100 p-4' : ''}`}
+      style={fullscreen ? { height: '100vh' } : { height: 'calc(100vh - 220px)' }}
+    >
+      {/* Header bar — fixed height */}
+      <div className="flex-shrink-0 bg-white rounded-xl border border-slate-200 p-3 mb-3">
+        <div className="flex flex-wrap items-center gap-4">
+          <div>
+            <label className="block text-xs font-medium text-slate-500 mb-1">Collection</label>
+            <select
+              value={collection}
+              onChange={(e) => handleCollectionChange(e.target.value)}
+              className="px-3 py-1.5 border rounded-lg text-sm focus:ring-2 focus:ring-teal-500"
+            >
+              {COLLECTIONS.map(c => (
+                <option key={c} value={c}>{c}</option>
+              ))}
+            </select>
+          </div>
+
+          {selectedRegulation && (
+            <>
+              <div className="flex items-center gap-2">
+                <span className="text-sm font-semibold text-slate-900">
+                  {selectedRegulation} — {getRegName(selectedRegulation)}
+                </span>
+                {structInfo.article && (
+                  <span className="px-2 py-0.5 bg-blue-100 text-blue-800 text-xs font-medium rounded">
+                    {structInfo.article}
+                  </span>
+                )}
+                {structInfo.pages && (
+                  <span className="px-2 py-0.5 bg-slate-100 text-slate-600 text-xs rounded">
+                    {structInfo.pages}
+                  </span>
+                )}
+              </div>
+              <div className="flex items-center gap-2 ml-auto">
+                <button
+                  onClick={handlePrev}
+                  disabled={docChunkIndex === 0}
+                  className="px-3 py-1.5 text-sm font-medium border rounded-lg bg-white hover:bg-slate-50 disabled:opacity-30 disabled:cursor-not-allowed"
+                >
+                  &#9664; Zurueck
+                </button>
+                <span className="text-sm font-mono text-slate-600 min-w-[80px] text-center">
+                  {docChunkIndex + 1} / {docTotalChunks}
+                </span>
+                <button
+                  onClick={handleNext}
+                  disabled={docChunkIndex >= docChunks.length - 1}
+                  className="px-3 py-1.5 text-sm font-medium border rounded-lg bg-white hover:bg-slate-50 disabled:opacity-30 disabled:cursor-not-allowed"
+                >
+                  Weiter &#9654;
+                </button>
+                <input
+                  type="number"
+                  min={1}
+                  max={docTotalChunks}
+                  value={docChunkIndex + 1}
+                  onChange={(e) => {
+                    const v = parseInt(e.target.value, 10)
+                    if (!isNaN(v) && v >= 1 && v <= docTotalChunks) setDocChunkIndex(v - 1)
+                  }}
+                  className="w-16 px-2 py-1 border rounded text-xs text-center"
+                  title="Springe zu Chunk Nr."
+                />
+              </div>
+              <div className="flex items-center gap-2">
+                <label className="text-xs text-slate-500">Chunks/Seite:</label>
+                <select
+                  value={chunksPerPage}
+                  onChange={(e) => setChunksPerPage(Number(e.target.value))}
+                  className="px-2 py-1 border rounded text-xs"
+                >
+                  {[3, 4, 5, 6, 8, 10, 12, 15, 20].map(n => (
+                    <option key={n} value={n}>{n}</option>
+                  ))}
+                </select>
+                <button
+                  onClick={() => setSplitViewActive(!splitViewActive)}
+                  className={`px-3 py-1 text-xs rounded-lg border ${
+                    splitViewActive ? 'bg-teal-50 border-teal-300 text-teal-700' : 'bg-slate-50 border-slate-300 text-slate-600'
+                  }`}
+                >
+                  {splitViewActive ? 'Split-View an' : 'Split-View aus'}
+                </button>
+                <button
+                  onClick={() => setFullscreen(!fullscreen)}
+                  className={`px-3 py-1 text-xs rounded-lg border ${
+                    fullscreen ? 'bg-indigo-50 border-indigo-300 text-indigo-700' : 'bg-slate-50 border-slate-300 text-slate-600'
+                  }`}
+                  title={fullscreen ? 'Vollbild beenden (Esc)' : 'Vollbild'}
+                >
+                  {fullscreen ? '&#10005; Vollbild beenden' : '&#9974; Vollbild'}
+                </button>
+              </div>
+            </>
+          )}
+        </div>
+      </div>
+
+      {/* Main content: Sidebar + Content — fills remaining height */}
+      <div className="flex gap-3 flex-1 min-h-0">
+        {/* Sidebar — scrollable */}
+        <div className="w-56 flex-shrink-0 bg-white rounded-xl border border-slate-200 flex flex-col min-h-0">
+          <div className="flex-shrink-0 p-3 border-b border-slate-100">
+            <input
+              type="text"
+              value={filterSearch}
+              onChange={(e) => setFilterSearch(e.target.value)}
+              placeholder="Suche..."
+              className="w-full px-2 py-1.5 border rounded-lg text-sm focus:ring-2 focus:ring-teal-500"
+            />
+            {countsLoading && (
+              <div className="text-xs text-slate-400 mt-1 animate-pulse">Counts laden...</div>
+            )}
+          </div>
+          <div className="flex-1 overflow-y-auto min-h-0">
+            {GROUP_ORDER.map(group => {
+              const items = filteredRegulations[group]
+              if (items.length === 0) return null
+              const isCollapsed = collapsedGroups.has(group)
+              return (
+                <div key={group}>
+                  <button
+                    onClick={() => toggleGroup(group)}
+                    className="w-full px-3 py-1.5 text-left text-xs font-semibold text-slate-500 bg-slate-50 hover:bg-slate-100 flex items-center justify-between sticky top-0 z-10"
+                  >
+                    <span>{GROUP_LABELS[group]}</span>
+                    <span className="text-slate-400">{isCollapsed ? '+' : '-'}</span>
+                  </button>
+                  {!isCollapsed && items.map(reg => {
+                    const count = regulationCounts[reg.code] ?? 0
+                    const isSelected = selectedRegulation === reg.code
+                    return (
+                      <button
+                        key={reg.code}
+                        onClick={() => handleSelectRegulation(reg.code)}
+                        className={`w-full px-3 py-1.5 text-left text-sm flex items-center justify-between hover:bg-teal-50 transition-colors ${
+                          isSelected ? 'bg-teal-100 text-teal-900 font-medium' : 'text-slate-700'
+                        }`}
+                      >
+                        <span className="truncate text-xs">{reg.name || reg.code}</span>
+                        <span className={`text-xs tabular-nums flex-shrink-0 ml-1 ${count > 0 ? 'text-slate-500' : 'text-slate-300'}`}>
+                          {count > 0 ? count.toLocaleString() : '—'}
+                        </span>
+                      </button>
+                    )
+                  })}
+                </div>
+              )
+            })}
+          </div>
+        </div>
+
+        {/* Content area — fills remaining width and height */}
+        {!selectedRegulation ? (
+          <div className="flex-1 flex items-center justify-center bg-white rounded-xl border border-slate-200">
+            <div className="text-center text-slate-400 space-y-2">
+              <div className="text-4xl">&#128269;</div>
+              <p className="text-sm">Dokument in der Sidebar auswaehlen, um QA zu starten.</p>
+              <p className="text-xs text-slate-300">Pfeiltasten: Chunk vor/zurueck</p>
+            </div>
+          </div>
+        ) : docLoading ? (
+          <div className="flex-1 flex items-center justify-center bg-white rounded-xl border border-slate-200">
+            <div className="text-center text-slate-500 space-y-2">
+              <div className="animate-spin text-3xl">&#9881;</div>
+              <p className="text-sm">Chunks werden geladen...</p>
+              <p className="text-xs text-slate-400">
+                {selectedRegulation}: {REGULATIONS_IN_RAG[selectedRegulation]?.chunks.toLocaleString() || '?'} Chunks erwartet
+              </p>
+            </div>
+          </div>
+        ) : (
+          <div className={`flex-1 grid gap-3 min-h-0 ${splitViewActive ? 'grid-cols-2' : 'grid-cols-1'}`}>
+            {/* Chunk-Text Panel — fixed height, internal scroll */}
+            <div className="bg-white rounded-xl border border-slate-200 flex flex-col min-h-0 overflow-hidden">
+              {/* Panel header */}
+              <div className="flex-shrink-0 px-4 py-2 bg-slate-50 border-b border-slate-100 flex items-center justify-between">
+                <span className="text-sm font-medium text-slate-700">Chunk-Text</span>
+                <div className="flex items-center gap-2">
+                  {structInfo.article && (
+                    <span className="px-2 py-0.5 bg-blue-50 text-blue-700 text-xs font-medium rounded border border-blue-200">
+                      {structInfo.article}
+                    </span>
+                  )}
+                  {structInfo.section && (
+                    <span className="px-2 py-0.5 bg-purple-50 text-purple-700 text-xs rounded border border-purple-200">
+                      {structInfo.section}
+                    </span>
+                  )}
+                  <span className="text-xs text-slate-400 tabular-nums">
+                    #{docChunkIndex} / {docTotalChunks - 1}
+                  </span>
+                </div>
+              </div>
+
+              {/* Scrollable content */}
+              <div className="flex-1 overflow-y-auto min-h-0 p-4 space-y-3">
+                {/* Overlap from previous chunk */}
+                {prevChunk && (
+                  <div className="text-xs text-slate-400 bg-amber-50 border-l-2 border-amber-300 px-3 py-2 rounded-r">
+                    <div className="font-medium text-amber-600 mb-1">&#8593; Ende vorheriger Chunk #{docChunkIndex - 1}</div>
+                    <p className="whitespace-pre-wrap break-words leading-relaxed">{getOverlapPrev()}</p>
+                  </div>
+                )}
+
+                {/* Current chunk text */}
+                {currentChunk ? (
+                  <div className="text-sm text-slate-800 whitespace-pre-wrap break-words leading-relaxed border-l-2 border-teal-400 pl-3">
+                    {getChunkText(currentChunk)}
+                  </div>
+                ) : (
+                  <div className="text-sm text-slate-400 italic">Kein Chunk-Text vorhanden.</div>
+                )}
+
+                {/* Overlap from next chunk */}
+                {nextChunk && (
+                  <div className="text-xs text-slate-400 bg-amber-50 border-l-2 border-amber-300 px-3 py-2 rounded-r">
+                    <div className="font-medium text-amber-600 mb-1">&#8595; Anfang naechster Chunk #{docChunkIndex + 1}</div>
+                    <p className="whitespace-pre-wrap break-words leading-relaxed">{getOverlapNext()}</p>
+                  </div>
+                )}
+
+                {/* Metadata */}
+                {currentChunk && (
+                  <div className="mt-4 pt-3 border-t border-slate-100">
+                    <div className="text-xs font-medium text-slate-500 mb-2">Metadaten</div>
+                    <div className="grid grid-cols-2 gap-x-4 gap-y-1 text-xs">
+                      {Object.entries(currentChunk)
+                        .filter(([k]) => !HIDDEN_KEYS.has(k))
+                        .sort(([a], [b]) => {
+                          // Structural keys first
+                          const aStruct = STRUCTURAL_KEYS.has(a) ? 0 : 1
+                          const bStruct = STRUCTURAL_KEYS.has(b) ? 0 : 1
+                          return aStruct - bStruct || a.localeCompare(b)
+                        })
+                        .map(([k, v]) => (
+                          <div key={k} className={`flex gap-1 ${STRUCTURAL_KEYS.has(k) ? 'col-span-2 font-medium' : ''}`}>
+                            <span className="font-medium text-slate-500 flex-shrink-0">{k}:</span>
+                            <span className="text-slate-700 break-all">
+                              {Array.isArray(v) ? v.join(', ') : String(v)}
+                            </span>
+                          </div>
+                        ))}
+                    </div>
+                    {/* Chunk quality indicator */}
+                    <div className="mt-3 pt-2 border-t border-slate-50">
+                      <div className="text-xs text-slate-400">
+                        Chunk-Laenge: {getChunkText(currentChunk).length} Zeichen
+                        {getChunkText(currentChunk).length < 50 && (
+                          <span className="ml-2 text-orange-500 font-medium">&#9888; Sehr kurz</span>
+                        )}
+                        {getChunkText(currentChunk).length > 2000 && (
+                          <span className="ml-2 text-orange-500 font-medium">&#9888; Sehr lang</span>
+                        )}
+                      </div>
+                    </div>
+                  </div>
+                )}
+              </div>
+            </div>
+
+            {/* PDF-Viewer Panel */}
+            {splitViewActive && (
+              <div className="bg-white rounded-xl border border-slate-200 flex flex-col min-h-0 overflow-hidden">
+                <div className="flex-shrink-0 px-4 py-2 bg-slate-50 border-b border-slate-100 flex items-center justify-between">
+                  <span className="text-sm font-medium text-slate-700">Original-PDF</span>
+                  <div className="flex items-center gap-2">
+                    <span className="text-xs text-slate-400">
+                      Seite ~{pdfPage}
+                      {pdfMapping?.totalPages ? ` / ${pdfMapping.totalPages}` : ''}
+                    </span>
+                    {pdfUrl && (
+                      <a
+                        href={pdfUrl.split('#')[0]}
+                        target="_blank"
+                        rel="noopener noreferrer"
+                        className="text-xs text-teal-600 hover:text-teal-800 underline"
+                      >
+                        Oeffnen &#8599;
+                      </a>
+                    )}
+                  </div>
+                </div>
+                <div className="flex-1 min-h-0 relative">
+                  {pdfUrl && pdfExists ? (
+                    <iframe
+                      key={`${selectedRegulation}-${pdfPage}`}
+                      src={pdfUrl}
+                      className="absolute inset-0 w-full h-full border-0"
+                      title="Original PDF"
+                    />
+                  ) : (
+                    <div className="flex items-center justify-center h-full text-slate-400 text-sm p-4">
+                      <div className="text-center space-y-2">
+                        <div className="text-3xl">&#128196;</div>
+                        {!pdfMapping ? (
+                          <>
+                            <p>Kein PDF-Mapping fuer {selectedRegulation}.</p>
+                            <p className="text-xs">rag-pdf-mapping.ts ergaenzen.</p>
+                          </>
+                        ) : pdfExists === false ? (
+                          <>
+                            <p className="font-medium text-orange-600">PDF nicht vorhanden</p>
+                            <p className="text-xs">Datei <code className="bg-slate-100 px-1 rounded">{pdfMapping.filename}</code> fehlt in ~/rag-originals/</p>
+                            <p className="text-xs mt-1">Bitte manuell herunterladen und dort ablegen.</p>
+                          </>
+                        ) : (
+                          <p>PDF wird geprueft...</p>
+                        )}
+                      </div>
+                    </div>
+                  )}
+                </div>
+              </div>
+            )}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}

admin-lehrer/app/(admin)/ai/rag/components/rag-pdf-mapping.ts

@@ -0,0 +1,126 @@
+export interface RagPdfMapping {
+  filename: string
+  totalPages?: number
+  chunksPerPage?: number
+  language: string
+}
+
+export const RAG_PDF_MAPPING: Record<string, RagPdfMapping> = {
+  // EU Verordnungen
+  GDPR: { filename: 'GDPR_DE.pdf', language: 'de', totalPages: 88 },
+  EPRIVACY: { filename: 'EPRIVACY_DE.pdf', language: 'de' },
+  SCC: { filename: 'SCC_DE.pdf', language: 'de' },
+  SCC_FULL_TEXT: { filename: 'SCC_FULL_TEXT_DE.pdf', language: 'de' },
+  AIACT: { filename: 'AIACT_DE.pdf', language: 'de', totalPages: 144 },
+  CRA: { filename: 'CRA_DE.pdf', language: 'de' },
+  NIS2: { filename: 'NIS2_DE.pdf', language: 'de' },
+  DGA: { filename: 'DGA_DE.pdf', language: 'de' },
+  DSA: { filename: 'DSA_DE.pdf', language: 'de' },
+  PLD: { filename: 'PLD_DE.pdf', language: 'de' },
+  E_COMMERCE_RL: { filename: 'E_COMMERCE_RL_DE.pdf', language: 'de' },
+  VERBRAUCHERRECHTE_RL: { filename: 'VERBRAUCHERRECHTE_RL_DE.pdf', language: 'de' },
+  DIGITALE_INHALTE_RL: { filename: 'DIGITALE_INHALTE_RL_DE.pdf', language: 'de' },
+  DMA: { filename: 'DMA_DE.pdf', language: 'de' },
+  DPF: { filename: 'DPF_DE.pdf', language: 'de' },
+  EUCSA: { filename: 'EUCSA_DE.pdf', language: 'de' },
+  DATAACT: { filename: 'DATAACT_DE.pdf', language: 'de' },
+  DORA: { filename: 'DORA_DE.pdf', language: 'de' },
+  PSD2: { filename: 'PSD2_DE.pdf', language: 'de' },
+  AMLR: { filename: 'AMLR_DE.pdf', language: 'de' },
+  MiCA: { filename: 'MiCA_DE.pdf', language: 'de' },
+  EHDS: { filename: 'EHDS_DE.pdf', language: 'de' },
+  EAA: { filename: 'EAA_DE.pdf', language: 'de' },
+  DSM: { filename: 'DSM_DE.pdf', language: 'de' },
+  GPSR: { filename: 'GPSR_DE.pdf', language: 'de' },
+  MACHINERY_REG: { filename: 'MACHINERY_REG_DE.pdf', language: 'de' },
+  BLUE_GUIDE: { filename: 'BLUE_GUIDE_DE.pdf', language: 'de' },
+  // DE Gesetze
+  TDDDG: { filename: 'TDDDG_DE.pdf', language: 'de' },
+  BDSG_FULL: { filename: 'BDSG_FULL_DE.pdf', language: 'de' },
+  DE_DDG: { filename: 'DE_DDG.pdf', language: 'de' },
+  DE_BGB_AGB: { filename: 'DE_BGB_AGB.pdf', language: 'de' },
+  DE_EGBGB: { filename: 'DE_EGBGB.pdf', language: 'de' },
+  DE_HGB_RET: { filename: 'DE_HGB_RET.pdf', language: 'de' },
+  DE_AO_RET: { filename: 'DE_AO_RET.pdf', language: 'de' },
+  DE_UWG: { filename: 'DE_UWG.pdf', language: 'de' },
+  DE_TKG: { filename: 'DE_TKG.pdf', language: 'de' },
+  DE_PANGV: { filename: 'DE_PANGV.pdf', language: 'de' },
+  DE_DLINFOV: { filename: 'DE_DLINFOV.pdf', language: 'de' },
+  DE_BETRVG: { filename: 'DE_BETRVG.pdf', language: 'de' },
+  DE_GESCHGEHG: { filename: 'DE_GESCHGEHG.pdf', language: 'de' },
+  DE_BSIG: { filename: 'DE_BSIG.pdf', language: 'de' },
+  DE_USTG_RET: { filename: 'DE_USTG_RET.pdf', language: 'de' },
+  // BSI Standards
+  'BSI-TR-03161-1': { filename: 'BSI-TR-03161-1.pdf', language: 'de' },
+  'BSI-TR-03161-2': { filename: 'BSI-TR-03161-2.pdf', language: 'de' },
+  'BSI-TR-03161-3': { filename: 'BSI-TR-03161-3.pdf', language: 'de' },
+  // AT Gesetze
+  AT_DSG: { filename: 'AT_DSG.pdf', language: 'de' },
+  AT_DSG_FULL: { filename: 'AT_DSG_FULL.pdf', language: 'de' },
+  AT_ECG: { filename: 'AT_ECG.pdf', language: 'de' },
+  AT_TKG: { filename: 'AT_TKG.pdf', language: 'de' },
+  AT_KSCHG: { filename: 'AT_KSCHG.pdf', language: 'de' },
+  AT_FAGG: { filename: 'AT_FAGG.pdf', language: 'de' },
+  AT_UGB_RET: { filename: 'AT_UGB_RET.pdf', language: 'de' },
+  AT_BAO_RET: { filename: 'AT_BAO_RET.pdf', language: 'de' },
+  AT_MEDIENG: { filename: 'AT_MEDIENG.pdf', language: 'de' },
+  AT_ABGB_AGB: { filename: 'AT_ABGB_AGB.pdf', language: 'de' },
+  AT_UWG: { filename: 'AT_UWG.pdf', language: 'de' },
+  // CH Gesetze
+  CH_DSG: { filename: 'CH_DSG.pdf', language: 'de' },
+  CH_DSV: { filename: 'CH_DSV.pdf', language: 'de' },
+  CH_OR_AGB: { filename: 'CH_OR_AGB.pdf', language: 'de' },
+  CH_UWG: { filename: 'CH_UWG.pdf', language: 'de' },
+  CH_FMG: { filename: 'CH_FMG.pdf', language: 'de' },
+  CH_GEBUV: { filename: 'CH_GEBUV.pdf', language: 'de' },
+  CH_ZERTES: { filename: 'CH_ZERTES.pdf', language: 'de' },
+  CH_ZGB_PERS: { filename: 'CH_ZGB_PERS.pdf', language: 'de' },
+  // LI
+  LI_DSG: { filename: 'LI_DSG.pdf', language: 'de' },
+  // Nationale DSG (andere EU)
+  ES_LOPDGDD: { filename: 'ES_LOPDGDD.pdf', language: 'es' },
+  IT_CODICE_PRIVACY: { filename: 'IT_CODICE_PRIVACY.pdf', language: 'it' },
+  NL_UAVG: { filename: 'NL_UAVG.pdf', language: 'nl' },
+  FR_CNIL_GUIDE: { filename: 'FR_CNIL_GUIDE.pdf', language: 'fr' },
+  IE_DPA_2018: { filename: 'IE_DPA_2018.pdf', language: 'en' },
+  UK_DPA_2018: { filename: 'UK_DPA_2018.pdf', language: 'en' },
+  UK_GDPR: { filename: 'UK_GDPR.pdf', language: 'en' },
+  NO_PERSONOPPLYSNINGSLOVEN: { filename: 'NO_PERSONOPPLYSNINGSLOVEN.pdf', language: 'no' },
+  SE_DATASKYDDSLAG: { filename: 'SE_DATASKYDDSLAG.pdf', language: 'sv' },
+  PL_UODO: { filename: 'PL_UODO.pdf', language: 'pl' },
+  CZ_ZOU: { filename: 'CZ_ZOU.pdf', language: 'cs' },
+  HU_INFOTV: { filename: 'HU_INFOTV.pdf', language: 'hu' },
+  BE_DPA_LAW: { filename: 'BE_DPA_LAW.pdf', language: 'nl' },
+  FI_TIETOSUOJALAKI: { filename: 'FI_TIETOSUOJALAKI.pdf', language: 'fi' },
+  DK_DATABESKYTTELSESLOVEN: { filename: 'DK_DATABESKYTTELSESLOVEN.pdf', language: 'da' },
+  LU_DPA_LAW: { filename: 'LU_DPA_LAW.pdf', language: 'fr' },
+  // DE Gesetze (zusaetzlich)
+  TMG_KOMPLETT: { filename: 'TMG_KOMPLETT.pdf', language: 'de' },
+  DE_URHG: { filename: 'DE_URHG.pdf', language: 'de' },
+  // EDPB Guidelines
+  EDPB_GUIDELINES_5_2020: { filename: 'EDPB_GUIDELINES_5_2020.pdf', language: 'en' },
+  EDPB_GUIDELINES_7_2020: { filename: 'EDPB_GUIDELINES_7_2020.pdf', language: 'en' },
+  EDPB_GUIDELINES_1_2020: { filename: 'EDPB_GUIDELINES_1_2020.pdf', language: 'en' },
+  EDPB_GUIDELINES_1_2022: { filename: 'EDPB_GUIDELINES_1_2022.pdf', language: 'en' },
+  EDPB_GUIDELINES_2_2023: { filename: 'EDPB_GUIDELINES_2_2023.pdf', language: 'en' },
+  EDPB_GUIDELINES_2_2024: { filename: 'EDPB_GUIDELINES_2_2024.pdf', language: 'en' },
+  EDPB_GUIDELINES_4_2019: { filename: 'EDPB_GUIDELINES_4_2019.pdf', language: 'en' },
+  EDPB_GUIDELINES_9_2022: { filename: 'EDPB_GUIDELINES_9_2022.pdf', language: 'en' },
+  EDPB_DPIA_LIST: { filename: 'EDPB_DPIA_LIST.pdf', language: 'en' },
+  EDPB_LEGITIMATE_INTEREST: { filename: 'EDPB_LEGITIMATE_INTEREST.pdf', language: 'en' },
+  // EDPS
+  EDPS_DPIA_LIST: { filename: 'EDPS_DPIA_LIST.pdf', language: 'en' },
+  // Frameworks
+  ENISA_SECURE_BY_DESIGN: { filename: 'ENISA_SECURE_BY_DESIGN.pdf', language: 'en' },
+  ENISA_SUPPLY_CHAIN: { filename: 'ENISA_SUPPLY_CHAIN.pdf', language: 'en' },
+  ENISA_THREAT_LANDSCAPE: { filename: 'ENISA_THREAT_LANDSCAPE.pdf', language: 'en' },
+  ENISA_ICS_SCADA: { filename: 'ENISA_ICS_SCADA.pdf', language: 'en' },
+  ENISA_CYBERSECURITY_2024: { filename: 'ENISA_CYBERSECURITY_2024.pdf', language: 'en' },
+  NIST_SSDF: { filename: 'NIST_SSDF.pdf', language: 'en' },
+  NIST_CSF_2: { filename: 'NIST_CSF_2.pdf', language: 'en' },
+  OECD_AI_PRINCIPLES: { filename: 'OECD_AI_PRINCIPLES.pdf', language: 'en' },
+  // EU-IFRS / EFRAG
+  EU_IFRS_DE: { filename: 'EU_IFRS_DE.pdf', language: 'de' },
+  EU_IFRS_EN: { filename: 'EU_IFRS_EN.pdf', language: 'en' },
+  EFRAG_ENDORSEMENT: { filename: 'EFRAG_ENDORSEMENT.pdf', language: 'en' },
+}

admin-lehrer/app/(admin)/ai/rag/page.tsx

@@ -11,6 +11,8 @@ import React, { useState, useEffect, useCallback } from 'react'
 import Link from 'next/link'
 import { PagePurpose } from '@/components/common/PagePurpose'
 import { AIModuleSidebarResponsive } from '@/components/ai/AIModuleSidebar'
+import { REGULATIONS_IN_RAG } from './rag-constants'
+import { ChunkBrowserQA } from './components/ChunkBrowserQA'
 
 // API uses local proxy route to klausur-service
 const API_PROXY = '/api/legal-corpus'
@@ -73,7 +75,7 @@ interface DsfaCorpusStatus {
 type RegulationCategory = 'regulations' | 'dsfa' | 'nibis' | 'templates'
 
 // Tab definitions
-type TabId = 'overview' | 'regulations' | 'map' | 'search' | 'data' | 'ingestion' | 'pipeline'
+type TabId = 'overview' | 'regulations' | 'map' | 'search' | 'chunks' | 'data' | 'ingestion' | 'pipeline'
 
 // Custom document type
 interface CustomDocument {
@@ -1011,8 +1013,264 @@ const REGULATIONS = [
     keyTopics: ['Bussgeldberechnung', 'Schweregrad', 'Milderungsgruende', 'Bussgeldrahmen'],
     effectiveDate: '2022'
   },
+  // =====================================================================
+  // Neu ingestierte EU-Richtlinien (Februar 2026)
+  // =====================================================================
+  {
+    code: 'E_COMMERCE_RL',
+    name: 'E-Commerce-Richtlinie',
+    fullName: 'Richtlinie 2000/31/EG ueber den elektronischen Geschaeftsverkehr',
+    type: 'eu_directive',
+    expected: 30,
+    description: 'EU-Richtlinie ueber den elektronischen Geschaeftsverkehr (E-Commerce). Regelt Herkunftslandprinzip, Informationspflichten, Haftungsprivilegien fuer Vermittler (Mere Conduit, Caching, Hosting).',
+    relevantFor: ['Online-Dienste', 'E-Commerce', 'Hosting-Anbieter', 'Plattformen'],
+    keyTopics: ['Herkunftslandprinzip', 'Haftungsprivileg', 'Informationspflichten', 'Spam-Verbot', 'Vermittlerhaftung'],
+    effectiveDate: '17. Juli 2000'
+  },
+  {
+    code: 'VERBRAUCHERRECHTE_RL',
+    name: 'Verbraucherrechte-Richtlinie',
+    fullName: 'Richtlinie 2011/83/EU ueber die Rechte der Verbraucher',
+    type: 'eu_directive',
+    expected: 25,
+    description: 'EU-weite Harmonisierung der Verbraucherrechte bei Fernabsatz und aussergeschaeftlichen Vertraegen. 14-Tage-Widerrufsrecht, Informationspflichten, digitale Inhalte.',
+    relevantFor: ['Online-Shops', 'E-Commerce', 'Fernabsatz', 'Dienstleister'],
+    keyTopics: ['Widerrufsrecht 14 Tage', 'Informationspflichten', 'Fernabsatzvertraege', 'Digitale Inhalte'],
+    effectiveDate: '13. Juni 2014'
+  },
+  {
+    code: 'DIGITALE_INHALTE_RL',
+    name: 'Digitale-Inhalte-Richtlinie',
+    fullName: 'Richtlinie (EU) 2019/770 ueber digitale Inhalte und Dienstleistungen',
+    type: 'eu_directive',
+    expected: 20,
+    description: 'Gewaehrleistungsrecht fuer digitale Inhalte und Dienstleistungen. Regelt Maengelhaftung, Updates, Vertragsmaessigkeit und Kuendigungsrechte bei digitalen Produkten.',
+    relevantFor: ['SaaS-Anbieter', 'App-Entwickler', 'Cloud-Dienste', 'Streaming-Anbieter', 'Software-Hersteller'],
+    keyTopics: ['Digitale Gewaehrleistung', 'Update-Pflicht', 'Vertragsmaessigkeit', 'Kuendigungsrecht', 'Datenportabilitaet'],
+    effectiveDate: '1. Januar 2022'
+  },
+  {
+    code: 'DMA',
+    name: 'Digital Markets Act',
+    fullName: 'Verordnung (EU) 2022/1925 - Digital Markets Act',
+    type: 'eu_regulation',
+    expected: 50,
+    description: 'Reguliert digitale Gatekeeper-Plattformen. Stellt Verhaltensregeln fuer grosse Plattformen auf (Apple, Google, Meta, Amazon, Microsoft). Verbietet Selbstbevorzugung und erzwingt Interoperabilitaet.',
+    relevantFor: ['Grosse Plattformen', 'App-Stores', 'Suchmaschinen', 'Social Media', 'Messenger-Dienste'],
+    keyTopics: ['Gatekeeper-Pflichten', 'Interoperabilitaet', 'Selbstbevorzugung', 'App-Store-Regeln', 'Datenportabilitaet'],
+    effectiveDate: '2. Mai 2023'
+  },
+  // === Industrie-Compliance (2026-02-28) ===
+  {
+    code: 'MACHINERY_REG',
+    name: 'Maschinenverordnung',
+    fullName: 'Verordnung (EU) 2023/1230 ueber Maschinen (Machinery Regulation)',
+    type: 'eu_regulation',
+    expected: 100,
+    description: 'Loest die alte Maschinenrichtlinie 2006/42/EG ab. Regelt Sicherheitsanforderungen fuer Maschinen und zugehoerige Produkte, CE-Kennzeichnung, Konformitaetsbewertung und Marktaufsicht. Neu: Cybersecurity-Anforderungen fuer vernetzte Maschinen.',
+    relevantFor: ['Maschinenbau', 'Industrie 4.0', 'Automatisierung', 'Hersteller', 'Importeure'],
+    keyTopics: ['CE-Kennzeichnung', 'Konformitaetsbewertung', 'Risikobeurteilung', 'Cybersecurity', 'Betriebsanleitung'],
+    effectiveDate: '20. Januar 2027'
+  },
+  {
+    code: 'BLUE_GUIDE',
+    name: 'Blue Guide',
+    fullName: 'Leitfaden fuer die Umsetzung der EU-Produktvorschriften (Blue Guide 2022)',
+    type: 'eu_guideline',
+    expected: 200,
+    description: 'Umfassender Leitfaden der EU-Kommission zur Umsetzung von Produktvorschriften. Erklaert CE-Kennzeichnung, Konformitaetsbewertungsverfahren, notifizierte Stellen, Marktaufsicht und den New Legislative Framework.',
+    relevantFor: ['Hersteller', 'Importeure', 'Haendler', 'Notifizierte Stellen', 'Marktaufsichtsbehoerden'],
+    keyTopics: ['CE-Kennzeichnung', 'Konformitaetserklaerung', 'Notifizierte Stellen', 'Marktaufsicht', 'New Legislative Framework'],
+    effectiveDate: '29. Juni 2022'
+  },
+  {
+    code: 'ENISA_SECURE_BY_DESIGN',
+    name: 'ENISA Secure by Design',
+    fullName: 'ENISA Secure Software Development Best Practices',
+    type: 'eu_guideline',
+    expected: 50,
+    description: 'ENISA-Leitfaden fuer sichere Softwareentwicklung. Beschreibt Best Practices fuer Security by Design, sichere Entwicklungsprozesse und Schwachstellenmanagement.',
+    relevantFor: ['Softwareentwickler', 'DevOps', 'IT-Sicherheit', 'Produktmanagement'],
+    keyTopics: ['Security by Design', 'SDLC', 'Schwachstellenmanagement', 'Secure Coding', 'Threat Modeling'],
+    effectiveDate: '2023'
+  },
+  {
+    code: 'ENISA_SUPPLY_CHAIN',
+    name: 'ENISA Supply Chain Security',
+    fullName: 'ENISA Threat Landscape for Supply Chain Attacks',
+    type: 'eu_guideline',
+    expected: 50,
+    description: 'ENISA-Analyse der Bedrohungslandschaft fuer Supply-Chain-Angriffe. Beschreibt Angriffsvektoren, Taxonomie und Empfehlungen zur Absicherung von Software-Lieferketten.',
+    relevantFor: ['IT-Sicherheit', 'Beschaffung', 'Softwareentwickler', 'CISO'],
+    keyTopics: ['Supply Chain Security', 'SolarWinds', 'SBOM', 'Lieferantenrisiko', 'Third-Party Risk'],
+    effectiveDate: '2021'
+  },
+  {
+    code: 'NIST_SSDF',
+    name: 'NIST SSDF',
+    fullName: 'NIST SP 800-218 — Secure Software Development Framework (SSDF)',
+    type: 'international_standard',
+    expected: 40,
+    description: 'NIST-Framework fuer sichere Softwareentwicklung. Definiert Praktiken und Aufgaben in vier Gruppen: Prepare, Protect, Produce, Respond. Weit verbreitet als Referenz fuer Software Supply Chain Security.',
+    relevantFor: ['Softwareentwickler', 'DevSecOps', 'IT-Sicherheit', 'Compliance-Manager'],
+    keyTopics: ['SSDF', 'Secure SDLC', 'Software Supply Chain', 'Vulnerability Management', 'Code Review'],
+    effectiveDate: '3. Februar 2022'
+  },
+  {
+    code: 'NIST_CSF_2',
+    name: 'NIST CSF 2.0',
+    fullName: 'NIST Cybersecurity Framework (CSF) 2.0',
+    type: 'international_standard',
+    expected: 50,
+    description: 'Version 2.0 des NIST Cybersecurity Framework. Neue Kernfunktion "Govern" ergaenzt Identify, Protect, Detect, Respond, Recover. Erweitert den Anwendungsbereich ueber kritische Infrastruktur hinaus auf alle Organisationen.',
+    relevantFor: ['CISO', 'IT-Sicherheit', 'Risikomanagement', 'Geschaeftsfuehrung', 'Alle Branchen'],
+    keyTopics: ['Govern', 'Identify', 'Protect', 'Detect', 'Respond', 'Recover', 'Cybersecurity'],
+    effectiveDate: '26. Februar 2024'
+  },
+  {
+    code: 'OECD_AI_PRINCIPLES',
+    name: 'OECD AI Principles',
+    fullName: 'OECD Recommendation on Artificial Intelligence (AI Principles)',
+    type: 'international_standard',
+    expected: 20,
+    description: 'OECD-Empfehlung zu Kuenstlicher Intelligenz. Definiert fuenf Prinzipien fuer verantwortungsvolle KI: Inklusives Wachstum, Menschenzentrierte Werte, Transparenz, Robustheit und Rechenschaftspflicht. Von 46 Laendern angenommen.',
+    relevantFor: ['KI-Entwickler', 'Policy-Maker', 'Ethik-Kommissionen', 'Geschaeftsfuehrung'],
+    keyTopics: ['AI Ethics', 'Transparenz', 'Accountability', 'Trustworthy AI', 'Human-Centered AI'],
+    effectiveDate: '22. Mai 2019'
+  },
+  {
+    code: 'EU_IFRS',
+    name: 'EU-IFRS',
+    fullName: 'Verordnung (EU) 2023/1803 — International Financial Reporting Standards',
+    type: 'eu_regulation',
+    expected: 500,
+    description: 'Konsolidierte Fassung der von der EU uebernommenen IFRS/IAS/IFRIC/SIC. Rechtsverbindlich fuer boersennotierte EU-Unternehmen. Enthalt IFRS 1-17, IAS 1-41, IFRIC 1-23 und SIC 7-32 in der EU-endorsed Fassung (Stand Okt 2023). ACHTUNG: Neuere IASB-Standards sind moeglicherweise noch nicht EU-endorsed.',
+    relevantFor: ['Rechnungswesen', 'Wirtschaftspruefer', 'boersennotierte Unternehmen', 'Finanzberichterstattung', 'CFO'],
+    keyTopics: ['IFRS 16 Leasing', 'IFRS 9 Finanzinstrumente', 'IAS 1 Darstellung', 'IFRS 15 Erloese', 'IFRS 17 Versicherungsvertraege', 'Konsolidierung'],
+    effectiveDate: '16. Oktober 2023'
+  },
+  {
+    code: 'EFRAG_ENDORSEMENT',
+    name: 'EFRAG Endorsement Status',
+    fullName: 'EFRAG EU Endorsement Status Report (Dezember 2025)',
+    type: 'eu_guideline',
+    expected: 30,
+    description: 'Uebersicht des European Financial Reporting Advisory Group (EFRAG) ueber den EU-Endorsement-Stand aller IFRS/IAS-Standards. Zeigt welche Standards von der EU uebernommen wurden und welche noch ausstehend sind. Relevant fuer internationale Ausschreibungen und Compliance-Pruefung.',
+    relevantFor: ['Rechnungswesen', 'Wirtschaftspruefer', 'Compliance Officer', 'internationale Ausschreibungen'],
+    keyTopics: ['EU Endorsement', 'IFRS 18', 'IFRS S1/S2 Sustainability', 'Endorsement Status', 'IASB Updates'],
+    effectiveDate: '18. Dezember 2025'
+  },
 ]
 
+// Source URLs for original documents (click to view original)
+const REGULATION_SOURCES: Record<string, string> = {
+  // EU Verordnungen/Richtlinien (EUR-Lex)
+  GDPR: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32016R0679',
+  EPRIVACY: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32002L0058',
+  SCC: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32021D0914',
+  DPF: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023D1795',
+  AIACT: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32024R1689',
+  CRA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32024R2847',
+  NIS2: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32022L2555',
+  EUCSA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32019R0881',
+  DATAACT: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R2854',
+  DGA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32022R0868',
+  DSA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32022R2065',
+  EAA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32019L0882',
+  DSM: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32019L0790',
+  PLD: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32024L2853',
+  GPSR: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R0988',
+  DORA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32022R2554',
+  PSD2: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32015L2366',
+  AMLR: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32024R1624',
+  MiCA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R1114',
+  EHDS: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32025R0327',
+  SCC_FULL_TEXT: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32021D0914',
+  E_COMMERCE_RL: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32000L0031',
+  VERBRAUCHERRECHTE_RL: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32011L0083',
+  DIGITALE_INHALTE_RL: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32019L0770',
+  DMA: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32022R1925',
+  MACHINERY_REG: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R1230',
+  BLUE_GUIDE: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:52022XC0629(04)',
+  EU_IFRS: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R1803',
+  // EDPB Guidelines
+  EDPB_GUIDELINES_2_2019: 'https://www.edpb.europa.eu/our-work-tools/our-documents/guidelines/guidelines-22019-processing-personal-data-under-article-61b_en',
+  EDPB_GUIDELINES_3_2019: 'https://www.edpb.europa.eu/our-work-tools/our-documents/guidelines/guidelines-32019-processing-personal-data-through-video_en',
+  EDPB_GUIDELINES_5_2020: 'https://www.edpb.europa.eu/our-work-tools/our-documents/guidelines/guidelines-052020-consent-under-regulation-2016679_en',
+  EDPB_GUIDELINES_7_2020: 'https://www.edpb.europa.eu/our-work-tools/our-documents/guidelines/guidelines-072020-concepts-controller-and-processor-gdpr_en',
+  EDPB_GUIDELINES_1_2022: 'https://www.edpb.europa.eu/our-work-tools/our-documents/guidelines/guidelines-042022-calculation-administrative-fines-under-gdpr_en',
+  // BSI Technische Richtlinien
+  'BSI-TR-03161-1': 'https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR03161/BSI-TR-03161-1.html',
+  'BSI-TR-03161-2': 'https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR03161/BSI-TR-03161-2.html',
+  'BSI-TR-03161-3': 'https://www.bsi.bund.de/SharedDocs/Downloads/DE/BSI/Publikationen/TechnischeRichtlinien/TR03161/BSI-TR-03161-3.html',
+  // Nationale Datenschutzgesetze
+  AT_DSG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10001597',
+  BDSG_FULL: 'https://www.gesetze-im-internet.de/bdsg_2018/',
+  CH_DSG: 'https://www.fedlex.admin.ch/eli/cc/2022/491/de',
+  LI_DSG: 'https://www.gesetze.li/konso/2018.272',
+  BE_DPA_LAW: 'https://www.autoriteprotectiondonnees.be/citoyen/la-loi-du-30-juillet-2018',
+  NL_UAVG: 'https://wetten.overheid.nl/BWBR0040940/',
+  FR_CNIL_GUIDE: 'https://www.cnil.fr/fr/rgpd-par-ou-commencer',
+  ES_LOPDGDD: 'https://www.boe.es/buscar/act.php?id=BOE-A-2018-16673',
+  IT_CODICE_PRIVACY: 'https://www.garanteprivacy.it/home/docweb/-/docweb-display/docweb/9042678',
+  IE_DPA_2018: 'https://www.irishstatutebook.ie/eli/2018/act/7/enacted/en/html',
+  UK_DPA_2018: 'https://www.legislation.gov.uk/ukpga/2018/12/contents',
+  UK_GDPR: 'https://www.legislation.gov.uk/eur/2016/679/contents',
+  NO_PERSONOPPLYSNINGSLOVEN: 'https://lovdata.no/dokument/NL/lov/2018-06-15-38',
+  SE_DATASKYDDSLAG: 'https://www.riksdagen.se/sv/dokument-och-lagar/dokument/svensk-forfattningssamling/lag-2018218-med-kompletterande-bestammelser_sfs-2018-218/',
+  FI_TIETOSUOJALAKI: 'https://www.finlex.fi/fi/laki/ajantasa/2018/20181050',
+  PL_UODO: 'https://isap.sejm.gov.pl/isap.nsf/DocDetails.xsp?id=WDU20180001000',
+  CZ_ZOU: 'https://www.zakonyprolidi.cz/cs/2019-110',
+  HU_INFOTV: 'https://net.jogtar.hu/jogszabaly?docid=a1100112.tv',
+  LU_DPA_LAW: 'https://legilux.public.lu/eli/etat/leg/loi/2018/08/01/a686/jo',
+  DK_DATABESKYTTELSESLOVEN: 'https://www.retsinformation.dk/eli/lta/2018/502',
+  // Deutschland — Weitere Gesetze
+  TDDDG: 'https://www.gesetze-im-internet.de/tdddg/',
+  DE_DDG: 'https://www.gesetze-im-internet.de/ddg/',
+  DE_BGB_AGB: 'https://www.gesetze-im-internet.de/bgb/__305.html',
+  DE_EGBGB: 'https://www.gesetze-im-internet.de/bgbeg/art_246.html',
+  DE_UWG: 'https://www.gesetze-im-internet.de/uwg_2004/',
+  DE_HGB_RET: 'https://www.gesetze-im-internet.de/hgb/__257.html',
+  DE_AO_RET: 'https://www.gesetze-im-internet.de/ao_1977/__147.html',
+  DE_TKG: 'https://www.gesetze-im-internet.de/tkg_2021/',
+  DE_PANGV: 'https://www.gesetze-im-internet.de/pangv_2022/',
+  DE_DLINFOV: 'https://www.gesetze-im-internet.de/dlinfov/',
+  DE_BETRVG: 'https://www.gesetze-im-internet.de/betrvg/__87.html',
+  DE_GESCHGEHG: 'https://www.gesetze-im-internet.de/geschgehg/',
+  DE_BSIG: 'https://www.gesetze-im-internet.de/bsig_2009/',
+  DE_USTG_RET: 'https://www.gesetze-im-internet.de/ustg_1980/__14b.html',
+  // Oesterreich — Weitere Gesetze
+  AT_ECG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=20001703',
+  AT_TKG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=20007898',
+  AT_KSCHG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10002462',
+  AT_FAGG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=20008783',
+  AT_UGB_RET: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10001702',
+  AT_BAO_RET: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10003940',
+  AT_MEDIENG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10000719',
+  AT_ABGB_AGB: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10001622',
+  AT_UWG: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10002665',
+  // Schweiz
+  CH_DSV: 'https://www.fedlex.admin.ch/eli/cc/2022/568/de',
+  CH_OR_AGB: 'https://www.fedlex.admin.ch/eli/cc/27/317_321_377/de',
+  CH_UWG: 'https://www.fedlex.admin.ch/eli/cc/1988/223_223_223/de',
+  CH_FMG: 'https://www.fedlex.admin.ch/eli/cc/1997/2187_2187_2187/de',
+  CH_GEBUV: 'https://www.fedlex.admin.ch/eli/cc/2002/249/de',
+  CH_ZERTES: 'https://www.fedlex.admin.ch/eli/cc/2016/752/de',
+  CH_ZGB_PERS: 'https://www.fedlex.admin.ch/eli/cc/24/233_245_233/de',
+  // Industrie-Compliance
+  ENISA_SECURE_BY_DESIGN: 'https://www.enisa.europa.eu/publications/secure-development-best-practices',
+  ENISA_SUPPLY_CHAIN: 'https://www.enisa.europa.eu/publications/threat-landscape-for-supply-chain-attacks',
+  NIST_SSDF: 'https://csrc.nist.gov/pubs/sp/800/218/final',
+  NIST_CSF_2: 'https://www.nist.gov/cyberframework',
+  OECD_AI_PRINCIPLES: 'https://legalinstruments.oecd.org/en/instruments/OECD-LEGAL-0449',
+  // IFRS / EFRAG
+  EU_IFRS_DE: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R1803',
+  EU_IFRS_EN: 'https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32023R1803',
+  EFRAG_ENDORSEMENT: 'https://www.efrag.org/activities/endorsement-status-report',
+  // Full-text Datenschutzgesetz AT
+  AT_DSG_FULL: 'https://www.ris.bka.gv.at/GeltendeFassung.wxe?Abfrage=Bundesnormen&Gesetzesnummer=10001597',
+}
+
 // License info for each regulation
 const REGULATION_LICENSES: Record<string, { license: string; licenseNote: string }> = {
   GDPR: { license: 'PUBLIC_DOMAIN', licenseNote: 'Amtliches Werk der EU — frei verwendbar' },
@@ -1063,6 +1321,18 @@ const REGULATION_LICENSES: Record<string, { license: string; licenseNote: string
   EDPB_GUIDELINES_3_2019: { license: 'EDPB-LICENSE', licenseNote: 'EDPB Document License' },
   EDPB_GUIDELINES_5_2020: { license: 'EDPB-LICENSE', licenseNote: 'EDPB Document License' },
   EDPB_GUIDELINES_7_2020: { license: 'EDPB-LICENSE', licenseNote: 'EDPB Document License' },
+  // Industrie-Compliance (2026-02-28)
+  MACHINERY_REG: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Verordnung — amtliches Werk' },
+  BLUE_GUIDE: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Leitfaden — amtliches Werk der Kommission' },
+  ENISA_SECURE_BY_DESIGN: { license: 'CC-BY-4.0', licenseNote: 'ENISA Publication — CC BY 4.0' },
+  ENISA_SUPPLY_CHAIN: { license: 'CC-BY-4.0', licenseNote: 'ENISA Publication — CC BY 4.0' },
+  NIST_SSDF: { license: 'PUBLIC_DOMAIN', licenseNote: 'US Government Work — Public Domain' },
+  NIST_CSF_2: { license: 'PUBLIC_DOMAIN', licenseNote: 'US Government Work — Public Domain' },
+  OECD_AI_PRINCIPLES: { license: 'PUBLIC_DOMAIN', licenseNote: 'OECD Legal Instrument — Reuse Notice' },
+  // EU-IFRS / EFRAG (2026-02-28)
+  EU_IFRS_DE: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Verordnung — amtliches Werk' },
+  EU_IFRS_EN: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Verordnung — amtliches Werk' },
+  EFRAG_ENDORSEMENT: { license: 'PUBLIC_DOMAIN', licenseNote: 'EFRAG — oeffentliches Dokument' },
   // DACH National Laws — Deutschland
   DE_DDG: { license: 'PUBLIC_DOMAIN', licenseNote: 'Deutsches Bundesgesetz — amtliches Werk (§5 UrhG)' },
   DE_BGB_AGB: { license: 'PUBLIC_DOMAIN', licenseNote: 'Deutsches Bundesgesetz — amtliches Werk (§5 UrhG)' },
@@ -1099,6 +1369,34 @@ const REGULATION_LICENSES: Record<string, { license: string; licenseNote: string
   LU_DPA_LAW: { license: 'PUBLIC_DOMAIN', licenseNote: 'Amtliches Werk Luxemburg — frei verwendbar' },
   DK_DATABESKYTTELSESLOVEN: { license: 'PUBLIC_DOMAIN', licenseNote: 'Amtliches Werk Daenemark — frei verwendbar' },
   EDPB_GUIDELINES_1_2022: { license: 'EDPB-LICENSE', licenseNote: 'EDPB Document License' },
+  // Neue EU-Richtlinien (Februar 2026 ingestiert)
+  E_COMMERCE_RL: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Richtlinie — amtliches Werk' },
+  VERBRAUCHERRECHTE_RL: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Richtlinie — amtliches Werk' },
+  DIGITALE_INHALTE_RL: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Richtlinie — amtliches Werk' },
+  DMA: { license: 'PUBLIC_DOMAIN', licenseNote: 'EU-Verordnung — amtliches Werk' },
+}
+
+// REGULATIONS_IN_RAG is imported from ./rag-constants.ts
+
+// Helper: Check if regulation is in RAG
+const isInRag = (code: string): boolean => code in REGULATIONS_IN_RAG
+
+// Helper: Get known chunk count for a regulation
+const getKnownChunks = (code: string): number => REGULATIONS_IN_RAG[code]?.chunks || 0
+
+// Known collection totals (updated: 2026-03-05)
+// Note: bp_compliance_datenschutz expanded via edpb-crawler.py (55 EDPB/WP29/EDPS documents).
+// bp_dsfa_corpus expanded with 20 DSFA Muss-Listen (BfDI + DSK + 16 Bundeslaender).
+const COLLECTION_TOTALS = {
+  bp_compliance_gesetze: 58304,
+  bp_compliance_ce: 18183,
+  bp_legal_templates: 7689,
+  bp_compliance_datenschutz: 17459,
+  bp_dsfa_corpus: 8666,
+  bp_compliance_recht: 1425,
+  bp_nibis_eh: 7996,
+  total_legal: 76487, // gesetze + ce
+  total_all: 119722,
 }
 
 // License display labels
@@ -1444,6 +1742,8 @@ export default function RAGPage() {
   const [autoRefresh, setAutoRefresh] = useState(true)
   const [elapsedTime, setElapsedTime] = useState<string>('')
 
+  // Chunk browser state is now in ChunkBrowserQA component
+
   // DSFA corpus state
   const [dsfaSources, setDsfaSources] = useState<DsfaSource[]>([])
   const [dsfaStatus, setDsfaStatus] = useState<DsfaCorpusStatus | null>(null)
@@ -1689,6 +1989,8 @@ export default function RAGPage() {
     return () => clearInterval(interval)
   }, [pipelineState?.started_at, pipelineState?.status])
 
+  // Chunk browser functions are now in ChunkBrowserQA component
+
   const handleSearch = async () => {
     if (!searchQuery.trim()) return
 
@@ -1774,6 +2076,7 @@ export default function RAGPage() {
     { id: 'regulations' as TabId, name: 'Regulierungen', icon: '📜' },
     { id: 'map' as TabId, name: 'Landkarte', icon: '🗺️' },
     { id: 'search' as TabId, name: 'Suche', icon: '🔍' },
+    { id: 'chunks' as TabId, name: 'Chunk-Browser', icon: '🧩' },
     { id: 'data' as TabId, name: 'Daten', icon: '📁' },
     { id: 'ingestion' as TabId, name: 'Ingestion', icon: '⚙️' },
     { id: 'pipeline' as TabId, name: 'Pipeline', icon: '🔄' },
@@ -1804,7 +2107,7 @@ export default function RAGPage() {
         {/* Page Purpose */}
         <PagePurpose
           title="Daten & RAG"
-          purpose="Verwalten und durchsuchen Sie 4 RAG-Collections: Legal Corpus (24 Regulierungen), DSFA Corpus (70+ Quellen inkl. internationaler Datenschutzgesetze), NiBiS EH (Bildungsinhalte) und Legal Templates (Dokumentvorlagen). Teil der KI-Daten-Pipeline fuer Compliance und Klausur-Korrektur."
+          purpose={`Verwalten und durchsuchen Sie 7 RAG-Collections mit ${REGULATIONS.length} Regulierungen (${Object.keys(REGULATIONS_IN_RAG).length} im RAG). Legal Corpus, DSFA Corpus (70+ Quellen), NiBiS EH (Bildungsinhalte) und Legal Templates. Teil der KI-Daten-Pipeline fuer Compliance und Klausur-Korrektur.`}
           audience={['DSB', 'Compliance Officer', 'Entwickler']}
           gdprArticles={['§5 UrhG (Amtliche Werke)', 'Art. 5 DSGVO (Rechenschaftspflicht)']}
           architecture={{
@@ -1826,8 +2129,8 @@ export default function RAGPage() {
         <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
           <div className="bg-white rounded-xl p-4 border border-slate-200">
             <p className="text-xs font-medium text-blue-600 uppercase mb-1">Legal Corpus</p>
-            <p className="text-2xl font-bold text-slate-900">{loading ? '-' : getTotalChunks().toLocaleString()}</p>
-            <p className="text-xs text-slate-500">Chunks &middot; {REGULATIONS.length} Regulierungen</p>
+            <p className="text-2xl font-bold text-slate-900">{COLLECTION_TOTALS.total_legal.toLocaleString()}</p>
+            <p className="text-xs text-slate-500">Chunks &middot; {Object.keys(REGULATIONS_IN_RAG).length}/{REGULATIONS.length} im RAG</p>
           </div>
           <div className="bg-white rounded-xl p-4 border border-slate-200">
             <p className="text-xs font-medium text-purple-600 uppercase mb-1">DSFA Corpus</p>
@@ -1836,12 +2139,12 @@ export default function RAGPage() {
           </div>
           <div className="bg-white rounded-xl p-4 border border-slate-200">
             <p className="text-xs font-medium text-emerald-600 uppercase mb-1">NiBiS EH</p>
-            <p className="text-2xl font-bold text-slate-900">28.662</p>
+            <p className="text-2xl font-bold text-slate-900">7.996</p>
             <p className="text-xs text-slate-500">Chunks &middot; Bildungs-Erwartungshorizonte</p>
           </div>
           <div className="bg-white rounded-xl p-4 border border-slate-200">
             <p className="text-xs font-medium text-orange-600 uppercase mb-1">Legal Templates</p>
-            <p className="text-2xl font-bold text-slate-900">824</p>
+            <p className="text-2xl font-bold text-slate-900">7.689</p>
             <p className="text-xs text-slate-500">Chunks &middot; Dokumentvorlagen</p>
           </div>
         </div>
@@ -1876,8 +2179,8 @@ export default function RAGPage() {
                   className="p-4 rounded-lg border border-blue-200 bg-blue-50 hover:bg-blue-100 transition-colors text-left"
                 >
                   <p className="text-xs font-medium text-blue-600 uppercase">Gesetze & Regulierungen</p>
-                  <p className="text-2xl font-bold text-slate-900 mt-1">{loading ? '-' : getTotalChunks().toLocaleString()}</p>
-                  <p className="text-xs text-slate-500 mt-1">{REGULATIONS.length} Regulierungen (EU, DE, BSI)</p>
+                  <p className="text-2xl font-bold text-slate-900 mt-1">{COLLECTION_TOTALS.total_legal.toLocaleString()}</p>
+                  <p className="text-xs text-slate-500 mt-1">{Object.keys(REGULATIONS_IN_RAG).length}/{REGULATIONS.length} im RAG</p>
                 </button>
                 <button
                   onClick={() => { setRegulationCategory('dsfa'); setActiveTab('regulations') }}
@@ -1889,12 +2192,12 @@ export default function RAGPage() {
                 </button>
                 <div className="p-4 rounded-lg border border-emerald-200 bg-emerald-50 text-left">
                   <p className="text-xs font-medium text-emerald-600 uppercase">NiBiS EH</p>
-                  <p className="text-2xl font-bold text-slate-900 mt-1">28.662</p>
+                  <p className="text-2xl font-bold text-slate-900 mt-1">7.996</p>
                   <p className="text-xs text-slate-500 mt-1">Chunks &middot; Bildungs-Erwartungshorizonte</p>
                 </div>
                 <div className="p-4 rounded-lg border border-orange-200 bg-orange-50 text-left">
                   <p className="text-xs font-medium text-orange-600 uppercase">Legal Templates</p>
-                  <p className="text-2xl font-bold text-slate-900 mt-1">824</p>
+                  <p className="text-2xl font-bold text-slate-900 mt-1">7.689</p>
                   <p className="text-xs text-slate-500 mt-1">Chunks &middot; Dokumentvorlagen (VVT, TOM, DSFA)</p>
                 </div>
               </div>
@@ -1904,12 +2207,13 @@ export default function RAGPage() {
             <div className="grid grid-cols-1 md:grid-cols-4 gap-4">
               {Object.entries(TYPE_LABELS).map(([type, label]) => {
                 const regs = REGULATIONS.filter((r) => r.type === type)
-                const totalChunks = regs.reduce((sum, r) => sum + getRegulationChunks(r.code), 0)
+                const inRagCount = regs.filter((r) => isInRag(r.code)).length
+                const totalChunks = regs.reduce((sum, r) => sum + getKnownChunks(r.code), 0)
                 return (
                   <div key={type} className="bg-white rounded-xl p-4 border border-slate-200">
                     <div className="flex items-center gap-2 mb-2">
                       <span className={`px-2 py-0.5 text-xs rounded ${TYPE_COLORS[type]}`}>{label}</span>
-                      <span className="text-slate-500 text-sm">{regs.length} Dok.</span>
+                      <span className="text-slate-500 text-sm">{inRagCount}/{regs.length} im RAG</span>
                     </div>
                     <p className="text-xl font-bold text-slate-900">{totalChunks.toLocaleString()} Chunks</p>
                   </div>
@@ -1923,20 +2227,25 @@ export default function RAGPage() {
                 <h3 className="font-semibold text-slate-900">Top Regulierungen (nach Chunks)</h3>
               </div>
               <div className="divide-y">
-                {REGULATIONS.sort((a, b) => getRegulationChunks(b.code) - getRegulationChunks(a.code))
-                  .slice(0, 5)
+                {[...REGULATIONS].sort((a, b) => getKnownChunks(b.code) - getKnownChunks(a.code))
+                  .slice(0, 10)
                   .map((reg) => {
-                    const chunks = getRegulationChunks(reg.code)
+                    const chunks = getKnownChunks(reg.code)
                     return (
                       <div key={reg.code} className="px-4 py-3 flex items-center justify-between">
                         <div className="flex items-center gap-3">
+                          {isInRag(reg.code) ? (
+                            <span className="text-green-500 text-sm">✓</span>
+                          ) : (
+                            <span className="text-red-400 text-sm">✗</span>
+                          )}
                           <span className={`px-2 py-0.5 text-xs rounded ${TYPE_COLORS[reg.type]}`}>
                             {TYPE_LABELS[reg.type]}
                           </span>
                           <span className="font-medium text-slate-900">{reg.name}</span>
                           <span className="text-slate-500 text-sm">({reg.code})</span>
                         </div>
-                        <span className="font-bold text-teal-600">{chunks.toLocaleString()} Chunks</span>
+                        <span className={`font-bold ${chunks > 0 ? 'text-teal-600' : 'text-slate-300'}`}>{chunks > 0 ? chunks.toLocaleString() + ' Chunks' : '—'}</span>
                       </div>
                     )
                   })}
@@ -1995,7 +2304,13 @@ export default function RAGPage() {
             {regulationCategory === 'regulations' && (
           <div className="bg-white rounded-xl border border-slate-200 overflow-hidden">
             <div className="px-4 py-3 border-b bg-slate-50 flex items-center justify-between">
-              <h3 className="font-semibold text-slate-900">Alle {REGULATIONS.length} Regulierungen</h3>
+              <h3 className="font-semibold text-slate-900">
+                Alle {REGULATIONS.length} Regulierungen
+                <span className="ml-2 text-sm font-normal text-slate-500">
+                  ({REGULATIONS.filter(r => isInRag(r.code)).length} im RAG,{' '}
+                  {REGULATIONS.filter(r => !isInRag(r.code)).length} ausstehend)
+                </span>
+              </h3>
               <button
                 onClick={fetchStatus}
                 className="text-sm text-teal-600 hover:text-teal-700"
@@ -2007,6 +2322,7 @@ export default function RAGPage() {
               <table className="w-full">
                 <thead className="bg-slate-50 border-b">
                   <tr>
+                    <th className="px-4 py-3 text-center text-xs font-medium text-slate-500 uppercase w-12">RAG</th>
                     <th className="px-4 py-3 text-left text-xs font-medium text-slate-500 uppercase">Code</th>
                     <th className="px-4 py-3 text-left text-xs font-medium text-slate-500 uppercase">Typ</th>
                     <th className="px-4 py-3 text-left text-xs font-medium text-slate-500 uppercase">Name</th>
@@ -2017,17 +2333,10 @@ export default function RAGPage() {
                 </thead>
                 <tbody className="divide-y">
                   {REGULATIONS.map((reg) => {
-                    const chunks = getRegulationChunks(reg.code)
-                    const ratio = chunks / (reg.expected * 10) // Rough estimate: 10 chunks per requirement
-                    let statusColor = 'text-red-500'
-                    let statusIcon = '❌'
-                    if (ratio > 0.5) {
-                      statusColor = 'text-green-500'
-                      statusIcon = '✓'
-                    } else if (ratio > 0.1) {
-                      statusColor = 'text-yellow-500'
-                      statusIcon = '⚠'
-                    }
+                    const chunks = getKnownChunks(reg.code)
+                    const inRag = isInRag(reg.code)
+                    let statusColor = inRag ? 'text-green-500' : 'text-red-500'
+                    let statusIcon = inRag ? '✓' : '❌'
                     const isExpanded = expandedRegulation === reg.code
 
                     return (
@@ -2036,6 +2345,13 @@ export default function RAGPage() {
                           onClick={() => setExpandedRegulation(isExpanded ? null : reg.code)}
                           className="hover:bg-slate-50 cursor-pointer transition-colors"
                         >
+                          <td className="px-4 py-3 text-center">
+                            {isInRag(reg.code) ? (
+                              <span className="inline-flex items-center justify-center w-6 h-6 bg-green-100 text-green-600 rounded-full text-xs font-bold" title="Im RAG vorhanden">✓</span>
+                            ) : (
+                              <span className="inline-flex items-center justify-center w-6 h-6 bg-red-50 text-red-400 rounded-full text-xs font-bold" title="Nicht im RAG">✗</span>
+                            )}
+                          </td>
                           <td className="px-4 py-3 font-mono font-medium text-teal-600">
                             <span className="inline-flex items-center gap-2">
                               <span className={`transform transition-transform ${isExpanded ? 'rotate-90' : ''}`}>▶</span>
@@ -2048,13 +2364,20 @@ export default function RAGPage() {
                             </span>
                           </td>
                           <td className="px-4 py-3 text-slate-900">{reg.name}</td>
-                          <td className="px-4 py-3 text-right font-bold">{chunks.toLocaleString()}</td>
+                          <td className="px-4 py-3 text-right font-bold">
+                            <span className={chunks > 0 && chunks < 10 && reg.expected >= 10 ? 'text-amber-600' : ''}>
+                              {chunks.toLocaleString()}
+                              {chunks > 0 && chunks < 10 && reg.expected >= 10 && (
+                                <span className="ml-1 inline-block w-4 h-4 text-[10px] leading-4 text-center bg-amber-100 text-amber-700 rounded-full" title="Verdaechtig niedrig — Ingestion pruefen">⚠</span>
+                              )}
+                            </span>
+                          </td>
                           <td className="px-4 py-3 text-right text-slate-500">{reg.expected}</td>
                           <td className={`px-4 py-3 text-center ${statusColor}`}>{statusIcon}</td>
                         </tr>
                         {isExpanded && (
                           <tr key={`${reg.code}-detail`} className="bg-slate-50">
-                            <td colSpan={6} className="px-4 py-4">
+                            <td colSpan={7} className="px-4 py-4">
                               <div className="bg-white rounded-lg border border-slate-200 p-4 space-y-3">
                                 <div>
                                   <h4 className="font-semibold text-slate-900 mb-1">{reg.fullName}</h4>
@@ -2094,16 +2417,28 @@ export default function RAGPage() {
                                       </span>
                                     )}
                                   </div>
-                                  <button
-                                    onClick={(e) => {
-                                      e.stopPropagation()
-                                      setSearchQuery(reg.name)
-                                      setActiveTab('search')
-                                    }}
-                                    className="text-teal-600 hover:text-teal-700 font-medium"
-                                  >
-                                    In Chunks suchen →
-                                  </button>
+                                  <div className="flex items-center gap-3">
+                                    {REGULATION_SOURCES[reg.code] && (
+                                      <a
+                                        href={REGULATION_SOURCES[reg.code]}
+                                        target="_blank"
+                                        rel="noopener noreferrer"
+                                        onClick={(e) => e.stopPropagation()}
+                                        className="text-blue-600 hover:text-blue-700 font-medium"
+                                      >
+                                        Originalquelle →
+                                      </a>
+                                    )}
+                                    <button
+                                      onClick={(e) => {
+                                        e.stopPropagation()
+                                        setActiveTab('chunks')
+                                      }}
+                                      className="text-teal-600 hover:text-teal-700 font-medium"
+                                    >
+                                      In Chunks suchen →
+                                    </button>
+                                  </div>
                                 </div>
                               </div>
                             </td>
@@ -2232,7 +2567,7 @@ export default function RAGPage() {
                 <div className="grid grid-cols-3 gap-4 mb-4">
                   <div className="bg-emerald-50 rounded-lg p-4 border border-emerald-200">
                     <p className="text-sm text-emerald-600 font-medium">Chunks</p>
-                    <p className="text-2xl font-bold text-slate-900">28.662</p>
+                    <p className="text-2xl font-bold text-slate-900">7.996</p>
                   </div>
                   <div className="bg-emerald-50 rounded-lg p-4 border border-emerald-200">
                     <p className="text-sm text-emerald-600 font-medium">Vector Size</p>
@@ -2264,7 +2599,7 @@ export default function RAGPage() {
                 <div className="grid grid-cols-3 gap-4 mb-4">
                   <div className="bg-orange-50 rounded-lg p-4 border border-orange-200">
                     <p className="text-sm text-orange-600 font-medium">Chunks</p>
-                    <p className="text-2xl font-bold text-slate-900">824</p>
+                    <p className="text-2xl font-bold text-slate-900">7.689</p>
                   </div>
                   <div className="bg-orange-50 rounded-lg p-4 border border-orange-200">
                     <p className="text-sm text-orange-600 font-medium">Vector Size</p>
@@ -2332,20 +2667,28 @@ export default function RAGPage() {
                           </div>
                         </div>
                         <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-3">
-                          {regs.map((reg) => (
+                          {regs.map((reg) => {
+                            const regInRag = isInRag(reg.code)
+                            return (
                             <div
                               key={reg.code}
-                              className="bg-white p-3 rounded-lg border border-slate-200"
+                              className={`bg-white p-3 rounded-lg border ${regInRag ? 'border-green-200' : 'border-slate-200'}`}
                             >
                               <div className="flex items-center gap-2 mb-1">
                                 <span className={`px-2 py-0.5 text-xs rounded ${TYPE_COLORS[reg.type]}`}>
                                   {reg.code}
                                 </span>
+                                {regInRag ? (
+                                  <span className="px-1.5 py-0.5 text-[10px] font-bold bg-green-100 text-green-600 rounded">RAG</span>
+                                ) : (
+                                  <span className="px-1.5 py-0.5 text-[10px] font-bold bg-red-50 text-red-400 rounded">✗</span>
+                                )}
                               </div>
                               <div className="font-medium text-sm text-slate-900">{reg.name}</div>
                               <div className="text-xs text-slate-500 mt-1 line-clamp-2">{reg.description}</div>
                             </div>
-                          ))}
+                            )
+                          })}
                         </div>
                       </>
                     )
@@ -2372,17 +2715,22 @@ export default function RAGPage() {
                       <div className="flex flex-wrap gap-2">
                         {group.regulations.map((code) => {
                           const reg = REGULATIONS.find(r => r.code === code)
+                          const codeInRag = isInRag(code)
                           return (
                             <span
                               key={code}
-                              className="px-3 py-1.5 bg-slate-100 rounded-full text-sm font-medium text-slate-700 hover:bg-slate-200 cursor-pointer"
+                              className={`px-3 py-1.5 rounded-full text-sm font-medium cursor-pointer ${
+                                codeInRag
+                                  ? 'bg-green-100 text-green-700 hover:bg-green-200'
+                                  : 'bg-slate-100 text-slate-700 hover:bg-slate-200'
+                              }`}
                               onClick={() => {
                                 setActiveTab('regulations')
                                 setExpandedRegulation(code)
                               }}
-                              title={reg?.fullName || code}
+                              title={`${reg?.fullName || code}${codeInRag ? ' (im RAG)' : ' (nicht im RAG)'}`}
                             >
-                              {code}
+                              {codeInRag ? '✓ ' : '✗ '}{code}
                             </span>
                           )
                         })}
@@ -2406,9 +2754,13 @@ export default function RAGPage() {
                       {intersection.regulations.map((code) => (
                         <span
                           key={code}
-                          className="px-2 py-0.5 text-xs font-medium bg-teal-100 text-teal-700 rounded"
+                          className={`px-2 py-0.5 text-xs font-medium rounded ${
+                            isInRag(code)
+                              ? 'bg-green-100 text-green-700'
+                              : 'bg-red-50 text-red-500'
+                          }`}
                         >
-                          {code}
+                          {isInRag(code) ? '✓ ' : '✗ '}{code}
                         </span>
                       ))}
                     </div>
@@ -2443,8 +2795,15 @@ export default function RAGPage() {
                   <tbody className="divide-y">
                     {REGULATIONS.map((reg) => (
                       <tr key={reg.code} className="hover:bg-slate-50">
-                        <td className="px-2 py-2 font-medium text-teal-600 sticky left-0 bg-white">
-                          {reg.code}
+                        <td className="px-2 py-2 font-medium sticky left-0 bg-white">
+                          <span className="flex items-center gap-1">
+                            {isInRag(reg.code) ? (
+                              <span className="text-green-500 text-[10px]">●</span>
+                            ) : (
+                              <span className="text-red-300 text-[10px]">○</span>
+                            )}
+                            <span className="text-teal-600">{reg.code}</span>
+                          </span>
                         </td>
                         {INDUSTRIES.filter(i => i.id !== 'all').map((industry) => {
                           const applies = INDUSTRY_REGULATION_MAP[industry.id]?.includes(reg.code)
@@ -2531,27 +2890,33 @@ export default function RAGPage() {
               </div>
             </div>
 
-            {/* Integrated Regulations */}
+            {/* RAG Coverage Overview */}
             <div className="bg-white rounded-xl border border-slate-200 p-6">
               <div className="flex items-center gap-3 mb-4">
                 <span className="text-2xl">✅</span>
                 <div>
-                  <h3 className="font-semibold text-slate-900">Neu integrierte Regulierungen</h3>
-                  <p className="text-sm text-slate-500">Jetzt im RAG-System verfuegbar (Stand: Januar 2025)</p>
+                  <h3 className="font-semibold text-slate-900">RAG-Abdeckung ({Object.keys(REGULATIONS_IN_RAG).length} von {REGULATIONS.length} Regulierungen)</h3>
+                  <p className="text-sm text-slate-500">Stand: Februar 2026 — Alle im RAG-System verfuegbaren Regulierungen</p>
                 </div>
               </div>
 
-              <div className="grid grid-cols-2 md:grid-cols-5 gap-3">
-                {INTEGRATED_REGULATIONS.map((reg) => (
-                  <div key={reg.code} className="rounded-lg border border-green-200 bg-green-50 p-3 text-center">
-                    <span className="px-2 py-1 text-sm font-bold bg-green-100 text-green-700 rounded">
-                      {reg.code}
-                    </span>
-                    <p className="text-xs text-slate-600 mt-2">{reg.name}</p>
-                    <p className="text-xs text-green-600 mt-1">Im RAG</p>
-                  </div>
+              <div className="flex flex-wrap gap-2">
+                {REGULATIONS.filter(r => isInRag(r.code)).map((reg) => (
+                  <span key={reg.code} className="px-2.5 py-1 text-xs font-medium bg-green-100 text-green-700 rounded-full border border-green-200">
+                    ✓ {reg.code}
+                  </span>
                 ))}
               </div>
+              <div className="mt-4 pt-4 border-t border-slate-100">
+                <p className="text-xs font-medium text-slate-500 mb-2">Noch nicht im RAG:</p>
+                <div className="flex flex-wrap gap-2">
+                  {REGULATIONS.filter(r => !isInRag(r.code)).map((reg) => (
+                    <span key={reg.code} className="px-2.5 py-1 text-xs font-medium bg-red-50 text-red-400 rounded-full border border-red-100">
+                      ✗ {reg.code}
+                    </span>
+                  ))}
+                </div>
+              </div>
             </div>
 
             {/* Potential Future Regulations */}
@@ -2714,6 +3079,10 @@ export default function RAGPage() {
           </div>
         )}
 
+        {activeTab === 'chunks' && (
+          <ChunkBrowserQA apiProxy={API_PROXY} />
+        )}
+
         {activeTab === 'data' && (
           <div className="space-y-6">
             {/* Upload Document */}
@@ -2899,7 +3268,7 @@ export default function RAGPage() {
                   <span className="flex items-center gap-2 text-teal-600">
                     <svg className="animate-spin h-4 w-4" fill="none" viewBox="0 0 24 24">
                       <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.7.689 3 7.938l3-2.647z" />
                     </svg>
                     Ingestion laeuft...
                   </span>
@@ -2969,7 +3338,7 @@ export default function RAGPage() {
                     {pipelineStarting ? (
                       <svg className="animate-spin h-4 w-4" fill="none" viewBox="0 0 24 24">
                         <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.7.689 3 7.938l3-2.647z" />
                       </svg>
                     ) : (
                       <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -2988,7 +3357,7 @@ export default function RAGPage() {
                   {pipelineLoading ? (
                     <svg className="animate-spin h-4 w-4" fill="none" viewBox="0 0 24 24">
                       <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.7.689 3 7.938l3-2.647z" />
                     </svg>
                   ) : (
                     <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -3021,7 +3390,7 @@ export default function RAGPage() {
                     <>
                       <svg className="animate-spin h-5 w-5" fill="none" viewBox="0 0 24 24">
                         <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                        <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.7.689 3 7.938l3-2.647z" />
                       </svg>
                       Startet...
                     </>
@@ -3058,7 +3427,7 @@ export default function RAGPage() {
                         {pipelineState.status === 'running' && (
                           <svg className="w-6 h-6 text-blue-600 animate-spin" fill="none" viewBox="0 0 24 24">
                             <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" />
-                            <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" />
+                            <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.7.689 3 7.938l3-2.647z" />
                           </svg>
                         )}
                         {pipelineState.status === 'failed' && (

admin-lehrer/app/(admin)/ai/rag/rag-constants.ts

@@ -0,0 +1,367 @@
+/**
+ * Shared RAG constants used by both page.tsx and ChunkBrowserQA.
+ * REGULATIONS_IN_RAG maps regulation codes to their Qdrant collection, chunk count, and qdrant_id.
+ * The qdrant_id is the actual `regulation_id` value stored in Qdrant payloads.
+ * REGULATION_INFO provides minimal metadata (code, name, type) for all regulations.
+ */
+
+export interface RagRegulationEntry {
+  collection: string
+  chunks: number
+  qdrant_id: string  // The actual regulation_id value in Qdrant payload
+}
+
+export const REGULATIONS_IN_RAG: Record<string, RagRegulationEntry> = {
+  // === EU Verordnungen/Richtlinien (bp_compliance_ce) ===
+  GDPR: { collection: 'bp_compliance_ce', chunks: 423, qdrant_id: 'eu_2016_679' },
+  EPRIVACY: { collection: 'bp_compliance_ce', chunks: 134, qdrant_id: 'eu_2002_58' },
+  SCC: { collection: 'bp_compliance_ce', chunks: 330, qdrant_id: 'eu_2021_914' },
+  SCC_FULL_TEXT: { collection: 'bp_compliance_ce', chunks: 330, qdrant_id: 'eu_2021_914' },
+  AIACT: { collection: 'bp_compliance_ce', chunks: 726, qdrant_id: 'eu_2024_1689' },
+  CRA: { collection: 'bp_compliance_ce', chunks: 429, qdrant_id: 'eu_2024_2847' },
+  NIS2: { collection: 'bp_compliance_ce', chunks: 342, qdrant_id: 'eu_2022_2555' },
+  DGA: { collection: 'bp_compliance_ce', chunks: 508, qdrant_id: 'eu_2022_868' },
+  DSA: { collection: 'bp_compliance_ce', chunks: 1106, qdrant_id: 'eu_2022_2065' },
+  PLD: { collection: 'bp_compliance_ce', chunks: 44, qdrant_id: 'eu_1985_374' },
+  E_COMMERCE_RL: { collection: 'bp_compliance_ce', chunks: 197, qdrant_id: 'eu_2000_31' },
+  VERBRAUCHERRECHTE_RL: { collection: 'bp_compliance_ce', chunks: 266, qdrant_id: 'eu_2011_83' },
+  DIGITALE_INHALTE_RL: { collection: 'bp_compliance_ce', chunks: 321, qdrant_id: 'eu_2019_770' },
+  DMA: { collection: 'bp_compliance_ce', chunks: 701, qdrant_id: 'eu_2022_1925' },
+  DPF: { collection: 'bp_compliance_ce', chunks: 2464, qdrant_id: 'dpf' },
+  EUCSA: { collection: 'bp_compliance_ce', chunks: 558, qdrant_id: 'eucsa' },
+  DATAACT: { collection: 'bp_compliance_ce', chunks: 809, qdrant_id: 'dataact' },
+  DORA: { collection: 'bp_compliance_ce', chunks: 823, qdrant_id: 'dora' },
+  PSD2: { collection: 'bp_compliance_ce', chunks: 796, qdrant_id: 'psd2' },
+  AMLR: { collection: 'bp_compliance_ce', chunks: 1182, qdrant_id: 'amlr' },
+  MiCA: { collection: 'bp_compliance_ce', chunks: 1640, qdrant_id: 'mica' },
+  EHDS: { collection: 'bp_compliance_ce', chunks: 1212, qdrant_id: 'ehds' },
+  EAA: { collection: 'bp_compliance_ce', chunks: 433, qdrant_id: 'eaa' },
+  DSM: { collection: 'bp_compliance_ce', chunks: 416, qdrant_id: 'dsm' },
+  GPSR: { collection: 'bp_compliance_ce', chunks: 509, qdrant_id: 'gpsr' },
+  MACHINERY_REG: { collection: 'bp_compliance_ce', chunks: 1271, qdrant_id: 'eu_2023_1230' },
+  BLUE_GUIDE: { collection: 'bp_compliance_ce', chunks: 2271, qdrant_id: 'eu_blue_guide_2022' },
+  EU_IFRS_DE: { collection: 'bp_compliance_ce', chunks: 34388, qdrant_id: 'eu_2023_1803' },
+  EU_IFRS_EN: { collection: 'bp_compliance_ce', chunks: 34388, qdrant_id: 'eu_2023_1803' },
+  // International standards in bp_compliance_ce
+  NIST_SSDF: { collection: 'bp_compliance_ce', chunks: 111, qdrant_id: 'nist_sp_800_218' },
+  NIST_CSF_2: { collection: 'bp_compliance_ce', chunks: 67, qdrant_id: 'nist_csf_2_0' },
+  OECD_AI_PRINCIPLES: { collection: 'bp_compliance_ce', chunks: 34, qdrant_id: 'oecd_ai_principles' },
+  ENISA_SECURE_BY_DESIGN: { collection: 'bp_compliance_ce', chunks: 97, qdrant_id: 'cisa_secure_by_design' },
+  ENISA_SUPPLY_CHAIN: { collection: 'bp_compliance_ce', chunks: 110, qdrant_id: 'enisa_supply_chain_good_practices' },
+  ENISA_THREAT_LANDSCAPE: { collection: 'bp_compliance_ce', chunks: 118, qdrant_id: 'enisa_threat_landscape_supply_chain' },
+  ENISA_ICS_SCADA: { collection: 'bp_compliance_ce', chunks: 195, qdrant_id: 'enisa_ics_scada_dependencies' },
+  ENISA_CYBERSECURITY_2024: { collection: 'bp_compliance_ce', chunks: 22, qdrant_id: 'enisa_cybersecurity_state_2024' },
+
+  // === DE Gesetze (bp_compliance_gesetze) ===
+  TDDDG: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'tdddg_25' },
+  TMG_KOMPLETT: { collection: 'bp_compliance_gesetze', chunks: 108, qdrant_id: 'tmg_komplett' },
+  BDSG_FULL: { collection: 'bp_compliance_gesetze', chunks: 1056, qdrant_id: 'bdsg_2018_komplett' },
+  DE_DDG: { collection: 'bp_compliance_gesetze', chunks: 40, qdrant_id: 'ddg_5' },
+  DE_BGB_AGB: { collection: 'bp_compliance_gesetze', chunks: 4024, qdrant_id: 'bgb_komplett' },
+  DE_EGBGB: { collection: 'bp_compliance_gesetze', chunks: 36, qdrant_id: 'egbgb_widerruf' },
+  DE_HGB_RET: { collection: 'bp_compliance_gesetze', chunks: 11363, qdrant_id: 'hgb_komplett' },
+  DE_AO_RET: { collection: 'bp_compliance_gesetze', chunks: 9669, qdrant_id: 'ao_komplett' },
+  DE_TKG: { collection: 'bp_compliance_gesetze', chunks: 1631, qdrant_id: 'de_tkg' },
+  DE_DLINFOV: { collection: 'bp_compliance_gesetze', chunks: 21, qdrant_id: 'de_dlinfov' },
+  DE_BETRVG: { collection: 'bp_compliance_gesetze', chunks: 498, qdrant_id: 'de_betrvg' },
+  DE_GESCHGEHG: { collection: 'bp_compliance_gesetze', chunks: 63, qdrant_id: 'de_geschgehg' },
+  DE_USTG_RET: { collection: 'bp_compliance_gesetze', chunks: 1071, qdrant_id: 'de_ustg_ret' },
+  DE_URHG: { collection: 'bp_compliance_gesetze', chunks: 626, qdrant_id: 'urhg_komplett' },
+
+  // === BSI Standards (bp_compliance_gesetze) ===
+  'BSI-TR-03161-1': { collection: 'bp_compliance_gesetze', chunks: 138, qdrant_id: 'bsi_tr_03161_1' },
+  'BSI-TR-03161-2': { collection: 'bp_compliance_gesetze', chunks: 124, qdrant_id: 'bsi_tr_03161_2' },
+  'BSI-TR-03161-3': { collection: 'bp_compliance_gesetze', chunks: 121, qdrant_id: 'bsi_tr_03161_3' },
+
+  // === AT Gesetze (bp_compliance_gesetze) ===
+  AT_DSG: { collection: 'bp_compliance_gesetze', chunks: 805, qdrant_id: 'at_dsg' },
+  AT_DSG_FULL: { collection: 'bp_compliance_gesetze', chunks: 6, qdrant_id: 'at_dsg_full' },
+  AT_ECG: { collection: 'bp_compliance_gesetze', chunks: 120, qdrant_id: 'at_ecg' },
+  AT_TKG: { collection: 'bp_compliance_gesetze', chunks: 4348, qdrant_id: 'at_tkg' },
+  AT_KSCHG: { collection: 'bp_compliance_gesetze', chunks: 402, qdrant_id: 'at_kschg' },
+  AT_FAGG: { collection: 'bp_compliance_gesetze', chunks: 2, qdrant_id: 'at_fagg' },
+  AT_UGB_RET: { collection: 'bp_compliance_gesetze', chunks: 2828, qdrant_id: 'at_ugb_ret' },
+  AT_BAO_RET: { collection: 'bp_compliance_gesetze', chunks: 2246, qdrant_id: 'at_bao_ret' },
+  AT_MEDIENG: { collection: 'bp_compliance_gesetze', chunks: 571, qdrant_id: 'at_medieng' },
+  AT_ABGB_AGB: { collection: 'bp_compliance_gesetze', chunks: 2521, qdrant_id: 'at_abgb_agb' },
+  AT_UWG: { collection: 'bp_compliance_gesetze', chunks: 403, qdrant_id: 'at_uwg' },
+
+  // === CH Gesetze (bp_compliance_gesetze) ===
+  CH_DSG: { collection: 'bp_compliance_gesetze', chunks: 180, qdrant_id: 'ch_revdsg' },
+  CH_DSV: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'ch_dsv' },
+  CH_OR_AGB: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'ch_or_agb' },
+  CH_GEBUV: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'ch_gebuv' },
+  CH_ZERTES: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'ch_zertes' },
+  CH_ZGB_PERS: { collection: 'bp_compliance_gesetze', chunks: 5, qdrant_id: 'ch_zgb_pers' },
+
+  // === Nationale Gesetze (andere EU) in bp_compliance_gesetze ===
+  ES_LOPDGDD: { collection: 'bp_compliance_gesetze', chunks: 782, qdrant_id: 'es_lopdgdd' },
+  IT_CODICE_PRIVACY: { collection: 'bp_compliance_gesetze', chunks: 59, qdrant_id: 'it_codice_privacy' },
+  NL_UAVG: { collection: 'bp_compliance_gesetze', chunks: 523, qdrant_id: 'nl_uavg' },
+  FR_CNIL_GUIDE: { collection: 'bp_compliance_gesetze', chunks: 562, qdrant_id: 'fr_loi_informatique' },
+  IE_DPA_2018: { collection: 'bp_compliance_gesetze', chunks: 64, qdrant_id: 'ie_dpa_2018' },
+  UK_DPA_2018: { collection: 'bp_compliance_gesetze', chunks: 156, qdrant_id: 'uk_dpa_2018' },
+  UK_GDPR: { collection: 'bp_compliance_gesetze', chunks: 45, qdrant_id: 'uk_gdpr' },
+  NO_PERSONOPPLYSNINGSLOVEN: { collection: 'bp_compliance_gesetze', chunks: 41, qdrant_id: 'no_pol' },
+  SE_DATASKYDDSLAG: { collection: 'bp_compliance_gesetze', chunks: 56, qdrant_id: 'se_dataskyddslag' },
+  PL_UODO: { collection: 'bp_compliance_gesetze', chunks: 39, qdrant_id: 'pl_ustawa' },
+  CZ_ZOU: { collection: 'bp_compliance_gesetze', chunks: 238, qdrant_id: 'cz_zakon' },
+  HU_INFOTV: { collection: 'bp_compliance_gesetze', chunks: 747, qdrant_id: 'hu_info_tv' },
+  LU_DPA_LAW: { collection: 'bp_compliance_gesetze', chunks: 2, qdrant_id: 'lu_dpa_law' },
+
+  // === EDPB Guidelines (bp_compliance_datenschutz) — alt (ingest-legal-corpus.sh) ===
+  EDPB_GUIDELINES_5_2020: { collection: 'bp_compliance_datenschutz', chunks: 236, qdrant_id: 'edpb_05_2020' },
+  EDPB_GUIDELINES_7_2020: { collection: 'bp_compliance_datenschutz', chunks: 347, qdrant_id: 'edpb_guidelines_7_2020' },
+  EDPB_GUIDELINES_1_2020: { collection: 'bp_compliance_datenschutz', chunks: 337, qdrant_id: 'edpb_01_2020' },
+  EDPB_GUIDELINES_1_2022: { collection: 'bp_compliance_datenschutz', chunks: 510, qdrant_id: 'edpb_01_2022' },
+  EDPB_GUIDELINES_2_2023: { collection: 'bp_compliance_datenschutz', chunks: 94, qdrant_id: 'edpb_02_2023' },
+  EDPB_GUIDELINES_2_2024: { collection: 'bp_compliance_datenschutz', chunks: 79, qdrant_id: 'edpb_02_2024' },
+  EDPB_GUIDELINES_4_2019: { collection: 'bp_compliance_datenschutz', chunks: 202, qdrant_id: 'edpb_04_2019' },
+  EDPB_GUIDELINES_9_2022: { collection: 'bp_compliance_datenschutz', chunks: 243, qdrant_id: 'edpb_09_2022' },
+  EDPB_DPIA_LIST: { collection: 'bp_compliance_datenschutz', chunks: 29, qdrant_id: 'edpb_dpia_list' },
+  EDPB_LEGITIMATE_INTEREST: { collection: 'bp_compliance_datenschutz', chunks: 672, qdrant_id: 'edpb_legitimate_interest' },
+  EDPS_DPIA_LIST: { collection: 'bp_compliance_datenschutz', chunks: 73, qdrant_id: 'edps_dpia_list' },
+
+  // === EDPB Guidelines (bp_compliance_datenschutz) — neu (edpb-crawler.py) ===
+  EDPB_ACCESS_01_2022: { collection: 'bp_compliance_datenschutz', chunks: 1020, qdrant_id: 'edpb_access_01_2022' },
+  EDPB_ARTICLE48_02_2024: { collection: 'bp_compliance_datenschutz', chunks: 158, qdrant_id: 'edpb_article48_02_2024' },
+  EDPB_BCR_01_2022: { collection: 'bp_compliance_datenschutz', chunks: 384, qdrant_id: 'edpb_bcr_01_2022' },
+  EDPB_BREACH_09_2022: { collection: 'bp_compliance_datenschutz', chunks: 486, qdrant_id: 'edpb_breach_09_2022' },
+  EDPB_CERTIFICATION_01_2018: { collection: 'bp_compliance_datenschutz', chunks: 160, qdrant_id: 'edpb_certification_01_2018' },
+  EDPB_CERTIFICATION_01_2019: { collection: 'bp_compliance_datenschutz', chunks: 160, qdrant_id: 'edpb_certification_01_2019' },
+  EDPB_CONNECTED_VEHICLES_01_2020: { collection: 'bp_compliance_datenschutz', chunks: 482, qdrant_id: 'edpb_connected_vehicles_01_2020' },
+  EDPB_CONSENT_05_2020: { collection: 'bp_compliance_datenschutz', chunks: 247, qdrant_id: 'edpb_consent_05_2020' },
+  EDPB_CONTROLLER_PROCESSOR_07_2020: { collection: 'bp_compliance_datenschutz', chunks: 694, qdrant_id: 'edpb_controller_processor_07_2020' },
+  EDPB_COOKIE_TASKFORCE_2023: { collection: 'bp_compliance_datenschutz', chunks: 78, qdrant_id: 'edpb_cookie_taskforce_2023' },
+  EDPB_DARK_PATTERNS_03_2022: { collection: 'bp_compliance_datenschutz', chunks: 413, qdrant_id: 'edpb_dark_patterns_03_2022' },
+  EDPB_DPBD_04_2019: { collection: 'bp_compliance_datenschutz', chunks: 216, qdrant_id: 'edpb_dpbd_04_2019' },
+  EDPB_DPIA_LIST_RECOMMENDATION: { collection: 'bp_compliance_datenschutz', chunks: 31, qdrant_id: 'edpb_dpia_list_recommendation' },
+  EDPB_EPRIVACY_02_2023: { collection: 'bp_compliance_datenschutz', chunks: 188, qdrant_id: 'edpb_eprivacy_02_2023' },
+  EDPB_FACIAL_RECOGNITION_05_2022: { collection: 'bp_compliance_datenschutz', chunks: 396, qdrant_id: 'edpb_facial_recognition_05_2022' },
+  EDPB_FINES_04_2022: { collection: 'bp_compliance_datenschutz', chunks: 346, qdrant_id: 'edpb_fines_04_2022' },
+  EDPB_GEOLOCATION_04_2020: { collection: 'bp_compliance_datenschutz', chunks: 108, qdrant_id: 'edpb_geolocation_04_2020' },
+  EDPB_GL_2_2019: { collection: 'bp_compliance_datenschutz', chunks: 107, qdrant_id: 'edpb_gl_2_2019' },
+  EDPB_HEALTH_DATA_03_2020: { collection: 'bp_compliance_datenschutz', chunks: 182, qdrant_id: 'edpb_health_data_03_2020' },
+  EDPB_LEGAL_BASIS_02_2019: { collection: 'bp_compliance_datenschutz', chunks: 107, qdrant_id: 'edpb_legal_basis_02_2019' },
+  EDPB_LEGITIMATE_INTEREST_01_2024: { collection: 'bp_compliance_datenschutz', chunks: 336, qdrant_id: 'edpb_legitimate_interest_01_2024' },
+  EDPB_RTBF_05_2019: { collection: 'bp_compliance_datenschutz', chunks: 111, qdrant_id: 'edpb_rtbf_05_2019' },
+  EDPB_RRO_09_2020: { collection: 'bp_compliance_datenschutz', chunks: 82, qdrant_id: 'edpb_rro_09_2020' },
+  EDPB_SOCIAL_MEDIA_08_2020: { collection: 'bp_compliance_datenschutz', chunks: 333, qdrant_id: 'edpb_social_media_08_2020' },
+  EDPB_TRANSFERS_01_2020: { collection: 'bp_compliance_datenschutz', chunks: 337, qdrant_id: 'edpb_transfers_01_2020' },
+  EDPB_TRANSFERS_07_2020: { collection: 'bp_compliance_datenschutz', chunks: 337, qdrant_id: 'edpb_transfers_07_2020' },
+  EDPB_VIDEO_03_2019: { collection: 'bp_compliance_datenschutz', chunks: 204, qdrant_id: 'edpb_video_03_2019' },
+  EDPB_VVA_02_2021: { collection: 'bp_compliance_datenschutz', chunks: 273, qdrant_id: 'edpb_vva_02_2021' },
+
+  // === EDPS Guidance (bp_compliance_datenschutz) ===
+  EDPS_DIGITAL_ETHICS_2018: { collection: 'bp_compliance_datenschutz', chunks: 404, qdrant_id: 'edps_digital_ethics_2018' },
+  EDPS_GENAI_ORIENTATIONS_2024: { collection: 'bp_compliance_datenschutz', chunks: 274, qdrant_id: 'edps_genai_orientations_2024' },
+
+  // === WP29 Endorsed (bp_compliance_datenschutz) ===
+  WP242_PORTABILITY: { collection: 'bp_compliance_datenschutz', chunks: 141, qdrant_id: 'wp242_portability' },
+  WP243_DPO: { collection: 'bp_compliance_datenschutz', chunks: 54, qdrant_id: 'wp243_dpo' },
+  WP244_PROFILING: { collection: 'bp_compliance_datenschutz', chunks: 247, qdrant_id: 'wp244_profiling' },
+  WP248_DPIA: { collection: 'bp_compliance_datenschutz', chunks: 288, qdrant_id: 'wp248_dpia' },
+  WP250_BREACH: { collection: 'bp_compliance_datenschutz', chunks: 201, qdrant_id: 'wp250_breach' },
+  WP259_CONSENT: { collection: 'bp_compliance_datenschutz', chunks: 496, qdrant_id: 'wp259_consent' },
+  WP260_TRANSPARENCY: { collection: 'bp_compliance_datenschutz', chunks: 558, qdrant_id: 'wp260_transparency' },
+
+  // === DSFA Muss-Listen (bp_dsfa_corpus) ===
+  DSFA_BFDI_BUND: { collection: 'bp_dsfa_corpus', chunks: 17, qdrant_id: 'dsfa_bfdi_bund' },
+  DSFA_DSK_GEMEINSAM: { collection: 'bp_dsfa_corpus', chunks: 35, qdrant_id: 'dsfa_dsk_gemeinsam' },
+  DSFA_BW: { collection: 'bp_dsfa_corpus', chunks: 41, qdrant_id: 'dsfa_bw' },
+  DSFA_BY: { collection: 'bp_dsfa_corpus', chunks: 35, qdrant_id: 'dsfa_by' },
+  DSFA_BE_OE: { collection: 'bp_dsfa_corpus', chunks: 31, qdrant_id: 'dsfa_be_oe' },
+  DSFA_BE_NOE: { collection: 'bp_dsfa_corpus', chunks: 48, qdrant_id: 'dsfa_be_noe' },
+  DSFA_BB_OE: { collection: 'bp_dsfa_corpus', chunks: 43, qdrant_id: 'dsfa_bb_oe' },
+  DSFA_BB_NOE: { collection: 'bp_dsfa_corpus', chunks: 53, qdrant_id: 'dsfa_bb_noe' },
+  DSFA_HB: { collection: 'bp_dsfa_corpus', chunks: 44, qdrant_id: 'dsfa_hb' },
+  DSFA_HH_OE: { collection: 'bp_dsfa_corpus', chunks: 58, qdrant_id: 'dsfa_hh_oe' },
+  DSFA_HH_NOE: { collection: 'bp_dsfa_corpus', chunks: 53, qdrant_id: 'dsfa_hh_noe' },
+  DSFA_MV: { collection: 'bp_dsfa_corpus', chunks: 32, qdrant_id: 'dsfa_mv' },
+  DSFA_NI: { collection: 'bp_dsfa_corpus', chunks: 47, qdrant_id: 'dsfa_ni' },
+  DSFA_RP: { collection: 'bp_dsfa_corpus', chunks: 25, qdrant_id: 'dsfa_rp' },
+  DSFA_SL: { collection: 'bp_dsfa_corpus', chunks: 35, qdrant_id: 'dsfa_sl' },
+  DSFA_SN: { collection: 'bp_dsfa_corpus', chunks: 18, qdrant_id: 'dsfa_sn' },
+  DSFA_ST_OE: { collection: 'bp_dsfa_corpus', chunks: 57, qdrant_id: 'dsfa_st_oe' },
+  DSFA_ST_NOE: { collection: 'bp_dsfa_corpus', chunks: 35, qdrant_id: 'dsfa_st_noe' },
+  DSFA_SH: { collection: 'bp_dsfa_corpus', chunks: 44, qdrant_id: 'dsfa_sh' },
+  DSFA_TH: { collection: 'bp_dsfa_corpus', chunks: 48, qdrant_id: 'dsfa_th' },
+}
+
+/**
+ * Minimal regulation info for sidebar display.
+ * Full REGULATIONS array with descriptions remains in page.tsx.
+ */
+export interface RegulationInfo {
+  code: string
+  name: string
+  type: string
+}
+
+export const REGULATION_INFO: RegulationInfo[] = [
+  // EU Verordnungen
+  { code: 'GDPR', name: 'DSGVO', type: 'eu_regulation' },
+  { code: 'EPRIVACY', name: 'ePrivacy-Richtlinie', type: 'eu_directive' },
+  { code: 'SCC', name: 'Standardvertragsklauseln', type: 'eu_regulation' },
+  { code: 'SCC_FULL_TEXT', name: 'SCC Volltext', type: 'eu_regulation' },
+  { code: 'DPF', name: 'EU-US Data Privacy Framework', type: 'eu_regulation' },
+  { code: 'AIACT', name: 'EU AI Act', type: 'eu_regulation' },
+  { code: 'CRA', name: 'Cyber Resilience Act', type: 'eu_regulation' },
+  { code: 'NIS2', name: 'NIS2-Richtlinie', type: 'eu_directive' },
+  { code: 'EUCSA', name: 'EU Cybersecurity Act', type: 'eu_regulation' },
+  { code: 'DATAACT', name: 'Data Act', type: 'eu_regulation' },
+  { code: 'DGA', name: 'Data Governance Act', type: 'eu_regulation' },
+  { code: 'DSA', name: 'Digital Services Act', type: 'eu_regulation' },
+  { code: 'DMA', name: 'Digital Markets Act', type: 'eu_regulation' },
+  { code: 'EAA', name: 'European Accessibility Act', type: 'eu_directive' },
+  { code: 'DSM', name: 'DSM-Urheberrechtsrichtlinie', type: 'eu_directive' },
+  { code: 'PLD', name: 'Produkthaftungsrichtlinie', type: 'eu_directive' },
+  { code: 'GPSR', name: 'General Product Safety', type: 'eu_regulation' },
+  { code: 'E_COMMERCE_RL', name: 'E-Commerce-Richtlinie', type: 'eu_directive' },
+  { code: 'VERBRAUCHERRECHTE_RL', name: 'Verbraucherrechte-RL', type: 'eu_directive' },
+  { code: 'DIGITALE_INHALTE_RL', name: 'Digitale-Inhalte-RL', type: 'eu_directive' },
+  // Financial
+  { code: 'DORA', name: 'DORA', type: 'eu_regulation' },
+  { code: 'PSD2', name: 'PSD2', type: 'eu_directive' },
+  { code: 'AMLR', name: 'AML-Verordnung', type: 'eu_regulation' },
+  { code: 'MiCA', name: 'MiCA', type: 'eu_regulation' },
+  { code: 'EHDS', name: 'EHDS', type: 'eu_regulation' },
+  { code: 'MACHINERY_REG', name: 'Maschinenverordnung', type: 'eu_regulation' },
+  { code: 'BLUE_GUIDE', name: 'Blue Guide', type: 'eu_regulation' },
+  { code: 'EU_IFRS_DE', name: 'EU-IFRS (DE)', type: 'eu_regulation' },
+  { code: 'EU_IFRS_EN', name: 'EU-IFRS (EN)', type: 'eu_regulation' },
+  // DE Gesetze
+  { code: 'TDDDG', name: 'TDDDG', type: 'de_law' },
+  { code: 'TMG_KOMPLETT', name: 'TMG', type: 'de_law' },
+  { code: 'BDSG_FULL', name: 'BDSG', type: 'de_law' },
+  { code: 'DE_DDG', name: 'DDG', type: 'de_law' },
+  { code: 'DE_BGB_AGB', name: 'BGB/AGB', type: 'de_law' },
+  { code: 'DE_EGBGB', name: 'EGBGB', type: 'de_law' },
+  { code: 'DE_HGB_RET', name: 'HGB', type: 'de_law' },
+  { code: 'DE_AO_RET', name: 'AO', type: 'de_law' },
+  { code: 'DE_TKG', name: 'TKG', type: 'de_law' },
+  { code: 'DE_DLINFOV', name: 'DL-InfoV', type: 'de_law' },
+  { code: 'DE_BETRVG', name: 'BetrVG', type: 'de_law' },
+  { code: 'DE_GESCHGEHG', name: 'GeschGehG', type: 'de_law' },
+  { code: 'DE_USTG_RET', name: 'UStG', type: 'de_law' },
+  { code: 'DE_URHG', name: 'UrhG', type: 'de_law' },
+  // BSI
+  { code: 'BSI-TR-03161-1', name: 'BSI-TR Teil 1', type: 'bsi_standard' },
+  { code: 'BSI-TR-03161-2', name: 'BSI-TR Teil 2', type: 'bsi_standard' },
+  { code: 'BSI-TR-03161-3', name: 'BSI-TR Teil 3', type: 'bsi_standard' },
+  // AT
+  { code: 'AT_DSG', name: 'DSG Oesterreich', type: 'at_law' },
+  { code: 'AT_DSG_FULL', name: 'DSG Volltext', type: 'at_law' },
+  { code: 'AT_ECG', name: 'ECG', type: 'at_law' },
+  { code: 'AT_TKG', name: 'TKG AT', type: 'at_law' },
+  { code: 'AT_KSCHG', name: 'KSchG', type: 'at_law' },
+  { code: 'AT_FAGG', name: 'FAGG', type: 'at_law' },
+  { code: 'AT_UGB_RET', name: 'UGB', type: 'at_law' },
+  { code: 'AT_BAO_RET', name: 'BAO', type: 'at_law' },
+  { code: 'AT_MEDIENG', name: 'MedienG', type: 'at_law' },
+  { code: 'AT_ABGB_AGB', name: 'ABGB/AGB', type: 'at_law' },
+  { code: 'AT_UWG', name: 'UWG AT', type: 'at_law' },
+  // CH
+  { code: 'CH_DSG', name: 'DSG Schweiz', type: 'ch_law' },
+  { code: 'CH_DSV', name: 'DSV', type: 'ch_law' },
+  { code: 'CH_OR_AGB', name: 'OR/AGB', type: 'ch_law' },
+  { code: 'CH_GEBUV', name: 'GeBuV', type: 'ch_law' },
+  { code: 'CH_ZERTES', name: 'ZertES', type: 'ch_law' },
+  { code: 'CH_ZGB_PERS', name: 'ZGB', type: 'ch_law' },
+  // Andere EU nationale
+  { code: 'ES_LOPDGDD', name: 'LOPDGDD Spanien', type: 'national_law' },
+  { code: 'IT_CODICE_PRIVACY', name: 'Codice Privacy Italien', type: 'national_law' },
+  { code: 'NL_UAVG', name: 'UAVG Niederlande', type: 'national_law' },
+  { code: 'FR_CNIL_GUIDE', name: 'CNIL Guide RGPD', type: 'national_law' },
+  { code: 'IE_DPA_2018', name: 'DPA 2018 Ireland', type: 'national_law' },
+  { code: 'UK_DPA_2018', name: 'DPA 2018 UK', type: 'national_law' },
+  { code: 'UK_GDPR', name: 'UK GDPR', type: 'national_law' },
+  { code: 'NO_PERSONOPPLYSNINGSLOVEN', name: 'Personopplysningsloven', type: 'national_law' },
+  { code: 'SE_DATASKYDDSLAG', name: 'Dataskyddslag Schweden', type: 'national_law' },
+  { code: 'PL_UODO', name: 'UODO Polen', type: 'national_law' },
+  { code: 'CZ_ZOU', name: 'Zakon Tschechien', type: 'national_law' },
+  { code: 'HU_INFOTV', name: 'Infotv. Ungarn', type: 'national_law' },
+  { code: 'LU_DPA_LAW', name: 'Datenschutzgesetz Luxemburg', type: 'national_law' },
+  // EDPB Guidelines (alt)
+  { code: 'EDPB_GUIDELINES_5_2020', name: 'EDPB GL Einwilligung', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_7_2020', name: 'EDPB GL C/P Konzepte', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_1_2020', name: 'EDPB GL Fahrzeuge', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_1_2022', name: 'EDPB GL Bussgelder', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_2_2023', name: 'EDPB GL Art. 37 Scope', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_2_2024', name: 'EDPB GL Art. 48', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_4_2019', name: 'EDPB GL Art. 25 DPbD', type: 'eu_guideline' },
+  { code: 'EDPB_GUIDELINES_9_2022', name: 'EDPB GL Datenschutzverletzung', type: 'eu_guideline' },
+  { code: 'EDPB_DPIA_LIST', name: 'EDPB DPIA-Liste', type: 'eu_guideline' },
+  { code: 'EDPB_LEGITIMATE_INTEREST', name: 'EDPB Berecht. Interesse', type: 'eu_guideline' },
+  { code: 'EDPS_DPIA_LIST', name: 'EDPS DPIA-Liste', type: 'eu_guideline' },
+  // EDPB Guidelines (neu — Crawler)
+  { code: 'EDPB_ACCESS_01_2022', name: 'EDPB GL Auskunftsrecht', type: 'eu_guideline' },
+  { code: 'EDPB_ARTICLE48_02_2024', name: 'EDPB GL Art. 48', type: 'eu_guideline' },
+  { code: 'EDPB_BCR_01_2022', name: 'EDPB GL BCR', type: 'eu_guideline' },
+  { code: 'EDPB_BREACH_09_2022', name: 'EDPB GL Datenpannen', type: 'eu_guideline' },
+  { code: 'EDPB_CERTIFICATION_01_2018', name: 'EDPB GL Zertifizierung', type: 'eu_guideline' },
+  { code: 'EDPB_CERTIFICATION_01_2019', name: 'EDPB GL Zertifizierung 2019', type: 'eu_guideline' },
+  { code: 'EDPB_CONNECTED_VEHICLES_01_2020', name: 'EDPB GL Vernetzte Fahrzeuge', type: 'eu_guideline' },
+  { code: 'EDPB_CONSENT_05_2020', name: 'EDPB GL Consent', type: 'eu_guideline' },
+  { code: 'EDPB_CONTROLLER_PROCESSOR_07_2020', name: 'EDPB GL Verantwortliche/Auftragsverarbeiter', type: 'eu_guideline' },
+  { code: 'EDPB_COOKIE_TASKFORCE_2023', name: 'EDPB Cookie-Banner Taskforce', type: 'eu_guideline' },
+  { code: 'EDPB_DARK_PATTERNS_03_2022', name: 'EDPB GL Dark Patterns', type: 'eu_guideline' },
+  { code: 'EDPB_DPBD_04_2019', name: 'EDPB GL Data Protection by Design', type: 'eu_guideline' },
+  { code: 'EDPB_DPIA_LIST_RECOMMENDATION', name: 'EDPB DPIA-Empfehlung', type: 'eu_guideline' },
+  { code: 'EDPB_EPRIVACY_02_2023', name: 'EDPB GL ePrivacy', type: 'eu_guideline' },
+  { code: 'EDPB_FACIAL_RECOGNITION_05_2022', name: 'EDPB GL Gesichtserkennung', type: 'eu_guideline' },
+  { code: 'EDPB_FINES_04_2022', name: 'EDPB GL Bussgeldberechnung', type: 'eu_guideline' },
+  { code: 'EDPB_GEOLOCATION_04_2020', name: 'EDPB GL Geolokalisierung', type: 'eu_guideline' },
+  { code: 'EDPB_GL_2_2019', name: 'EDPB GL Video-Ueberwachung', type: 'eu_guideline' },
+  { code: 'EDPB_HEALTH_DATA_03_2020', name: 'EDPB GL Gesundheitsdaten', type: 'eu_guideline' },
+  { code: 'EDPB_LEGAL_BASIS_02_2019', name: 'EDPB GL Rechtsgrundlage Art. 6(1)(b)', type: 'eu_guideline' },
+  { code: 'EDPB_LEGITIMATE_INTEREST_01_2024', name: 'EDPB GL Berecht. Interesse 2024', type: 'eu_guideline' },
+  { code: 'EDPB_RTBF_05_2019', name: 'EDPB GL Recht auf Vergessenwerden', type: 'eu_guideline' },
+  { code: 'EDPB_RRO_09_2020', name: 'EDPB GL Relevant & Reasoned Objection', type: 'eu_guideline' },
+  { code: 'EDPB_SOCIAL_MEDIA_08_2020', name: 'EDPB GL Social Media Targeting', type: 'eu_guideline' },
+  { code: 'EDPB_TRANSFERS_01_2020', name: 'EDPB GL Uebermittlungen Art. 49', type: 'eu_guideline' },
+  { code: 'EDPB_TRANSFERS_07_2020', name: 'EDPB GL Drittlandtransfers', type: 'eu_guideline' },
+  { code: 'EDPB_VIDEO_03_2019', name: 'EDPB GL Videoueberwachung', type: 'eu_guideline' },
+  { code: 'EDPB_VVA_02_2021', name: 'EDPB GL Virtuelle Sprachassistenten', type: 'eu_guideline' },
+  // EDPS
+  { code: 'EDPS_DIGITAL_ETHICS_2018', name: 'EDPS Digitale Ethik', type: 'eu_guideline' },
+  { code: 'EDPS_GENAI_ORIENTATIONS_2024', name: 'EDPS GenAI Orientierungen', type: 'eu_guideline' },
+  // WP29 Endorsed
+  { code: 'WP242_PORTABILITY', name: 'WP242 Datenportabilitaet', type: 'wp29_endorsed' },
+  { code: 'WP243_DPO', name: 'WP243 Datenschutzbeauftragter', type: 'wp29_endorsed' },
+  { code: 'WP244_PROFILING', name: 'WP244 Profiling', type: 'wp29_endorsed' },
+  { code: 'WP248_DPIA', name: 'WP248 DSFA', type: 'wp29_endorsed' },
+  { code: 'WP250_BREACH', name: 'WP250 Datenpannen', type: 'wp29_endorsed' },
+  { code: 'WP259_CONSENT', name: 'WP259 Einwilligung', type: 'wp29_endorsed' },
+  { code: 'WP260_TRANSPARENCY', name: 'WP260 Transparenz', type: 'wp29_endorsed' },
+  // DSFA Muss-Listen
+  { code: 'DSFA_BFDI_BUND', name: 'DSFA BfDI Bund', type: 'dsfa_mussliste' },
+  { code: 'DSFA_DSK_GEMEINSAM', name: 'DSFA DSK Gemeinsam', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BW', name: 'DSFA Baden-Wuerttemberg', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BY', name: 'DSFA Bayern', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BE_OE', name: 'DSFA Berlin oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BE_NOE', name: 'DSFA Berlin nicht-oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BB_OE', name: 'DSFA Brandenburg oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_BB_NOE', name: 'DSFA Brandenburg nicht-oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_HB', name: 'DSFA Bremen', type: 'dsfa_mussliste' },
+  { code: 'DSFA_HH_OE', name: 'DSFA Hamburg oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_HH_NOE', name: 'DSFA Hamburg nicht-oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_MV', name: 'DSFA Mecklenburg-Vorpommern', type: 'dsfa_mussliste' },
+  { code: 'DSFA_NI', name: 'DSFA Niedersachsen', type: 'dsfa_mussliste' },
+  { code: 'DSFA_RP', name: 'DSFA Rheinland-Pfalz', type: 'dsfa_mussliste' },
+  { code: 'DSFA_SL', name: 'DSFA Saarland', type: 'dsfa_mussliste' },
+  { code: 'DSFA_SN', name: 'DSFA Sachsen', type: 'dsfa_mussliste' },
+  { code: 'DSFA_ST_OE', name: 'DSFA Sachsen-Anhalt oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_ST_NOE', name: 'DSFA Sachsen-Anhalt nicht-oeffentlich', type: 'dsfa_mussliste' },
+  { code: 'DSFA_SH', name: 'DSFA Schleswig-Holstein', type: 'dsfa_mussliste' },
+  { code: 'DSFA_TH', name: 'DSFA Thueringen', type: 'dsfa_mussliste' },
+  // International Standards
+  { code: 'NIST_SSDF', name: 'NIST SSDF', type: 'international_standard' },
+  { code: 'NIST_CSF_2', name: 'NIST CSF 2.0', type: 'international_standard' },
+  { code: 'OECD_AI_PRINCIPLES', name: 'OECD AI Principles', type: 'international_standard' },
+  { code: 'ENISA_SECURE_BY_DESIGN', name: 'CISA Secure by Design', type: 'international_standard' },
+  { code: 'ENISA_SUPPLY_CHAIN', name: 'ENISA Supply Chain', type: 'international_standard' },
+  { code: 'ENISA_THREAT_LANDSCAPE', name: 'ENISA Threat Landscape', type: 'international_standard' },
+  { code: 'ENISA_ICS_SCADA', name: 'ENISA ICS/SCADA', type: 'international_standard' },
+  { code: 'ENISA_CYBERSECURITY_2024', name: 'ENISA Cybersecurity 2024', type: 'international_standard' },
+]

admin-lehrer/app/(admin)/ai/test-quality/page.tsx

@@ -1430,7 +1430,6 @@ export default function TestQualityPage() {
           databases: ['Qdrant', 'PostgreSQL'],
         }}
         relatedPages={[
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'Provider-Vergleich' },
           { name: 'GPU Infrastruktur', href: '/ai/gpu', description: 'GPU-Ressourcen verwalten' },
           { name: 'RAG Management', href: '/ai/rag', description: 'Training Data & RAG Pipelines' },
         ]}

admin-lehrer/app/(admin)/communication/matrix/page.tsx

@@ -141,7 +141,6 @@ export default function VoiceMatrixPage() {
         }}
         relatedPages={[
           { name: 'Matrix & Jitsi', href: '/communication/matrix', description: 'Kommunikation Monitoring' },
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'KI-Provider vergleichen' },
           { name: 'GPU Infrastruktur', href: '/infrastructure/gpu', description: 'GPU fuer Voice-Service' },
         ]}
         collapsible={true}

admin-lehrer/app/(admin)/development/page.tsx

@@ -24,7 +24,6 @@ export default function DevelopmentPage() {
         }}
         relatedPages={[
           { name: 'GPU Infrastruktur', href: '/infrastructure/gpu', description: 'GPU fuer Voice/Game' },
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'LLM fuer Voice/Game' },
         ]}
         collapsible={true}
         defaultCollapsed={false}

admin-lehrer/app/(admin)/development/screen-flow/page.tsx

@@ -149,7 +149,6 @@ const ADMIN_SCREENS: ScreenDefinition[] = [
   { id: 'admin-obligations', name: 'Pflichten', description: 'NIS2, DSGVO, AI Act', category: 'sdk', icon: '⚡', url: '/sdk/obligations' },
 
   // === KI & AUTOMATISIERUNG (Teal #14b8a6) ===
-  { id: 'admin-llm-compare', name: 'LLM Vergleich', description: 'KI-Provider Vergleich', category: 'ai', icon: '🤖', url: '/ai/llm-compare' },
   { id: 'admin-rag', name: 'Daten & RAG', description: 'Training Data & RAG', category: 'ai', icon: '🗄️', url: '/ai/rag' },
   { id: 'admin-ocr-labeling', name: 'OCR-Labeling', description: 'Handschrift-Training', category: 'ai', icon: '✍️', url: '/ai/ocr-labeling' },
   { id: 'admin-magic-help', name: 'Magic Help', description: 'TrOCR Handschrift-OCR', category: 'ai', icon: '🪄', url: '/ai/magic-help' },
@@ -196,7 +195,6 @@ const ADMIN_CONNECTIONS: ConnectionDef[] = [
   { source: 'admin-dashboard', target: 'admin-backlog', label: 'Go-Live' },
   { source: 'admin-dashboard', target: 'admin-compliance-hub', label: 'Compliance' },
   { source: 'admin-onboarding', target: 'admin-consent' },
-  { source: 'admin-onboarding', target: 'admin-llm-compare' },
   { source: 'admin-rbac', target: 'admin-consent' },
 
   // === DSGVO FLOW ===
@@ -224,7 +222,6 @@ const ADMIN_CONNECTIONS: ConnectionDef[] = [
   { source: 'admin-dsms', target: 'admin-compliance-workflow' },
 
   // === KI & AUTOMATISIERUNG FLOW ===
-  { source: 'admin-llm-compare', target: 'admin-rag', label: 'Daten' },
   { source: 'admin-rag', target: 'admin-quality' },
   { source: 'admin-rag', target: 'admin-agents' },
   { source: 'admin-ocr-labeling', target: 'admin-magic-help', label: 'Training' },

admin-lehrer/app/(admin)/development/workflow/page.tsx

@@ -1,665 +0,0 @@
-'use client'
-
-import { useState, useEffect } from 'react'
-import {
-  GitBranch,
-  Terminal,
-  Server,
-  Database,
-  CheckCircle2,
-  ArrowRight,
-  Laptop,
-  HardDrive,
-  RefreshCw,
-  Clock,
-  Shield,
-  Users,
-  FileCode,
-  Play,
-  Eye,
-  Download,
-  AlertTriangle,
-  Info,
-  Container
-} from 'lucide-react'
-
-interface WorkflowStep {
-  id: number
-  title: string
-  description: string
-  command?: string
-  icon: React.ReactNode
-  location: 'macbook' | 'macmini'
-}
-
-interface BackupInfo {
-  lastRun: string | null
-  nextRun: string
-  status: 'ok' | 'warning' | 'error'
-}
-
-export default function WorkflowPage() {
-  const [activeStep, setActiveStep] = useState<number>(1)
-  const [backupInfo, setBackupInfo] = useState<BackupInfo>({
-    lastRun: null,
-    nextRun: '02:00 Uhr',
-    status: 'ok'
-  })
-
-  const workflowSteps: WorkflowStep[] = [
-    {
-      id: 1,
-      title: 'Code bearbeiten',
-      description: 'Arbeite mit Claude Code im Terminal. Beschreibe was du brauchst und Claude schreibt den Code.',
-      command: 'claude',
-      icon: <Terminal className="h-6 w-6" />,
-      location: 'macbook'
-    },
-    {
-      id: 2,
-      title: 'Änderungen stagen',
-      description: 'Füge die geänderten Dateien zum nächsten Commit hinzu.',
-      command: 'git add <dateien>',
-      icon: <FileCode className="h-6 w-6" />,
-      location: 'macbook'
-    },
-    {
-      id: 3,
-      title: 'Commit erstellen',
-      description: 'Erstelle einen Commit mit einer aussagekräftigen Nachricht.',
-      command: 'git commit -m "feat: neue Funktion"',
-      icon: <GitBranch className="h-6 w-6" />,
-      location: 'macbook'
-    },
-    {
-      id: 4,
-      title: 'Push zum Server',
-      description: 'Sende die Änderungen an den Mac Mini. Dies startet automatisch die CI/CD Pipeline.',
-      command: 'git push origin main',
-      icon: <ArrowRight className="h-6 w-6" />,
-      location: 'macbook'
-    },
-    {
-      id: 5,
-      title: 'CI/CD Pipeline',
-      description: 'Woodpecker führt automatisch Tests aus und baut die Container.',
-      command: '(automatisch)',
-      icon: <RefreshCw className="h-6 w-6" />,
-      location: 'macmini'
-    },
-    {
-      id: 6,
-      title: 'Integration Tests',
-      description: 'Docker Compose Test-Umgebung mit Backend, DB und Consent-Service fuer vollstaendige E2E-Tests.',
-      command: 'docker compose -f docker-compose.test.yml up -d',
-      icon: <Container className="h-6 w-6" />,
-      location: 'macmini'
-    },
-    {
-      id: 7,
-      title: 'Frontend testen',
-      description: 'Teste die Änderungen im Browser auf dem Mac Mini.',
-      command: 'http://macmini:3000',
-      icon: <Eye className="h-6 w-6" />,
-      location: 'macbook'
-    }
-  ]
-
-  const services = [
-    { name: 'Website', url: 'http://macmini:3000', port: 3000, status: 'running' },
-    { name: 'Admin v2', url: 'http://macmini:3002', port: 3002, status: 'running' },
-    { name: 'Studio v2', url: 'http://macmini:3001', port: 3001, status: 'running' },
-    { name: 'Backend', url: 'http://macmini:8000', port: 8000, status: 'running' },
-    { name: 'Gitea', url: 'http://macmini:3003', port: 3003, status: 'running' },
-    { name: 'Klausur-Service', url: 'http://macmini:8086', port: 8086, status: 'running' },
-  ]
-
-  const commitTypes = [
-    { type: 'feat:', description: 'Neue Funktion', example: 'feat: add user login' },
-    { type: 'fix:', description: 'Bugfix', example: 'fix: resolve login timeout' },
-    { type: 'docs:', description: 'Dokumentation', example: 'docs: update API docs' },
-    { type: 'style:', description: 'Formatierung', example: 'style: fix indentation' },
-    { type: 'refactor:', description: 'Code-Umbau', example: 'refactor: extract helper' },
-    { type: 'test:', description: 'Tests', example: 'test: add unit tests' },
-    { type: 'chore:', description: 'Wartung', example: 'chore: update deps' },
-  ]
-
-  return (
-    <div className="space-y-8">
-      {/* Header */}
-      <div className="bg-gradient-to-r from-indigo-600 to-purple-600 rounded-2xl p-8 text-white">
-        <h1 className="text-3xl font-bold mb-2">Entwicklungs-Workflow</h1>
-        <p className="text-indigo-100">
-          Wie wir bei BreakPilot entwickeln - von der Idee bis zum Deployment
-        </p>
-      </div>
-
-      {/* Architecture Overview */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <Server className="h-5 w-5 text-indigo-600" />
-          Systemarchitektur
-        </h2>
-
-        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-          {/* MacBook */}
-          <div className="bg-slate-50 rounded-xl p-5 border-2 border-slate-200">
-            <div className="flex items-center gap-3 mb-4">
-              <div className="p-2 bg-blue-100 rounded-lg">
-                <Laptop className="h-6 w-6 text-blue-600" />
-              </div>
-              <div>
-                <h3 className="font-semibold text-slate-900">MacBook (Entwicklung)</h3>
-                <p className="text-sm text-slate-500">Dein Arbeitsplatz</p>
-              </div>
-            </div>
-            <ul className="space-y-2 text-sm">
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Terminal + Claude Code</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Lokales Git Repository</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Browser für Frontend-Tests</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <AlertTriangle className="h-4 w-4 text-amber-500" />
-                <span>Backup manuell (MacBook nachts aus)</span>
-              </li>
-            </ul>
-          </div>
-
-          {/* Mac Mini */}
-          <div className="bg-slate-50 rounded-xl p-5 border-2 border-indigo-200">
-            <div className="flex items-center gap-3 mb-4">
-              <div className="p-2 bg-indigo-100 rounded-lg">
-                <HardDrive className="h-6 w-6 text-indigo-600" />
-              </div>
-              <div>
-                <h3 className="font-semibold text-slate-900">Mac Mini (Server)</h3>
-                <p className="text-sm text-slate-500">192.168.178.100</p>
-              </div>
-            </div>
-            <ul className="space-y-2 text-sm">
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Gitea (Git Server)</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Woodpecker (CI/CD)</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Docker Container (alle Services)</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>PostgreSQL Datenbank</span>
-              </li>
-              <li className="flex items-center gap-2">
-                <CheckCircle2 className="h-4 w-4 text-green-500" />
-                <span>Automatisches Backup (02:00 Uhr lokal)</span>
-              </li>
-            </ul>
-          </div>
-        </div>
-      </div>
-
-      {/* Workflow Steps */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-6 flex items-center gap-2">
-          <Play className="h-5 w-5 text-indigo-600" />
-          Entwicklungs-Schritte
-        </h2>
-
-        <div className="space-y-4">
-          {workflowSteps.map((step, index) => (
-            <div
-              key={step.id}
-              className={`relative flex items-start gap-4 p-4 rounded-xl transition-all cursor-pointer ${
-                activeStep === step.id
-                  ? 'bg-indigo-50 border-2 border-indigo-300'
-                  : 'bg-slate-50 border-2 border-transparent hover:border-slate-200'
-              }`}
-              onClick={() => setActiveStep(step.id)}
-            >
-              {/* Step Number */}
-              <div className={`flex-shrink-0 w-10 h-10 rounded-full flex items-center justify-center font-bold ${
-                activeStep === step.id
-                  ? 'bg-indigo-600 text-white'
-                  : 'bg-slate-200 text-slate-600'
-              }`}>
-                {step.id}
-              </div>
-
-              {/* Content */}
-              <div className="flex-grow">
-                <div className="flex items-center gap-2 mb-1">
-                  <h3 className="font-semibold text-slate-900">{step.title}</h3>
-                  <span className={`text-xs px-2 py-0.5 rounded-full ${
-                    step.location === 'macbook'
-                      ? 'bg-blue-100 text-blue-700'
-                      : 'bg-purple-100 text-purple-700'
-                  }`}>
-                    {step.location === 'macbook' ? 'MacBook' : 'Mac Mini'}
-                  </span>
-                </div>
-                <p className="text-sm text-slate-600 mb-2">{step.description}</p>
-                {step.command && (
-                  <code className="text-xs bg-slate-800 text-green-400 px-3 py-1.5 rounded-lg font-mono">
-                    {step.command}
-                  </code>
-                )}
-              </div>
-
-              {/* Icon */}
-              <div className={`flex-shrink-0 p-2 rounded-lg ${
-                activeStep === step.id ? 'bg-indigo-100 text-indigo-600' : 'bg-slate-100 text-slate-400'
-              }`}>
-                {step.icon}
-              </div>
-
-              {/* Connector Line */}
-              {index < workflowSteps.length - 1 && (
-                <div className="absolute left-9 top-14 w-0.5 h-8 bg-slate-200" />
-              )}
-            </div>
-          ))}
-        </div>
-      </div>
-
-      {/* Services & URLs */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <Eye className="h-5 w-5 text-indigo-600" />
-          Services & URLs zum Testen
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-3">
-          {services.map((service) => (
-            <a
-              key={service.name}
-              href={service.url}
-              target="_blank"
-              rel="noopener noreferrer"
-              className="flex items-center justify-between p-4 bg-slate-50 rounded-lg hover:bg-slate-100 transition-colors border border-slate-200"
-            >
-              <div>
-                <h3 className="font-medium text-slate-900">{service.name}</h3>
-                <p className="text-sm text-slate-500">Port {service.port}</p>
-              </div>
-              <div className="flex items-center gap-2">
-                <span className="w-2 h-2 bg-green-500 rounded-full animate-pulse" />
-                <ArrowRight className="h-4 w-4 text-slate-400" />
-              </div>
-            </a>
-          ))}
-        </div>
-      </div>
-
-      {/* Commit Convention */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <GitBranch className="h-5 w-5 text-indigo-600" />
-          Commit-Konventionen
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-3">
-          {commitTypes.map((item) => (
-            <div key={item.type} className="bg-slate-50 rounded-lg p-3 border border-slate-200">
-              <code className="text-sm font-bold text-indigo-600">{item.type}</code>
-              <p className="text-sm text-slate-600 mt-1">{item.description}</p>
-              <p className="text-xs text-slate-400 mt-1 font-mono">{item.example}</p>
-            </div>
-          ))}
-        </div>
-      </div>
-
-      {/* Backup Info */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <Shield className="h-5 w-5 text-indigo-600" />
-          Backup & Sicherheit
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
-          {/* Mac Mini - Automatisches lokales Backup */}
-          <div className="bg-green-50 rounded-xl p-5 border border-green-200">
-            <div className="flex items-center gap-3 mb-3">
-              <Clock className="h-5 w-5 text-green-600" />
-              <h3 className="font-semibold text-green-900">Mac Mini (Auto)</h3>
-            </div>
-            <ul className="space-y-2 text-sm text-green-800">
-              <li>• Automatisch um 02:00 Uhr</li>
-              <li>• PostgreSQL-Dump lokal</li>
-              <li>• Git Repository gesichert</li>
-              <li>• 7 Tage Aufbewahrung</li>
-            </ul>
-            <div className="mt-4 p-3 bg-green-100 rounded-lg">
-              <code className="text-xs text-green-700 font-mono">
-                ~/Projekte/backup-logs/
-              </code>
-            </div>
-          </div>
-
-          {/* MacBook - Manuelles Backup */}
-          <div className="bg-amber-50 rounded-xl p-5 border border-amber-200">
-            <div className="flex items-center gap-3 mb-3">
-              <AlertTriangle className="h-5 w-5 text-amber-600" />
-              <h3 className="font-semibold text-amber-900">MacBook (Manuell)</h3>
-            </div>
-            <ul className="space-y-2 text-sm text-amber-800">
-              <li>• MacBook nachts aus (02:00)</li>
-              <li>• Keine Auto-Synchronisation</li>
-              <li>• Backup manuell anstoßen</li>
-            </ul>
-            <div className="mt-4 p-3 bg-amber-100 rounded-lg">
-              <code className="text-xs text-amber-700 font-mono">
-                rsync -avz macmini:~/Projekte/ ~/Projekte/
-              </code>
-            </div>
-          </div>
-
-          {/* Manuelles Backup starten */}
-          <div className="bg-blue-50 rounded-xl p-5 border border-blue-200">
-            <div className="flex items-center gap-3 mb-3">
-              <Download className="h-5 w-5 text-blue-600" />
-              <h3 className="font-semibold text-blue-900">Backup Script</h3>
-            </div>
-            <p className="text-sm text-blue-800 mb-3">
-              Backup jederzeit manuell starten:
-            </p>
-            <code className="block text-xs bg-slate-800 text-green-400 p-3 rounded-lg font-mono">
-              ~/Projekte/breakpilot-pwa/scripts/daily-backup.sh
-            </code>
-          </div>
-        </div>
-      </div>
-
-      {/* Quick Commands */}
-      <div className="bg-slate-800 rounded-xl p-6 text-white">
-        <h2 className="text-xl font-semibold mb-4 flex items-center gap-2">
-          <Terminal className="h-5 w-5 text-green-400" />
-          Wichtige Befehle
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 gap-4 font-mono text-sm">
-          <div className="bg-slate-900 rounded-lg p-4">
-            <p className="text-slate-400 mb-2"># CI/CD Logs ansehen</p>
-            <code className="text-green-400">ssh macmini &quot;docker logs breakpilot-pwa-backend --tail 50&quot;</code>
-          </div>
-          <div className="bg-slate-900 rounded-lg p-4">
-            <p className="text-slate-400 mb-2"># Container neu starten</p>
-            <code className="text-green-400">ssh macmini &quot;docker compose restart backend&quot;</code>
-          </div>
-          <div className="bg-slate-900 rounded-lg p-4">
-            <p className="text-slate-400 mb-2"># Alle Container Status</p>
-            <code className="text-green-400">ssh macmini &quot;docker ps&quot;</code>
-          </div>
-          <div className="bg-slate-900 rounded-lg p-4">
-            <p className="text-slate-400 mb-2"># Pipeline Status (Gitea)</p>
-            <code className="text-green-400">open http://macmini:3003</code>
-          </div>
-        </div>
-      </div>
-
-      {/* Team Workflow with Feature Branches */}
-      <div className="bg-indigo-50 rounded-xl border border-indigo-200 p-6">
-        <h2 className="text-xl font-semibold text-indigo-900 mb-4 flex items-center gap-2">
-          <GitBranch className="h-5 w-5 text-indigo-600" />
-          Team-Workflow (3+ Entwickler)
-        </h2>
-
-        <div className="bg-white rounded-xl p-5 mb-4">
-          <h3 className="font-semibold text-slate-900 mb-3">Feature Branch Workflow</h3>
-          <div className="flex flex-wrap items-center gap-2 text-sm">
-            <code className="bg-slate-100 px-2 py-1 rounded">main</code>
-            <ArrowRight className="h-4 w-4 text-slate-400" />
-            <code className="bg-blue-100 text-blue-700 px-2 py-1 rounded">feature/neue-funktion</code>
-            <ArrowRight className="h-4 w-4 text-slate-400" />
-            <span className="text-slate-600">Entwicklung</span>
-            <ArrowRight className="h-4 w-4 text-slate-400" />
-            <span className="bg-purple-100 text-purple-700 px-2 py-1 rounded">Pull Request</span>
-            <ArrowRight className="h-4 w-4 text-slate-400" />
-            <span className="bg-green-100 text-green-700 px-2 py-1 rounded">Code Review</span>
-            <ArrowRight className="h-4 w-4 text-slate-400" />
-            <code className="bg-slate-100 px-2 py-1 rounded">main</code>
-          </div>
-        </div>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-          <div className="bg-white rounded-lg p-4 border border-indigo-100">
-            <h4 className="font-medium text-slate-900 mb-2">1. Feature Branch erstellen</h4>
-            <code className="block text-xs bg-slate-800 text-green-400 p-2 rounded font-mono">
-              git checkout -b feature/mein-feature
-            </code>
-          </div>
-          <div className="bg-white rounded-lg p-4 border border-indigo-100">
-            <h4 className="font-medium text-slate-900 mb-2">2. Änderungen committen</h4>
-            <code className="block text-xs bg-slate-800 text-green-400 p-2 rounded font-mono">
-              git commit -m &quot;feat: beschreibung&quot;
-            </code>
-          </div>
-          <div className="bg-white rounded-lg p-4 border border-indigo-100">
-            <h4 className="font-medium text-slate-900 mb-2">3. Branch pushen</h4>
-            <code className="block text-xs bg-slate-800 text-green-400 p-2 rounded font-mono">
-              git push -u origin feature/mein-feature
-            </code>
-          </div>
-          <div className="bg-white rounded-lg p-4 border border-indigo-100">
-            <h4 className="font-medium text-slate-900 mb-2">4. Pull Request in Gitea</h4>
-            <code className="block text-xs bg-slate-800 text-green-400 p-2 rounded font-mono">
-              http://macmini:3003 → Pull Request
-            </code>
-          </div>
-        </div>
-
-        <div className="mt-4 p-4 bg-indigo-100 rounded-lg">
-          <h4 className="font-medium text-indigo-900 mb-2">Branch-Namenskonvention</h4>
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-2 text-sm">
-            <div><code className="text-indigo-700">feature/</code> Neue Funktion</div>
-            <div><code className="text-indigo-700">fix/</code> Bugfix</div>
-            <div><code className="text-indigo-700">hotfix/</code> Dringender Fix</div>
-            <div><code className="text-indigo-700">refactor/</code> Code-Umbau</div>
-          </div>
-        </div>
-      </div>
-
-      {/* Team Rules */}
-      <div className="bg-amber-50 rounded-xl border border-amber-200 p-6">
-        <h2 className="text-xl font-semibold text-amber-900 mb-4 flex items-center gap-2">
-          <Users className="h-5 w-5 text-amber-600" />
-          Team-Regeln
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-          <div className="flex items-start gap-3">
-            <CheckCircle2 className="h-5 w-5 text-green-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Feature Branches nutzen</h3>
-              <p className="text-sm text-slate-600">Nie direkt auf main pushen - immer über Pull Request</p>
-            </div>
-          </div>
-          <div className="flex items-start gap-3">
-            <CheckCircle2 className="h-5 w-5 text-green-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Code Review erforderlich</h3>
-              <p className="text-sm text-slate-600">Mindestens 1 Approval vor dem Merge</p>
-            </div>
-          </div>
-          <div className="flex items-start gap-3">
-            <CheckCircle2 className="h-5 w-5 text-green-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Tests müssen grün sein</h3>
-              <p className="text-sm text-slate-600">CI/CD Pipeline muss erfolgreich durchlaufen</p>
-            </div>
-          </div>
-          <div className="flex items-start gap-3">
-            <CheckCircle2 className="h-5 w-5 text-green-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Aussagekräftige Commits</h3>
-              <p className="text-sm text-slate-600">Nutze Conventional Commits (feat:, fix:, etc.)</p>
-            </div>
-          </div>
-          <div className="flex items-start gap-3">
-            <CheckCircle2 className="h-5 w-5 text-green-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Branch aktuell halten</h3>
-              <p className="text-sm text-slate-600">Regelmäßig main in deinen Branch mergen</p>
-            </div>
-          </div>
-          <div className="flex items-start gap-3">
-            <AlertTriangle className="h-5 w-5 text-amber-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h3 className="font-medium text-slate-900">Nie Force-Push auf main</h3>
-              <p className="text-sm text-slate-600">Geschichte von main nie überschreiben</p>
-            </div>
-          </div>
-        </div>
-      </div>
-
-      {/* CI/CD Infrastruktur - Automatisierte OAuth Integration */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <Shield className="h-5 w-5 text-indigo-600" />
-          CI/CD Infrastruktur (Automatisiert)
-        </h2>
-
-        <div className="bg-blue-50 rounded-xl p-4 mb-6 border border-blue-200">
-          <div className="flex items-start gap-3">
-            <Info className="h-5 w-5 text-blue-600 flex-shrink-0 mt-0.5" />
-            <div>
-              <h4 className="font-medium text-blue-900">Warum automatisiert?</h4>
-              <p className="text-sm text-blue-800 mt-1">
-                Die OAuth-Integration zwischen Woodpecker und Gitea ist vollautomatisiert.
-                Dies ist eine DevSecOps Best Practice: Credentials werden in HashiCorp Vault gespeichert
-                und können bei Bedarf automatisch regeneriert werden.
-              </p>
-            </div>
-          </div>
-        </div>
-
-        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-          {/* Architektur */}
-          <div className="bg-slate-50 rounded-xl p-5 border border-slate-200">
-            <h3 className="font-semibold text-slate-900 mb-3">Architektur</h3>
-            <div className="space-y-3 text-sm">
-              <div className="flex items-center gap-3 p-2 bg-white rounded-lg border">
-                <div className="w-3 h-3 bg-green-500 rounded-full" />
-                <span className="font-medium">Gitea</span>
-                <span className="text-slate-500">Port 3003</span>
-                <span className="text-xs text-slate-400 ml-auto">Git Server</span>
-              </div>
-              <div className="flex items-center justify-center">
-                <ArrowRight className="h-4 w-4 text-slate-400 rotate-90" />
-                <span className="text-xs text-slate-500 ml-2">OAuth 2.0</span>
-              </div>
-              <div className="flex items-center gap-3 p-2 bg-white rounded-lg border">
-                <div className="w-3 h-3 bg-blue-500 rounded-full" />
-                <span className="font-medium">Woodpecker</span>
-                <span className="text-slate-500">Port 8090</span>
-                <span className="text-xs text-slate-400 ml-auto">CI/CD Server</span>
-              </div>
-              <div className="flex items-center justify-center">
-                <ArrowRight className="h-4 w-4 text-slate-400 rotate-90" />
-                <span className="text-xs text-slate-500 ml-2">Credentials</span>
-              </div>
-              <div className="flex items-center gap-3 p-2 bg-white rounded-lg border">
-                <div className="w-3 h-3 bg-purple-500 rounded-full" />
-                <span className="font-medium">Vault</span>
-                <span className="text-slate-500">Port 8200</span>
-                <span className="text-xs text-slate-400 ml-auto">Secrets Manager</span>
-              </div>
-            </div>
-          </div>
-
-          {/* Credentials Speicherort */}
-          <div className="bg-slate-50 rounded-xl p-5 border border-slate-200">
-            <h3 className="font-semibold text-slate-900 mb-3">Credentials Speicherorte</h3>
-            <div className="space-y-3 text-sm">
-              <div className="p-3 bg-white rounded-lg border">
-                <div className="flex items-center gap-2 mb-1">
-                  <Database className="h-4 w-4 text-purple-500" />
-                  <span className="font-medium">HashiCorp Vault</span>
-                </div>
-                <code className="text-xs bg-slate-100 px-2 py-1 rounded">
-                  secret/cicd/woodpecker
-                </code>
-                <p className="text-xs text-slate-500 mt-1">Client ID + Secret (Quelle der Wahrheit)</p>
-              </div>
-              <div className="p-3 bg-white rounded-lg border">
-                <div className="flex items-center gap-2 mb-1">
-                  <FileCode className="h-4 w-4 text-blue-500" />
-                  <span className="font-medium">.env Datei</span>
-                </div>
-                <code className="text-xs bg-slate-100 px-2 py-1 rounded">
-                  WOODPECKER_GITEA_CLIENT/SECRET
-                </code>
-                <p className="text-xs text-slate-500 mt-1">Für Docker Compose (aus Vault geladen)</p>
-              </div>
-              <div className="p-3 bg-white rounded-lg border">
-                <div className="flex items-center gap-2 mb-1">
-                  <Database className="h-4 w-4 text-green-500" />
-                  <span className="font-medium">Gitea PostgreSQL</span>
-                </div>
-                <code className="text-xs bg-slate-100 px-2 py-1 rounded">
-                  oauth2_application
-                </code>
-                <p className="text-xs text-slate-500 mt-1">OAuth App Registration (gehashtes Secret)</p>
-              </div>
-            </div>
-          </div>
-        </div>
-
-        {/* Troubleshooting */}
-        <div className="mt-6 bg-amber-50 rounded-xl p-5 border border-amber-200">
-          <h3 className="font-semibold text-amber-900 mb-3 flex items-center gap-2">
-            <AlertTriangle className="h-5 w-5 text-amber-600" />
-            Troubleshooting: OAuth Fehler beheben
-          </h3>
-          <p className="text-sm text-amber-800 mb-3">
-            Falls der Fehler &quot;Client ID not registered&quot; oder &quot;user does not exist&quot; auftritt:
-          </p>
-          <div className="bg-slate-800 rounded-lg p-4 font-mono text-sm">
-            <p className="text-slate-400"># Credentials automatisch regenerieren</p>
-            <p className="text-green-400">./scripts/sync-woodpecker-credentials.sh --regenerate</p>
-            <p className="text-slate-400 mt-2"># Oder manuell: Vault → Gitea → .env → Restart</p>
-            <p className="text-green-400">rsync .env macmini:~/Projekte/breakpilot-pwa/</p>
-            <p className="text-green-400">ssh macmini &quot;cd ~/Projekte/breakpilot-pwa && docker compose up -d --force-recreate woodpecker-server&quot;</p>
-          </div>
-        </div>
-      </div>
-
-      {/* Team Members Info */}
-      <div className="bg-white rounded-xl border border-slate-200 p-6">
-        <h2 className="text-xl font-semibold text-slate-900 mb-4 flex items-center gap-2">
-          <Users className="h-5 w-5 text-indigo-600" />
-          Team-Kommunikation
-        </h2>
-
-        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-          <div className="bg-slate-50 rounded-lg p-4 text-center">
-            <div className="text-3xl mb-2">💬</div>
-            <h3 className="font-medium text-slate-900">Pull Request Kommentare</h3>
-            <p className="text-sm text-slate-600 mt-1">Code-Diskussionen im PR</p>
-          </div>
-          <div className="bg-slate-50 rounded-lg p-4 text-center">
-            <div className="text-3xl mb-2">📋</div>
-            <h3 className="font-medium text-slate-900">Issues in Gitea</h3>
-            <p className="text-sm text-slate-600 mt-1">Bugs & Features tracken</p>
-          </div>
-          <div className="bg-slate-50 rounded-lg p-4 text-center">
-            <div className="text-3xl mb-2">🔔</div>
-            <h3 className="font-medium text-slate-900">CI/CD Notifications</h3>
-            <p className="text-sm text-slate-600 mt-1">Pipeline-Status per Mail</p>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}

admin-lehrer/app/(admin)/infrastructure/gpu/page.tsx

@@ -177,7 +177,6 @@ export default function GPUInfrastructurePage() {
           databases: ['PostgreSQL (Logs)'],
         }}
         relatedPages={[
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'KI-Provider testen' },
           { name: 'Security', href: '/infrastructure/security', description: 'DevSecOps Dashboard' },
           { name: 'Builds', href: '/infrastructure/builds', description: 'CI/CD Pipeline' },
         ]}

admin-lehrer/app/(admin)/rbac/page.tsx

@@ -335,7 +335,6 @@ export default function RBACPage() {
         }}
         relatedPages={[
           { name: 'Audit Trail', href: '/sdk/audit-report', description: 'LLM-Operationen protokollieren' },
-          { name: 'LLM Vergleich', href: '/ai/llm-compare', description: 'KI-Provider testen' },
         ]}
       />
 

admin-lehrer/app/api/legal-corpus/__tests__/chunk-browser-logic.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+/**
+ * Tests for Chunk-Browser logic:
+ * - Collection dropdown has all 10 collections
+ * - COLLECTION_TOTALS has expected keys
+ * - Text search highlighting logic
+ * - Pagination state management
+ */
+
+// Replicate the COMPLIANCE_COLLECTIONS from the dropdown
+const COMPLIANCE_COLLECTIONS = [
+  'bp_compliance_gesetze',
+  'bp_compliance_ce',
+  'bp_compliance_datenschutz',
+  'bp_dsfa_corpus',
+  'bp_compliance_recht',
+  'bp_legal_templates',
+  'bp_compliance_gdpr',
+  'bp_compliance_schulrecht',
+  'bp_dsfa_templates',
+  'bp_dsfa_risks',
+] as const
+
+// Replicate COLLECTION_TOTALS from page.tsx
+const COLLECTION_TOTALS: Record<string, number> = {
+  bp_compliance_gesetze: 58304,
+  bp_compliance_ce: 18183,
+  bp_legal_templates: 7689,
+  bp_compliance_datenschutz: 2448,
+  bp_dsfa_corpus: 7867,
+  bp_compliance_recht: 1425,
+  bp_nibis_eh: 7996,
+  total_legal: 76487,
+  total_all: 103912,
+}
+
+describe('Chunk-Browser Logic', () => {
+  describe('COMPLIANCE_COLLECTIONS', () => {
+    it('should have exactly 10 collections', () => {
+      expect(COMPLIANCE_COLLECTIONS).toHaveLength(10)
+    })
+
+    it('should include bp_compliance_ce for IFRS documents', () => {
+      expect(COMPLIANCE_COLLECTIONS).toContain('bp_compliance_ce')
+    })
+
+    it('should include bp_compliance_datenschutz for EFRAG/ENISA', () => {
+      expect(COMPLIANCE_COLLECTIONS).toContain('bp_compliance_datenschutz')
+    })
+
+    it('should include bp_compliance_gesetze as default', () => {
+      expect(COMPLIANCE_COLLECTIONS[0]).toBe('bp_compliance_gesetze')
+    })
+
+    it('should have all collection names starting with bp_', () => {
+      COMPLIANCE_COLLECTIONS.forEach((col) => {
+        expect(col).toMatch(/^bp_/)
+      })
+    })
+  })
+
+  describe('COLLECTION_TOTALS', () => {
+    it('should have bp_compliance_ce key', () => {
+      expect(COLLECTION_TOTALS).toHaveProperty('bp_compliance_ce')
+    })
+
+    it('should have bp_compliance_datenschutz key', () => {
+      expect(COLLECTION_TOTALS).toHaveProperty('bp_compliance_datenschutz')
+    })
+
+    it('should have positive counts for all collections', () => {
+      Object.values(COLLECTION_TOTALS).forEach((count) => {
+        expect(count).toBeGreaterThan(0)
+      })
+    })
+
+    it('total_all should be greater than total_legal', () => {
+      expect(COLLECTION_TOTALS.total_all).toBeGreaterThan(COLLECTION_TOTALS.total_legal)
+    })
+  })
+
+  describe('Text search filtering logic', () => {
+    const mockChunks = [
+      { id: '1', text: 'DSGVO Artikel 1 Datenschutz', regulation_code: 'GDPR' },
+      { id: '2', text: 'IFRS 16 Leasing Standard', regulation_code: 'EU_IFRS' },
+      { id: '3', text: 'Datenschutz Grundverordnung', regulation_code: 'GDPR' },
+      { id: '4', text: 'ENISA Supply Chain Security', regulation_code: 'ENISA' },
+    ]
+
+    it('should filter chunks by text search (case insensitive)', () => {
+      const search = 'datenschutz'
+      const filtered = mockChunks.filter((c) =>
+        c.text.toLowerCase().includes(search.toLowerCase())
+      )
+      expect(filtered).toHaveLength(2)
+    })
+
+    it('should return all chunks when search is empty', () => {
+      const search = ''
+      const filtered = search
+        ? mockChunks.filter((c) => c.text.toLowerCase().includes(search.toLowerCase()))
+        : mockChunks
+      expect(filtered).toHaveLength(4)
+    })
+
+    it('should return 0 chunks when no match', () => {
+      const search = 'blockchain'
+      const filtered = mockChunks.filter((c) =>
+        c.text.toLowerCase().includes(search.toLowerCase())
+      )
+      expect(filtered).toHaveLength(0)
+    })
+
+    it('should match IFRS chunks', () => {
+      const search = 'IFRS'
+      const filtered = mockChunks.filter((c) =>
+        c.text.toLowerCase().includes(search.toLowerCase())
+      )
+      expect(filtered).toHaveLength(1)
+      expect(filtered[0].regulation_code).toBe('EU_IFRS')
+    })
+  })
+
+  describe('Pagination state', () => {
+    it('should start at page 0', () => {
+      const currentPage = 0
+      expect(currentPage).toBe(0)
+    })
+
+    it('should increment page on next', () => {
+      let currentPage = 0
+      currentPage += 1
+      expect(currentPage).toBe(1)
+    })
+
+    it('should maintain offset history for back navigation', () => {
+      const history: (string | null)[] = []
+      history.push(null) // page 0 offset
+      history.push('uuid-20') // page 1 offset
+      history.push('uuid-40') // page 2 offset
+
+      // Go back to page 1
+      const prevOffset = history[history.length - 2]
+      expect(prevOffset).toBe('uuid-20')
+    })
+
+    it('should reset state on collection change', () => {
+      let chunkOffset: string | null = 'some-offset'
+      let chunkHistory: (string | null)[] = [null, 'uuid-1']
+      let chunkCurrentPage = 3
+
+      // Simulate collection change
+      chunkOffset = null
+      chunkHistory = []
+      chunkCurrentPage = 0
+
+      expect(chunkOffset).toBeNull()
+      expect(chunkHistory).toHaveLength(0)
+      expect(chunkCurrentPage).toBe(0)
+    })
+  })
+})

admin-lehrer/app/api/legal-corpus/__tests__/rag-constants.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest'
+
+/**
+ * Tests for RAG page constants - REGULATIONS_IN_RAG, REGULATION_SOURCES, REGULATION_LICENSES
+ *
+ * These are defined inline in page.tsx, so we test the data structures
+ * by importing a subset of the expected values.
+ */
+
+// Expected IFRS entries in REGULATIONS_IN_RAG
+const EXPECTED_IFRS_ENTRIES = {
+  EU_IFRS_DE: { collection: 'bp_compliance_ce', chunks: 0 },
+  EU_IFRS_EN: { collection: 'bp_compliance_ce', chunks: 0 },
+  EFRAG_ENDORSEMENT: { collection: 'bp_compliance_datenschutz', chunks: 0 },
+}
+
+// Expected REGULATION_SOURCES URLs
+const EXPECTED_SOURCES = {
+  GDPR: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32016R0679',
+  EU_IFRS_DE: 'https://eur-lex.europa.eu/legal-content/DE/TXT/?uri=CELEX:32023R1803',
+  EU_IFRS_EN: 'https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32023R1803',
+  EFRAG_ENDORSEMENT: 'https://www.efrag.org/activities/endorsement-status-report',
+  ENISA_SECURE_DEV: 'https://www.enisa.europa.eu/publications/secure-development-best-practices',
+  NIST_SSDF: 'https://csrc.nist.gov/pubs/sp/800/218/final',
+  NIST_CSF: 'https://www.nist.gov/cyberframework',
+  OECD_AI: 'https://oecd.ai/en/ai-principles',
+}
+
+describe('RAG Page Constants', () => {
+  describe('IFRS entries in REGULATIONS_IN_RAG', () => {
+    it('should have EU_IFRS_DE entry with bp_compliance_ce collection', () => {
+      expect(EXPECTED_IFRS_ENTRIES.EU_IFRS_DE.collection).toBe('bp_compliance_ce')
+    })
+
+    it('should have EU_IFRS_EN entry with bp_compliance_ce collection', () => {
+      expect(EXPECTED_IFRS_ENTRIES.EU_IFRS_EN.collection).toBe('bp_compliance_ce')
+    })
+
+    it('should have EFRAG_ENDORSEMENT entry with bp_compliance_datenschutz collection', () => {
+      expect(EXPECTED_IFRS_ENTRIES.EFRAG_ENDORSEMENT.collection).toBe('bp_compliance_datenschutz')
+    })
+  })
+
+  describe('REGULATION_SOURCES URLs', () => {
+    it('should have valid EUR-Lex URLs for EU regulations', () => {
+      expect(EXPECTED_SOURCES.GDPR).toMatch(/^https:\/\/eur-lex\.europa\.eu/)
+      expect(EXPECTED_SOURCES.EU_IFRS_DE).toMatch(/^https:\/\/eur-lex\.europa\.eu/)
+      expect(EXPECTED_SOURCES.EU_IFRS_EN).toMatch(/^https:\/\/eur-lex\.europa\.eu/)
+    })
+
+    it('should have correct CELEX for IFRS DE (32023R1803)', () => {
+      expect(EXPECTED_SOURCES.EU_IFRS_DE).toContain('32023R1803')
+    })
+
+    it('should have correct CELEX for IFRS EN (32023R1803)', () => {
+      expect(EXPECTED_SOURCES.EU_IFRS_EN).toContain('32023R1803')
+    })
+
+    it('should have DE language for IFRS DE', () => {
+      expect(EXPECTED_SOURCES.EU_IFRS_DE).toContain('/DE/')
+    })
+
+    it('should have EN language for IFRS EN', () => {
+      expect(EXPECTED_SOURCES.EU_IFRS_EN).toContain('/EN/')
+    })
+
+    it('should have EFRAG URL for endorsement status', () => {
+      expect(EXPECTED_SOURCES.EFRAG_ENDORSEMENT).toMatch(/^https:\/\/www\.efrag\.org/)
+    })
+
+    it('should have ENISA URL for secure development', () => {
+      expect(EXPECTED_SOURCES.ENISA_SECURE_DEV).toMatch(/^https:\/\/www\.enisa\.europa\.eu/)
+    })
+
+    it('should have NIST URLs for SSDF and CSF', () => {
+      expect(EXPECTED_SOURCES.NIST_SSDF).toMatch(/nist\.gov/)
+      expect(EXPECTED_SOURCES.NIST_CSF).toMatch(/nist\.gov/)
+    })
+
+    it('should have OECD URL for AI principles', () => {
+      expect(EXPECTED_SOURCES.OECD_AI).toMatch(/oecd\.ai/)
+    })
+
+    it('should all be valid HTTPS URLs', () => {
+      Object.values(EXPECTED_SOURCES).forEach((url) => {
+        expect(url).toMatch(/^https:\/\//)
+      })
+    })
+  })
+})

admin-lehrer/app/api/legal-corpus/__tests__/route.test.ts

@@ -0,0 +1,249 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// Mock fetch globally
+const mockFetch = vi.fn()
+global.fetch = mockFetch
+
+// Mock NextRequest and NextResponse
+vi.mock('next/server', () => ({
+  NextRequest: class MockNextRequest {
+    url: string
+    constructor(url: string) {
+      this.url = url
+    }
+  },
+  NextResponse: {
+    json: (data: unknown, init?: { status?: number }) => ({
+      data,
+      status: init?.status || 200,
+    }),
+  },
+}))
+
+describe('Legal Corpus API Proxy', () => {
+  beforeEach(() => {
+    mockFetch.mockClear()
+  })
+
+  describe('scroll action', () => {
+    it('should call Qdrant scroll endpoint with correct collection', async () => {
+      const mockScrollResponse = {
+        result: {
+          points: [
+            { id: 'uuid-1', payload: { text: 'DSGVO Artikel 1', regulation_code: 'GDPR' } },
+            { id: 'uuid-2', payload: { text: 'DSGVO Artikel 2', regulation_code: 'GDPR' } },
+          ],
+          next_page_offset: 'uuid-3',
+        },
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockScrollResponse),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce&limit=20' }
+      const response = await GET(request as any)
+
+      expect(mockFetch).toHaveBeenCalledTimes(1)
+      const calledUrl = mockFetch.mock.calls[0][0]
+      expect(calledUrl).toContain('/collections/bp_compliance_ce/points/scroll')
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+      expect(body.limit).toBe(20)
+      expect(body.with_payload).toBe(true)
+      expect(body.with_vector).toBe(false)
+    })
+
+    it('should pass offset parameter to Qdrant', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ result: { points: [], next_page_offset: null } }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_gesetze&offset=some-uuid' }
+      await GET(request as any)
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+      expect(body.offset).toBe('some-uuid')
+    })
+
+    it('should limit chunks to max 100', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ result: { points: [], next_page_offset: null } }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce&limit=500' }
+      await GET(request as any)
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+      expect(body.limit).toBe(100)
+    })
+
+    it('should apply text_search filter client-side', async () => {
+      const mockScrollResponse = {
+        result: {
+          points: [
+            { id: 'uuid-1', payload: { text: 'DSGVO Artikel 1 Datenschutz' } },
+            { id: 'uuid-2', payload: { text: 'IFRS Standard 16 Leasing' } },
+            { id: 'uuid-3', payload: { text: 'Datenschutz Grundverordnung' } },
+          ],
+          next_page_offset: null,
+        },
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockScrollResponse),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce&text_search=Datenschutz' }
+      const response = await GET(request as any)
+
+      // Should filter to only chunks containing "Datenschutz"
+      expect((response as any).data.chunks).toHaveLength(2)
+      expect((response as any).data.chunks[0].text).toContain('Datenschutz')
+    })
+
+    it('should flatten payload into chunk objects', async () => {
+      const mockScrollResponse = {
+        result: {
+          points: [
+            {
+              id: 'uuid-1',
+              payload: {
+                text: 'IFRS 16 Leasing',
+                regulation_code: 'EU_IFRS',
+                language: 'de',
+                celex: '32023R1803',
+              },
+            },
+          ],
+          next_page_offset: null,
+        },
+      }
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockScrollResponse),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce' }
+      const response = await GET(request as any)
+
+      const chunk = (response as any).data.chunks[0]
+      expect(chunk.id).toBe('uuid-1')
+      expect(chunk.text).toBe('IFRS 16 Leasing')
+      expect(chunk.regulation_code).toBe('EU_IFRS')
+      expect(chunk.language).toBe('de')
+    })
+
+    it('should return next_offset from Qdrant response', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          result: { points: [], next_page_offset: 'next-uuid' },
+        }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce' }
+      const response = await GET(request as any)
+
+      expect((response as any).data.next_offset).toBe('next-uuid')
+    })
+
+    it('should handle Qdrant scroll failure', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 404,
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=nonexistent' }
+      const response = await GET(request as any)
+
+      expect((response as any).status).toBe(404)
+    })
+
+    it('should apply filter when filter_key and filter_value provided', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ result: { points: [], next_page_offset: null } }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll&collection=bp_compliance_ce&filter_key=language&filter_value=de' }
+      await GET(request as any)
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+      expect(body.filter).toEqual({
+        must: [{ key: 'language', match: { value: 'de' } }],
+      })
+    })
+
+    it('should default collection to bp_compliance_gesetze', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ result: { points: [], next_page_offset: null } }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=scroll' }
+      await GET(request as any)
+
+      const calledUrl = mockFetch.mock.calls[0][0]
+      expect(calledUrl).toContain('/collections/bp_compliance_gesetze/')
+    })
+  })
+
+  describe('collection-count action', () => {
+    it('should return points_count from Qdrant collection info', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          result: { points_count: 55053 },
+        }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=collection-count&collection=bp_compliance_ce' }
+      const response = await GET(request as any)
+
+      expect((response as any).data.count).toBe(55053)
+    })
+
+    it('should return 0 when Qdrant is unavailable', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=collection-count&collection=bp_compliance_ce' }
+      const response = await GET(request as any)
+
+      expect((response as any).data.count).toBe(0)
+    })
+
+    it('should default to bp_compliance_gesetze collection', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({ result: { points_count: 1234 } }),
+      })
+
+      const { GET } = await import('../route')
+      const request = { url: 'http://localhost/api/legal-corpus?action=collection-count' }
+      await GET(request as any)
+
+      const calledUrl = mockFetch.mock.calls[0][0]
+      expect(calledUrl).toContain('/collections/bp_compliance_gesetze')
+    })
+  })
+})

admin-lehrer/app/api/legal-corpus/route.ts

@@ -66,6 +66,99 @@ export async function GET(request: NextRequest) {
         url += `/traceability?chunk_id=${encodeURIComponent(chunkId || '')}&regulation=${encodeURIComponent(regulation || '')}`
         break
       }
+      case 'scroll': {
+        const collection = searchParams.get('collection') || 'bp_compliance_gesetze'
+        const limit = parseInt(searchParams.get('limit') || '20', 10)
+        const offsetParam = searchParams.get('offset')
+        const filterKey = searchParams.get('filter_key')
+        const filterValue = searchParams.get('filter_value')
+        const textSearch = searchParams.get('text_search')
+
+        const scrollBody: Record<string, unknown> = {
+          limit: Math.min(limit, 100),
+          with_payload: true,
+          with_vector: false,
+        }
+        if (offsetParam) {
+          scrollBody.offset = offsetParam
+        }
+        if (filterKey && filterValue) {
+          scrollBody.filter = {
+            must: [{ key: filterKey, match: { value: filterValue } }],
+          }
+        }
+
+        const scrollRes = await fetch(`${QDRANT_URL}/collections/${encodeURIComponent(collection)}/points/scroll`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(scrollBody),
+          cache: 'no-store',
+        })
+        if (!scrollRes.ok) {
+          return NextResponse.json({ error: 'Qdrant scroll failed' }, { status: scrollRes.status })
+        }
+        const scrollData = await scrollRes.json()
+        const points = (scrollData.result?.points || []).map((p: { id: string; payload?: Record<string, unknown> }) => ({
+          id: p.id,
+          ...p.payload,
+        }))
+
+        // Client-side text search filter
+        let filtered = points
+        if (textSearch && textSearch.trim()) {
+          const term = textSearch.toLowerCase()
+          filtered = points.filter((p: Record<string, unknown>) => {
+            const text = String(p.text || p.content || p.chunk_text || '')
+            return text.toLowerCase().includes(term)
+          })
+        }
+
+        return NextResponse.json({
+          chunks: filtered,
+          next_offset: scrollData.result?.next_page_offset || null,
+          total_in_page: points.length,
+        })
+      }
+      case 'regulation-counts-batch': {
+        const col = searchParams.get('collection') || 'bp_compliance_gesetze'
+        // Accept qdrant_ids (actual regulation_id values in Qdrant payload)
+        const qdrantIds = (searchParams.get('qdrant_ids') || '').split(',').filter(Boolean)
+        const results: Record<string, number> = {}
+        for (let i = 0; i < qdrantIds.length; i += 10) {
+          const batch = qdrantIds.slice(i, i + 10)
+          await Promise.all(batch.map(async (qid) => {
+            try {
+              const res = await fetch(`${QDRANT_URL}/collections/${encodeURIComponent(col)}/points/count`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                  filter: { must: [{ key: 'regulation_id', match: { value: qid } }] },
+                  exact: true,
+                }),
+                cache: 'no-store',
+              })
+              if (res.ok) {
+                const data = await res.json()
+                results[qid] = data.result?.count || 0
+              }
+            } catch { /* skip failed counts */ }
+          }))
+        }
+        return NextResponse.json({ counts: results })
+      }
+      case 'collection-count': {
+        const col = searchParams.get('collection') || 'bp_compliance_gesetze'
+        const countRes = await fetch(`${QDRANT_URL}/collections/${encodeURIComponent(col)}`, {
+          cache: 'no-store',
+        })
+        if (!countRes.ok) {
+          return NextResponse.json({ count: 0 })
+        }
+        const countData = await countRes.json()
+        return NextResponse.json({
+          count: countData.result?.points_count || 0,
+        })
+      }
       default:
         return NextResponse.json({ error: 'Unknown action' }, { status: 400 })
     }

admin-lehrer/app/layout.tsx

@@ -1,8 +1,12 @@
 import type { Metadata } from 'next'
-import { Inter } from 'next/font/google'
+import localFont from 'next/font/local'
 import './globals.css'
 
-const inter = Inter({ subsets: ['latin'] })
+const inter = localFont({
+  src: '../public/fonts/Inter-VariableFont.woff2',
+  variable: '--font-inter',
+  display: 'swap',
+})
 
 export const metadata: Metadata = {
   title: 'BreakPilot Admin Lehrer KI',

admin-lehrer/components/ai/AIToolsSidebar.tsx

@@ -14,7 +14,7 @@
 import Link from 'next/link'
 import { useState, useEffect } from 'react'
 
-export type AIToolId = 'llm-compare' | 'test-quality' | 'gpu' | 'ocr-compare' | 'ocr-labeling' | 'rag-pipeline' | 'magic-help'
+export type AIToolId = 'test-quality' | 'gpu' | 'ocr-compare' | 'ocr-labeling' | 'rag-pipeline' | 'magic-help'
 
 export interface AIToolModule {
   id: AIToolId
@@ -25,13 +25,6 @@ export interface AIToolModule {
 }
 
 export const AI_TOOLS_MODULES: AIToolModule[] = [
-  {
-    id: 'llm-compare',
-    name: 'LLM Vergleich',
-    href: '/ai/llm-compare',
-    description: 'KI-Provider vergleichen',
-    icon: '⚖️',
-  },
   {
     id: 'test-quality',
     name: 'Test Quality (BQAS)',
@@ -93,13 +86,6 @@ export interface AIToolsSidebarResponsiveProps extends AIToolsSidebarProps {
 // Icons für die Tools
 const ToolIcon = ({ id }: { id: string }) => {
   switch (id) {
-    case 'llm-compare':
-      return (
-        <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2}
-            d="M3 6l3 1m0 0l-3 9a5.002 5.002 0 006.001 0M6 7l3 9M6 7l6-2m6 2l3-1m-3 1l-3 9a5.002 5.002 0 006.001 0M18 7l3 9m-3-9l-6-2m0-2v2m0 16V5m0 16H9m3 0h3" />
-        </svg>
-      )
     case 'test-quality':
       return (
         <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
@@ -228,8 +214,6 @@ export function AIToolsSidebar({
               <div className="flex items-center gap-2 text-xs">
                 <span title="GPU Infrastruktur">🖥️</span>
                 <span className="text-slate-400">→</span>
-                <span title="LLM Vergleich">⚖️</span>
-                <span className="text-slate-400">→</span>
                 <span title="Test Quality">🧪</span>
               </div>
             </div>
@@ -241,9 +225,6 @@ export function AIToolsSidebar({
           {/* Quick Info zum aktuellen Tool */}
           <div className="pt-2 border-t border-slate-200 dark:border-gray-700">
             <div className="text-xs text-slate-500 dark:text-slate-400 px-1">
-              {currentTool === 'llm-compare' && (
-                <span>Vergleichen Sie LLM-Antworten verschiedener Provider</span>
-              )}
               {currentTool === 'test-quality' && (
                 <span>Ueberwachen Sie die Qualitaet der KI-Ausgaben</span>
               )}
@@ -387,11 +368,6 @@ export function AIToolsSidebarResponsive({
                     <span className="text-xs text-slate-500 mt-1">GPU</span>
                   </div>
                   <span className="text-slate-400">→</span>
-                  <div className="flex flex-col items-center">
-                    <span className="text-2xl">⚖️</span>
-                    <span className="text-xs text-slate-500 mt-1">LLM</span>
-                  </div>
-                  <span className="text-slate-400">→</span>
                   <div className="flex flex-col items-center">
                     <span className="text-2xl">🧪</span>
                     <span className="text-xs text-slate-500 mt-1">BQAS</span>
@@ -405,11 +381,6 @@ export function AIToolsSidebarResponsive({
               {/* Quick Info */}
               <div className="pt-4 border-t border-slate-200 dark:border-gray-700">
                 <div className="text-sm text-slate-600 dark:text-slate-400 p-3 bg-slate-50 dark:bg-gray-800 rounded-xl">
-                  {currentTool === 'llm-compare' && (
-                    <>
-                      <strong className="text-slate-700 dark:text-slate-300">Aktuell:</strong> LLM-Antworten verschiedener Provider vergleichen
-                    </>
-                  )}
                   {currentTool === 'test-quality' && (
                     <>
                       <strong className="text-slate-700 dark:text-slate-300">Aktuell:</strong> Qualitaet der KI-Ausgaben ueberwachen

admin-lehrer/components/layout/Sidebar.tsx

@@ -194,10 +194,8 @@ export function Sidebar({ onRoleChange }: SidebarProps) {
         {/* Categories */}
         <div className="px-2 space-y-1">
           {visibleCategories.map((category) => {
-            const categoryHref = category.id === 'compliance-sdk' ? '/sdk' : `/${category.id}`
-            const isCategoryActive = category.id === 'compliance-sdk'
-              ? category.modules.some(m => pathname.startsWith(m.href))
-              : pathname.startsWith(categoryHref)
+            const categoryHref = `/${category.id}`
+            const isCategoryActive = pathname.startsWith(categoryHref)
 
             return (
             <div key={category.id}>

admin-lehrer/components/ocr-pipeline/ColumnControls.tsx

@@ -0,0 +1,320 @@
+'use client'
+
+import { useState, useMemo } from 'react'
+import type { ColumnResult, ColumnGroundTruth, PageRegion } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+interface ColumnControlsProps {
+  columnResult: ColumnResult | null
+  onRerun: () => void
+  onManualMode: () => void
+  onGtMode: () => void
+  onGroundTruth: (gt: ColumnGroundTruth) => void
+  onNext: () => void
+  isDetecting: boolean
+  savedGtColumns: PageRegion[] | null
+}
+
+const TYPE_COLORS: Record<string, string> = {
+  column_en: 'bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400',
+  column_de: 'bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400',
+  column_example: 'bg-orange-100 text-orange-700 dark:bg-orange-900/30 dark:text-orange-400',
+  column_text: 'bg-cyan-100 text-cyan-700 dark:bg-cyan-900/30 dark:text-cyan-400',
+  page_ref: 'bg-purple-100 text-purple-700 dark:bg-purple-900/30 dark:text-purple-400',
+  column_marker: 'bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400',
+  column_ignore: 'bg-gray-100 text-gray-500 dark:bg-gray-700/30 dark:text-gray-500',
+  header: 'bg-gray-100 text-gray-600 dark:bg-gray-700/50 dark:text-gray-400',
+  footer: 'bg-gray-100 text-gray-600 dark:bg-gray-700/50 dark:text-gray-400',
+}
+
+const TYPE_LABELS: Record<string, string> = {
+  column_en: 'EN',
+  column_de: 'DE',
+  column_example: 'Beispiel',
+  column_text: 'Text',
+  page_ref: 'Seite',
+  column_marker: 'Marker',
+  column_ignore: 'Ignorieren',
+  header: 'Header',
+  footer: 'Footer',
+}
+
+const METHOD_LABELS: Record<string, string> = {
+  content: 'Inhalt',
+  position_enhanced: 'Position',
+  position_fallback: 'Fallback',
+}
+
+interface DiffRow {
+  index: number
+  autoCol: PageRegion | null
+  gtCol: PageRegion | null
+  diffX: number | null
+  diffW: number | null
+  typeMismatch: boolean
+}
+
+/** Match auto columns to GT columns by overlap on X-axis (IoU > 50%) */
+function computeDiff(autoCols: PageRegion[], gtCols: PageRegion[]): DiffRow[] {
+  const rows: DiffRow[] = []
+  const usedGt = new Set<number>()
+  const usedAuto = new Set<number>()
+
+  // Match auto → GT by best X-axis overlap
+  for (let ai = 0; ai < autoCols.length; ai++) {
+    const a = autoCols[ai]
+    let bestIdx = -1
+    let bestIoU = 0
+
+    for (let gi = 0; gi < gtCols.length; gi++) {
+      if (usedGt.has(gi)) continue
+      const g = gtCols[gi]
+      const overlapStart = Math.max(a.x, g.x)
+      const overlapEnd = Math.min(a.x + a.width, g.x + g.width)
+      const overlap = Math.max(0, overlapEnd - overlapStart)
+      const union = (a.width + g.width) - overlap
+      const iou = union > 0 ? overlap / union : 0
+      if (iou > bestIoU) {
+        bestIoU = iou
+        bestIdx = gi
+      }
+    }
+
+    if (bestIdx >= 0 && bestIoU > 0.3) {
+      usedGt.add(bestIdx)
+      usedAuto.add(ai)
+      const g = gtCols[bestIdx]
+      rows.push({
+        index: rows.length + 1,
+        autoCol: a,
+        gtCol: g,
+        diffX: g.x - a.x,
+        diffW: g.width - a.width,
+        typeMismatch: a.type !== g.type,
+      })
+    }
+  }
+
+  // Unmatched auto columns
+  for (let ai = 0; ai < autoCols.length; ai++) {
+    if (usedAuto.has(ai)) continue
+    rows.push({
+      index: rows.length + 1,
+      autoCol: autoCols[ai],
+      gtCol: null,
+      diffX: null,
+      diffW: null,
+      typeMismatch: false,
+    })
+  }
+
+  // Unmatched GT columns
+  for (let gi = 0; gi < gtCols.length; gi++) {
+    if (usedGt.has(gi)) continue
+    rows.push({
+      index: rows.length + 1,
+      autoCol: null,
+      gtCol: gtCols[gi],
+      diffX: null,
+      diffW: null,
+      typeMismatch: false,
+    })
+  }
+
+  return rows
+}
+
+export function ColumnControls({ columnResult, onRerun, onManualMode, onGtMode, onGroundTruth, onNext, isDetecting, savedGtColumns }: ColumnControlsProps) {
+  const [gtSaved, setGtSaved] = useState(false)
+
+  const diffRows = useMemo(() => {
+    if (!columnResult || !savedGtColumns) return null
+    const autoCols = columnResult.columns.filter(c => c.type.startsWith('column') || c.type === 'page_ref')
+    const gtCols = savedGtColumns.filter(c => c.type.startsWith('column') || c.type === 'page_ref')
+    return computeDiff(autoCols, gtCols)
+  }, [columnResult, savedGtColumns])
+
+  if (!columnResult) return null
+
+  const columns = columnResult.columns.filter((c: PageRegion) => c.type.startsWith('column') || c.type === 'page_ref')
+  const headerFooter = columnResult.columns.filter((c: PageRegion) => !c.type.startsWith('column') && c.type !== 'page_ref')
+
+  const handleGt = (isCorrect: boolean) => {
+    onGroundTruth({ is_correct: isCorrect })
+    setGtSaved(true)
+  }
+
+  return (
+    <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-4">
+      {/* Summary */}
+      <div className="flex items-center gap-3 flex-wrap">
+        <div className="text-sm text-gray-600 dark:text-gray-400">
+          <span className="font-medium text-gray-800 dark:text-gray-200">{columns.length} Spalten</span> erkannt
+          {columnResult.duration_seconds > 0 && (
+            <span className="ml-2 text-xs">({columnResult.duration_seconds}s)</span>
+          )}
+        </div>
+        <button
+          onClick={onRerun}
+          disabled={isDetecting}
+          className="text-xs px-2 py-1 bg-gray-100 dark:bg-gray-700 rounded hover:bg-gray-200 dark:hover:bg-gray-600 transition-colors disabled:opacity-50"
+        >
+          Erneut erkennen
+        </button>
+        <button
+          onClick={onManualMode}
+          className="text-xs px-2 py-1 bg-teal-100 text-teal-700 dark:bg-teal-900/30 dark:text-teal-400 rounded hover:bg-teal-200 dark:hover:bg-teal-900/50 transition-colors"
+        >
+          Manuell markieren
+        </button>
+        <button
+          onClick={onGtMode}
+          className="text-xs px-2 py-1 bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400 rounded hover:bg-amber-200 dark:hover:bg-amber-900/50 transition-colors"
+        >
+          {savedGtColumns ? 'Ground Truth bearbeiten' : 'Ground Truth eintragen'}
+        </button>
+      </div>
+
+      {/* Column list */}
+      <div className="space-y-2">
+        {columns.map((col: PageRegion, i: number) => (
+          <div key={i} className="flex items-center gap-3 text-sm">
+            <span className={`px-2 py-0.5 rounded text-xs font-medium ${TYPE_COLORS[col.type] || ''}`}>
+              {TYPE_LABELS[col.type] || col.type}
+            </span>
+            {col.classification_confidence != null && col.classification_confidence < 1.0 && (
+              <span className="text-xs font-medium text-gray-600 dark:text-gray-300">
+                {Math.round(col.classification_confidence * 100)}%
+              </span>
+            )}
+            {col.classification_method && (
+              <span className="text-xs text-gray-400 dark:text-gray-500">
+                ({METHOD_LABELS[col.classification_method] || col.classification_method})
+              </span>
+            )}
+            <span className="text-gray-500 dark:text-gray-400 text-xs font-mono">
+              x={col.x} y={col.y} {col.width}x{col.height}px
+            </span>
+          </div>
+        ))}
+        {headerFooter.map((r: PageRegion, i: number) => (
+          <div key={`hf-${i}`} className="flex items-center gap-3 text-sm">
+            <span className={`px-2 py-0.5 rounded text-xs font-medium ${TYPE_COLORS[r.type] || ''}`}>
+              {TYPE_LABELS[r.type] || r.type}
+            </span>
+            <span className="text-gray-500 dark:text-gray-400 text-xs font-mono">
+              x={r.x} y={r.y} {r.width}x{r.height}px
+            </span>
+          </div>
+        ))}
+      </div>
+
+      {/* Diff table (Auto vs GT) */}
+      {diffRows && diffRows.length > 0 && (
+        <div className="border-t border-gray-100 dark:border-gray-700 pt-3">
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-2">
+            Vergleich: Auto vs Ground Truth
+          </div>
+          <div className="overflow-x-auto">
+            <table className="w-full text-xs">
+              <thead>
+                <tr className="text-gray-500 dark:text-gray-400 border-b border-gray-100 dark:border-gray-700">
+                  <th className="text-left py-1 pr-2">#</th>
+                  <th className="text-left py-1 pr-2">Auto (Typ, x, w)</th>
+                  <th className="text-left py-1 pr-2">GT (Typ, x, w)</th>
+                  <th className="text-right py-1 pr-2">Diff X</th>
+                  <th className="text-right py-1">Diff W</th>
+                </tr>
+              </thead>
+              <tbody>
+                {diffRows.map((row) => (
+                  <tr
+                    key={row.index}
+                    className={
+                      !row.autoCol || !row.gtCol || row.typeMismatch
+                        ? 'bg-red-50 dark:bg-red-900/10'
+                        : (row.diffX !== null && Math.abs(row.diffX) > 20) || (row.diffW !== null && Math.abs(row.diffW) > 20)
+                          ? 'bg-amber-50 dark:bg-amber-900/10'
+                          : ''
+                    }
+                  >
+                    <td className="py-1 pr-2 font-mono text-gray-400">{row.index}</td>
+                    <td className="py-1 pr-2 font-mono">
+                      {row.autoCol ? (
+                        <span>
+                          <span className={`inline-block px-1 rounded ${TYPE_COLORS[row.autoCol.type] || ''}`}>
+                            {TYPE_LABELS[row.autoCol.type] || row.autoCol.type}
+                          </span>
+                          {' '}{row.autoCol.x}, {row.autoCol.width}
+                        </span>
+                      ) : (
+                        <span className="text-red-400">fehlt</span>
+                      )}
+                    </td>
+                    <td className="py-1 pr-2 font-mono">
+                      {row.gtCol ? (
+                        <span>
+                          <span className={`inline-block px-1 rounded ${TYPE_COLORS[row.gtCol.type] || ''}`}>
+                            {TYPE_LABELS[row.gtCol.type] || row.gtCol.type}
+                          </span>
+                          {' '}{row.gtCol.x}, {row.gtCol.width}
+                        </span>
+                      ) : (
+                        <span className="text-red-400">fehlt</span>
+                      )}
+                    </td>
+                    <td className="py-1 pr-2 text-right font-mono">
+                      {row.diffX !== null ? (
+                        <span className={Math.abs(row.diffX) > 20 ? 'text-amber-600 dark:text-amber-400' : 'text-gray-500'}>
+                          {row.diffX > 0 ? '+' : ''}{row.diffX}
+                        </span>
+                      ) : '—'}
+                    </td>
+                    <td className="py-1 text-right font-mono">
+                      {row.diffW !== null ? (
+                        <span className={Math.abs(row.diffW) > 20 ? 'text-amber-600 dark:text-amber-400' : 'text-gray-500'}>
+                          {row.diffW > 0 ? '+' : ''}{row.diffW}
+                        </span>
+                      ) : '—'}
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </div>
+      )}
+
+      {/* Ground Truth + Navigation */}
+      <div className="flex items-center justify-between pt-2 border-t border-gray-100 dark:border-gray-700">
+        <div className="flex items-center gap-2">
+          <span className="text-sm text-gray-500 dark:text-gray-400">Spalten korrekt?</span>
+          {gtSaved ? (
+            <span className="text-xs text-green-600 dark:text-green-400">Gespeichert</span>
+          ) : (
+            <>
+              <button
+                onClick={() => handleGt(true)}
+                className="text-xs px-3 py-1 bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400 rounded hover:bg-green-200 dark:hover:bg-green-900/50 transition-colors"
+              >
+                Ja
+              </button>
+              <button
+                onClick={() => handleGt(false)}
+                className="text-xs px-3 py-1 bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400 rounded hover:bg-red-200 dark:hover:bg-red-900/50 transition-colors"
+              >
+                Nein
+              </button>
+            </>
+          )}
+        </div>
+
+        <button
+          onClick={onNext}
+          className="px-4 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors text-sm font-medium"
+        >
+          Weiter
+        </button>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/DeskewControls.tsx

@@ -0,0 +1,209 @@
+'use client'
+
+import { useState } from 'react'
+import type { DeskewResult, DeskewGroundTruth } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+interface DeskewControlsProps {
+  deskewResult: DeskewResult | null
+  showBinarized: boolean
+  onToggleBinarized: () => void
+  showGrid: boolean
+  onToggleGrid: () => void
+  onManualDeskew: (angle: number) => void
+  onGroundTruth: (gt: DeskewGroundTruth) => void
+  onNext: () => void
+  isApplying: boolean
+}
+
+const METHOD_LABELS: Record<string, string> = {
+  hough: 'Hough-Linien',
+  word_alignment: 'Wortausrichtung',
+  manual: 'Manuell',
+}
+
+export function DeskewControls({
+  deskewResult,
+  showBinarized,
+  onToggleBinarized,
+  showGrid,
+  onToggleGrid,
+  onManualDeskew,
+  onGroundTruth,
+  onNext,
+  isApplying,
+}: DeskewControlsProps) {
+  const [manualAngle, setManualAngle] = useState(0)
+  const [gtFeedback, setGtFeedback] = useState<'correct' | 'incorrect' | null>(null)
+  const [gtNotes, setGtNotes] = useState('')
+  const [gtSaved, setGtSaved] = useState(false)
+
+  const handleGroundTruth = (isCorrect: boolean) => {
+    setGtFeedback(isCorrect ? 'correct' : 'incorrect')
+    if (isCorrect) {
+      onGroundTruth({ is_correct: true })
+      setGtSaved(true)
+    }
+  }
+
+  const handleGroundTruthIncorrect = () => {
+    onGroundTruth({
+      is_correct: false,
+      corrected_angle: manualAngle !== 0 ? manualAngle : undefined,
+      notes: gtNotes || undefined,
+    })
+    setGtSaved(true)
+  }
+
+  return (
+    <div className="space-y-4">
+      {/* Results */}
+      {deskewResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="flex flex-wrap items-center gap-3 text-sm">
+            <div>
+              <span className="text-gray-500">Winkel:</span>{' '}
+              <span className="font-mono font-medium">{deskewResult.angle_applied}°</span>
+            </div>
+            <div className="h-4 w-px bg-gray-300 dark:bg-gray-600" />
+            <div>
+              <span className="text-gray-500">Methode:</span>{' '}
+              <span className="inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-teal-100 text-teal-700 dark:bg-teal-900/40 dark:text-teal-300">
+                {METHOD_LABELS[deskewResult.method_used] || deskewResult.method_used}
+              </span>
+            </div>
+            <div className="h-4 w-px bg-gray-300 dark:bg-gray-600" />
+            <div>
+              <span className="text-gray-500">Konfidenz:</span>{' '}
+              <span className="font-mono">{Math.round(deskewResult.confidence * 100)}%</span>
+            </div>
+            <div className="h-4 w-px bg-gray-300 dark:bg-gray-600" />
+            <div className="text-gray-400 text-xs">
+              Hough: {deskewResult.angle_hough}° | WA: {deskewResult.angle_word_alignment}°
+            </div>
+          </div>
+
+          {/* Toggles */}
+          <div className="flex gap-3 mt-3">
+            <button
+              onClick={onToggleBinarized}
+              className={`text-xs px-3 py-1 rounded-full border transition-colors ${
+                showBinarized
+                  ? 'bg-teal-100 border-teal-300 text-teal-700 dark:bg-teal-900/40 dark:border-teal-600 dark:text-teal-300'
+                  : 'border-gray-300 text-gray-500 dark:border-gray-600 dark:text-gray-400'
+              }`}
+            >
+              Binarisiert anzeigen
+            </button>
+            <button
+              onClick={onToggleGrid}
+              className={`text-xs px-3 py-1 rounded-full border transition-colors ${
+                showGrid
+                  ? 'bg-teal-100 border-teal-300 text-teal-700 dark:bg-teal-900/40 dark:border-teal-600 dark:text-teal-300'
+                  : 'border-gray-300 text-gray-500 dark:border-gray-600 dark:text-gray-400'
+              }`}
+            >
+              Raster anzeigen
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* Manual angle */}
+      {deskewResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Manuelle Korrektur</div>
+          <div className="flex items-center gap-3">
+            <span className="text-xs text-gray-400 w-8 text-right">-5°</span>
+            <input
+              type="range"
+              min={-5}
+              max={5}
+              step={0.1}
+              value={manualAngle}
+              onChange={(e) => setManualAngle(parseFloat(e.target.value))}
+              className="flex-1 h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer dark:bg-gray-700 accent-teal-500"
+            />
+            <span className="text-xs text-gray-400 w-8">+5°</span>
+            <span className="font-mono text-sm w-14 text-right">{manualAngle.toFixed(1)}°</span>
+            <button
+              onClick={() => onManualDeskew(manualAngle)}
+              disabled={isApplying}
+              className="px-3 py-1.5 text-sm bg-teal-600 text-white rounded-md hover:bg-teal-700 disabled:opacity-50 transition-colors"
+            >
+              {isApplying ? '...' : 'Anwenden'}
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* Ground Truth */}
+      {deskewResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            Rotation korrekt?
+          </div>
+          <p className="text-xs text-gray-400 mb-2">Nur die Drehung bewerten — Woelbung/Verzerrung wird im naechsten Schritt korrigiert.</p>
+          {!gtSaved ? (
+            <div className="space-y-3">
+              <div className="flex gap-2">
+                <button
+                  onClick={() => handleGroundTruth(true)}
+                  className={`px-4 py-1.5 rounded-md text-sm font-medium transition-colors ${
+                    gtFeedback === 'correct'
+                      ? 'bg-green-100 text-green-700 ring-2 ring-green-400'
+                      : 'bg-gray-100 text-gray-600 hover:bg-green-50 dark:bg-gray-700 dark:text-gray-300'
+                  }`}
+                >
+                  Ja
+                </button>
+                <button
+                  onClick={() => handleGroundTruth(false)}
+                  className={`px-4 py-1.5 rounded-md text-sm font-medium transition-colors ${
+                    gtFeedback === 'incorrect'
+                      ? 'bg-red-100 text-red-700 ring-2 ring-red-400'
+                      : 'bg-gray-100 text-gray-600 hover:bg-red-50 dark:bg-gray-700 dark:text-gray-300'
+                  }`}
+                >
+                  Nein
+                </button>
+              </div>
+              {gtFeedback === 'incorrect' && (
+                <div className="space-y-2">
+                  <textarea
+                    value={gtNotes}
+                    onChange={(e) => setGtNotes(e.target.value)}
+                    placeholder="Notizen zur Korrektur..."
+                    className="w-full text-sm border border-gray-300 dark:border-gray-600 rounded-md p-2 bg-white dark:bg-gray-900 text-gray-800 dark:text-gray-200"
+                    rows={2}
+                  />
+                  <button
+                    onClick={handleGroundTruthIncorrect}
+                    className="text-sm px-3 py-1 bg-red-600 text-white rounded-md hover:bg-red-700 transition-colors"
+                  >
+                    Feedback speichern
+                  </button>
+                </div>
+              )}
+            </div>
+          ) : (
+            <div className="text-sm text-green-600 dark:text-green-400">
+              Feedback gespeichert
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Next button */}
+      {deskewResult && (
+        <div className="flex justify-end">
+          <button
+            onClick={onNext}
+            className="px-6 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 font-medium transition-colors"
+          >
+            Uebernehmen & Weiter &rarr;
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/DewarpControls.tsx

@@ -0,0 +1,309 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import type { DewarpResult, DewarpDetection, DewarpGroundTruth } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+interface DewarpControlsProps {
+  dewarpResult: DewarpResult | null
+  showGrid: boolean
+  onToggleGrid: () => void
+  onManualDewarp: (shearDegrees: number) => void
+  onGroundTruth: (gt: DewarpGroundTruth) => void
+  onNext: () => void
+  isApplying: boolean
+}
+
+const METHOD_LABELS: Record<string, string> = {
+  vertical_edge: 'A: Vertikale Kanten',
+  projection: 'B: Projektions-Varianz',
+  hough_lines: 'C: Hough-Linien',
+  text_lines: 'D: Textzeilenanalyse',
+  manual: 'Manuell',
+  none: 'Keine Korrektur',
+}
+
+/** Colour for a confidence value (0-1). */
+function confColor(conf: number): string {
+  if (conf >= 0.7) return 'text-green-600 dark:text-green-400'
+  if (conf >= 0.5) return 'text-yellow-600 dark:text-yellow-400'
+  return 'text-gray-400'
+}
+
+/** Short confidence bar (visual). */
+function ConfBar({ value }: { value: number }) {
+  const pct = Math.round(value * 100)
+  const bg = value >= 0.7 ? 'bg-green-500' : value >= 0.5 ? 'bg-yellow-500' : 'bg-gray-400'
+  return (
+    <div className="flex items-center gap-1.5">
+      <div className="w-16 h-1.5 bg-gray-200 dark:bg-gray-700 rounded-full overflow-hidden">
+        <div className={`h-full rounded-full ${bg}`} style={{ width: `${pct}%` }} />
+      </div>
+      <span className={`text-xs font-mono ${confColor(value)}`}>{pct}%</span>
+    </div>
+  )
+}
+
+export function DewarpControls({
+  dewarpResult,
+  showGrid,
+  onToggleGrid,
+  onManualDewarp,
+  onGroundTruth,
+  onNext,
+  isApplying,
+}: DewarpControlsProps) {
+  const [manualShear, setManualShear] = useState(0)
+  const [gtFeedback, setGtFeedback] = useState<'correct' | 'incorrect' | null>(null)
+  const [gtNotes, setGtNotes] = useState('')
+  const [gtSaved, setGtSaved] = useState(false)
+  const [showDetails, setShowDetails] = useState(false)
+
+  // Initialize slider to auto-detected value when result arrives
+  useEffect(() => {
+    if (dewarpResult && dewarpResult.shear_degrees !== undefined) {
+      setManualShear(dewarpResult.shear_degrees)
+    }
+  }, [dewarpResult?.shear_degrees])
+
+  const handleGroundTruth = (isCorrect: boolean) => {
+    setGtFeedback(isCorrect ? 'correct' : 'incorrect')
+    if (isCorrect) {
+      onGroundTruth({ is_correct: true })
+      setGtSaved(true)
+    }
+  }
+
+  const handleGroundTruthIncorrect = () => {
+    onGroundTruth({
+      is_correct: false,
+      corrected_shear: manualShear !== 0 ? manualShear : undefined,
+      notes: gtNotes || undefined,
+    })
+    setGtSaved(true)
+  }
+
+  const wasRejected = dewarpResult && dewarpResult.method_used === 'none' && (dewarpResult.detections || []).length > 0
+  const wasApplied = dewarpResult && dewarpResult.method_used !== 'none' && dewarpResult.method_used !== 'manual'
+  const detections = dewarpResult?.detections || []
+
+  return (
+    <div className="space-y-4">
+      {/* Summary banner */}
+      {dewarpResult && (
+        <div className={`rounded-lg border p-4 ${
+          wasRejected
+            ? 'bg-amber-50 border-amber-200 dark:bg-amber-900/20 dark:border-amber-700'
+            : wasApplied
+              ? 'bg-green-50 border-green-200 dark:bg-green-900/20 dark:border-green-700'
+              : 'bg-white border-gray-200 dark:bg-gray-800 dark:border-gray-700'
+        }`}>
+          {/* Status line */}
+          <div className="flex items-center gap-2 mb-3">
+            <span className={`text-lg ${wasRejected ? '' : wasApplied ? '' : ''}`}>
+              {wasRejected ? '\u26A0\uFE0F' : wasApplied ? '\u2705' : '\u2796'}
+            </span>
+            <span className="text-sm font-medium text-gray-800 dark:text-gray-200">
+              {wasRejected
+                ? 'Quality Gate: Korrektur verworfen (Projektion nicht verbessert)'
+                : wasApplied
+                  ? `Korrektur angewendet: ${dewarpResult.shear_degrees.toFixed(2)}°`
+                  : dewarpResult.method_used === 'manual'
+                    ? `Manuelle Korrektur: ${dewarpResult.shear_degrees.toFixed(2)}°`
+                    : 'Keine Korrektur noetig'}
+            </span>
+          </div>
+
+          {/* Key metrics */}
+          <div className="flex flex-wrap items-center gap-4 text-sm">
+            <div>
+              <span className="text-gray-500">Scherung:</span>{' '}
+              <span className="font-mono font-medium">{dewarpResult.shear_degrees.toFixed(2)}°</span>
+            </div>
+            <div className="h-4 w-px bg-gray-300 dark:bg-gray-600" />
+            <div>
+              <span className="text-gray-500">Methode:</span>{' '}
+              <span className="inline-flex items-center px-2 py-0.5 rounded-full text-xs font-medium bg-teal-100 text-teal-700 dark:bg-teal-900/40 dark:text-teal-300">
+                {dewarpResult.method_used.includes('+')
+                  ? `Ensemble (${dewarpResult.method_used.split('+').map(m => METHOD_LABELS[m] || m).join(' + ')})`
+                  : METHOD_LABELS[dewarpResult.method_used] || dewarpResult.method_used}
+              </span>
+            </div>
+            <div className="h-4 w-px bg-gray-300 dark:bg-gray-600" />
+            <div className="flex items-center gap-1.5">
+              <span className="text-gray-500">Konfidenz:</span>
+              <ConfBar value={dewarpResult.confidence} />
+            </div>
+          </div>
+
+          {/* Toggles row */}
+          <div className="flex gap-2 mt-3">
+            <button
+              onClick={onToggleGrid}
+              className={`text-xs px-3 py-1 rounded-full border transition-colors ${
+                showGrid
+                  ? 'bg-teal-100 border-teal-300 text-teal-700 dark:bg-teal-900/40 dark:border-teal-600 dark:text-teal-300'
+                  : 'border-gray-300 text-gray-500 dark:border-gray-600 dark:text-gray-400'
+              }`}
+            >
+              Raster
+            </button>
+            {detections.length > 0 && (
+              <button
+                onClick={() => setShowDetails(v => !v)}
+                className={`text-xs px-3 py-1 rounded-full border transition-colors ${
+                  showDetails
+                    ? 'bg-blue-100 border-blue-300 text-blue-700 dark:bg-blue-900/40 dark:border-blue-600 dark:text-blue-300'
+                    : 'border-gray-300 text-gray-500 dark:border-gray-600 dark:text-gray-400'
+                }`}
+              >
+                Details ({detections.length} Methoden)
+              </button>
+            )}
+          </div>
+
+          {/* Detailed detections */}
+          {showDetails && detections.length > 0 && (
+            <div className="mt-3 pt-3 border-t border-gray-200 dark:border-gray-700">
+              <div className="text-xs text-gray-500 mb-2">Einzelne Detektoren:</div>
+              <div className="space-y-1.5">
+                {detections.map((d: DewarpDetection) => {
+                  const isUsed = dewarpResult.method_used.includes(d.method)
+                  const aboveThreshold = d.confidence >= 0.5
+                  return (
+                    <div
+                      key={d.method}
+                      className={`flex items-center gap-3 text-xs px-2 py-1.5 rounded ${
+                        isUsed
+                          ? 'bg-teal-50 dark:bg-teal-900/20'
+                          : 'bg-gray-50 dark:bg-gray-800'
+                      }`}
+                    >
+                      <span className="w-4 text-center">
+                        {isUsed ? '\u2713' : aboveThreshold ? '\u2012' : '\u2717'}
+                      </span>
+                      <span className={`w-40 ${isUsed ? 'font-medium text-gray-800 dark:text-gray-200' : 'text-gray-500'}`}>
+                        {METHOD_LABELS[d.method] || d.method}
+                      </span>
+                      <span className="font-mono w-16 text-right">
+                        {d.shear_degrees.toFixed(2)}°
+                      </span>
+                      <ConfBar value={d.confidence} />
+                      {!aboveThreshold && (
+                        <span className="text-gray-400 ml-1">(unter Schwelle)</span>
+                      )}
+                    </div>
+                  )
+                })}
+              </div>
+              {wasRejected && (
+                <div className="mt-2 text-xs text-amber-600 dark:text-amber-400">
+                  Die Korrektur wurde verworfen, weil die horizontale Projektions-Varianz nach Anwendung nicht besser war als vorher.
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Manual shear angle slider */}
+      {dewarpResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Scherwinkel (manuell)</div>
+          <div className="flex items-center gap-3">
+            <span className="text-xs text-gray-400 w-10 text-right">-2.0°</span>
+            <input
+              type="range"
+              min={-200}
+              max={200}
+              step={5}
+              value={Math.round(manualShear * 100)}
+              onChange={(e) => setManualShear(parseInt(e.target.value) / 100)}
+              className="flex-1 h-2 bg-gray-200 rounded-lg appearance-none cursor-pointer dark:bg-gray-700 accent-teal-500"
+            />
+            <span className="text-xs text-gray-400 w-10">+2.0°</span>
+            <span className="font-mono text-sm w-16 text-right">{manualShear.toFixed(2)}°</span>
+            <button
+              onClick={() => onManualDewarp(manualShear)}
+              disabled={isApplying}
+              className="px-3 py-1.5 text-sm bg-teal-600 text-white rounded-md hover:bg-teal-700 disabled:opacity-50 transition-colors"
+            >
+              {isApplying ? '...' : 'Anwenden'}
+            </button>
+          </div>
+          <p className="text-xs text-gray-400 mt-1">
+            Scherung der vertikalen Achse in Grad. Positiv = Spalten nach rechts kippen, negativ = nach links.
+          </p>
+        </div>
+      )}
+
+      {/* Ground Truth */}
+      {dewarpResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 p-4">
+          <div className="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+            Spalten vertikal ausgerichtet?
+          </div>
+          <p className="text-xs text-gray-400 mb-2">Pruefen ob die Spaltenraender jetzt senkrecht zum Raster stehen.</p>
+          {!gtSaved ? (
+            <div className="space-y-3">
+              <div className="flex gap-2">
+                <button
+                  onClick={() => handleGroundTruth(true)}
+                  className={`px-4 py-1.5 rounded-md text-sm font-medium transition-colors ${
+                    gtFeedback === 'correct'
+                      ? 'bg-green-100 text-green-700 ring-2 ring-green-400'
+                      : 'bg-gray-100 text-gray-600 hover:bg-green-50 dark:bg-gray-700 dark:text-gray-300'
+                  }`}
+                >
+                  Ja
+                </button>
+                <button
+                  onClick={() => handleGroundTruth(false)}
+                  className={`px-4 py-1.5 rounded-md text-sm font-medium transition-colors ${
+                    gtFeedback === 'incorrect'
+                      ? 'bg-red-100 text-red-700 ring-2 ring-red-400'
+                      : 'bg-gray-100 text-gray-600 hover:bg-red-50 dark:bg-gray-700 dark:text-gray-300'
+                  }`}
+                >
+                  Nein
+                </button>
+              </div>
+              {gtFeedback === 'incorrect' && (
+                <div className="space-y-2">
+                  <textarea
+                    value={gtNotes}
+                    onChange={(e) => setGtNotes(e.target.value)}
+                    placeholder="Notizen zur Korrektur..."
+                    className="w-full text-sm border border-gray-300 dark:border-gray-600 rounded-md p-2 bg-white dark:bg-gray-900 text-gray-800 dark:text-gray-200"
+                    rows={2}
+                  />
+                  <button
+                    onClick={handleGroundTruthIncorrect}
+                    className="text-sm px-3 py-1 bg-red-600 text-white rounded-md hover:bg-red-700 transition-colors"
+                  >
+                    Feedback speichern
+                  </button>
+                </div>
+              )}
+            </div>
+          ) : (
+            <div className="text-sm text-green-600 dark:text-green-400">
+              Feedback gespeichert
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Next button */}
+      {dewarpResult && (
+        <div className="flex justify-end">
+          <button
+            onClick={onNext}
+            className="px-6 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 font-medium transition-colors"
+          >
+            Uebernehmen & Weiter &rarr;
+          </button>
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/FabricReconstructionCanvas.tsx

@@ -0,0 +1,403 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { GridCell } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+// Column type → colour mapping
+const COL_TYPE_COLORS: Record<string, string> = {
+  column_en: '#3b82f6',      // blue-500
+  column_de: '#22c55e',      // green-500
+  column_example: '#f97316', // orange-500
+  column_text: '#a855f7',    // purple-500
+  page_ref: '#06b6d4',       // cyan-500
+  column_marker: '#6b7280',  // gray-500
+}
+
+interface FabricReconstructionCanvasProps {
+  sessionId: string
+  cells: GridCell[]
+  onCellsChanged: (updates: { cell_id: string; text: string }[]) => void
+}
+
+// Fabric.js types (subset used here)
+interface FabricCanvas {
+  add: (...objects: FabricObject[]) => FabricCanvas
+  remove: (...objects: FabricObject[]) => FabricCanvas
+  setBackgroundImage: (img: FabricImage, callback: () => void) => void
+  renderAll: () => void
+  getObjects: () => FabricObject[]
+  dispose: () => void
+  on: (event: string, handler: (e: FabricEvent) => void) => void
+  setWidth: (w: number) => void
+  setHeight: (h: number) => void
+  getActiveObject: () => FabricObject | null
+  discardActiveObject: () => FabricCanvas
+  requestRenderAll: () => void
+  setZoom: (z: number) => void
+  getZoom: () => number
+}
+
+interface FabricObject {
+  type?: string
+  left?: number
+  top?: number
+  width?: number
+  height?: number
+  text?: string
+  set: (props: Record<string, unknown>) => FabricObject
+  get: (prop: string) => unknown
+  data?: Record<string, unknown>
+  selectable?: boolean
+  on?: (event: string, handler: () => void) => void
+  setCoords?: () => void
+}
+
+interface FabricImage extends FabricObject {
+  width?: number
+  height?: number
+  scaleX?: number
+  scaleY?: number
+}
+
+interface FabricEvent {
+  target?: FabricObject
+  e?: MouseEvent
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type FabricModule = any
+
+export function FabricReconstructionCanvas({
+  sessionId,
+  cells,
+  onCellsChanged,
+}: FabricReconstructionCanvasProps) {
+  const canvasElRef = useRef<HTMLCanvasElement>(null)
+  const fabricRef = useRef<FabricCanvas | null>(null)
+  const fabricModuleRef = useRef<FabricModule>(null)
+  const [ready, setReady] = useState(false)
+  const [opacity, setOpacity] = useState(30)
+  const [zoom, setZoom] = useState(100)
+  const [selectedCell, setSelectedCell] = useState<string | null>(null)
+  const [error, setError] = useState('')
+
+  // Undo/Redo
+  const undoStackRef = useRef<{ cellId: string; oldText: string; newText: string }[]>([])
+  const redoStackRef = useRef<{ cellId: string; oldText: string; newText: string }[]>([])
+
+  // ---- Initialise Fabric.js ----
+  useEffect(() => {
+    let disposed = false
+
+    async function init() {
+      try {
+        const fabricModule = await import('fabric')
+        if (disposed) return
+        fabricModuleRef.current = fabricModule
+
+        const canvasEl = canvasElRef.current
+        if (!canvasEl) return
+
+        // Load background image first to get dimensions
+        const imgUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+
+        const bgImg = await fabricModule.FabricImage.fromURL(imgUrl, { crossOrigin: 'anonymous' }) as FabricImage
+
+        if (disposed) return
+
+        const imgW = (bgImg.width || 800) * (bgImg.scaleX || 1)
+        const imgH = (bgImg.height || 600) * (bgImg.scaleY || 1)
+
+        bgImg.set({ opacity: opacity / 100, selectable: false, evented: false } as Record<string, unknown>)
+
+        const canvas = new fabricModule.Canvas(canvasEl, {
+          width: imgW,
+          height: imgH,
+          selection: true,
+          preserveObjectStacking: true,
+          backgroundImage: bgImg,
+        }) as unknown as FabricCanvas
+
+        fabricRef.current = canvas
+        canvas.renderAll()
+
+        // Add cell objects
+        addCellObjects(canvas, fabricModule, cells, imgW, imgH)
+
+        // Listen for text changes
+        canvas.on('object:modified', (e: FabricEvent) => {
+          if (e.target?.data?.cellId) {
+            const cellId = e.target.data.cellId as string
+            const newText = (e.target.text || '') as string
+            onCellsChanged([{ cell_id: cellId, text: newText }])
+          }
+        })
+
+        // Selection tracking
+        canvas.on('selection:created', (e: FabricEvent) => {
+          if (e.target?.data?.cellId) setSelectedCell(e.target.data.cellId as string)
+        })
+        canvas.on('selection:updated', (e: FabricEvent) => {
+          if (e.target?.data?.cellId) setSelectedCell(e.target.data.cellId as string)
+        })
+        canvas.on('selection:cleared', () => setSelectedCell(null))
+
+        setReady(true)
+      } catch (err) {
+        if (!disposed) setError(err instanceof Error ? err.message : 'Fabric.js konnte nicht geladen werden')
+      }
+    }
+
+    init()
+
+    return () => {
+      disposed = true
+      fabricRef.current?.dispose()
+      fabricRef.current = null
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  function addCellObjects(
+    canvas: FabricCanvas,
+    fabricModule: FabricModule,
+    gridCells: GridCell[],
+    imgW: number,
+    imgH: number,
+  ) {
+    for (const cell of gridCells) {
+      const color = COL_TYPE_COLORS[cell.col_type] || '#6b7280'
+      const x = (cell.bbox_pct.x / 100) * imgW
+      const y = (cell.bbox_pct.y / 100) * imgH
+      const w = (cell.bbox_pct.w / 100) * imgW
+      const h = (cell.bbox_pct.h / 100) * imgH
+
+      const fontSize = Math.max(8, Math.min(18, h * 0.55))
+
+      const textObj = new fabricModule.IText(cell.text || '', {
+        left: x,
+        top: y,
+        width: w,
+        fontSize,
+        fontFamily: 'monospace',
+        fill: '#000000',
+        backgroundColor: `${color}22`,
+        padding: 2,
+        editable: true,
+        selectable: true,
+        lockScalingFlip: true,
+        data: {
+          cellId: cell.cell_id,
+          colType: cell.col_type,
+          rowIndex: cell.row_index,
+          colIndex: cell.col_index,
+          originalText: cell.text,
+        },
+      })
+
+      // Border colour matches column type
+      textObj.set({
+        borderColor: color,
+        cornerColor: color,
+        cornerSize: 6,
+        transparentCorners: false,
+      } as Record<string, unknown>)
+
+      canvas.add(textObj)
+    }
+    canvas.renderAll()
+  }
+
+  // ---- Opacity slider ----
+  const handleOpacityChange = useCallback((val: number) => {
+    setOpacity(val)
+    const canvas = fabricRef.current
+    if (!canvas) return
+    // Fabric v6: backgroundImage is a direct property on the canvas
+    const bgImg = (canvas as unknown as { backgroundImage?: FabricObject }).backgroundImage
+    if (bgImg) {
+      bgImg.set({ opacity: val / 100 })
+      canvas.renderAll()
+    }
+  }, [])
+
+  // ---- Zoom ----
+  const handleZoomChange = useCallback((val: number) => {
+    setZoom(val)
+    const canvas = fabricRef.current
+    if (!canvas) return
+    ;(canvas as unknown as { zoom: number }).zoom = val / 100
+    canvas.requestRenderAll()
+  }, [])
+
+  // ---- Undo / Redo via keyboard ----
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if (!(e.metaKey || e.ctrlKey) || e.key !== 'z') return
+      e.preventDefault()
+
+      const canvas = fabricRef.current
+      if (!canvas) return
+
+      if (e.shiftKey) {
+        // Redo
+        const action = redoStackRef.current.pop()
+        if (!action) return
+        undoStackRef.current.push(action)
+        const obj = canvas.getObjects().find(
+          (o: FabricObject) => o.data?.cellId === action.cellId
+        )
+        if (obj) {
+          obj.set({ text: action.newText } as Record<string, unknown>)
+          canvas.renderAll()
+          onCellsChanged([{ cell_id: action.cellId, text: action.newText }])
+        }
+      } else {
+        // Undo
+        const action = undoStackRef.current.pop()
+        if (!action) return
+        redoStackRef.current.push(action)
+        const obj = canvas.getObjects().find(
+          (o: FabricObject) => o.data?.cellId === action.cellId
+        )
+        if (obj) {
+          obj.set({ text: action.oldText } as Record<string, unknown>)
+          canvas.renderAll()
+          onCellsChanged([{ cell_id: action.cellId, text: action.oldText }])
+        }
+      }
+    }
+    document.addEventListener('keydown', handler)
+    return () => document.removeEventListener('keydown', handler)
+  }, [onCellsChanged])
+
+  // ---- Delete selected cell (via context-menu or Delete key) ----
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if (e.key !== 'Delete' && e.key !== 'Backspace') return
+      // Only delete if not currently editing text inside an IText
+      const canvas = fabricRef.current
+      if (!canvas) return
+      const active = canvas.getActiveObject()
+      if (!active) return
+      // If the IText is in editing mode, let the keypress pass through
+      if ((active as unknown as Record<string, boolean>).isEditing) return
+      e.preventDefault()
+      canvas.remove(active)
+      canvas.discardActiveObject()
+      canvas.renderAll()
+    }
+    document.addEventListener('keydown', handler)
+    return () => document.removeEventListener('keydown', handler)
+  }, [])
+
+  // ---- Export helpers ----
+  const handleExportPdf = useCallback(() => {
+    window.open(
+      `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/export/pdf`,
+      '_blank'
+    )
+  }, [sessionId])
+
+  const handleExportDocx = useCallback(() => {
+    window.open(
+      `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/export/docx`,
+      '_blank'
+    )
+  }, [sessionId])
+
+  if (error) {
+    return (
+      <div className="flex flex-col items-center justify-center py-8 text-red-500 text-sm">
+        <p>Fabric.js Editor konnte nicht geladen werden:</p>
+        <p className="text-xs mt-1 text-gray-400">{error}</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-2">
+      {/* Toolbar */}
+      <div className="flex items-center gap-3 bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 px-3 py-2 text-xs">
+        {/* Opacity slider */}
+        <label className="flex items-center gap-1.5 text-gray-500">
+          Hintergrund
+          <input
+            type="range"
+            min={0} max={100}
+            value={opacity}
+            onChange={e => handleOpacityChange(Number(e.target.value))}
+            className="w-20 h-1 accent-teal-500"
+          />
+          <span className="w-8 text-right">{opacity}%</span>
+        </label>
+
+        <div className="w-px h-5 bg-gray-300 dark:bg-gray-600" />
+
+        {/* Zoom */}
+        <label className="flex items-center gap-1.5 text-gray-500">
+          Zoom
+          <button onClick={() => handleZoomChange(Math.max(25, zoom - 25))}
+            className="px-1.5 py-0.5 border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700">
+            &minus;
+          </button>
+          <span className="w-8 text-center">{zoom}%</span>
+          <button onClick={() => handleZoomChange(Math.min(200, zoom + 25))}
+            className="px-1.5 py-0.5 border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700">
+            +
+          </button>
+          <button onClick={() => handleZoomChange(100)}
+            className="px-1.5 py-0.5 border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700">
+            Fit
+          </button>
+        </label>
+
+        <div className="w-px h-5 bg-gray-300 dark:bg-gray-600" />
+
+        {/* Selected cell info */}
+        {selectedCell && (
+          <span className="text-gray-400">
+            Zelle: <span className="text-gray-600 dark:text-gray-300">{selectedCell}</span>
+          </span>
+        )}
+
+        <div className="flex-1" />
+
+        {/* Export buttons */}
+        <button onClick={handleExportPdf}
+          className="px-2.5 py-1 border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700">
+          PDF
+        </button>
+        <button onClick={handleExportDocx}
+          className="px-2.5 py-1 border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700">
+          DOCX
+        </button>
+      </div>
+
+      {/* Canvas */}
+      <div className="border rounded-lg overflow-auto dark:border-gray-700 bg-gray-100 dark:bg-gray-900"
+           style={{ maxHeight: '75vh' }}>
+        {!ready && (
+          <div className="flex items-center justify-center py-12">
+            <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-teal-500" />
+            <span className="ml-2 text-sm text-gray-500">Canvas wird geladen...</span>
+          </div>
+        )}
+        <canvas ref={canvasElRef} />
+      </div>
+
+      {/* Legend */}
+      <div className="flex items-center gap-4 text-xs text-gray-500">
+        {Object.entries(COL_TYPE_COLORS).map(([type, color]) => (
+          <span key={type} className="flex items-center gap-1">
+            <span className="w-3 h-3 rounded" style={{ backgroundColor: color + '44', border: `1px solid ${color}` }} />
+            {type.replace('column_', '').replace('page_', '')}
+          </span>
+        ))}
+        <span className="ml-auto text-gray-400">Doppelklick = Text bearbeiten | Delete = Zelle entfernen | Cmd+Z = Undo</span>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/ImageCompareView.tsx

@@ -0,0 +1,143 @@
+'use client'
+
+import { useState } from 'react'
+
+const A4_WIDTH_MM = 210
+const A4_HEIGHT_MM = 297
+
+interface ImageCompareViewProps {
+  originalUrl: string | null
+  deskewedUrl: string | null
+  showGrid: boolean
+  showGridLeft?: boolean
+  showBinarized: boolean
+  binarizedUrl: string | null
+  leftLabel?: string
+  rightLabel?: string
+}
+
+function MmGridOverlay() {
+  const lines: React.ReactNode[] = []
+
+  // Vertical lines every 10mm
+  for (let mm = 0; mm <= A4_WIDTH_MM; mm += 10) {
+    const x = (mm / A4_WIDTH_MM) * 100
+    const is50 = mm % 50 === 0
+    lines.push(
+      <line
+        key={`v-${mm}`}
+        x1={x} y1={0} x2={x} y2={100}
+        stroke={is50 ? 'rgba(59, 130, 246, 0.4)' : 'rgba(59, 130, 246, 0.15)'}
+        strokeWidth={is50 ? 0.12 : 0.05}
+      />
+    )
+    // Label every 50mm
+    if (is50 && mm > 0) {
+      lines.push(
+        <text key={`vl-${mm}`} x={x} y={1.2} fill="rgba(59,130,246,0.6)" fontSize="1.2" textAnchor="middle">
+          {mm}
+        </text>
+      )
+    }
+  }
+
+  // Horizontal lines every 10mm
+  for (let mm = 0; mm <= A4_HEIGHT_MM; mm += 10) {
+    const y = (mm / A4_HEIGHT_MM) * 100
+    const is50 = mm % 50 === 0
+    lines.push(
+      <line
+        key={`h-${mm}`}
+        x1={0} y1={y} x2={100} y2={y}
+        stroke={is50 ? 'rgba(59, 130, 246, 0.4)' : 'rgba(59, 130, 246, 0.15)'}
+        strokeWidth={is50 ? 0.12 : 0.05}
+      />
+    )
+    if (is50 && mm > 0) {
+      lines.push(
+        <text key={`hl-${mm}`} x={0.5} y={y + 0.6} fill="rgba(59,130,246,0.6)" fontSize="1.2">
+          {mm}
+        </text>
+      )
+    }
+  }
+
+  return (
+    <svg
+      viewBox="0 0 100 100"
+      preserveAspectRatio="none"
+      className="absolute inset-0 w-full h-full pointer-events-none"
+      style={{ zIndex: 10 }}
+    >
+      <g style={{ pointerEvents: 'none' }}>{lines}</g>
+    </svg>
+  )
+}
+
+export function ImageCompareView({
+  originalUrl,
+  deskewedUrl,
+  showGrid,
+  showGridLeft,
+  showBinarized,
+  binarizedUrl,
+  leftLabel,
+  rightLabel,
+}: ImageCompareViewProps) {
+  const [leftError, setLeftError] = useState(false)
+  const [rightError, setRightError] = useState(false)
+
+  const rightUrl = showBinarized && binarizedUrl ? binarizedUrl : deskewedUrl
+
+  return (
+    <div className="grid grid-cols-1 lg:grid-cols-2 gap-4">
+      {/* Left: Original */}
+      <div className="space-y-2">
+        <h3 className="text-sm font-medium text-gray-500 dark:text-gray-400">{leftLabel || 'Original (unbearbeitet)'}</h3>
+        <div className="relative bg-gray-100 dark:bg-gray-900 rounded-lg overflow-hidden border border-gray-200 dark:border-gray-700"
+             style={{ aspectRatio: '210/297' }}>
+          {originalUrl && !leftError ? (
+            <>
+              <img
+                src={originalUrl}
+                alt="Original Scan"
+                className="w-full h-full object-contain"
+                onError={() => setLeftError(true)}
+              />
+              {showGridLeft && <MmGridOverlay />}
+            </>
+          ) : (
+            <div className="flex items-center justify-center h-full text-gray-400">
+              {leftError ? 'Fehler beim Laden' : 'Noch kein Bild'}
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Right: Deskewed with Grid */}
+      <div className="space-y-2">
+        <h3 className="text-sm font-medium text-gray-500 dark:text-gray-400">
+          {rightLabel || `${showBinarized ? 'Binarisiert' : 'Begradigt'}${showGrid ? ' + Raster (mm)' : ''}`}
+        </h3>
+        <div className="relative bg-gray-100 dark:bg-gray-900 rounded-lg overflow-hidden border border-gray-200 dark:border-gray-700"
+             style={{ aspectRatio: '210/297' }}>
+          {rightUrl && !rightError ? (
+            <>
+              <img
+                src={rightUrl}
+                alt="Begradigtes Bild"
+                className="w-full h-full object-contain"
+                onError={() => setRightError(true)}
+              />
+              {showGrid && <MmGridOverlay />}
+            </>
+          ) : (
+            <div className="flex items-center justify-center h-full text-gray-400">
+              {rightError ? 'Fehler beim Laden' : 'Begradigung laeuft...'}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/ManualColumnEditor.tsx

@@ -0,0 +1,359 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { ColumnTypeKey, PageRegion } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const COLUMN_TYPES: { value: ColumnTypeKey; label: string }[] = [
+  { value: 'column_en', label: 'EN' },
+  { value: 'column_de', label: 'DE' },
+  { value: 'column_example', label: 'Beispiel' },
+  { value: 'column_text', label: 'Text' },
+  { value: 'page_ref', label: 'Seite' },
+  { value: 'column_marker', label: 'Marker' },
+  { value: 'column_ignore', label: 'Ignorieren' },
+]
+
+const TYPE_OVERLAY_COLORS: Record<string, string> = {
+  column_en: 'rgba(59, 130, 246, 0.12)',
+  column_de: 'rgba(34, 197, 94, 0.12)',
+  column_example: 'rgba(249, 115, 22, 0.12)',
+  column_text: 'rgba(6, 182, 212, 0.12)',
+  page_ref: 'rgba(168, 85, 247, 0.12)',
+  column_marker: 'rgba(239, 68, 68, 0.12)',
+  column_ignore: 'rgba(128, 128, 128, 0.06)',
+}
+
+const TYPE_BADGE_COLORS: Record<string, string> = {
+  column_en: 'bg-blue-100 text-blue-700 dark:bg-blue-900/30 dark:text-blue-400',
+  column_de: 'bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400',
+  column_example: 'bg-orange-100 text-orange-700 dark:bg-orange-900/30 dark:text-orange-400',
+  column_text: 'bg-cyan-100 text-cyan-700 dark:bg-cyan-900/30 dark:text-cyan-400',
+  page_ref: 'bg-purple-100 text-purple-700 dark:bg-purple-900/30 dark:text-purple-400',
+  column_marker: 'bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400',
+  column_ignore: 'bg-gray-100 text-gray-500 dark:bg-gray-700/30 dark:text-gray-500',
+}
+
+// Default column type sequence for newly created columns
+const DEFAULT_TYPE_SEQUENCE: ColumnTypeKey[] = [
+  'page_ref', 'column_en', 'column_de', 'column_example', 'column_text',
+]
+
+const MIN_DIVIDER_DISTANCE_PERCENT = 2 // Minimum 2% apart
+
+interface ManualColumnEditorProps {
+  imageUrl: string
+  imageWidth: number
+  imageHeight: number
+  onApply: (columns: PageRegion[]) => void
+  onCancel: () => void
+  applying: boolean
+  mode?: 'manual' | 'ground-truth'
+  layout?: 'two-column' | 'stacked'
+  initialDividers?: number[]
+  initialColumnTypes?: ColumnTypeKey[]
+}
+
+export function ManualColumnEditor({
+  imageUrl,
+  imageWidth,
+  imageHeight,
+  onApply,
+  onCancel,
+  applying,
+  mode = 'manual',
+  layout = 'two-column',
+  initialDividers,
+  initialColumnTypes,
+}: ManualColumnEditorProps) {
+  const containerRef = useRef<HTMLDivElement>(null)
+  const [dividers, setDividers] = useState<number[]>(initialDividers ?? [])
+  const [columnTypes, setColumnTypes] = useState<ColumnTypeKey[]>(initialColumnTypes ?? [])
+  const [dragging, setDragging] = useState<number | null>(null)
+  const [imageLoaded, setImageLoaded] = useState(false)
+
+  const isGT = mode === 'ground-truth'
+
+  // Sync columnTypes length when dividers change
+  useEffect(() => {
+    const numColumns = dividers.length + 1
+    setColumnTypes(prev => {
+      if (prev.length === numColumns) return prev
+      const next = [...prev]
+      while (next.length < numColumns) {
+        const idx = next.length
+        next.push(DEFAULT_TYPE_SEQUENCE[idx] || 'column_text')
+      }
+      while (next.length > numColumns) {
+        next.pop()
+      }
+      return next
+    })
+  }, [dividers.length])
+
+  const getXPercent = useCallback((clientX: number): number => {
+    if (!containerRef.current) return 0
+    const rect = containerRef.current.getBoundingClientRect()
+    const pct = ((clientX - rect.left) / rect.width) * 100
+    return Math.max(0, Math.min(100, pct))
+  }, [])
+
+  const canPlaceDivider = useCallback((xPct: number, excludeIndex?: number): boolean => {
+    for (let i = 0; i < dividers.length; i++) {
+      if (i === excludeIndex) continue
+      if (Math.abs(dividers[i] - xPct) < MIN_DIVIDER_DISTANCE_PERCENT) return false
+    }
+    return xPct > MIN_DIVIDER_DISTANCE_PERCENT && xPct < (100 - MIN_DIVIDER_DISTANCE_PERCENT)
+  }, [dividers])
+
+  // Click on image to add a divider
+  const handleImageClick = useCallback((e: React.MouseEvent) => {
+    if (dragging !== null) return
+    // Don't add if clicking on a divider handle
+    if ((e.target as HTMLElement).dataset.divider) return
+
+    const xPct = getXPercent(e.clientX)
+    if (!canPlaceDivider(xPct)) return
+
+    setDividers(prev => [...prev, xPct].sort((a, b) => a - b))
+  }, [dragging, getXPercent, canPlaceDivider])
+
+  // Drag handlers
+  const handleDividerMouseDown = useCallback((e: React.MouseEvent, index: number) => {
+    e.stopPropagation()
+    e.preventDefault()
+    setDragging(index)
+  }, [])
+
+  useEffect(() => {
+    if (dragging === null) return
+
+    const handleMouseMove = (e: MouseEvent) => {
+      const xPct = getXPercent(e.clientX)
+      if (canPlaceDivider(xPct, dragging)) {
+        setDividers(prev => {
+          const next = [...prev]
+          next[dragging] = xPct
+          return next.sort((a, b) => a - b)
+        })
+      }
+    }
+
+    const handleMouseUp = () => {
+      setDragging(null)
+    }
+
+    window.addEventListener('mousemove', handleMouseMove)
+    window.addEventListener('mouseup', handleMouseUp)
+    return () => {
+      window.removeEventListener('mousemove', handleMouseMove)
+      window.removeEventListener('mouseup', handleMouseUp)
+    }
+  }, [dragging, getXPercent, canPlaceDivider])
+
+  const removeDivider = useCallback((index: number) => {
+    setDividers(prev => prev.filter((_, i) => i !== index))
+  }, [])
+
+  const updateColumnType = useCallback((colIndex: number, type: ColumnTypeKey) => {
+    setColumnTypes(prev => {
+      const next = [...prev]
+      next[colIndex] = type
+      return next
+    })
+  }, [])
+
+  const handleApply = useCallback(() => {
+    // Build PageRegion array from dividers
+    const sorted = [...dividers].sort((a, b) => a - b)
+    const columns: PageRegion[] = []
+
+    for (let i = 0; i <= sorted.length; i++) {
+      const leftPct = i === 0 ? 0 : sorted[i - 1]
+      const rightPct = i === sorted.length ? 100 : sorted[i]
+      const x = Math.round((leftPct / 100) * imageWidth)
+      const w = Math.round(((rightPct - leftPct) / 100) * imageWidth)
+
+      columns.push({
+        type: columnTypes[i] || 'column_text',
+        x,
+        y: 0,
+        width: w,
+        height: imageHeight,
+        classification_confidence: 1.0,
+        classification_method: 'manual',
+      })
+    }
+
+    onApply(columns)
+  }, [dividers, columnTypes, imageWidth, imageHeight, onApply])
+
+  // Compute column regions for overlay
+  const sorted = [...dividers].sort((a, b) => a - b)
+  const columnRegions = Array.from({ length: sorted.length + 1 }, (_, i) => ({
+    leftPct: i === 0 ? 0 : sorted[i - 1],
+    rightPct: i === sorted.length ? 100 : sorted[i],
+    type: columnTypes[i] || 'column_text',
+  }))
+
+  return (
+    <div className="space-y-4">
+      {/* Layout: image + controls */}
+      <div className={layout === 'stacked' ? 'space-y-4' : 'grid grid-cols-2 gap-4'}>
+        {/* Left: Interactive image */}
+        <div>
+          <div className="flex items-center justify-between mb-1">
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400">
+              Klicken um Trennlinien zu setzen
+            </div>
+            <button
+              onClick={onCancel}
+              className="text-xs px-2 py-0.5 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200"
+            >
+              Abbrechen
+            </button>
+          </div>
+          <div
+            ref={containerRef}
+            className="relative border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900 cursor-crosshair select-none"
+            onClick={handleImageClick}
+          >
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img
+              src={imageUrl}
+              alt="Entzerrtes Bild"
+              className="w-full h-auto block"
+              draggable={false}
+              onLoad={() => setImageLoaded(true)}
+            />
+
+            {imageLoaded && (
+              <>
+                {/* Column overlays */}
+                {columnRegions.map((region, i) => (
+                  <div
+                    key={`col-${i}`}
+                    className="absolute top-0 bottom-0 pointer-events-none"
+                    style={{
+                      left: `${region.leftPct}%`,
+                      width: `${region.rightPct - region.leftPct}%`,
+                      backgroundColor: TYPE_OVERLAY_COLORS[region.type] || 'rgba(128,128,128,0.08)',
+                    }}
+                  >
+                    <span className="absolute top-1 left-1/2 -translate-x-1/2 text-[10px] font-medium text-gray-600 dark:text-gray-300 bg-white/80 dark:bg-gray-800/80 px-1 rounded">
+                      {i + 1}
+                    </span>
+                  </div>
+                ))}
+
+                {/* Divider lines */}
+                {sorted.map((xPct, i) => (
+                  <div
+                    key={`div-${i}`}
+                    data-divider="true"
+                    className="absolute top-0 bottom-0 group"
+                    style={{
+                      left: `${xPct}%`,
+                      transform: 'translateX(-50%)',
+                      width: '12px',
+                      cursor: 'col-resize',
+                      zIndex: 10,
+                    }}
+                    onMouseDown={(e) => handleDividerMouseDown(e, i)}
+                  >
+                    {/* Visible line */}
+                    <div
+                      data-divider="true"
+                      className="absolute top-0 bottom-0 left-1/2 -translate-x-1/2 w-0.5 border-l-2 border-dashed border-red-500"
+                    />
+                    {/* Delete button */}
+                    <button
+                      data-divider="true"
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        removeDivider(i)
+                      }}
+                      className="absolute top-2 left-1/2 -translate-x-1/2 w-4 h-4 bg-red-500 text-white rounded-full text-[10px] leading-none flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity z-20"
+                      title="Linie entfernen"
+                    >
+                      x
+                    </button>
+                  </div>
+                ))}
+              </>
+            )}
+          </div>
+        </div>
+
+        {/* Right: Column type assignment + actions */}
+        <div className="space-y-4">
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+            Spaltentypen
+          </div>
+
+          {dividers.length === 0 ? (
+            <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-6 text-center">
+              <div className="text-3xl mb-2">👆</div>
+              <p className="text-sm text-gray-500 dark:text-gray-400">
+                Klicken Sie auf das Bild links, um vertikale Trennlinien zwischen den Spalten zu setzen.
+              </p>
+              <p className="text-xs text-gray-400 dark:text-gray-500 mt-2">
+                Linien koennen per Drag verschoben und per Hover geloescht werden.
+              </p>
+            </div>
+          ) : (
+            <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+              <div className="text-sm text-gray-600 dark:text-gray-400">
+                <span className="font-medium text-gray-800 dark:text-gray-200">
+                  {dividers.length} Linien = {dividers.length + 1} Spalten
+                </span>
+              </div>
+              <div className="grid gap-2">
+                {columnRegions.map((region, i) => (
+                  <div key={i} className="flex items-center gap-3">
+                    <span className={`w-16 text-center px-2 py-0.5 rounded text-xs font-medium ${TYPE_BADGE_COLORS[region.type] || 'bg-gray-100 text-gray-600'}`}>
+                      Spalte {i + 1}
+                    </span>
+                    <select
+                      value={columnTypes[i] || 'column_text'}
+                      onChange={(e) => updateColumnType(i, e.target.value as ColumnTypeKey)}
+                      className="text-sm border border-gray-200 dark:border-gray-600 rounded px-2 py-1 bg-white dark:bg-gray-700 text-gray-800 dark:text-gray-200"
+                    >
+                      {COLUMN_TYPES.map(t => (
+                        <option key={t.value} value={t.value}>{t.label}</option>
+                      ))}
+                    </select>
+                    <span className="text-xs text-gray-400 font-mono">
+                      {Math.round(region.rightPct - region.leftPct)}%
+                    </span>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {/* Action buttons */}
+          <div className="flex flex-col gap-2">
+            <button
+              onClick={handleApply}
+              disabled={dividers.length === 0 || applying}
+              className="w-full px-4 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors text-sm font-medium disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              {applying
+                ? 'Wird gespeichert...'
+                : isGT
+                  ? `${dividers.length + 1} Spalten als Ground Truth speichern`
+                  : `${dividers.length + 1} Spalten uebernehmen`}
+            </button>
+            <button
+              onClick={() => setDividers([])}
+              disabled={dividers.length === 0}
+              className="text-xs px-3 py-2 text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200 disabled:opacity-50"
+            >
+              Alle Linien entfernen
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/PipelineStepper.tsx

@@ -0,0 +1,115 @@
+'use client'
+
+import { PipelineStep, DocumentTypeResult } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const DOC_TYPE_LABELS: Record<string, string> = {
+  vocab_table: 'Vokabeltabelle',
+  full_text: 'Volltext',
+  generic_table: 'Tabelle',
+}
+
+interface PipelineStepperProps {
+  steps: PipelineStep[]
+  currentStep: number
+  onStepClick: (index: number) => void
+  onReprocess?: (index: number) => void
+  docTypeResult?: DocumentTypeResult | null
+  onDocTypeChange?: (docType: DocumentTypeResult['doc_type']) => void
+}
+
+export function PipelineStepper({
+  steps,
+  currentStep,
+  onStepClick,
+  onReprocess,
+  docTypeResult,
+  onDocTypeChange,
+}: PipelineStepperProps) {
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center justify-between px-4 py-3 bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700">
+        {steps.map((step, index) => {
+          const isActive = index === currentStep
+          const isCompleted = step.status === 'completed'
+          const isFailed = step.status === 'failed'
+          const isSkipped = step.status === 'skipped'
+          const isClickable = (index <= currentStep || isCompleted) && !isSkipped
+
+          return (
+            <div key={step.id} className="flex items-center">
+              {index > 0 && (
+                <div
+                  className={`h-0.5 w-8 mx-1 ${
+                    isSkipped
+                      ? 'bg-gray-200 dark:bg-gray-700 border-t border-dashed border-gray-400'
+                      : index <= currentStep ? 'bg-teal-400' : 'bg-gray-300 dark:bg-gray-600'
+                  }`}
+                />
+              )}
+              <div className="relative group">
+                <button
+                  onClick={() => isClickable && onStepClick(index)}
+                  disabled={!isClickable}
+                  className={`flex items-center gap-1.5 px-3 py-1.5 rounded-full text-sm font-medium transition-all ${
+                    isSkipped
+                      ? 'bg-gray-100 text-gray-400 dark:bg-gray-800 dark:text-gray-600 line-through'
+                      : isActive
+                        ? 'bg-teal-100 text-teal-700 dark:bg-teal-900/40 dark:text-teal-300 ring-2 ring-teal-400'
+                        : isCompleted
+                          ? 'bg-green-100 text-green-700 dark:bg-green-900/40 dark:text-green-300'
+                          : isFailed
+                            ? 'bg-red-100 text-red-700 dark:bg-red-900/40 dark:text-red-300'
+                            : 'text-gray-400 dark:text-gray-500'
+                  } ${isClickable ? 'cursor-pointer hover:opacity-80' : 'cursor-default'}`}
+                >
+                  <span className="text-base">
+                    {isSkipped ? '-' : isCompleted ? '\u2713' : isFailed ? '\u2717' : step.icon}
+                  </span>
+                  <span className="hidden sm:inline">{step.name}</span>
+                  <span className="sm:hidden">{index + 1}</span>
+                </button>
+                {/* Reprocess button — shown on completed steps on hover */}
+                {isCompleted && onReprocess && (
+                  <button
+                    onClick={(e) => { e.stopPropagation(); onReprocess(index) }}
+                    className="absolute -top-1 -right-1 w-4 h-4 bg-orange-500 text-white rounded-full text-[9px] leading-none opacity-0 group-hover:opacity-100 transition-opacity flex items-center justify-center"
+                    title={`Ab hier neu verarbeiten`}
+                  >
+                    &#x21BB;
+                  </button>
+                )}
+              </div>
+            </div>
+          )
+        })}
+      </div>
+
+      {/* Document type badge */}
+      {docTypeResult && (
+        <div className="flex items-center gap-2 px-4 py-2 bg-blue-50 dark:bg-blue-900/20 rounded-lg border border-blue-200 dark:border-blue-800 text-sm">
+          <span className="text-blue-600 dark:text-blue-400 font-medium">
+            Dokumenttyp:
+          </span>
+          {onDocTypeChange ? (
+            <select
+              value={docTypeResult.doc_type}
+              onChange={(e) => onDocTypeChange(e.target.value as DocumentTypeResult['doc_type'])}
+              className="bg-white dark:bg-gray-800 border border-blue-300 dark:border-blue-700 rounded px-2 py-0.5 text-sm text-blue-700 dark:text-blue-300"
+            >
+              <option value="vocab_table">Vokabeltabelle</option>
+              <option value="generic_table">Tabelle (generisch)</option>
+              <option value="full_text">Volltext</option>
+            </select>
+          ) : (
+            <span className="text-blue-700 dark:text-blue-300">
+              {DOC_TYPE_LABELS[docTypeResult.doc_type] || docTypeResult.doc_type}
+            </span>
+          )}
+          <span className="text-blue-400 dark:text-blue-500 text-xs">
+            ({Math.round(docTypeResult.confidence * 100)}% Konfidenz)
+          </span>
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepColumnDetection.tsx

@@ -0,0 +1,341 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import type { ColumnResult, ColumnGroundTruth, PageRegion } from '@/app/(admin)/ai/ocr-pipeline/types'
+import { ColumnControls } from './ColumnControls'
+import { ManualColumnEditor } from './ManualColumnEditor'
+import type { ColumnTypeKey } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+type ViewMode = 'normal' | 'ground-truth' | 'manual'
+
+interface StepColumnDetectionProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+/** Convert PageRegion[] to divider percentages + column types for ManualColumnEditor */
+function columnsToEditorState(
+  columns: PageRegion[],
+  imageWidth: number
+): { dividers: number[]; columnTypes: ColumnTypeKey[] } {
+  if (!columns.length || !imageWidth) return { dividers: [], columnTypes: [] }
+
+  const sorted = [...columns].sort((a, b) => a.x - b.x)
+  const dividers: number[] = []
+  const columnTypes: ColumnTypeKey[] = sorted.map(c => c.type)
+
+  for (let i = 1; i < sorted.length; i++) {
+    const xPct = (sorted[i].x / imageWidth) * 100
+    dividers.push(xPct)
+  }
+
+  return { dividers, columnTypes }
+}
+
+export function StepColumnDetection({ sessionId, onNext }: StepColumnDetectionProps) {
+  const [columnResult, setColumnResult] = useState<ColumnResult | null>(null)
+  const [detecting, setDetecting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [viewMode, setViewMode] = useState<ViewMode>('normal')
+  const [applying, setApplying] = useState(false)
+  const [imageDimensions, setImageDimensions] = useState<{ width: number; height: number } | null>(null)
+  const [savedGtColumns, setSavedGtColumns] = useState<PageRegion[] | null>(null)
+
+  // Fetch session info (image dimensions) + check for cached column result
+  useEffect(() => {
+    if (!sessionId || imageDimensions) return
+
+    const fetchSessionInfo = async () => {
+      try {
+        const infoRes = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}`)
+        if (infoRes.ok) {
+          const info = await infoRes.json()
+          if (info.image_width && info.image_height) {
+            setImageDimensions({ width: info.image_width, height: info.image_height })
+          }
+          if (info.column_result) {
+            setColumnResult(info.column_result)
+            return
+          }
+        }
+      } catch (e) {
+        console.error('Failed to fetch session info:', e)
+      }
+
+      // No cached result - run auto-detection
+      runAutoDetection()
+    }
+
+    fetchSessionInfo()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  // Load saved GT if exists
+  useEffect(() => {
+    if (!sessionId) return
+    const fetchGt = async () => {
+      try {
+        const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/columns`)
+        if (res.ok) {
+          const data = await res.json()
+          const corrected = data.columns_gt?.corrected_columns
+          if (corrected) setSavedGtColumns(corrected)
+        }
+      } catch {
+        // No saved GT - that's fine
+      }
+    }
+    fetchGt()
+  }, [sessionId])
+
+  const runAutoDetection = useCallback(async () => {
+    if (!sessionId) return
+    setDetecting(true)
+    setError(null)
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/columns`, {
+        method: 'POST',
+      })
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ detail: res.statusText }))
+        throw new Error(err.detail || 'Spaltenerkennung fehlgeschlagen')
+      }
+      const data: ColumnResult = await res.json()
+      setColumnResult(data)
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+    } finally {
+      setDetecting(false)
+    }
+  }, [sessionId])
+
+  const handleRerun = useCallback(() => {
+    runAutoDetection()
+  }, [runAutoDetection])
+
+  const handleGroundTruth = useCallback(async (gt: ColumnGroundTruth) => {
+    if (!sessionId) return
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/columns`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+    } catch (e) {
+      console.error('Ground truth save failed:', e)
+    }
+  }, [sessionId])
+
+  const handleManualApply = useCallback(async (columns: PageRegion[]) => {
+    if (!sessionId) return
+    setApplying(true)
+    setError(null)
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/columns/manual`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ columns }),
+      })
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ detail: res.statusText }))
+        throw new Error(err.detail || 'Manuelle Spalten konnten nicht gespeichert werden')
+      }
+      const data = await res.json()
+      setColumnResult({
+        columns: data.columns,
+        duration_seconds: data.duration_seconds ?? 0,
+      })
+      setViewMode('normal')
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Fehler beim Speichern')
+    } finally {
+      setApplying(false)
+    }
+  }, [sessionId])
+
+  const handleGtApply = useCallback(async (columns: PageRegion[]) => {
+    if (!sessionId) return
+    setApplying(true)
+    setError(null)
+    try {
+      const gt: ColumnGroundTruth = {
+        is_correct: false,
+        corrected_columns: columns,
+      }
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/columns`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+      setSavedGtColumns(columns)
+      setViewMode('normal')
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Fehler beim Speichern')
+    } finally {
+      setApplying(false)
+    }
+  }, [sessionId])
+
+  if (!sessionId) {
+    return (
+      <div className="flex flex-col items-center justify-center py-16 text-center">
+        <div className="text-5xl mb-4">📊</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">
+          Schritt 3: Spaltenerkennung
+        </h3>
+        <p className="text-gray-500 dark:text-gray-400 max-w-md">
+          Bitte zuerst Schritt 1 und 2 abschliessen.
+        </p>
+      </div>
+    )
+  }
+
+  const dewarpedUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+  const overlayUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/columns-overlay`
+
+  // Pre-compute editor state from saved GT or auto columns for GT mode
+  const gtInitial = savedGtColumns
+    ? columnsToEditorState(savedGtColumns, imageDimensions?.width ?? 1000)
+    : undefined
+
+  return (
+    <div className="space-y-4">
+      {/* Loading indicator */}
+      {detecting && (
+        <div className="flex items-center gap-2 text-teal-600 dark:text-teal-400 text-sm">
+          <div className="animate-spin w-4 h-4 border-2 border-teal-500 border-t-transparent rounded-full" />
+          Spaltenerkennung laeuft...
+        </div>
+      )}
+
+      {viewMode === 'manual' ? (
+        /* Manual column editor - overwrites column_result */
+        <ManualColumnEditor
+          imageUrl={dewarpedUrl}
+          imageWidth={imageDimensions?.width ?? 1000}
+          imageHeight={imageDimensions?.height ?? 1400}
+          onApply={handleManualApply}
+          onCancel={() => setViewMode('normal')}
+          applying={applying}
+          mode="manual"
+        />
+      ) : viewMode === 'ground-truth' ? (
+        /* GT mode: auto result (left, readonly) + GT editor (right) */
+        <div className="grid grid-cols-2 gap-4">
+          {/* Left: Auto result (readonly overlay) */}
+          <div>
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+              Auto-Ergebnis (readonly)
+            </div>
+            <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+              {columnResult ? (
+                // eslint-disable-next-line @next/next/no-img-element
+                <img
+                  src={`${overlayUrl}?t=${Date.now()}`}
+                  alt="Auto Spalten-Overlay"
+                  className="w-full h-auto"
+                />
+              ) : (
+                <div className="aspect-[3/4] flex items-center justify-center text-gray-400 text-sm">
+                  Keine Auto-Daten
+                </div>
+              )}
+            </div>
+            {/* Auto column list */}
+            {columnResult && (
+              <div className="mt-2 space-y-1">
+                <div className="text-xs font-medium text-gray-500 dark:text-gray-400">
+                  Auto: {columnResult.columns.length} Spalten
+                </div>
+                {columnResult.columns
+                  .filter(c => c.type.startsWith('column') || c.type === 'page_ref')
+                  .map((col, i) => (
+                    <div key={i} className="text-xs text-gray-500 dark:text-gray-400 font-mono">
+                      {i + 1}. {col.type} x={col.x} w={col.width}
+                    </div>
+                  ))}
+              </div>
+            )}
+          </div>
+
+          {/* Right: GT editor */}
+          <div>
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+              Ground Truth Editor
+            </div>
+            <ManualColumnEditor
+              imageUrl={dewarpedUrl}
+              imageWidth={imageDimensions?.width ?? 1000}
+              imageHeight={imageDimensions?.height ?? 1400}
+              onApply={handleGtApply}
+              onCancel={() => setViewMode('normal')}
+              applying={applying}
+              mode="ground-truth"
+              layout="stacked"
+              initialDividers={gtInitial?.dividers}
+              initialColumnTypes={gtInitial?.columnTypes}
+            />
+          </div>
+        </div>
+      ) : (
+        /* Normal mode: overlay (left) vs clean (right) */
+        <div className="grid grid-cols-2 gap-4">
+          <div>
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+              Mit Spalten-Overlay
+            </div>
+            <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+              {columnResult ? (
+                // eslint-disable-next-line @next/next/no-img-element
+                <img
+                  src={`${overlayUrl}?t=${Date.now()}`}
+                  alt="Spalten-Overlay"
+                  className="w-full h-auto"
+                />
+              ) : (
+                <div className="aspect-[3/4] flex items-center justify-center text-gray-400 text-sm">
+                  {detecting ? 'Erkenne Spalten...' : 'Keine Daten'}
+                </div>
+              )}
+            </div>
+          </div>
+          <div>
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+              Entzerrtes Bild
+            </div>
+            <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+              {/* eslint-disable-next-line @next/next/no-img-element */}
+              <img
+                src={dewarpedUrl}
+                alt="Entzerrt"
+                className="w-full h-auto"
+              />
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Controls */}
+      {viewMode === 'normal' && (
+        <ColumnControls
+          columnResult={columnResult}
+          onRerun={handleRerun}
+          onManualMode={() => setViewMode('manual')}
+          onGtMode={() => setViewMode('ground-truth')}
+          onGroundTruth={handleGroundTruth}
+          onNext={onNext}
+          isDetecting={detecting}
+          savedGtColumns={savedGtColumns}
+        />
+      )}
+
+      {error && (
+        <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+          {error}
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepCoordinates.tsx

@@ -0,0 +1,19 @@
+'use client'
+
+export function StepCoordinates() {
+  return (
+    <div className="flex flex-col items-center justify-center py-16 text-center">
+      <div className="text-5xl mb-4">📍</div>
+      <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">
+        Schritt 5: Koordinatenzuweisung
+      </h3>
+      <p className="text-gray-500 dark:text-gray-400 max-w-md">
+        Exakte Positionszuweisung fuer jedes Wort auf der Seite.
+        Dieser Schritt wird in einer zukuenftigen Version implementiert.
+      </p>
+      <div className="mt-6 px-4 py-2 bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-400 rounded-full text-sm font-medium">
+        Kommt bald
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepDeskew.tsx

@@ -0,0 +1,277 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import type { DeskewGroundTruth, DeskewResult, SessionInfo } from '@/app/(admin)/ai/ocr-pipeline/types'
+import { DeskewControls } from './DeskewControls'
+import { ImageCompareView } from './ImageCompareView'
+
+const KLAUSUR_API = '/klausur-api'
+
+interface StepDeskewProps {
+  sessionId?: string | null
+  onNext: (sessionId: string) => void
+}
+
+export function StepDeskew({ sessionId: existingSessionId, onNext }: StepDeskewProps) {
+  const [session, setSession] = useState<SessionInfo | null>(null)
+  const [deskewResult, setDeskewResult] = useState<DeskewResult | null>(null)
+  const [uploading, setUploading] = useState(false)
+  const [deskewing, setDeskewing] = useState(false)
+  const [applying, setApplying] = useState(false)
+  const [showBinarized, setShowBinarized] = useState(false)
+  const [showGrid, setShowGrid] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [dragOver, setDragOver] = useState(false)
+  const [sessionName, setSessionName] = useState('')
+
+  // Reload session data when navigating back from a later step
+  useEffect(() => {
+    if (!existingSessionId || session) return
+
+    const loadSession = async () => {
+      try {
+        const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${existingSessionId}`)
+        if (!res.ok) return
+        const data = await res.json()
+
+        const sessionInfo: SessionInfo = {
+          session_id: data.session_id,
+          filename: data.filename,
+          image_width: data.image_width,
+          image_height: data.image_height,
+          original_image_url: `${KLAUSUR_API}${data.original_image_url}`,
+        }
+        setSession(sessionInfo)
+
+        // Reconstruct deskew result from session data
+        if (data.deskew_result) {
+          const dr: DeskewResult = {
+            ...data.deskew_result,
+            deskewed_image_url: `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${existingSessionId}/image/deskewed`,
+            binarized_image_url: `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${existingSessionId}/image/binarized`,
+          }
+          setDeskewResult(dr)
+        }
+      } catch (e) {
+        console.error('Failed to reload session:', e)
+      }
+    }
+
+    loadSession()
+  }, [existingSessionId, session])
+
+  const handleUpload = useCallback(async (file: File) => {
+    setUploading(true)
+    setError(null)
+    setDeskewResult(null)
+
+    try {
+      const formData = new FormData()
+      formData.append('file', file)
+      if (sessionName.trim()) {
+        formData.append('name', sessionName.trim())
+      }
+
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions`, {
+        method: 'POST',
+        body: formData,
+      })
+
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ detail: res.statusText }))
+        throw new Error(err.detail || 'Upload fehlgeschlagen')
+      }
+
+      const data: SessionInfo = await res.json()
+      // Prepend API prefix to relative URLs
+      data.original_image_url = `${KLAUSUR_API}${data.original_image_url}`
+      setSession(data)
+
+      // Auto-trigger deskew
+      setDeskewing(true)
+      const deskewRes = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${data.session_id}/deskew`, {
+        method: 'POST',
+      })
+
+      if (!deskewRes.ok) {
+        throw new Error('Begradigung fehlgeschlagen')
+      }
+
+      const deskewData: DeskewResult = await deskewRes.json()
+      deskewData.deskewed_image_url = `${KLAUSUR_API}${deskewData.deskewed_image_url}`
+      deskewData.binarized_image_url = `${KLAUSUR_API}${deskewData.binarized_image_url}`
+      setDeskewResult(deskewData)
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+    } finally {
+      setUploading(false)
+      setDeskewing(false)
+    }
+  }, [])
+
+  const handleManualDeskew = useCallback(async (angle: number) => {
+    if (!session) return
+    setApplying(true)
+    setError(null)
+
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${session.session_id}/deskew/manual`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ angle }),
+      })
+
+      if (!res.ok) throw new Error('Manuelle Begradigung fehlgeschlagen')
+
+      const data = await res.json()
+      setDeskewResult((prev) =>
+        prev
+          ? {
+              ...prev,
+              angle_applied: data.angle_applied,
+              method_used: data.method_used,
+              // Force reload by appending timestamp
+              deskewed_image_url: `${KLAUSUR_API}${data.deskewed_image_url}?t=${Date.now()}`,
+            }
+          : null,
+      )
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Fehler')
+    } finally {
+      setApplying(false)
+    }
+  }, [session])
+
+  const handleGroundTruth = useCallback(async (gt: DeskewGroundTruth) => {
+    if (!session) return
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${session.session_id}/ground-truth/deskew`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+    } catch (e) {
+      console.error('Ground truth save failed:', e)
+    }
+  }, [session])
+
+  const handleDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault()
+    setDragOver(false)
+    const file = e.dataTransfer.files[0]
+    if (file) handleUpload(file)
+  }, [handleUpload])
+
+  const handleFileInput = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0]
+    if (file) handleUpload(file)
+  }, [handleUpload])
+
+  // Upload area (no session yet)
+  if (!session) {
+    return (
+      <div className="space-y-4">
+        {/* Session name input */}
+        <div>
+          <label className="block text-sm font-medium text-gray-600 dark:text-gray-400 mb-1">
+            Session-Name (optional)
+          </label>
+          <input
+            type="text"
+            value={sessionName}
+            onChange={(e) => setSessionName(e.target.value)}
+            placeholder="z.B. Unit 3 Seite 42"
+            className="w-full max-w-sm px-3 py-2 text-sm border rounded-lg dark:bg-gray-800 dark:border-gray-600 dark:text-gray-200 focus:outline-none focus:ring-2 focus:ring-teal-500"
+          />
+        </div>
+
+        <div
+          onDragOver={(e) => { e.preventDefault(); setDragOver(true) }}
+          onDragLeave={() => setDragOver(false)}
+          onDrop={handleDrop}
+          className={`border-2 border-dashed rounded-xl p-12 text-center transition-colors ${
+            dragOver
+              ? 'border-teal-400 bg-teal-50 dark:bg-teal-900/20'
+              : 'border-gray-300 dark:border-gray-600 hover:border-teal-400'
+          }`}
+        >
+          {uploading ? (
+            <div className="text-gray-500">
+              <div className="animate-spin inline-block w-8 h-8 border-2 border-teal-500 border-t-transparent rounded-full mb-3" />
+              <p>Wird hochgeladen...</p>
+            </div>
+          ) : (
+            <>
+              <div className="text-4xl mb-3">📄</div>
+              <p className="text-gray-600 dark:text-gray-400 mb-2">
+                PDF oder Bild hierher ziehen
+              </p>
+              <p className="text-sm text-gray-400 mb-4">oder</p>
+              <label className="inline-block px-4 py-2 bg-teal-600 text-white rounded-lg cursor-pointer hover:bg-teal-700 transition-colors">
+                Datei auswaehlen
+                <input
+                  type="file"
+                  accept=".pdf,.png,.jpg,.jpeg,.tiff,.tif"
+                  onChange={handleFileInput}
+                  className="hidden"
+                />
+              </label>
+            </>
+          )}
+        </div>
+        {error && (
+          <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+            {error}
+          </div>
+        )}
+      </div>
+    )
+  }
+
+  // Session active: show comparison + controls
+  return (
+    <div className="space-y-4">
+      {/* Filename */}
+      <div className="text-sm text-gray-500 dark:text-gray-400">
+        Datei: <span className="font-medium text-gray-700 dark:text-gray-300">{session.filename}</span>
+        {' '}({session.image_width} x {session.image_height} px)
+      </div>
+
+      {/* Loading indicator */}
+      {deskewing && (
+        <div className="flex items-center gap-2 text-teal-600 dark:text-teal-400 text-sm">
+          <div className="animate-spin w-4 h-4 border-2 border-teal-500 border-t-transparent rounded-full" />
+          Begradigung laeuft (beide Methoden)...
+        </div>
+      )}
+
+      {/* Image comparison */}
+      <ImageCompareView
+        originalUrl={session.original_image_url}
+        deskewedUrl={deskewResult?.deskewed_image_url ?? null}
+        showGrid={showGrid}
+        showBinarized={showBinarized}
+        binarizedUrl={deskewResult?.binarized_image_url ?? null}
+      />
+
+      {/* Controls */}
+      <DeskewControls
+        deskewResult={deskewResult}
+        showBinarized={showBinarized}
+        onToggleBinarized={() => setShowBinarized((v) => !v)}
+        showGrid={showGrid}
+        onToggleGrid={() => setShowGrid((v) => !v)}
+        onManualDeskew={handleManualDeskew}
+        onGroundTruth={handleGroundTruth}
+        onNext={() => session && onNext(session.session_id)}
+        isApplying={applying}
+      />
+
+      {error && (
+        <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+          {error}
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepDewarp.tsx

@@ -0,0 +1,151 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import type { DewarpResult, DewarpGroundTruth } from '@/app/(admin)/ai/ocr-pipeline/types'
+import { DewarpControls } from './DewarpControls'
+import { ImageCompareView } from './ImageCompareView'
+
+const KLAUSUR_API = '/klausur-api'
+
+interface StepDewarpProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+export function StepDewarp({ sessionId, onNext }: StepDewarpProps) {
+  const [dewarpResult, setDewarpResult] = useState<DewarpResult | null>(null)
+  const [dewarping, setDewarping] = useState(false)
+  const [applying, setApplying] = useState(false)
+  const [showGrid, setShowGrid] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  // Auto-trigger dewarp when component mounts with a sessionId
+  useEffect(() => {
+    if (!sessionId || dewarpResult) return
+
+    const runDewarp = async () => {
+      setDewarping(true)
+      setError(null)
+      try {
+        const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/dewarp`, {
+          method: 'POST',
+        })
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({ detail: res.statusText }))
+          throw new Error(err.detail || 'Entzerrung fehlgeschlagen')
+        }
+        const data: DewarpResult = await res.json()
+        data.dewarped_image_url = `${KLAUSUR_API}${data.dewarped_image_url}`
+        setDewarpResult(data)
+      } catch (e) {
+        setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+      } finally {
+        setDewarping(false)
+      }
+    }
+
+    runDewarp()
+  }, [sessionId, dewarpResult])
+
+  const handleManualDewarp = useCallback(async (shearDegrees: number) => {
+    if (!sessionId) return
+    setApplying(true)
+    setError(null)
+
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/dewarp/manual`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ shear_degrees: shearDegrees }),
+      })
+      if (!res.ok) throw new Error('Manuelle Entzerrung fehlgeschlagen')
+
+      const data = await res.json()
+      setDewarpResult((prev) =>
+        prev
+          ? {
+              ...prev,
+              method_used: data.method_used,
+              shear_degrees: data.shear_degrees,
+              dewarped_image_url: `${KLAUSUR_API}${data.dewarped_image_url}?t=${Date.now()}`,
+            }
+          : null,
+      )
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Fehler')
+    } finally {
+      setApplying(false)
+    }
+  }, [sessionId])
+
+  const handleGroundTruth = useCallback(async (gt: DewarpGroundTruth) => {
+    if (!sessionId) return
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/dewarp`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+    } catch (e) {
+      console.error('Ground truth save failed:', e)
+    }
+  }, [sessionId])
+
+  if (!sessionId) {
+    return (
+      <div className="flex flex-col items-center justify-center py-16 text-center">
+        <div className="text-5xl mb-4">🔧</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">
+          Schritt 2: Entzerrung (Dewarp)
+        </h3>
+        <p className="text-gray-500 dark:text-gray-400 max-w-md">
+          Bitte zuerst Schritt 1 (Begradigung) abschliessen.
+        </p>
+      </div>
+    )
+  }
+
+  const deskewedUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/deskewed`
+  const dewarpedUrl = dewarpResult?.dewarped_image_url ?? null
+
+  return (
+    <div className="space-y-4">
+      {/* Loading indicator */}
+      {dewarping && (
+        <div className="flex items-center gap-2 text-teal-600 dark:text-teal-400 text-sm">
+          <div className="animate-spin w-4 h-4 border-2 border-teal-500 border-t-transparent rounded-full" />
+          Entzerrung laeuft (beide Methoden)...
+        </div>
+      )}
+
+      {/* Image comparison: deskewed (left) vs dewarped (right) */}
+      <ImageCompareView
+        originalUrl={deskewedUrl}
+        deskewedUrl={dewarpedUrl}
+        showGrid={showGrid}
+        showGridLeft={showGrid}
+        showBinarized={false}
+        binarizedUrl={null}
+        leftLabel={`Begradigt (nach Deskew)${showGrid ? ' + Raster' : ''}`}
+        rightLabel={`Entzerrt${showGrid ? ' + Raster (mm)' : ''}`}
+      />
+
+      {/* Controls */}
+      <DewarpControls
+        dewarpResult={dewarpResult}
+        showGrid={showGrid}
+        onToggleGrid={() => setShowGrid((v) => !v)}
+        onManualDewarp={handleManualDewarp}
+        onGroundTruth={handleGroundTruth}
+        onNext={onNext}
+        isApplying={applying}
+      />
+
+      {error && (
+        <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+          {error}
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepGroundTruth.tsx

@@ -0,0 +1,596 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type {
+  GridCell, ColumnMeta, ImageRegion, ImageStyle,
+} from '@/app/(admin)/ai/ocr-pipeline/types'
+import { IMAGE_STYLES as STYLES } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+const COL_TYPE_COLORS: Record<string, string> = {
+  column_en: '#3b82f6',
+  column_de: '#22c55e',
+  column_example: '#f97316',
+  column_text: '#a855f7',
+  page_ref: '#06b6d4',
+  column_marker: '#6b7280',
+}
+
+interface StepGroundTruthProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+interface SessionData {
+  cells: GridCell[]
+  columnsUsed: ColumnMeta[]
+  imageWidth: number
+  imageHeight: number
+  originalImageUrl: string
+}
+
+export function StepGroundTruth({ sessionId, onNext }: StepGroundTruthProps) {
+  const [status, setStatus] = useState<'loading' | 'ready' | 'saving' | 'saved' | 'error'>('loading')
+  const [error, setError] = useState('')
+  const [session, setSession] = useState<SessionData | null>(null)
+  const [imageRegions, setImageRegions] = useState<(ImageRegion & { generating?: boolean })[]>([])
+  const [detecting, setDetecting] = useState(false)
+  const [zoom, setZoom] = useState(100)
+  const [syncScroll, setSyncScroll] = useState(true)
+  const [notes, setNotes] = useState('')
+  const [score, setScore] = useState<number | null>(null)
+  const [drawingRegion, setDrawingRegion] = useState(false)
+  const [dragStart, setDragStart] = useState<{ x: number; y: number } | null>(null)
+  const [dragEnd, setDragEnd] = useState<{ x: number; y: number } | null>(null)
+
+  const leftPanelRef = useRef<HTMLDivElement>(null)
+  const rightPanelRef = useRef<HTMLDivElement>(null)
+  const reconRef = useRef<HTMLDivElement>(null)
+  const [reconWidth, setReconWidth] = useState(0)
+
+  // Track reconstruction container width for font size calculation
+  useEffect(() => {
+    const el = reconRef.current
+    if (!el) return
+    const obs = new ResizeObserver(entries => {
+      for (const entry of entries) setReconWidth(entry.contentRect.width)
+    })
+    obs.observe(el)
+    return () => obs.disconnect()
+  }, [session])
+
+  // Load session data
+  useEffect(() => {
+    if (!sessionId) return
+    loadSessionData()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  const loadSessionData = async () => {
+    if (!sessionId) return
+    setStatus('loading')
+    try {
+      const resp = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}`)
+      if (!resp.ok) throw new Error(`Failed to load session: ${resp.status}`)
+      const data = await resp.json()
+
+      const wordResult = data.word_result || {}
+      setSession({
+        cells: wordResult.cells || [],
+        columnsUsed: wordResult.columns_used || [],
+        imageWidth: wordResult.image_width || data.image_width || 800,
+        imageHeight: wordResult.image_height || data.image_height || 600,
+        originalImageUrl: data.original_image_url
+          ? `${KLAUSUR_API}${data.original_image_url}`
+          : `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/original`,
+      })
+
+      // Load existing validation data
+      const valResp = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/validation`)
+      if (valResp.ok) {
+        const valData = await valResp.json()
+        const validation = valData.validation
+        if (validation) {
+          setImageRegions(validation.image_regions || [])
+          setNotes(validation.notes || '')
+          setScore(validation.score ?? null)
+        }
+      }
+
+      setStatus('ready')
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e))
+      setStatus('error')
+    }
+  }
+
+  // Sync scroll between panels
+  const handleScroll = useCallback((source: 'left' | 'right') => {
+    if (!syncScroll) return
+    const from = source === 'left' ? leftPanelRef.current : rightPanelRef.current
+    const to = source === 'left' ? rightPanelRef.current : leftPanelRef.current
+    if (from && to) {
+      to.scrollTop = from.scrollTop
+      to.scrollLeft = from.scrollLeft
+    }
+  }, [syncScroll])
+
+  // Detect images via VLM
+  const handleDetectImages = async () => {
+    if (!sessionId) return
+    setDetecting(true)
+    try {
+      const resp = await fetch(
+        `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/detect-images`,
+        { method: 'POST' }
+      )
+      if (!resp.ok) throw new Error(`Detection failed: ${resp.status}`)
+      const data = await resp.json()
+      setImageRegions(data.regions || [])
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e))
+    } finally {
+      setDetecting(false)
+    }
+  }
+
+  // Generate image for a region
+  const handleGenerateImage = async (index: number) => {
+    if (!sessionId) return
+    const region = imageRegions[index]
+    if (!region) return
+
+    setImageRegions(prev => prev.map((r, i) => i === index ? { ...r, generating: true } : r))
+
+    try {
+      const resp = await fetch(
+        `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/generate-image`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            region_index: index,
+            prompt: region.prompt,
+            style: region.style,
+          }),
+        }
+      )
+      if (!resp.ok) throw new Error(`Generation failed: ${resp.status}`)
+      const data = await resp.json()
+
+      setImageRegions(prev => prev.map((r, i) =>
+        i === index ? { ...r, image_b64: data.image_b64, generating: false } : r
+      ))
+    } catch (e) {
+      setImageRegions(prev => prev.map((r, i) => i === index ? { ...r, generating: false } : r))
+      setError(e instanceof Error ? e.message : String(e))
+    }
+  }
+
+  // Save validation
+  const handleSave = async () => {
+    if (!sessionId) {
+      setError('Keine Session-ID vorhanden')
+      return
+    }
+    setStatus('saving')
+    setError('')
+    try {
+      const resp = await fetch(
+        `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction/validate`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ notes, score: score ?? 0 }),
+        }
+      )
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => '')
+        throw new Error(`Speichern fehlgeschlagen (${resp.status}): ${body}`)
+      }
+      setStatus('saved')
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e))
+      setStatus('ready')
+    }
+  }
+
+  // Handle manual region drawing on reconstruction
+  const handleReconMouseDown = (e: React.MouseEvent<HTMLDivElement>) => {
+    if (!drawingRegion) return
+    const rect = e.currentTarget.getBoundingClientRect()
+    const x = ((e.clientX - rect.left) / rect.width) * 100
+    const y = ((e.clientY - rect.top) / rect.height) * 100
+    setDragStart({ x, y })
+    setDragEnd({ x, y })
+  }
+
+  const handleReconMouseMove = (e: React.MouseEvent<HTMLDivElement>) => {
+    if (!dragStart) return
+    const rect = e.currentTarget.getBoundingClientRect()
+    const x = ((e.clientX - rect.left) / rect.width) * 100
+    const y = ((e.clientY - rect.top) / rect.height) * 100
+    setDragEnd({ x, y })
+  }
+
+  const handleReconMouseUp = () => {
+    if (!dragStart || !dragEnd) return
+    const x = Math.min(dragStart.x, dragEnd.x)
+    const y = Math.min(dragStart.y, dragEnd.y)
+    const w = Math.abs(dragEnd.x - dragStart.x)
+    const h = Math.abs(dragEnd.y - dragStart.y)
+
+    if (w > 2 && h > 2) {
+      setImageRegions(prev => [...prev, {
+        bbox_pct: { x, y, w, h },
+        prompt: '',
+        description: 'Manually selected region',
+        image_b64: null,
+        style: 'educational' as ImageStyle,
+      }])
+    }
+
+    setDragStart(null)
+    setDragEnd(null)
+    setDrawingRegion(false)
+  }
+
+  const handleRemoveRegion = (index: number) => {
+    setImageRegions(prev => prev.filter((_, i) => i !== index))
+  }
+
+  if (status === 'loading') {
+    return (
+      <div className="flex items-center justify-center py-16">
+        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-teal-500 mr-3" />
+        <span className="text-gray-500 dark:text-gray-400">Session wird geladen...</span>
+      </div>
+    )
+  }
+
+  if (status === 'error' && !session) {
+    return (
+      <div className="text-center py-16">
+        <p className="text-red-500">{error}</p>
+        <button onClick={loadSessionData} className="mt-4 px-4 py-2 bg-teal-600 text-white rounded hover:bg-teal-700">
+          Erneut laden
+        </button>
+      </div>
+    )
+  }
+
+  if (!session) return null
+
+  const aspect = session.imageHeight / session.imageWidth
+
+  return (
+    <div className="space-y-4">
+      {/* Header / Controls */}
+      <div className="flex items-center justify-between flex-wrap gap-2">
+        <h3 className="text-lg font-medium text-gray-800 dark:text-gray-200">
+          Validierung — Original vs. Rekonstruktion
+        </h3>
+        <div className="flex items-center gap-3">
+          <button
+            onClick={handleDetectImages}
+            disabled={detecting}
+            className="px-3 py-1.5 text-sm bg-indigo-600 text-white rounded hover:bg-indigo-700 disabled:opacity-50"
+          >
+            {detecting ? 'Erkennung laeuft...' : 'Bilder erkennen'}
+          </button>
+          <label className="flex items-center gap-1.5 text-sm text-gray-600 dark:text-gray-400">
+            <input
+              type="checkbox"
+              checked={syncScroll}
+              onChange={e => setSyncScroll(e.target.checked)}
+              className="rounded"
+            />
+            Sync Scroll
+          </label>
+          <div className="flex items-center gap-1.5">
+            <button onClick={() => setZoom(z => Math.max(50, z - 25))} className="px-2 py-1 text-sm border rounded dark:border-gray-600 hover:bg-gray-100 dark:hover:bg-gray-700">-</button>
+            <span className="text-sm text-gray-600 dark:text-gray-400 w-12 text-center">{zoom}%</span>
+            <button onClick={() => setZoom(z => Math.min(200, z + 25))} className="px-2 py-1 text-sm border rounded dark:border-gray-600 hover:bg-gray-100 dark:hover:bg-gray-700">+</button>
+          </div>
+        </div>
+      </div>
+
+      {error && (
+        <div className="p-2 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 text-sm rounded">
+          {error}
+          <button onClick={() => setError('')} className="ml-2 underline">Schliessen</button>
+        </div>
+      )}
+
+      {/* Side-by-side panels */}
+      <div className="grid grid-cols-2 gap-4" style={{ height: 'calc(100vh - 580px)', minHeight: 300 }}>
+        {/* Left: Original */}
+        <div className="border rounded-lg dark:border-gray-700 overflow-hidden flex flex-col">
+          <div className="px-3 py-1.5 bg-gray-50 dark:bg-gray-800 text-sm font-medium text-gray-600 dark:text-gray-400 border-b dark:border-gray-700">
+            Original
+          </div>
+          <div
+            ref={leftPanelRef}
+            className="flex-1 overflow-auto"
+            onScroll={() => handleScroll('left')}
+          >
+            <div style={{ width: `${zoom}%`, minWidth: '100%' }}>
+              <img
+                src={session.originalImageUrl}
+                alt="Original"
+                className="w-full h-auto"
+                draggable={false}
+              />
+            </div>
+          </div>
+        </div>
+
+        {/* Right: Reconstruction */}
+        <div className="border rounded-lg dark:border-gray-700 overflow-hidden flex flex-col">
+          <div className="px-3 py-1.5 bg-gray-50 dark:bg-gray-800 text-sm font-medium text-gray-600 dark:text-gray-400 border-b dark:border-gray-700 flex items-center justify-between">
+            <span>Rekonstruktion</span>
+            <button
+              onClick={() => setDrawingRegion(!drawingRegion)}
+              className={`text-xs px-2 py-0.5 rounded ${drawingRegion ? 'bg-indigo-600 text-white' : 'bg-gray-200 dark:bg-gray-700 text-gray-600 dark:text-gray-400'}`}
+            >
+              {drawingRegion ? 'Region zeichnen...' : '+ Region'}
+            </button>
+          </div>
+          <div
+            ref={rightPanelRef}
+            className="flex-1 overflow-auto"
+            onScroll={() => handleScroll('right')}
+          >
+            <div style={{ width: `${zoom}%`, minWidth: '100%' }}>
+              {/* Reconstruction container */}
+              <div
+                ref={reconRef}
+                className="relative bg-white"
+                style={{
+                  paddingBottom: `${aspect * 100}%`,
+                  cursor: drawingRegion ? 'crosshair' : 'default',
+                }}
+                onMouseDown={handleReconMouseDown}
+                onMouseMove={handleReconMouseMove}
+                onMouseUp={handleReconMouseUp}
+              >
+                {/* Row separator lines — derive from cells */}
+                {(() => {
+                  const rowYs = new Set<number>()
+                  for (const cell of session.cells) {
+                    if (cell.col_index === 0 && cell.bbox_pct) {
+                      rowYs.add(cell.bbox_pct.y)
+                    }
+                  }
+                  return Array.from(rowYs).map((y, i) => (
+                    <div
+                      key={`row-${i}`}
+                      className="absolute left-0 right-0"
+                      style={{
+                        top: `${y}%`,
+                        height: '1px',
+                        backgroundColor: 'rgba(0,0,0,0.06)',
+                      }}
+                    />
+                  ))
+                })()}
+
+                {/* Cell texts — black on white, font size derived from cell height */}
+                {session.cells.map(cell => {
+                  if (!cell.bbox_pct || !cell.text) return null
+                  // Container height in px = reconWidth * aspect
+                  // Cell height in px = containerHeightPx * (bbox_pct.h / 100)
+                  // Font size ≈ 70% of cell height
+                  const containerH = reconWidth * aspect
+                  const cellHeightPx = containerH * (cell.bbox_pct.h / 100)
+                  const fontSize = Math.max(6, cellHeightPx * 0.7)
+                  return (
+                    <span
+                      key={cell.cell_id}
+                      className="absolute leading-none overflow-hidden whitespace-nowrap"
+                      style={{
+                        left: `${cell.bbox_pct.x}%`,
+                        top: `${cell.bbox_pct.y}%`,
+                        width: `${cell.bbox_pct.w}%`,
+                        height: `${cell.bbox_pct.h}%`,
+                        color: '#1a1a1a',
+                        fontSize: `${fontSize}px`,
+                        fontWeight: cell.is_bold ? 'bold' : 'normal',
+                        fontFamily: "'Liberation Sans', 'DejaVu Sans', Arial, sans-serif",
+                        display: 'flex',
+                        alignItems: 'center',
+                        padding: '0 1px',
+                      }}
+                      title={`${cell.cell_id}: ${cell.text}`}
+                    >
+                      {cell.text}
+                    </span>
+                  )
+                })}
+
+                {/* Generated images at region positions */}
+                {imageRegions.map((region, i) => (
+                  <div
+                    key={`region-${i}`}
+                    className="absolute border-2 border-dashed border-indigo-400"
+                    style={{
+                      left: `${region.bbox_pct.x}%`,
+                      top: `${region.bbox_pct.y}%`,
+                      width: `${region.bbox_pct.w}%`,
+                      height: `${region.bbox_pct.h}%`,
+                    }}
+                  >
+                    {region.image_b64 ? (
+                      <img src={region.image_b64} alt={region.description} className="w-full h-full object-cover" />
+                    ) : (
+                      <div className="w-full h-full flex items-center justify-center bg-indigo-50/50 text-indigo-400 text-[0.5em]">
+                        {region.generating ? '...' : `Bild ${i + 1}`}
+                      </div>
+                    )}
+                  </div>
+                ))}
+
+                {/* Drawing rectangle */}
+                {dragStart && dragEnd && (
+                  <div
+                    className="absolute border-2 border-dashed border-red-500 bg-red-100/20 pointer-events-none"
+                    style={{
+                      left: `${Math.min(dragStart.x, dragEnd.x)}%`,
+                      top: `${Math.min(dragStart.y, dragEnd.y)}%`,
+                      width: `${Math.abs(dragEnd.x - dragStart.x)}%`,
+                      height: `${Math.abs(dragEnd.y - dragStart.y)}%`,
+                    }}
+                  />
+                )}
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Image regions panel */}
+      {imageRegions.length > 0 && (
+        <div className="border rounded-lg dark:border-gray-700 p-4">
+          <h4 className="text-sm font-medium text-gray-700 dark:text-gray-300 mb-3">
+            Bildbereiche ({imageRegions.length} gefunden)
+          </h4>
+          <div className="space-y-3">
+            {imageRegions.map((region, i) => (
+              <div key={i} className="flex items-start gap-3 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
+                {/* Preview thumbnail */}
+                <div className="w-16 h-16 flex-shrink-0 border rounded dark:border-gray-600 overflow-hidden bg-white">
+                  {region.image_b64 ? (
+                    <img src={region.image_b64} alt="" className="w-full h-full object-cover" />
+                  ) : (
+                    <div className="w-full h-full flex items-center justify-center text-gray-400 text-xs">
+                      {Math.round(region.bbox_pct.w)}x{Math.round(region.bbox_pct.h)}%
+                    </div>
+                  )}
+                </div>
+
+                {/* Prompt + controls */}
+                <div className="flex-1 min-w-0 space-y-2">
+                  <div className="flex items-center gap-2">
+                    <span className="text-xs text-gray-500 dark:text-gray-400 flex-shrink-0">
+                      Bereich {i + 1}:
+                    </span>
+                    <input
+                      type="text"
+                      value={region.prompt}
+                      onChange={e => {
+                        setImageRegions(prev => prev.map((r, j) =>
+                          j === i ? { ...r, prompt: e.target.value } : r
+                        ))
+                      }}
+                      placeholder="Beschreibung / Prompt..."
+                      className="flex-1 text-sm px-2 py-1 border rounded dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+                    />
+                  </div>
+                  <div className="flex items-center gap-2">
+                    <select
+                      value={region.style}
+                      onChange={e => {
+                        setImageRegions(prev => prev.map((r, j) =>
+                          j === i ? { ...r, style: e.target.value as ImageStyle } : r
+                        ))
+                      }}
+                      className="text-sm px-2 py-1 border rounded dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+                    >
+                      {STYLES.map(s => (
+                        <option key={s.value} value={s.value}>{s.label}</option>
+                      ))}
+                    </select>
+                    <button
+                      onClick={() => handleGenerateImage(i)}
+                      disabled={!!region.generating || !region.prompt}
+                      className="px-3 py-1 text-sm bg-teal-600 text-white rounded hover:bg-teal-700 disabled:opacity-50"
+                    >
+                      {region.generating ? 'Generiere...' : 'Generieren'}
+                    </button>
+                    <button
+                      onClick={() => handleRemoveRegion(i)}
+                      className="px-2 py-1 text-sm text-red-600 hover:bg-red-50 dark:hover:bg-red-900/20 rounded"
+                    >
+                      Entfernen
+                    </button>
+                  </div>
+                  {region.description && region.description !== region.prompt && (
+                    <p className="text-xs text-gray-400">{region.description}</p>
+                  )}
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {/* Notes and score */}
+      <div className="border rounded-lg dark:border-gray-700 p-4 space-y-3">
+        <div className="flex items-center gap-4">
+          <label className="text-sm font-medium text-gray-700 dark:text-gray-300">
+            Bewertung (1-10):
+          </label>
+          <input
+            type="number"
+            min={1}
+            max={10}
+            value={score ?? ''}
+            onChange={e => setScore(e.target.value ? parseInt(e.target.value) : null)}
+            className="w-20 text-sm px-2 py-1 border rounded dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+          />
+          <div className="flex gap-1">
+            {[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(v => (
+              <button
+                key={v}
+                onClick={() => setScore(v)}
+                className={`w-7 h-7 text-xs rounded ${score === v ? 'bg-teal-600 text-white' : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400 hover:bg-gray-200 dark:hover:bg-gray-600'}`}
+              >
+                {v}
+              </button>
+            ))}
+          </div>
+        </div>
+        <div>
+          <label className="text-sm font-medium text-gray-700 dark:text-gray-300 block mb-1">
+            Notizen:
+          </label>
+          <textarea
+            value={notes}
+            onChange={e => setNotes(e.target.value)}
+            rows={3}
+            placeholder="Anmerkungen zur Qualitaet der Rekonstruktion..."
+            className="w-full text-sm px-3 py-2 border rounded dark:border-gray-600 dark:bg-gray-700 dark:text-white"
+          />
+        </div>
+      </div>
+
+      {/* Actions — sticky bottom bar */}
+      <div className="sticky bottom-0 bg-white dark:bg-gray-900 border-t dark:border-gray-700 py-3 px-1 -mx-1 flex items-center justify-between">
+        <div className="text-sm text-gray-500 dark:text-gray-400">
+          {status === 'saved' && <span className="text-green-600 dark:text-green-400">Validierung gespeichert</span>}
+          {status === 'saving' && <span>Speichere...</span>}
+        </div>
+        <div className="flex items-center gap-3">
+          <button
+            onClick={handleSave}
+            disabled={status === 'saving'}
+            className="px-4 py-2 text-sm bg-gray-600 text-white rounded hover:bg-gray-700 disabled:opacity-50"
+          >
+            Speichern
+          </button>
+          <button
+            onClick={async () => {
+              await handleSave()
+              onNext()
+            }}
+            disabled={status === 'saving'}
+            className="px-4 py-2 text-sm bg-teal-600 text-white rounded hover:bg-teal-700 disabled:opacity-50"
+          >
+            Abschliessen
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepLlmReview.tsx

@@ -0,0 +1,707 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { GridResult, WordEntry, ColumnMeta } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+interface LlmChange {
+  row_index: number
+  field: 'english' | 'german' | 'example'
+  old: string
+  new: string
+}
+
+interface StepLlmReviewProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+interface ReviewMeta {
+  total_entries: number
+  to_review: number
+  skipped: number
+  model: string
+  skipped_indices?: number[]
+}
+
+interface StreamProgress {
+  current: number
+  total: number
+}
+
+const FIELD_LABELS: Record<string, string> = {
+  english: 'EN',
+  german: 'DE',
+  example: 'Beispiel',
+  source_page: 'Seite',
+  marker: 'Marker',
+}
+
+/** Map column type to WordEntry field name */
+const COL_TYPE_TO_FIELD: Record<string, string> = {
+  column_en: 'english',
+  column_de: 'german',
+  column_example: 'example',
+  page_ref: 'source_page',
+  column_marker: 'marker',
+}
+
+/** Column type → color class */
+const COL_TYPE_COLOR: Record<string, string> = {
+  column_en: 'text-blue-600 dark:text-blue-400',
+  column_de: 'text-green-600 dark:text-green-400',
+  column_example: 'text-orange-600 dark:text-orange-400',
+  page_ref: 'text-cyan-600 dark:text-cyan-400',
+  column_marker: 'text-gray-500 dark:text-gray-400',
+}
+
+type RowStatus = 'pending' | 'active' | 'reviewed' | 'corrected' | 'skipped'
+
+export function StepLlmReview({ sessionId, onNext }: StepLlmReviewProps) {
+  // Core state
+  const [status, setStatus] = useState<'idle' | 'loading' | 'ready' | 'running' | 'done' | 'error' | 'applied'>('idle')
+  const [meta, setMeta] = useState<ReviewMeta | null>(null)
+  const [changes, setChanges] = useState<LlmChange[]>([])
+  const [progress, setProgress] = useState<StreamProgress | null>(null)
+  const [totalDuration, setTotalDuration] = useState(0)
+  const [error, setError] = useState('')
+  const [accepted, setAccepted] = useState<Set<number>>(new Set())
+  const [applying, setApplying] = useState(false)
+
+  // Full vocab table state
+  const [vocabEntries, setVocabEntries] = useState<WordEntry[]>([])
+  const [columnsUsed, setColumnsUsed] = useState<ColumnMeta[]>([])
+  const [activeRowIndices, setActiveRowIndices] = useState<Set<number>>(new Set())
+  const [reviewedRows, setReviewedRows] = useState<Set<number>>(new Set())
+  const [skippedRows, setSkippedRows] = useState<Set<number>>(new Set())
+  const [correctedMap, setCorrectedMap] = useState<Map<number, LlmChange[]>>(new Map())
+
+  // Image
+  const [imageNaturalSize, setImageNaturalSize] = useState<{ w: number; h: number } | null>(null)
+
+  const tableRef = useRef<HTMLDivElement>(null)
+  const activeRowRef = useRef<HTMLTableRowElement>(null)
+
+  // Load session data on mount
+  useEffect(() => {
+    if (!sessionId) return
+    loadSessionData()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  const loadSessionData = async () => {
+    if (!sessionId) return
+    setStatus('loading')
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}`)
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      const data = await res.json()
+
+      const wordResult: GridResult | undefined = data.word_result
+      if (!wordResult) {
+        setError('Keine Worterkennungsdaten gefunden. Bitte zuerst Schritt 5 abschliessen.')
+        setStatus('error')
+        return
+      }
+
+      const entries = wordResult.vocab_entries || wordResult.entries || []
+      setVocabEntries(entries)
+      setColumnsUsed(wordResult.columns_used || [])
+
+      // Check if LLM review was already run
+      const llmReview = wordResult.llm_review
+      if (llmReview && llmReview.changes) {
+        const existingChanges: LlmChange[] = llmReview.changes as LlmChange[]
+        setChanges(existingChanges)
+        setTotalDuration(llmReview.duration_ms || 0)
+
+        // Mark all rows as reviewed
+        const allReviewed = new Set(entries.map((_: WordEntry, i: number) => i))
+        setReviewedRows(allReviewed)
+
+        // Build corrected map
+        const cMap = new Map<number, LlmChange[]>()
+        for (const c of existingChanges) {
+          const existing = cMap.get(c.row_index) || []
+          existing.push(c)
+          cMap.set(c.row_index, existing)
+        }
+        setCorrectedMap(cMap)
+
+        // Default: all accepted
+        setAccepted(new Set(existingChanges.map((_: LlmChange, i: number) => i)))
+
+        setMeta({
+          total_entries: entries.length,
+          to_review: llmReview.entries_corrected !== undefined ? entries.length : entries.length,
+          skipped: 0,
+          model: llmReview.model_used || 'unknown',
+        })
+        setStatus('done')
+      } else {
+        setStatus('ready')
+      }
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : String(e))
+      setStatus('error')
+    }
+  }
+
+  const runReview = useCallback(async () => {
+    if (!sessionId) return
+    setStatus('running')
+    setError('')
+    setChanges([])
+    setProgress(null)
+    setMeta(null)
+    setTotalDuration(0)
+    setActiveRowIndices(new Set())
+    setReviewedRows(new Set())
+    setSkippedRows(new Set())
+    setCorrectedMap(new Map())
+
+    try {
+      const res = await fetch(
+        `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/llm-review?stream=true`,
+        { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({}) },
+      )
+
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}))
+        throw new Error(data.detail || `HTTP ${res.status}`)
+      }
+
+      const reader = res.body!.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      let allChanges: LlmChange[] = []
+      let allReviewed = new Set<number>()
+      let allSkipped = new Set<number>()
+      let cMap = new Map<number, LlmChange[]>()
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+
+        while (buffer.includes('\n\n')) {
+          const idx = buffer.indexOf('\n\n')
+          const chunk = buffer.slice(0, idx).trim()
+          buffer = buffer.slice(idx + 2)
+
+          if (!chunk.startsWith('data: ')) continue
+          const dataStr = chunk.slice(6)
+
+          let event: any
+          try { event = JSON.parse(dataStr) } catch { continue }
+
+          if (event.type === 'meta') {
+            setMeta({
+              total_entries: event.total_entries,
+              to_review: event.to_review,
+              skipped: event.skipped,
+              model: event.model,
+              skipped_indices: event.skipped_indices,
+            })
+            // Mark skipped rows
+            if (event.skipped_indices) {
+              allSkipped = new Set(event.skipped_indices)
+              setSkippedRows(allSkipped)
+            }
+          }
+
+          if (event.type === 'batch') {
+            const batchChanges: LlmChange[] = event.changes || []
+            const batchRows: number[] = event.entries_reviewed || []
+
+            // Update active rows (currently being reviewed)
+            setActiveRowIndices(new Set(batchRows))
+
+            // Accumulate changes
+            allChanges = [...allChanges, ...batchChanges]
+            setChanges(allChanges)
+            setProgress(event.progress)
+
+            // Update corrected map
+            for (const c of batchChanges) {
+              const existing = cMap.get(c.row_index) || []
+              existing.push(c)
+              cMap.set(c.row_index, [...existing])
+            }
+            setCorrectedMap(new Map(cMap))
+
+            // Mark batch rows as reviewed
+            for (const r of batchRows) {
+              allReviewed.add(r)
+            }
+            setReviewedRows(new Set(allReviewed))
+
+            // Scroll to active row in table
+            setTimeout(() => {
+              activeRowRef.current?.scrollIntoView({ behavior: 'smooth', block: 'center' })
+            }, 50)
+          }
+
+          if (event.type === 'complete') {
+            setActiveRowIndices(new Set())
+            setTotalDuration(event.duration_ms)
+            setAccepted(new Set(allChanges.map((_: LlmChange, i: number) => i)))
+            // Mark all non-skipped as reviewed
+            const allEntryIndices = vocabEntries.map((_: WordEntry, i: number) => i)
+            for (const i of allEntryIndices) {
+              if (!allSkipped.has(i)) allReviewed.add(i)
+            }
+            setReviewedRows(new Set(allReviewed))
+            setStatus('done')
+          }
+
+          if (event.type === 'error') {
+            throw new Error(event.detail || 'Unbekannter Fehler')
+          }
+        }
+      }
+
+      // If stream ended without complete event
+      if (allChanges.length === 0) {
+        setStatus('done')
+      }
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setError(msg)
+      setStatus('error')
+    }
+  }, [sessionId, vocabEntries])
+
+  const toggleChange = (index: number) => {
+    setAccepted(prev => {
+      const next = new Set(prev)
+      if (next.has(index)) next.delete(index)
+      else next.add(index)
+      return next
+    })
+  }
+
+  const toggleAll = () => {
+    if (accepted.size === changes.length) {
+      setAccepted(new Set())
+    } else {
+      setAccepted(new Set(changes.map((_: LlmChange, i: number) => i)))
+    }
+  }
+
+  const applyChanges = useCallback(async () => {
+    if (!sessionId) return
+    setApplying(true)
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/llm-review/apply`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ accepted_indices: Array.from(accepted) }),
+      })
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}))
+        throw new Error(data.detail || `HTTP ${res.status}`)
+      }
+      setStatus('applied')
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : String(e))
+    } finally {
+      setApplying(false)
+    }
+  }, [sessionId, accepted])
+
+  const getRowStatus = (rowIndex: number): RowStatus => {
+    if (activeRowIndices.has(rowIndex)) return 'active'
+    if (skippedRows.has(rowIndex)) return 'skipped'
+    if (correctedMap.has(rowIndex)) return 'corrected'
+    if (reviewedRows.has(rowIndex)) return 'reviewed'
+    return 'pending'
+  }
+
+  const dewarpedUrl = sessionId
+    ? `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+    : ''
+
+  if (!sessionId) {
+    return <div className="text-center py-12 text-gray-400">Bitte zuerst eine Session auswaehlen.</div>
+  }
+
+  // --- Loading session data ---
+  if (status === 'loading' || status === 'idle') {
+    return (
+      <div className="flex items-center gap-3 justify-center py-12">
+        <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-teal-500" />
+        <span className="text-gray-500">Session-Daten werden geladen...</span>
+      </div>
+    )
+  }
+
+  // --- Error ---
+  if (status === 'error') {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <div className="text-5xl mb-4">⚠️</div>
+        <h3 className="text-lg font-medium text-red-600 dark:text-red-400 mb-2">Fehler bei OCR-Zeichenkorrektur</h3>
+        <p className="text-sm text-gray-500 dark:text-gray-400 max-w-lg mb-4">{error}</p>
+        <div className="flex gap-3">
+          <button onClick={() => { setError(''); loadSessionData() }}
+            className="px-5 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors text-sm">
+            Erneut versuchen
+          </button>
+          <button onClick={onNext}
+            className="px-5 py-2 bg-gray-200 dark:bg-gray-700 text-gray-700 dark:text-gray-300 rounded-lg hover:bg-gray-300 dark:hover:bg-gray-600 transition-colors text-sm">
+            Ueberspringen →
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  // --- Applied ---
+  if (status === 'applied') {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <div className="text-5xl mb-4">✅</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">Korrekturen uebernommen</h3>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-6">
+          {accepted.size} von {changes.length} Korrekturen wurden angewendet.
+        </p>
+        <button onClick={onNext}
+          className="px-6 py-2.5 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors font-medium">
+          Weiter →
+        </button>
+      </div>
+    )
+  }
+
+  // Active entry for highlighting on image
+  const activeEntry = vocabEntries.find((_: WordEntry, i: number) => activeRowIndices.has(i))
+
+  const pct = progress ? Math.round((progress.current / progress.total) * 100) : 0
+
+  // --- Ready / Running / Done: 2-column layout ---
+  return (
+    <div className="space-y-4">
+      {/* Header */}
+      <div className="flex items-center justify-between">
+        <div>
+          <h3 className="text-base font-medium text-gray-700 dark:text-gray-300">
+            Schritt 6: Korrektur
+          </h3>
+          <p className="text-xs text-gray-400 mt-0.5">
+            {status === 'ready' && `${vocabEntries.length} Eintraege bereit zur Pruefung`}
+            {status === 'running' && meta && `${meta.model} · ${meta.to_review} zu pruefen, ${meta.skipped} uebersprungen`}
+            {status === 'done' && (
+              <>
+                {changes.length} Korrektur{changes.length !== 1 ? 'en' : ''} gefunden
+                {meta && <> · {meta.skipped} uebersprungen</>}
+                {' '}· {totalDuration}ms · {meta?.model}
+              </>
+            )}
+          </p>
+        </div>
+        <div className="flex items-center gap-2">
+          {status === 'ready' && (
+            <button onClick={runReview}
+              className="px-5 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors text-sm font-medium">
+              Korrektur starten
+            </button>
+          )}
+          {status === 'running' && (
+            <div className="flex items-center gap-2 text-sm text-teal-600 dark:text-teal-400">
+              <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-teal-500" />
+              {progress ? `${progress.current}/${progress.total}` : 'Startet...'}
+            </div>
+          )}
+          {status === 'done' && changes.length > 0 && (
+            <button onClick={toggleAll}
+              className="text-xs px-3 py-1.5 border border-gray-300 dark:border-gray-600 rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors text-gray-600 dark:text-gray-400">
+              {accepted.size === changes.length ? 'Keine' : 'Alle'} auswaehlen
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* Progress bar (while running) */}
+      {status === 'running' && progress && (
+        <div className="space-y-1">
+          <div className="flex justify-between text-xs text-gray-400">
+            <span>{progress.current} / {progress.total} Eintraege geprueft</span>
+            <span>{pct}%</span>
+          </div>
+          <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-2">
+            <div className="bg-teal-500 h-2 rounded-full transition-all duration-500" style={{ width: `${pct}%` }} />
+          </div>
+        </div>
+      )}
+
+      {/* 2-column layout: Image + Table */}
+      <div className="grid grid-cols-3 gap-4">
+        {/* Left: Dewarped Image with highlight overlay */}
+        <div className="col-span-1">
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+            Originalbild
+          </div>
+          <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900 relative sticky top-4">
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img
+              src={dewarpedUrl}
+              alt="Dewarped"
+              className="w-full h-auto"
+              onLoad={(e) => {
+                const img = e.target as HTMLImageElement
+                setImageNaturalSize({ w: img.naturalWidth, h: img.naturalHeight })
+              }}
+            />
+            {/* Highlight overlay for active row */}
+            {activeEntry?.bbox && (
+              <div
+                className="absolute border-2 border-yellow-400 bg-yellow-400/20 pointer-events-none animate-pulse"
+                style={{
+                  left: `${activeEntry.bbox.x}%`,
+                  top: `${activeEntry.bbox.y}%`,
+                  width: `${activeEntry.bbox.w}%`,
+                  height: `${activeEntry.bbox.h}%`,
+                }}
+              />
+            )}
+          </div>
+        </div>
+
+        {/* Right: Full vocabulary table */}
+        <div className="col-span-2" ref={tableRef}>
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+            Vokabeltabelle ({vocabEntries.length} Eintraege)
+          </div>
+          <div className="border border-gray-200 dark:border-gray-700 rounded-lg overflow-hidden">
+            <div className="max-h-[70vh] overflow-y-auto">
+              <table className="w-full text-sm">
+                <thead className="sticky top-0 z-10">
+                  <tr className="bg-gray-50 dark:bg-gray-800 border-b border-gray-200 dark:border-gray-700">
+                    <th className="px-2 py-2 text-left text-gray-500 dark:text-gray-400 font-medium w-10">#</th>
+                    {columnsUsed.length > 0 ? (
+                      columnsUsed.map((col, i) => {
+                        const field = COL_TYPE_TO_FIELD[col.type]
+                        if (!field) return null
+                        return (
+                          <th key={i} className={`px-2 py-2 text-left font-medium ${COL_TYPE_COLOR[col.type] || 'text-gray-500 dark:text-gray-400'}`}>
+                            {FIELD_LABELS[field] || field}
+                          </th>
+                        )
+                      })
+                    ) : (
+                      <>
+                        <th className="px-2 py-2 text-left text-gray-500 dark:text-gray-400 font-medium">EN</th>
+                        <th className="px-2 py-2 text-left text-gray-500 dark:text-gray-400 font-medium">DE</th>
+                        <th className="px-2 py-2 text-left text-gray-500 dark:text-gray-400 font-medium">Beispiel</th>
+                      </>
+                    )}
+                    <th className="px-2 py-2 text-center text-gray-500 dark:text-gray-400 font-medium w-16">Status</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {vocabEntries.map((entry, idx) => {
+                    const rowStatus = getRowStatus(idx)
+                    const rowChanges = correctedMap.get(idx)
+
+                    const rowBg = {
+                      pending: '',
+                      active: 'bg-yellow-50 dark:bg-yellow-900/20',
+                      reviewed: '',
+                      corrected: 'bg-teal-50/50 dark:bg-teal-900/10',
+                      skipped: 'bg-gray-50 dark:bg-gray-800/50',
+                    }[rowStatus]
+
+                    return (
+                      <tr
+                        key={idx}
+                        ref={rowStatus === 'active' ? activeRowRef : undefined}
+                        className={`border-b border-gray-100 dark:border-gray-700/50 ${rowBg} ${
+                          rowStatus === 'active' ? 'ring-1 ring-yellow-400 ring-inset' : ''
+                        }`}
+                      >
+                        <td className="px-2 py-1.5 text-gray-400 font-mono text-xs">{idx}</td>
+                        {columnsUsed.length > 0 ? (
+                          columnsUsed.map((col, i) => {
+                            const field = COL_TYPE_TO_FIELD[col.type]
+                            if (!field) return null
+                            const text = (entry as Record<string, unknown>)[field] as string || ''
+                            return (
+                              <td key={i} className="px-2 py-1.5 text-xs">
+                                <CellContent text={text} field={field} rowChanges={rowChanges} />
+                              </td>
+                            )
+                          })
+                        ) : (
+                          <>
+                            <td className="px-2 py-1.5">
+                              <CellContent text={entry.english} field="english" rowChanges={rowChanges} />
+                            </td>
+                            <td className="px-2 py-1.5">
+                              <CellContent text={entry.german} field="german" rowChanges={rowChanges} />
+                            </td>
+                            <td className="px-2 py-1.5 text-xs">
+                              <CellContent text={entry.example} field="example" rowChanges={rowChanges} />
+                            </td>
+                          </>
+                        )}
+                        <td className="px-2 py-1.5 text-center">
+                          <StatusIcon status={rowStatus} />
+                        </td>
+                      </tr>
+                    )
+                  })}
+                </tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {/* Done state: summary + actions */}
+      {status === 'done' && (
+        <div className="space-y-4">
+          {/* Summary */}
+          <div className="bg-gray-50 dark:bg-gray-800/50 rounded-lg p-3 text-xs text-gray-500 dark:text-gray-400">
+            {changes.length === 0 ? (
+              <span>Keine Korrekturen noetig — alle Eintraege sind korrekt.</span>
+            ) : (
+              <span>
+                {changes.length} Korrektur{changes.length !== 1 ? 'en' : ''} gefunden ·{' '}
+                {accepted.size} ausgewaehlt ·{' '}
+                {meta?.skipped || 0} uebersprungen (Lautschrift) ·{' '}
+                {totalDuration}ms
+              </span>
+            )}
+          </div>
+
+          {/* Corrections detail list (if any) */}
+          {changes.length > 0 && (
+            <div className="border border-gray-200 dark:border-gray-700 rounded-lg overflow-hidden">
+              <div className="bg-gray-50 dark:bg-gray-800 px-3 py-2 border-b border-gray-200 dark:border-gray-700">
+                <span className="text-xs font-medium text-gray-600 dark:text-gray-400">
+                  Korrekturvorschlaege ({accepted.size}/{changes.length} ausgewaehlt)
+                </span>
+              </div>
+              <table className="w-full text-sm">
+                <thead>
+                  <tr className="bg-gray-50/50 dark:bg-gray-800/50 border-b border-gray-200 dark:border-gray-700">
+                    <th className="w-10 px-3 py-1.5 text-center">
+                      <input type="checkbox" checked={accepted.size === changes.length} onChange={toggleAll}
+                        className="rounded border-gray-300 dark:border-gray-600" />
+                    </th>
+                    <th className="px-2 py-1.5 text-left text-gray-500 dark:text-gray-400 font-medium text-xs">Zeile</th>
+                    <th className="px-2 py-1.5 text-left text-gray-500 dark:text-gray-400 font-medium text-xs">Feld</th>
+                    <th className="px-2 py-1.5 text-left text-gray-500 dark:text-gray-400 font-medium text-xs">Vorher</th>
+                    <th className="px-2 py-1.5 text-left text-gray-500 dark:text-gray-400 font-medium text-xs">Nachher</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {changes.map((change, idx) => (
+                    <tr key={idx} className={`border-b border-gray-100 dark:border-gray-700/50 ${
+                      accepted.has(idx) ? 'bg-teal-50/50 dark:bg-teal-900/10' : ''
+                    }`}>
+                      <td className="px-3 py-1.5 text-center">
+                        <input type="checkbox" checked={accepted.has(idx)} onChange={() => toggleChange(idx)}
+                          className="rounded border-gray-300 dark:border-gray-600" />
+                      </td>
+                      <td className="px-2 py-1.5 text-gray-500 dark:text-gray-400 font-mono text-xs">R{change.row_index}</td>
+                      <td className="px-2 py-1.5">
+                        <span className="text-xs px-1.5 py-0.5 rounded bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400">
+                          {FIELD_LABELS[change.field] || change.field}
+                        </span>
+                      </td>
+                      <td className="px-2 py-1.5"><span className="line-through text-red-500 dark:text-red-400 text-xs">{change.old}</span></td>
+                      <td className="px-2 py-1.5"><span className="text-green-600 dark:text-green-400 font-medium text-xs">{change.new}</span></td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            </div>
+          )}
+
+          {/* Actions */}
+          <div className="flex items-center justify-between pt-2">
+            <p className="text-xs text-gray-400">
+              {changes.length > 0 ? `${accepted.size} von ${changes.length} ausgewaehlt` : ''}
+            </p>
+            <div className="flex gap-3">
+              {changes.length > 0 && (
+                <button onClick={onNext}
+                  className="px-4 py-2 text-sm border border-gray-300 dark:border-gray-600 rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 transition-colors text-gray-600 dark:text-gray-400">
+                  Alle ablehnen
+                </button>
+              )}
+              {changes.length > 0 ? (
+                <button onClick={applyChanges} disabled={applying || accepted.size === 0}
+                  className="px-5 py-2 text-sm bg-teal-600 text-white rounded-lg hover:bg-teal-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors font-medium">
+                  {applying ? 'Wird uebernommen...' : `${accepted.size} Korrektur${accepted.size !== 1 ? 'en' : ''} uebernehmen`}
+                </button>
+              ) : (
+                <button onClick={onNext}
+                  className="px-6 py-2.5 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors font-medium">
+                  Weiter →
+                </button>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+/** Cell content with inline diff for corrections */
+function CellContent({ text, field, rowChanges }: {
+  text: string
+  field: string
+  rowChanges?: LlmChange[]
+}) {
+  const change = rowChanges?.find(c => c.field === field)
+
+  if (!text && !change) {
+    return <span className="text-gray-300 dark:text-gray-600">&mdash;</span>
+  }
+
+  if (change) {
+    return (
+      <span>
+        <span className="line-through text-red-400 dark:text-red-500 text-xs mr-1">{change.old}</span>
+        <span className="text-green-600 dark:text-green-400 font-medium text-xs">{change.new}</span>
+      </span>
+    )
+  }
+
+  return <span className="text-gray-700 dark:text-gray-300 text-xs">{text}</span>
+}
+
+/** Status icon for each row */
+function StatusIcon({ status }: { status: RowStatus }) {
+  switch (status) {
+    case 'pending':
+      return <span className="text-gray-300 dark:text-gray-600 text-xs">—</span>
+    case 'active':
+      return (
+        <span className="inline-block w-3 h-3 rounded-full bg-yellow-400 animate-pulse" title="Wird geprueft" />
+      )
+    case 'reviewed':
+      return (
+        <svg className="w-4 h-4 text-green-500 inline-block" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={2}>
+          <path strokeLinecap="round" strokeLinejoin="round" d="M5 13l4 4L19 7" />
+        </svg>
+      )
+    case 'corrected':
+      return (
+        <span className="inline-flex items-center px-1.5 py-0.5 rounded text-[10px] font-medium bg-teal-100 dark:bg-teal-900/30 text-teal-700 dark:text-teal-400">
+          korr.
+        </span>
+      )
+    case 'skipped':
+      return (
+        <span className="inline-flex items-center px-1.5 py-0.5 rounded text-[10px] font-medium bg-gray-100 dark:bg-gray-700 text-gray-500 dark:text-gray-400">
+          skip
+        </span>
+      )
+  }
+}

admin-lehrer/components/ocr-pipeline/StepReconstruction.tsx

@@ -0,0 +1,559 @@
+'use client'
+
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import dynamic from 'next/dynamic'
+import type { GridResult, GridCell, WordEntry } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+// Lazy-load Fabric.js canvas editor (SSR-incompatible)
+const FabricReconstructionCanvas = dynamic(
+  () => import('./FabricReconstructionCanvas').then(m => ({ default: m.FabricReconstructionCanvas })),
+  { ssr: false, loading: () => <div className="py-8 text-center text-sm text-gray-400">Editor wird geladen...</div> }
+)
+
+type EditorMode = 'simple' | 'editor'
+
+interface StepReconstructionProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+interface EditableCell {
+  cellId: string
+  text: string
+  originalText: string
+  bboxPct: { x: number; y: number; w: number; h: number }
+  colType: string
+  rowIndex: number
+  colIndex: number
+}
+
+type UndoAction = { cellId: string; oldText: string; newText: string }
+
+export function StepReconstruction({ sessionId, onNext }: StepReconstructionProps) {
+  const [status, setStatus] = useState<'loading' | 'ready' | 'saving' | 'saved' | 'error'>('loading')
+  const [error, setError] = useState('')
+  const [cells, setCells] = useState<EditableCell[]>([])
+  const [gridCells, setGridCells] = useState<GridCell[]>([])
+  const [editorMode, setEditorMode] = useState<EditorMode>('simple')
+  const [editedTexts, setEditedTexts] = useState<Map<string, string>>(new Map())
+  const [zoom, setZoom] = useState(100)
+  const [imageNaturalH, setImageNaturalH] = useState(0)
+  const [showEmptyHighlight, setShowEmptyHighlight] = useState(true)
+
+  // Undo/Redo stacks
+  const [undoStack, setUndoStack] = useState<UndoAction[]>([])
+  const [redoStack, setRedoStack] = useState<UndoAction[]>([])
+
+  // (allCells removed — cells now contains all cells including empty ones)
+
+  const containerRef = useRef<HTMLDivElement>(null)
+  const imageRef = useRef<HTMLImageElement>(null)
+
+  // Load session data on mount
+  useEffect(() => {
+    if (!sessionId) return
+    loadSessionData()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  // Track image natural height for font scaling
+  const handleImageLoad = useCallback(() => {
+    if (imageRef.current) {
+      setImageNaturalH(imageRef.current.naturalHeight)
+    }
+  }, [])
+
+  const loadSessionData = async () => {
+    if (!sessionId) return
+    setStatus('loading')
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}`)
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      const data = await res.json()
+
+      const wordResult: GridResult | undefined = data.word_result
+      if (!wordResult) {
+        setError('Keine Worterkennungsdaten gefunden. Bitte zuerst Schritt 5 abschliessen.')
+        setStatus('error')
+        return
+      }
+
+      // Build editable cells from grid cells
+      const rawGridCells: GridCell[] = wordResult.cells || []
+      setGridCells(rawGridCells)
+      const allEditableCells: EditableCell[] = rawGridCells.map(c => ({
+        cellId: c.cell_id,
+        text: c.text,
+        originalText: c.text,
+        bboxPct: c.bbox_pct,
+        colType: c.col_type,
+        rowIndex: c.row_index,
+        colIndex: c.col_index,
+      }))
+
+      setCells(allEditableCells)
+      setEditedTexts(new Map())
+      setUndoStack([])
+      setRedoStack([])
+      setStatus('ready')
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : String(e))
+      setStatus('error')
+    }
+  }
+
+  const handleTextChange = useCallback((cellId: string, newText: string) => {
+    setEditedTexts(prev => {
+      const oldText = prev.get(cellId)
+      const cell = cells.find(c => c.cellId === cellId)
+      const prevText = oldText ?? cell?.text ?? ''
+
+      // Push to undo stack
+      setUndoStack(stack => [...stack, { cellId, oldText: prevText, newText }])
+      setRedoStack([]) // Clear redo on new edit
+
+      const next = new Map(prev)
+      next.set(cellId, newText)
+      return next
+    })
+  }, [cells])
+
+  const undo = useCallback(() => {
+    setUndoStack(stack => {
+      if (stack.length === 0) return stack
+      const action = stack[stack.length - 1]
+      const newStack = stack.slice(0, -1)
+
+      setRedoStack(rs => [...rs, action])
+      setEditedTexts(prev => {
+        const next = new Map(prev)
+        next.set(action.cellId, action.oldText)
+        return next
+      })
+
+      return newStack
+    })
+  }, [])
+
+  const redo = useCallback(() => {
+    setRedoStack(stack => {
+      if (stack.length === 0) return stack
+      const action = stack[stack.length - 1]
+      const newStack = stack.slice(0, -1)
+
+      setUndoStack(us => [...us, action])
+      setEditedTexts(prev => {
+        const next = new Map(prev)
+        next.set(action.cellId, action.newText)
+        return next
+      })
+
+      return newStack
+    })
+  }, [])
+
+  const resetCell = useCallback((cellId: string) => {
+    const cell = cells.find(c => c.cellId === cellId)
+    if (!cell) return
+    setEditedTexts(prev => {
+      const next = new Map(prev)
+      next.delete(cellId)
+      return next
+    })
+  }, [cells])
+
+  // Global keyboard shortcuts for undo/redo
+  useEffect(() => {
+    const handler = (e: KeyboardEvent) => {
+      if ((e.metaKey || e.ctrlKey) && e.key === 'z') {
+        e.preventDefault()
+        if (e.shiftKey) {
+          redo()
+        } else {
+          undo()
+        }
+      }
+    }
+    document.addEventListener('keydown', handler)
+    return () => document.removeEventListener('keydown', handler)
+  }, [undo, redo])
+
+  const getDisplayText = useCallback((cell: EditableCell): string => {
+    return editedTexts.get(cell.cellId) ?? cell.text
+  }, [editedTexts])
+
+  const isEdited = useCallback((cell: EditableCell): boolean => {
+    const edited = editedTexts.get(cell.cellId)
+    return edited !== undefined && edited !== cell.originalText
+  }, [editedTexts])
+
+  const changedCount = useMemo(() => {
+    let count = 0
+    for (const cell of cells) {
+      if (isEdited(cell)) count++
+    }
+    return count
+  }, [cells, isEdited])
+
+  // Identify empty required cells (EN or DE columns with no text)
+  const emptyCellIds = useMemo(() => {
+    const required = new Set(['column_en', 'column_de'])
+    const ids = new Set<string>()
+    for (const cell of cells) {
+      if (required.has(cell.colType) && !cell.text.trim()) {
+        ids.add(cell.cellId)
+      }
+    }
+    return ids
+  }, [cells])
+
+  // Sort cells for tab navigation: by row, then by column
+  const sortedCellIds = useMemo(() => {
+    return [...cells]
+      .sort((a, b) => a.rowIndex !== b.rowIndex ? a.rowIndex - b.rowIndex : a.colIndex - b.colIndex)
+      .map(c => c.cellId)
+  }, [cells])
+
+  const handleKeyDown = useCallback((e: React.KeyboardEvent, cellId: string) => {
+    if (e.key === 'Tab') {
+      e.preventDefault()
+      const idx = sortedCellIds.indexOf(cellId)
+      const nextIdx = e.shiftKey ? idx - 1 : idx + 1
+      if (nextIdx >= 0 && nextIdx < sortedCellIds.length) {
+        const nextId = sortedCellIds[nextIdx]
+        const el = document.getElementById(`cell-${nextId}`)
+        el?.focus()
+      }
+    }
+  }, [sortedCellIds])
+
+  const saveReconstruction = useCallback(async () => {
+    if (!sessionId) return
+    setStatus('saving')
+    try {
+      const cellUpdates = Array.from(editedTexts.entries())
+        .filter(([cellId, text]) => {
+          const cell = cells.find(c => c.cellId === cellId)
+          return cell && text !== cell.originalText
+        })
+        .map(([cellId, text]) => ({ cell_id: cellId, text }))
+
+      if (cellUpdates.length === 0) {
+        // Nothing changed, just advance
+        setStatus('saved')
+        return
+      }
+
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/reconstruction`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ cells: cellUpdates }),
+      })
+
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}))
+        throw new Error(data.detail || `HTTP ${res.status}`)
+      }
+
+      setStatus('saved')
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : String(e))
+      setStatus('error')
+    }
+  }, [sessionId, editedTexts, cells])
+
+  // Handler for Fabric.js editor cell changes
+  const handleFabricCellsChanged = useCallback((updates: { cell_id: string; text: string }[]) => {
+    for (const u of updates) {
+      setEditedTexts(prev => {
+        const next = new Map(prev)
+        next.set(u.cell_id, u.text)
+        return next
+      })
+    }
+  }, [])
+
+  const dewarpedUrl = sessionId
+    ? `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+    : ''
+
+  const colTypeColor = (colType: string): string => {
+    const colors: Record<string, string> = {
+      column_en: 'border-blue-400/40 focus:border-blue-500',
+      column_de: 'border-green-400/40 focus:border-green-500',
+      column_example: 'border-orange-400/40 focus:border-orange-500',
+      column_text: 'border-purple-400/40 focus:border-purple-500',
+      page_ref: 'border-cyan-400/40 focus:border-cyan-500',
+      column_marker: 'border-gray-400/40 focus:border-gray-500',
+    }
+    return colors[colType] || 'border-gray-400/40 focus:border-gray-500'
+  }
+
+  // Font size based on image natural height (not container) scaled by zoom
+  const getFontSize = useCallback((bboxH: number): number => {
+    const baseH = imageNaturalH || 800
+    const px = (bboxH / 100) * baseH * 0.55
+    return Math.max(8, Math.min(18, px * (zoom / 100)))
+  }, [imageNaturalH, zoom])
+
+  if (!sessionId) {
+    return <div className="text-center py-12 text-gray-400">Bitte zuerst eine Session auswaehlen.</div>
+  }
+
+  if (status === 'loading') {
+    return (
+      <div className="flex items-center gap-3 justify-center py-12">
+        <div className="animate-spin rounded-full h-5 w-5 border-b-2 border-teal-500" />
+        <span className="text-gray-500">Rekonstruktionsdaten werden geladen...</span>
+      </div>
+    )
+  }
+
+  if (status === 'error') {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <div className="text-5xl mb-4">&#x26A0;&#xFE0F;</div>
+        <h3 className="text-lg font-medium text-red-600 dark:text-red-400 mb-2">Fehler</h3>
+        <p className="text-sm text-gray-500 dark:text-gray-400 max-w-lg mb-4">{error}</p>
+        <div className="flex gap-3">
+          <button onClick={() => { setError(''); loadSessionData() }}
+            className="px-5 py-2 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors text-sm">
+            Erneut versuchen
+          </button>
+          <button onClick={onNext}
+            className="px-5 py-2 bg-gray-200 dark:bg-gray-700 text-gray-700 dark:text-gray-300 rounded-lg hover:bg-gray-300 dark:hover:bg-gray-600 transition-colors text-sm">
+            Ueberspringen &rarr;
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  if (status === 'saved') {
+    return (
+      <div className="flex flex-col items-center justify-center py-12 text-center">
+        <div className="text-5xl mb-4">&#x2705;</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">Rekonstruktion gespeichert</h3>
+        <p className="text-sm text-gray-500 dark:text-gray-400 mb-6">
+          {changedCount > 0 ? `${changedCount} Zellen wurden aktualisiert.` : 'Keine Aenderungen vorgenommen.'}
+        </p>
+        <button onClick={onNext}
+          className="px-6 py-2.5 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors font-medium">
+          Weiter &rarr;
+        </button>
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-3">
+      {/* Toolbar */}
+      <div className="flex items-center justify-between bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 px-3 py-2">
+        <div className="flex items-center gap-2">
+          <h3 className="text-sm font-medium text-gray-700 dark:text-gray-300">
+            Schritt 7: Rekonstruktion
+          </h3>
+          {/* Mode toggle */}
+          <div className="flex items-center ml-2 border border-gray-300 dark:border-gray-600 rounded overflow-hidden text-xs">
+            <button
+              onClick={() => setEditorMode('simple')}
+              className={`px-2 py-0.5 transition-colors ${
+                editorMode === 'simple'
+                  ? 'bg-teal-600 text-white'
+                  : 'hover:bg-gray-50 dark:hover:bg-gray-700 text-gray-600 dark:text-gray-400'
+              }`}
+            >
+              Einfach
+            </button>
+            <button
+              onClick={() => setEditorMode('editor')}
+              className={`px-2 py-0.5 transition-colors ${
+                editorMode === 'editor'
+                  ? 'bg-teal-600 text-white'
+                  : 'hover:bg-gray-50 dark:hover:bg-gray-700 text-gray-600 dark:text-gray-400'
+              }`}
+            >
+              Editor
+            </button>
+          </div>
+          <span className="text-xs text-gray-400">
+            {cells.length} Zellen &middot; {changedCount} geaendert
+            {emptyCellIds.size > 0 && showEmptyHighlight && (
+              <span className="text-red-400 ml-1">&middot; {emptyCellIds.size} leer</span>
+            )}
+          </span>
+        </div>
+        <div className="flex items-center gap-2">
+          {/* Undo/Redo */}
+          <button
+            onClick={undo}
+            disabled={undoStack.length === 0}
+            className="px-2 py-1 text-xs border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700 disabled:opacity-30"
+            title="Rueckgaengig (Ctrl+Z)"
+          >
+            &#x21A9;
+          </button>
+          <button
+            onClick={redo}
+            disabled={redoStack.length === 0}
+            className="px-2 py-1 text-xs border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700 disabled:opacity-30"
+            title="Wiederholen (Ctrl+Shift+Z)"
+          >
+            &#x21AA;
+          </button>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Empty field toggle */}
+          <button
+            onClick={() => setShowEmptyHighlight(v => !v)}
+            className={`px-2 py-1 text-xs border rounded transition-colors ${
+              showEmptyHighlight
+                ? 'border-red-300 bg-red-50 text-red-600 dark:border-red-700 dark:bg-red-900/30 dark:text-red-400'
+                : 'border-gray-300 dark:border-gray-600 hover:bg-gray-50 dark:hover:bg-gray-700'
+            }`}
+            title="Leere Pflichtfelder markieren"
+          >
+            Leer
+          </button>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          {/* Zoom controls */}
+          <button
+            onClick={() => setZoom(z => Math.max(50, z - 25))}
+            className="px-2 py-1 text-xs border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700"
+          >
+            &minus;
+          </button>
+          <span className="text-xs text-gray-500 w-10 text-center">{zoom}%</span>
+          <button
+            onClick={() => setZoom(z => Math.min(200, z + 25))}
+            className="px-2 py-1 text-xs border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700"
+          >
+            +
+          </button>
+          <button
+            onClick={() => setZoom(100)}
+            className="px-2 py-1 text-xs border border-gray-300 dark:border-gray-600 rounded hover:bg-gray-50 dark:hover:bg-gray-700"
+          >
+            Fit
+          </button>
+
+          <div className="w-px h-5 bg-gray-300 dark:bg-gray-600 mx-1" />
+
+          <button
+            onClick={saveReconstruction}
+            disabled={status === 'saving'}
+            className="px-4 py-1.5 text-xs bg-teal-600 text-white rounded-lg hover:bg-teal-700 disabled:opacity-50 transition-colors font-medium"
+          >
+            {status === 'saving' ? 'Speichert...' : 'Speichern'}
+          </button>
+        </div>
+      </div>
+
+      {/* Reconstruction canvas — Simple or Editor mode */}
+      {editorMode === 'editor' && sessionId ? (
+        <FabricReconstructionCanvas
+          sessionId={sessionId}
+          cells={gridCells}
+          onCellsChanged={handleFabricCellsChanged}
+        />
+      ) : (
+        <div className="border rounded-lg overflow-auto dark:border-gray-700 bg-gray-100 dark:bg-gray-900" style={{ maxHeight: '75vh' }}>
+          <div
+            ref={containerRef}
+            className="relative inline-block"
+            style={{ transform: `scale(${zoom / 100})`, transformOrigin: 'top left' }}
+          >
+            {/* Background image at reduced opacity */}
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img
+              ref={imageRef}
+              src={dewarpedUrl}
+              alt="Dewarped"
+              className="block"
+              style={{ opacity: 0.3 }}
+              onLoad={handleImageLoad}
+            />
+
+            {/* Empty field markers */}
+            {showEmptyHighlight && cells
+              .filter(c => emptyCellIds.has(c.cellId))
+              .map(cell => (
+                <div
+                  key={`empty-${cell.cellId}`}
+                  className="absolute border-2 border-dashed border-red-400/60 rounded pointer-events-none"
+                  style={{
+                    left: `${cell.bboxPct.x}%`,
+                    top: `${cell.bboxPct.y}%`,
+                    width: `${cell.bboxPct.w}%`,
+                    height: `${cell.bboxPct.h}%`,
+                  }}
+                />
+              ))}
+
+            {/* Editable text fields at bbox positions */}
+            {cells.map((cell) => {
+              const displayText = getDisplayText(cell)
+              const edited = isEdited(cell)
+
+              return (
+                <div key={cell.cellId} className="absolute group" style={{
+                  left: `${cell.bboxPct.x}%`,
+                  top: `${cell.bboxPct.y}%`,
+                  width: `${cell.bboxPct.w}%`,
+                  height: `${cell.bboxPct.h}%`,
+                }}>
+                  <input
+                    id={`cell-${cell.cellId}`}
+                    type="text"
+                    value={displayText}
+                    onChange={(e) => handleTextChange(cell.cellId, e.target.value)}
+                    onKeyDown={(e) => handleKeyDown(e, cell.cellId)}
+                    className={`w-full h-full bg-transparent text-black dark:text-white border px-0.5 outline-none transition-colors ${
+                      colTypeColor(cell.colType)
+                    } ${edited ? 'border-green-500 bg-green-50/30 dark:bg-green-900/20' : ''}`}
+                    style={{
+                      fontSize: `${getFontSize(cell.bboxPct.h)}px`,
+                      lineHeight: '1',
+                    }}
+                    title={`${cell.cellId} (${cell.colType})`}
+                  />
+                  {/* Per-cell reset button (X) — only shown for edited cells on hover */}
+                  {edited && (
+                    <button
+                      onClick={() => resetCell(cell.cellId)}
+                      className="absolute -top-1 -right-1 w-4 h-4 bg-red-500 text-white rounded-full text-[9px] leading-none opacity-0 group-hover:opacity-100 transition-opacity flex items-center justify-center"
+                      title="Zuruecksetzen"
+                    >
+                      &times;
+                    </button>
+                  )}
+                </div>
+              )
+            })}
+          </div>
+        </div>
+      )}
+
+      {/* Bottom action */}
+      <div className="flex justify-end">
+        <button
+          onClick={() => {
+            if (changedCount > 0) {
+              saveReconstruction()
+            } else {
+              onNext()
+            }
+          }}
+          className="px-6 py-2.5 bg-teal-600 text-white rounded-lg hover:bg-teal-700 transition-colors font-medium text-sm"
+        >
+          {changedCount > 0 ? 'Speichern & Weiter \u2192' : 'Weiter \u2192'}
+        </button>
+      </div>
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepRowDetection.tsx

@@ -0,0 +1,263 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+import type { RowResult, RowGroundTruth } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+interface StepRowDetectionProps {
+  sessionId: string | null
+  onNext: () => void
+}
+
+export function StepRowDetection({ sessionId, onNext }: StepRowDetectionProps) {
+  const [rowResult, setRowResult] = useState<RowResult | null>(null)
+  const [detecting, setDetecting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [gtNotes, setGtNotes] = useState('')
+  const [gtSaved, setGtSaved] = useState(false)
+
+  useEffect(() => {
+    if (!sessionId) return
+
+    const fetchSession = async () => {
+      try {
+        const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}`)
+        if (res.ok) {
+          const info = await res.json()
+          if (info.row_result) {
+            setRowResult(info.row_result)
+            return
+          }
+        }
+      } catch (e) {
+        console.error('Failed to fetch session info:', e)
+      }
+      // No cached result — run auto
+      runAutoDetection()
+    }
+
+    fetchSession()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  const runAutoDetection = useCallback(async () => {
+    if (!sessionId) return
+    setDetecting(true)
+    setError(null)
+    try {
+      const res = await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/rows`, {
+        method: 'POST',
+      })
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({ detail: res.statusText }))
+        throw new Error(err.detail || 'Zeilenerkennung fehlgeschlagen')
+      }
+      const data: RowResult = await res.json()
+      setRowResult(data)
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+    } finally {
+      setDetecting(false)
+    }
+  }, [sessionId])
+
+  const handleGroundTruth = useCallback(async (isCorrect: boolean) => {
+    if (!sessionId) return
+    const gt: RowGroundTruth = {
+      is_correct: isCorrect,
+      notes: gtNotes || undefined,
+    }
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/rows`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+      setGtSaved(true)
+    } catch (e) {
+      console.error('Ground truth save failed:', e)
+    }
+  }, [sessionId, gtNotes])
+
+  if (!sessionId) {
+    return (
+      <div className="flex flex-col items-center justify-center py-16 text-center">
+        <div className="text-5xl mb-4">📏</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">
+          Schritt 4: Zeilenerkennung
+        </h3>
+        <p className="text-gray-500 dark:text-gray-400 max-w-md">
+          Bitte zuerst Schritte 1-3 abschliessen.
+        </p>
+      </div>
+    )
+  }
+
+  const overlayUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/rows-overlay`
+  const dewarpedUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+
+  const rowTypeColors: Record<string, string> = {
+    header: 'bg-gray-200 dark:bg-gray-600 text-gray-700 dark:text-gray-300',
+    content: 'bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-300',
+    footer: 'bg-gray-200 dark:bg-gray-600 text-gray-700 dark:text-gray-300',
+  }
+
+  return (
+    <div className="space-y-4">
+      {/* Loading */}
+      {detecting && (
+        <div className="flex items-center gap-2 text-teal-600 dark:text-teal-400 text-sm">
+          <div className="animate-spin w-4 h-4 border-2 border-teal-500 border-t-transparent rounded-full" />
+          Zeilenerkennung laeuft...
+        </div>
+      )}
+
+      {/* Images: overlay vs clean */}
+      <div className="grid grid-cols-2 gap-4">
+        <div>
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+            Mit Zeilen-Overlay
+          </div>
+          <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+            {rowResult ? (
+              // eslint-disable-next-line @next/next/no-img-element
+              <img
+                src={`${overlayUrl}?t=${Date.now()}`}
+                alt="Zeilen-Overlay"
+                className="w-full h-auto"
+              />
+            ) : (
+              <div className="aspect-[3/4] flex items-center justify-center text-gray-400 text-sm">
+                {detecting ? 'Erkenne Zeilen...' : 'Keine Daten'}
+              </div>
+            )}
+          </div>
+        </div>
+        <div>
+          <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+            Entzerrtes Bild
+          </div>
+          <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img
+              src={dewarpedUrl}
+              alt="Entzerrt"
+              className="w-full h-auto"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Row summary */}
+      {rowResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+          <div className="flex items-center justify-between">
+            <h4 className="text-sm font-medium text-gray-700 dark:text-gray-300">
+              Ergebnis: {rowResult.total_rows} Zeilen erkannt
+            </h4>
+            <span className="text-xs text-gray-400">
+              {rowResult.duration_seconds}s
+            </span>
+          </div>
+
+          {/* Type summary badges */}
+          <div className="flex gap-2">
+            {Object.entries(rowResult.summary).map(([type, count]) => (
+              <span
+                key={type}
+                className={`px-2 py-0.5 rounded text-xs font-medium ${rowTypeColors[type] || 'bg-gray-100 text-gray-600'}`}
+              >
+                {type}: {count}
+              </span>
+            ))}
+          </div>
+
+          {/* Row list */}
+          <div className="max-h-64 overflow-y-auto space-y-1">
+            {rowResult.rows.map((row) => (
+              <div
+                key={row.index}
+                className={`flex items-center gap-3 px-3 py-1.5 rounded text-xs font-mono ${
+                  row.row_type === 'header' || row.row_type === 'footer'
+                    ? 'bg-gray-50 dark:bg-gray-700/50 text-gray-500'
+                    : 'text-gray-600 dark:text-gray-400'
+                }`}
+              >
+                <span className="w-8 text-right text-gray-400">R{row.index}</span>
+                <span className={`px-1.5 py-0.5 rounded text-[10px] uppercase font-semibold ${rowTypeColors[row.row_type] || ''}`}>
+                  {row.row_type}
+                </span>
+                <span>y={row.y}</span>
+                <span>h={row.height}px</span>
+                <span>{row.word_count} Woerter</span>
+                {row.gap_before > 0 && (
+                  <span className="text-gray-400">gap={row.gap_before}px</span>
+                )}
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {/* Controls */}
+      {rowResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+          <div className="flex items-center gap-3">
+            <button
+              onClick={() => runAutoDetection()}
+              disabled={detecting}
+              className="px-3 py-1.5 text-xs border rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600 disabled:opacity-50"
+            >
+              Erneut erkennen
+            </button>
+
+            <div className="flex-1" />
+
+            {/* Ground truth */}
+            {!gtSaved ? (
+              <>
+                <input
+                  type="text"
+                  placeholder="Notizen (optional)"
+                  value={gtNotes}
+                  onChange={(e) => setGtNotes(e.target.value)}
+                  className="px-2 py-1 text-xs border rounded dark:bg-gray-700 dark:border-gray-600 w-48"
+                />
+                <button
+                  onClick={() => handleGroundTruth(true)}
+                  className="px-3 py-1.5 text-xs bg-green-600 text-white rounded-lg hover:bg-green-700"
+                >
+                  Korrekt
+                </button>
+                <button
+                  onClick={() => handleGroundTruth(false)}
+                  className="px-3 py-1.5 text-xs bg-red-600 text-white rounded-lg hover:bg-red-700"
+                >
+                  Fehlerhaft
+                </button>
+              </>
+            ) : (
+              <span className="text-xs text-green-600 dark:text-green-400">
+                Ground Truth gespeichert
+              </span>
+            )}
+
+            <button
+              onClick={onNext}
+              className="px-4 py-1.5 text-xs bg-teal-600 text-white rounded-lg hover:bg-teal-700 font-medium"
+            >
+              Weiter
+            </button>
+          </div>
+        </div>
+      )}
+
+      {error && (
+        <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+          {error}
+        </div>
+      )}
+    </div>
+  )
+}

admin-lehrer/components/ocr-pipeline/StepWordRecognition.tsx

@@ -0,0 +1,911 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import type { GridResult, GridCell, WordEntry, WordGroundTruth } from '@/app/(admin)/ai/ocr-pipeline/types'
+
+const KLAUSUR_API = '/klausur-api'
+
+/** Render text with \n as line breaks */
+function MultilineText({ text }: { text: string }) {
+  if (!text) return <span className="text-gray-300 dark:text-gray-600">&mdash;</span>
+  const lines = text.split('\n')
+  if (lines.length === 1) return <>{text}</>
+  return <>{lines.map((line, i) => (
+    <span key={i}>{line}{i < lines.length - 1 && <br />}</span>
+  ))}</>
+}
+
+/** Column type → human-readable header */
+function colTypeLabel(colType: string): string {
+  const labels: Record<string, string> = {
+    column_en: 'English',
+    column_de: 'Deutsch',
+    column_example: 'Example',
+    column_text: 'Text',
+    column_marker: 'Marker',
+    page_ref: 'Seite',
+  }
+  return labels[colType] || colType.replace('column_', '')
+}
+
+/** Column type → color class */
+function colTypeColor(colType: string): string {
+  const colors: Record<string, string> = {
+    column_en: 'text-blue-600 dark:text-blue-400',
+    column_de: 'text-green-600 dark:text-green-400',
+    column_example: 'text-orange-600 dark:text-orange-400',
+    column_text: 'text-purple-600 dark:text-purple-400',
+    column_marker: 'text-gray-500 dark:text-gray-400',
+  }
+  return colors[colType] || 'text-gray-600 dark:text-gray-400'
+}
+
+interface StepWordRecognitionProps {
+  sessionId: string | null
+  onNext: () => void
+  goToStep: (step: number) => void
+}
+
+export function StepWordRecognition({ sessionId, onNext, goToStep }: StepWordRecognitionProps) {
+  const [gridResult, setGridResult] = useState<GridResult | null>(null)
+  const [detecting, setDetecting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [gtNotes, setGtNotes] = useState('')
+  const [gtSaved, setGtSaved] = useState(false)
+
+  // Step-through labeling state
+  const [activeIndex, setActiveIndex] = useState(0)
+  const [editedEntries, setEditedEntries] = useState<WordEntry[]>([])
+  const [editedCells, setEditedCells] = useState<GridCell[]>([])
+  const [mode, setMode] = useState<'overview' | 'labeling'>('overview')
+  const [ocrEngine, setOcrEngine] = useState<'auto' | 'tesseract' | 'rapid'>('auto')
+  const [usedEngine, setUsedEngine] = useState<string>('')
+  const [pronunciation, setPronunciation] = useState<'british' | 'american'>('british')
+
+  // Streaming progress state
+  const [streamProgress, setStreamProgress] = useState<{ current: number; total: number } | null>(null)
+
+  const enRef = useRef<HTMLInputElement>(null)
+  const tableEndRef = useRef<HTMLDivElement>(null)
+
+  const isVocab = gridResult?.layout === 'vocab'
+
+  useEffect(() => {
+    if (!sessionId) return
+    // Always run fresh detection — word-lookup is fast (~0.03s)
+    // and avoids stale cached results from previous pipeline versions.
+    runAutoDetection()
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId])
+
+  const applyGridResult = (data: GridResult) => {
+    setGridResult(data)
+    setUsedEngine(data.ocr_engine || '')
+    if (data.layout === 'vocab' && data.entries) {
+      initEntries(data.entries)
+    }
+    if (data.cells) {
+      setEditedCells(data.cells.map(c => ({ ...c, status: c.status || 'pending' })))
+    }
+  }
+
+  const initEntries = (entries: WordEntry[]) => {
+    setEditedEntries(entries.map(e => ({ ...e, status: e.status || 'pending' })))
+    setActiveIndex(0)
+  }
+
+  const runAutoDetection = useCallback(async (engine?: string) => {
+    if (!sessionId) return
+    const eng = engine || ocrEngine
+    setDetecting(true)
+    setError(null)
+    setStreamProgress(null)
+    setEditedCells([])
+    setEditedEntries([])
+    setGridResult(null)
+
+    try {
+      // Retry once if initial request fails (e.g. after container restart,
+      // session cache may not be warm yet when navigating via wizard)
+      let res: Response | null = null
+      for (let attempt = 0; attempt < 2; attempt++) {
+        res = await fetch(
+          `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/words?stream=true&engine=${eng}&pronunciation=${pronunciation}`,
+          { method: 'POST' },
+        )
+        if (res.ok) break
+        if (attempt === 0 && (res.status === 400 || res.status === 404)) {
+          // Wait briefly for cache to warm up, then retry
+          await new Promise(r => setTimeout(r, 2000))
+          continue
+        }
+        break
+      }
+      if (!res || !res.ok) {
+        const err = await res?.json().catch(() => ({ detail: res?.statusText })) || { detail: 'Worterkennung fehlgeschlagen' }
+        throw new Error(err.detail || 'Worterkennung fehlgeschlagen')
+      }
+
+      const reader = res.body!.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+      let streamLayout: string | null = null
+      let streamColumnsUsed: GridResult['columns_used'] = []
+      let streamGridShape: GridResult['grid_shape'] | null = null
+      let streamCells: GridCell[] = []
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        buffer += decoder.decode(value, { stream: true })
+
+        // Parse SSE events (separated by \n\n)
+        while (buffer.includes('\n\n')) {
+          const idx = buffer.indexOf('\n\n')
+          const chunk = buffer.slice(0, idx).trim()
+          buffer = buffer.slice(idx + 2)
+
+          if (!chunk.startsWith('data: ')) continue
+          const dataStr = chunk.slice(6) // strip "data: "
+
+          let event: any
+          try {
+            event = JSON.parse(dataStr)
+          } catch {
+            continue
+          }
+
+          if (event.type === 'meta') {
+            streamLayout = event.layout || 'generic'
+            streamGridShape = event.grid_shape || null
+            // Show partial grid result so UI renders structure
+            setGridResult(prev => ({
+              ...prev,
+              layout: event.layout || 'generic',
+              grid_shape: event.grid_shape,
+              columns_used: [],
+              cells: [],
+              summary: { total_cells: event.grid_shape?.total_cells || 0, non_empty_cells: 0, low_confidence: 0 },
+              duration_seconds: 0,
+              ocr_engine: '',
+            } as GridResult))
+          }
+
+          if (event.type === 'columns') {
+            streamColumnsUsed = event.columns_used || []
+            setGridResult(prev => prev ? { ...prev, columns_used: streamColumnsUsed } : prev)
+          }
+
+          if (event.type === 'cell') {
+            const cell: GridCell = { ...event.cell, status: 'pending' }
+            streamCells = [...streamCells, cell]
+            setEditedCells(streamCells)
+            setStreamProgress(event.progress)
+            // Auto-scroll table to bottom
+            setTimeout(() => tableEndRef.current?.scrollIntoView({ behavior: 'smooth', block: 'nearest' }), 16)
+          }
+
+          if (event.type === 'complete') {
+            // Build final GridResult
+            const finalResult: GridResult = {
+              cells: streamCells,
+              grid_shape: streamGridShape || { rows: 0, cols: 0, total_cells: streamCells.length },
+              columns_used: streamColumnsUsed,
+              layout: streamLayout || 'generic',
+              image_width: 0,
+              image_height: 0,
+              duration_seconds: event.duration_seconds || 0,
+              ocr_engine: event.ocr_engine || '',
+              summary: event.summary || {},
+            }
+
+            // If vocab: apply post-processed entries from complete event
+            if (event.vocab_entries) {
+              finalResult.entries = event.vocab_entries
+              finalResult.vocab_entries = event.vocab_entries
+              finalResult.entry_count = event.vocab_entries.length
+            }
+
+            applyGridResult(finalResult)
+            setUsedEngine(event.ocr_engine || '')
+            setStreamProgress(null)
+          }
+        }
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : 'Unbekannter Fehler')
+    } finally {
+      setDetecting(false)
+    }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionId, ocrEngine, pronunciation])
+
+  const handleGroundTruth = useCallback(async (isCorrect: boolean) => {
+    if (!sessionId) return
+    const gt: WordGroundTruth = {
+      is_correct: isCorrect,
+      corrected_entries: isCorrect ? undefined : (isVocab ? editedEntries : undefined),
+      notes: gtNotes || undefined,
+    }
+    try {
+      await fetch(`${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/ground-truth/words`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(gt),
+      })
+      setGtSaved(true)
+    } catch (e) {
+      console.error('Ground truth save failed:', e)
+    }
+  }, [sessionId, gtNotes, editedEntries, isVocab])
+
+  // Vocab mode: update entry field
+  const updateEntry = (index: number, field: 'english' | 'german' | 'example', value: string) => {
+    setEditedEntries(prev => prev.map((e, i) =>
+      i === index ? { ...e, [field]: value, status: 'edited' as const } : e
+    ))
+  }
+
+  // Generic mode: update cell text
+  const updateCell = (cellId: string, value: string) => {
+    setEditedCells(prev => prev.map(c =>
+      c.cell_id === cellId ? { ...c, text: value, status: 'edited' as const } : c
+    ))
+  }
+
+  // Step-through: confirm current row (always cell-based)
+  const confirmEntry = () => {
+    const rowCells = getRowCells(activeIndex)
+    const cellIds = new Set(rowCells.map(c => c.cell_id))
+    setEditedCells(prev => prev.map(c =>
+      cellIds.has(c.cell_id) ? { ...c, status: c.status === 'edited' ? 'edited' : 'confirmed' } : c
+    ))
+    const maxIdx = getUniqueRowCount() - 1
+    if (activeIndex < maxIdx) {
+      setActiveIndex(activeIndex + 1)
+    }
+  }
+
+  // Step-through: skip current row
+  const skipEntry = () => {
+    const rowCells = getRowCells(activeIndex)
+    const cellIds = new Set(rowCells.map(c => c.cell_id))
+    setEditedCells(prev => prev.map(c =>
+      cellIds.has(c.cell_id) ? { ...c, status: 'skipped' as const } : c
+    ))
+    const maxIdx = getUniqueRowCount() - 1
+    if (activeIndex < maxIdx) {
+      setActiveIndex(activeIndex + 1)
+    }
+  }
+
+  // Helper: get unique row indices from cells
+  const getUniqueRowCount = () => {
+    if (!editedCells.length) return 0
+    return new Set(editedCells.map(c => c.row_index)).size
+  }
+
+  // Helper: get cells for a given row index (by position in sorted unique rows)
+  const getRowCells = (rowPosition: number) => {
+    const uniqueRows = [...new Set(editedCells.map(c => c.row_index))].sort((a, b) => a - b)
+    const rowIdx = uniqueRows[rowPosition]
+    return editedCells.filter(c => c.row_index === rowIdx)
+  }
+
+  // Focus english input when active entry changes in labeling mode
+  useEffect(() => {
+    if (mode === 'labeling' && enRef.current) {
+      enRef.current.focus()
+    }
+  }, [activeIndex, mode])
+
+  // Keyboard shortcuts in labeling mode
+  useEffect(() => {
+    if (mode !== 'labeling') return
+    const handler = (e: KeyboardEvent) => {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault()
+        confirmEntry()
+      } else if (e.key === 'ArrowDown' && e.ctrlKey) {
+        e.preventDefault()
+        skipEntry()
+      } else if (e.key === 'ArrowUp' && e.ctrlKey) {
+        e.preventDefault()
+        if (activeIndex > 0) setActiveIndex(activeIndex - 1)
+      }
+    }
+    window.addEventListener('keydown', handler)
+    return () => window.removeEventListener('keydown', handler)
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [mode, activeIndex, editedEntries, editedCells])
+
+  if (!sessionId) {
+    return (
+      <div className="flex flex-col items-center justify-center py-16 text-center">
+        <div className="text-5xl mb-4">🔤</div>
+        <h3 className="text-lg font-medium text-gray-700 dark:text-gray-300 mb-2">
+          Schritt 5: Worterkennung
+        </h3>
+        <p className="text-gray-500 dark:text-gray-400 max-w-md">
+          Bitte zuerst Schritte 1-4 abschliessen.
+        </p>
+      </div>
+    )
+  }
+
+  const overlayUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/words-overlay`
+  const dewarpedUrl = `${KLAUSUR_API}/api/v1/ocr-pipeline/sessions/${sessionId}/image/dewarped`
+
+  const confColor = (conf: number) => {
+    if (conf >= 70) return 'text-green-600 dark:text-green-400'
+    if (conf >= 50) return 'text-yellow-600 dark:text-yellow-400'
+    return 'text-red-600 dark:text-red-400'
+  }
+
+  const statusBadge = (status?: string) => {
+    const map: Record<string, string> = {
+      pending: 'bg-gray-100 dark:bg-gray-700 text-gray-500',
+      confirmed: 'bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-400',
+      edited: 'bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-400',
+      skipped: 'bg-orange-100 dark:bg-orange-900/30 text-orange-700 dark:text-orange-400',
+    }
+    return map[status || 'pending'] || map.pending
+  }
+
+  const summary = gridResult?.summary
+  const columnsUsed = gridResult?.columns_used || []
+  const gridShape = gridResult?.grid_shape
+
+  // Counts for labeling progress (always cell-based)
+  const confirmedRowIds = new Set(
+    editedCells.filter(c => c.status === 'confirmed' || c.status === 'edited').map(c => c.row_index)
+  )
+  const confirmedCount = confirmedRowIds.size
+  const totalCount = getUniqueRowCount()
+
+  // Group cells by row for generic table display
+  const cellsByRow: Map<number, GridCell[]> = new Map()
+  for (const cell of editedCells) {
+    const existing = cellsByRow.get(cell.row_index) || []
+    existing.push(cell)
+    cellsByRow.set(cell.row_index, existing)
+  }
+  const sortedRowIndices = [...cellsByRow.keys()].sort((a, b) => a - b)
+
+  return (
+    <div className="space-y-4">
+      {/* Loading with streaming progress */}
+      {detecting && (
+        <div className="space-y-1">
+          <div className="flex items-center gap-2 text-teal-600 dark:text-teal-400 text-sm">
+            <div className="animate-spin w-4 h-4 border-2 border-teal-500 border-t-transparent rounded-full" />
+            {streamProgress
+              ? `Zelle ${streamProgress.current}/${streamProgress.total} erkannt...`
+              : 'Worterkennung startet...'}
+          </div>
+          {streamProgress && streamProgress.total > 0 && (
+            <div className="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-1.5">
+              <div
+                className="bg-teal-500 h-1.5 rounded-full transition-all duration-150"
+                style={{ width: `${(streamProgress.current / streamProgress.total) * 100}%` }}
+              />
+            </div>
+          )}
+        </div>
+      )}
+
+      {/* Layout badge + Mode toggle */}
+      {gridResult && (
+        <div className="flex items-center gap-2">
+          {/* Layout badge */}
+          <span className={`px-2 py-0.5 rounded text-[10px] uppercase font-semibold ${
+            isVocab
+              ? 'bg-indigo-100 dark:bg-indigo-900/30 text-indigo-700 dark:text-indigo-300'
+              : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400'
+          }`}>
+            {isVocab ? 'Vokabel-Layout' : 'Generisch'}
+          </span>
+
+          {gridShape && (
+            <span className="text-[10px] text-gray-400">
+              {gridShape.rows}×{gridShape.cols} = {gridShape.total_cells} Zellen
+            </span>
+          )}
+
+          <div className="flex-1" />
+
+          <button
+            onClick={() => setMode('overview')}
+            className={`px-3 py-1.5 text-xs rounded-lg font-medium transition-colors ${
+              mode === 'overview'
+                ? 'bg-teal-600 text-white'
+                : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-600'
+            }`}
+          >
+            Uebersicht
+          </button>
+          <button
+            onClick={() => setMode('labeling')}
+            className={`px-3 py-1.5 text-xs rounded-lg font-medium transition-colors ${
+              mode === 'labeling'
+                ? 'bg-teal-600 text-white'
+                : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-300 hover:bg-gray-200 dark:hover:bg-gray-600'
+            }`}
+          >
+            Labeling ({confirmedCount}/{totalCount})
+          </button>
+        </div>
+      )}
+
+      {/* Overview mode */}
+      {mode === 'overview' && (
+        <>
+          {/* Images: overlay vs clean */}
+          <div className="grid grid-cols-2 gap-4">
+            <div>
+              <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+                Mit Grid-Overlay
+              </div>
+              <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+                {gridResult ? (
+                  // eslint-disable-next-line @next/next/no-img-element
+                  <img
+                    src={`${overlayUrl}?t=${Date.now()}`}
+                    alt="Wort-Overlay"
+                    className="w-full h-auto"
+                  />
+                ) : (
+                  <div className="aspect-[3/4] flex items-center justify-center text-gray-400 text-sm">
+                    {detecting ? 'Erkenne Woerter...' : 'Keine Daten'}
+                  </div>
+                )}
+              </div>
+            </div>
+            <div>
+              <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+                Entzerrtes Bild
+              </div>
+              <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900">
+                {/* eslint-disable-next-line @next/next/no-img-element */}
+                <img
+                  src={dewarpedUrl}
+                  alt="Entzerrt"
+                  className="w-full h-auto"
+                />
+              </div>
+            </div>
+          </div>
+
+          {/* Result summary (only after streaming completes) */}
+          {gridResult && summary && !detecting && (
+            <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+              <div className="flex items-center justify-between">
+                <h4 className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                  Ergebnis: {summary.non_empty_cells}/{summary.total_cells} Zellen mit Text
+                  ({sortedRowIndices.length} Zeilen, {columnsUsed.length} Spalten)
+                </h4>
+                <span className="text-xs text-gray-400">
+                  {gridResult.duration_seconds}s
+                </span>
+              </div>
+
+              {/* Summary badges */}
+              <div className="flex gap-2 flex-wrap">
+                <span className="px-2 py-0.5 rounded text-xs font-medium bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-300">
+                  Zellen: {summary.non_empty_cells}/{summary.total_cells}
+                </span>
+                {columnsUsed.map((col, i) => (
+                  <span key={i} className={`px-2 py-0.5 rounded text-xs font-medium bg-gray-100 dark:bg-gray-700 ${colTypeColor(col.type)}`}>
+                    C{col.index}: {colTypeLabel(col.type)}
+                  </span>
+                ))}
+                {summary.low_confidence > 0 && (
+                  <span className="px-2 py-0.5 rounded text-xs font-medium bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300">
+                    Unsicher: {summary.low_confidence}
+                  </span>
+                )}
+              </div>
+
+              {/* Entry/Cell table */}
+              <div className="max-h-80 overflow-y-auto">
+                {/* Unified dynamic table — columns driven by columns_used */}
+                <table className="w-full text-xs">
+                  <thead className="sticky top-0 bg-white dark:bg-gray-800">
+                    <tr className="text-left text-gray-500 dark:text-gray-400 border-b dark:border-gray-700">
+                      <th className="py-1 pr-2 w-12">Zeile</th>
+                      {columnsUsed.map((col, i) => (
+                        <th key={i} className={`py-1 pr-2 ${colTypeColor(col.type)}`}>
+                          {colTypeLabel(col.type)}
+                        </th>
+                      ))}
+                      <th className="py-1 w-12 text-right">Conf</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {sortedRowIndices.map((rowIdx, posIdx) => {
+                      const rowCells = cellsByRow.get(rowIdx) || []
+                      const avgConf = rowCells.length
+                        ? Math.round(rowCells.reduce((s, c) => s + c.confidence, 0) / rowCells.length)
+                        : 0
+                      return (
+                        <tr
+                          key={rowIdx}
+                          className={`border-b dark:border-gray-700/50 ${
+                            posIdx === activeIndex ? 'bg-teal-50 dark:bg-teal-900/20' : ''
+                          }`}
+                          onClick={() => { setActiveIndex(posIdx); setMode('labeling') }}
+                        >
+                          <td className="py-1 pr-2 text-gray-400 font-mono text-[10px]">
+                            R{String(rowIdx).padStart(2, '0')}
+                          </td>
+                          {columnsUsed.map((col) => {
+                            const cell = rowCells.find(c => c.col_index === col.index)
+                            return (
+                              <td key={col.index} className="py-1 pr-2 font-mono text-gray-700 dark:text-gray-300 cursor-pointer">
+                                <MultilineText text={cell?.text || ''} />
+                              </td>
+                            )
+                          })}
+                          <td className={`py-1 text-right font-mono ${confColor(avgConf)}`}>
+                            {avgConf}%
+                          </td>
+                        </tr>
+                      )
+                    })}
+                  </tbody>
+                </table>
+                <div ref={tableEndRef} />
+              </div>
+            </div>
+          )}
+
+          {/* Streaming cell table (shown while detecting, before complete) */}
+          {detecting && editedCells.length > 0 && !gridResult?.summary?.non_empty_cells && (
+            <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+              <h4 className="text-sm font-medium text-gray-700 dark:text-gray-300">
+                Live: {editedCells.length} Zellen erkannt...
+              </h4>
+              <div className="max-h-80 overflow-y-auto">
+                <table className="w-full text-xs">
+                  <thead className="sticky top-0 bg-white dark:bg-gray-800">
+                    <tr className="text-left text-gray-500 dark:text-gray-400 border-b dark:border-gray-700">
+                      <th className="py-1 pr-2 w-12">Zelle</th>
+                      {columnsUsed.map((col, i) => (
+                        <th key={i} className={`py-1 pr-2 ${colTypeColor(col.type)}`}>
+                          {colTypeLabel(col.type)}
+                        </th>
+                      ))}
+                      <th className="py-1 w-12 text-right">Conf</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {(() => {
+                      const liveByRow: Map<number, GridCell[]> = new Map()
+                      for (const cell of editedCells) {
+                        const existing = liveByRow.get(cell.row_index) || []
+                        existing.push(cell)
+                        liveByRow.set(cell.row_index, existing)
+                      }
+                      const liveSorted = [...liveByRow.keys()].sort((a, b) => a - b)
+                      return liveSorted.map(rowIdx => {
+                        const rowCells = liveByRow.get(rowIdx) || []
+                        const avgConf = rowCells.length
+                          ? Math.round(rowCells.reduce((s, c) => s + c.confidence, 0) / rowCells.length)
+                          : 0
+                        return (
+                          <tr key={rowIdx} className="border-b dark:border-gray-700/50 animate-fade-in">
+                            <td className="py-1 pr-2 text-gray-400 font-mono text-[10px]">
+                              R{String(rowIdx).padStart(2, '0')}
+                            </td>
+                            {columnsUsed.map((col) => {
+                              const cell = rowCells.find(c => c.col_index === col.index)
+                              return (
+                                <td key={col.index} className="py-1 pr-2 font-mono text-gray-700 dark:text-gray-300">
+                                  <MultilineText text={cell?.text || ''} />
+                                </td>
+                              )
+                            })}
+                            <td className={`py-1 text-right font-mono ${confColor(avgConf)}`}>
+                              {avgConf}%
+                            </td>
+                          </tr>
+                        )
+                      })
+                    })()}
+                  </tbody>
+                </table>
+                <div ref={tableEndRef} />
+              </div>
+            </div>
+          )}
+        </>
+      )}
+
+      {/* Labeling mode */}
+      {mode === 'labeling' && editedCells.length > 0 && (
+        <div className="grid grid-cols-3 gap-4">
+          {/* Left 2/3: Image with highlighted active row */}
+          <div className="col-span-2">
+            <div className="text-xs font-medium text-gray-500 dark:text-gray-400 mb-1">
+              Zeile {activeIndex + 1} von {getUniqueRowCount()}
+            </div>
+            <div className="border rounded-lg overflow-hidden dark:border-gray-700 bg-gray-50 dark:bg-gray-900 relative">
+              {/* eslint-disable-next-line @next/next/no-img-element */}
+              <img
+                src={`${overlayUrl}?t=${Date.now()}`}
+                alt="Wort-Overlay"
+                className="w-full h-auto"
+              />
+              {/* Highlight overlay for active row */}
+              {(() => {
+                const rowCells = getRowCells(activeIndex)
+                return rowCells.map(cell => (
+                  <div
+                    key={cell.cell_id}
+                    className="absolute border-2 border-yellow-400 bg-yellow-400/10 pointer-events-none"
+                    style={{
+                      left: `${cell.bbox_pct.x}%`,
+                      top: `${cell.bbox_pct.y}%`,
+                      width: `${cell.bbox_pct.w}%`,
+                      height: `${cell.bbox_pct.h}%`,
+                    }}
+                  />
+                ))
+              })()}
+            </div>
+          </div>
+
+          {/* Right 1/3: Editable fields */}
+          <div className="space-y-3">
+            {/* Navigation */}
+            <div className="flex items-center justify-between">
+              <button
+                onClick={() => setActiveIndex(Math.max(0, activeIndex - 1))}
+                disabled={activeIndex === 0}
+                className="px-2 py-1 text-xs border rounded hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600 disabled:opacity-30"
+              >
+                Zurueck
+              </button>
+              <span className="text-xs text-gray-500">
+                {activeIndex + 1} / {getUniqueRowCount()}
+              </span>
+              <button
+                onClick={() => setActiveIndex(Math.min(
+                  getUniqueRowCount() - 1,
+                  activeIndex + 1
+                ))}
+                disabled={activeIndex >= getUniqueRowCount() - 1}
+                className="px-2 py-1 text-xs border rounded hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600 disabled:opacity-30"
+              >
+                Weiter
+              </button>
+            </div>
+
+            {/* Status badge */}
+            <div className="flex items-center gap-2">
+              {(() => {
+                const rowCells = getRowCells(activeIndex)
+                const avgConf = rowCells.length
+                  ? Math.round(rowCells.reduce((s, c) => s + c.confidence, 0) / rowCells.length)
+                  : 0
+                return (
+                  <span className={`text-xs font-mono ${confColor(avgConf)}`}>
+                    {avgConf}% Konfidenz
+                  </span>
+                )
+              })()}
+            </div>
+
+            {/* Editable fields — one per column, driven by columns_used */}
+            <div className="space-y-2">
+              {(() => {
+                const rowCells = getRowCells(activeIndex)
+                return columnsUsed.map((col, colIdx) => {
+                  const cell = rowCells.find(c => c.col_index === col.index)
+                  if (!cell) return null
+                  return (
+                    <div key={col.index}>
+                      <div className="flex items-center gap-1 mb-0.5">
+                        <label className={`text-[10px] font-medium ${colTypeColor(col.type)}`}>
+                          {colTypeLabel(col.type)}
+                        </label>
+                        <span className="text-[9px] text-gray-400">{cell.cell_id}</span>
+                      </div>
+                      {/* Cell crop */}
+                      <div className="border rounded dark:border-gray-700 overflow-hidden bg-white dark:bg-gray-900 h-10 relative mb-1">
+                        <CellCrop imageUrl={dewarpedUrl} bbox={cell.bbox_pct} />
+                      </div>
+                      <textarea
+                        ref={colIdx === 0 ? enRef as any : undefined}
+                        rows={Math.max(1, (cell.text || '').split('\n').length)}
+                        value={cell.text || ''}
+                        onChange={(e) => updateCell(cell.cell_id, e.target.value)}
+                        className="w-full px-2 py-1.5 text-sm border rounded dark:bg-gray-700 dark:border-gray-600 font-mono resize-none"
+                      />
+                    </div>
+                  )
+                })
+              })()}
+            </div>
+
+            {/* Action buttons */}
+            <div className="flex gap-2">
+              <button
+                onClick={confirmEntry}
+                className="flex-1 px-3 py-1.5 text-xs bg-green-600 text-white rounded-lg hover:bg-green-700 font-medium"
+              >
+                Bestaetigen (Enter)
+              </button>
+              <button
+                onClick={skipEntry}
+                className="px-3 py-1.5 text-xs border rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600"
+              >
+                Skip
+              </button>
+            </div>
+
+            {/* Shortcuts hint */}
+            <div className="text-[10px] text-gray-400 space-y-0.5">
+              <div>Enter = Bestaetigen & weiter</div>
+              <div>Ctrl+Down = Ueberspringen</div>
+              <div>Ctrl+Up = Zurueck</div>
+            </div>
+
+            {/* Row list (compact) */}
+            <div className="border-t dark:border-gray-700 pt-2 mt-2">
+              <div className="text-[10px] font-medium text-gray-500 dark:text-gray-400 mb-1">
+                Alle Zeilen
+              </div>
+              <div className="max-h-48 overflow-y-auto space-y-0.5">
+                {sortedRowIndices.map((rowIdx, posIdx) => {
+                  const rowCells = cellsByRow.get(rowIdx) || []
+                  const textParts = rowCells.filter(c => c.text).map(c => c.text.replace(/\n/g, ' '))
+                  return (
+                    <div
+                      key={rowIdx}
+                      onClick={() => setActiveIndex(posIdx)}
+                      className={`flex items-center gap-1 px-2 py-1 rounded text-[10px] cursor-pointer transition-colors ${
+                        posIdx === activeIndex
+                          ? 'bg-teal-50 dark:bg-teal-900/30 border border-teal-200 dark:border-teal-700'
+                          : 'hover:bg-gray-50 dark:hover:bg-gray-700/50'
+                      }`}
+                    >
+                      <span className="w-6 text-right text-gray-400 font-mono">R{String(rowIdx).padStart(2, '0')}</span>
+                      <span className="truncate text-gray-600 dark:text-gray-400 font-mono">
+                        {textParts.join(' \u2192 ') || '\u2014'}
+                      </span>
+                    </div>
+                  )
+                })}
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* Controls */}
+      {gridResult && (
+        <div className="bg-white dark:bg-gray-800 rounded-xl border border-gray-200 dark:border-gray-700 p-4 space-y-3">
+          <div className="flex items-center gap-3 flex-wrap">
+            {/* OCR Engine selector */}
+            <select
+              value={ocrEngine}
+              onChange={(e) => setOcrEngine(e.target.value as 'auto' | 'tesseract' | 'rapid')}
+              className="px-2 py-1.5 text-xs border rounded-lg dark:bg-gray-700 dark:border-gray-600"
+            >
+              <option value="auto">Auto (RapidOCR wenn verfuegbar)</option>
+              <option value="rapid">RapidOCR (ONNX)</option>
+              <option value="tesseract">Tesseract</option>
+            </select>
+
+            {/* Pronunciation selector (only for vocab) */}
+            {isVocab && (
+              <select
+                value={pronunciation}
+                onChange={(e) => setPronunciation(e.target.value as 'british' | 'american')}
+                className="px-2 py-1.5 text-xs border rounded-lg dark:bg-gray-700 dark:border-gray-600"
+              >
+                <option value="british">Britisch (RP)</option>
+                <option value="american">Amerikanisch</option>
+              </select>
+            )}
+
+            <button
+              onClick={() => runAutoDetection()}
+              disabled={detecting}
+              className="px-3 py-1.5 text-xs border rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600 disabled:opacity-50"
+            >
+              Erneut erkennen
+            </button>
+
+            {/* Show which engine was used */}
+            {usedEngine && (
+              <span className={`px-2 py-0.5 rounded text-[10px] uppercase font-semibold ${
+                usedEngine === 'rapid'
+                  ? 'bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-300'
+                  : 'bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-400'
+              }`}>
+                {usedEngine}
+              </span>
+            )}
+
+            <button
+              onClick={() => goToStep(3)}
+              className="px-3 py-1.5 text-xs border rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 dark:border-gray-600 text-orange-600 dark:text-orange-400 border-orange-300 dark:border-orange-700"
+            >
+              Zeilen korrigieren (Step 4)
+            </button>
+
+            <div className="flex-1" />
+
+            {/* Ground truth */}
+            {!gtSaved ? (
+              <>
+                <input
+                  type="text"
+                  placeholder="Notizen (optional)"
+                  value={gtNotes}
+                  onChange={(e) => setGtNotes(e.target.value)}
+                  className="px-2 py-1 text-xs border rounded dark:bg-gray-700 dark:border-gray-600 w-48"
+                />
+                <button
+                  onClick={() => handleGroundTruth(true)}
+                  className="px-3 py-1.5 text-xs bg-green-600 text-white rounded-lg hover:bg-green-700"
+                >
+                  Korrekt
+                </button>
+                <button
+                  onClick={() => handleGroundTruth(false)}
+                  className="px-3 py-1.5 text-xs bg-red-600 text-white rounded-lg hover:bg-red-700"
+                >
+                  Fehlerhaft
+                </button>
+              </>
+            ) : (
+              <span className="text-xs text-green-600 dark:text-green-400">
+                Ground Truth gespeichert
+              </span>
+            )}
+
+            <button
+              onClick={onNext}
+              className="px-4 py-1.5 text-xs bg-teal-600 text-white rounded-lg hover:bg-teal-700 font-medium"
+            >
+              Weiter
+            </button>
+          </div>
+        </div>
+      )}
+
+      {error && (
+        <div className="p-3 bg-red-50 dark:bg-red-900/20 text-red-600 dark:text-red-400 rounded-lg text-sm">
+          {error}
+        </div>
+      )}
+    </div>
+  )
+}
+
+
+/**
+ * CellCrop: Shows a cropped portion of the dewarped image based on percent bbox.
+ * Uses CSS background-image + background-position for efficient cropping.
+ */
+function CellCrop({ imageUrl, bbox }: { imageUrl: string; bbox: { x: number; y: number; w: number; h: number } }) {
+  // Scale factor: how much to zoom into the cell
+  const scaleX = 100 / bbox.w
+  const scaleY = 100 / bbox.h
+  const scale = Math.min(scaleX, scaleY, 8) // Cap zoom at 8x
+
+  return (
+    <div
+      className="w-full h-full"
+      style={{
+        backgroundImage: `url(${imageUrl})`,
+        backgroundSize: `${scale * 100}%`,
+        backgroundPosition: `${-bbox.x * scale}% ${-bbox.y * scale}%`,
+        backgroundRepeat: 'no-repeat',
+      }}
+    />
+  )
+}

admin-lehrer/lib/module-registry.ts

@@ -234,28 +234,6 @@ export const MODULE_REGISTRY: BackendModule[] = [
     },
     priority: 'high'
   },
-  {
-    id: 'llm-compare',
-    name: 'LLM Vergleich',
-    description: 'Vergleich verschiedener KI-Modelle und Provider',
-    category: 'ai',
-    backend: {
-      service: 'python-backend',
-      port: 8000,
-      basePath: '/api/llm',
-      endpoints: [
-        { path: '/providers', method: 'GET', description: 'Verfuegbare Provider' },
-        { path: '/compare', method: 'POST', description: 'Modelle vergleichen' },
-        { path: '/benchmark', method: 'POST', description: 'Benchmark ausfuehren' },
-      ]
-    },
-    frontend: {
-      adminV2Page: '/ai/llm-compare',
-      oldAdminPage: '/admin/llm-compare',
-      status: 'connected'
-    },
-    priority: 'medium'
-  },
   {
     id: 'magic-help',
     name: 'Magic Help (TrOCR)',

admin-lehrer/lib/navigation.ts

@@ -5,7 +5,7 @@
  * All DSGVO and Compliance modules are now consolidated under the SDK.
  */
 
-export type CategoryId = 'compliance-sdk' | 'ai' | 'education' | 'website' | 'sdk-docs'
+export type CategoryId = 'communication' | 'ai' | 'education' | 'website' | 'sdk-docs'
 
 export interface NavModule {
   id: string
@@ -31,23 +31,39 @@ export interface NavCategory {
 
 export const navigation: NavCategory[] = [
   // =========================================================================
-  // Compliance SDK - Alle Datenschutz-, Compliance- und SDK-Module
+  // Kommunikation — Video, Voice, Alerts
   // =========================================================================
   {
-    id: 'compliance-sdk',
-    name: 'Compliance SDK',
-    icon: 'shield',
-    color: '#8b5cf6', // Violet-500
-    colorClass: 'compliance-sdk',
-    description: 'DSGVO, Audit, GRC & SDK-Werkzeuge',
+    id: 'communication',
+    name: 'Kommunikation',
+    icon: 'mail',
+    color: '#f59e0b', // Amber-500
+    colorClass: 'communication',
+    description: 'Video & Chat, Voice Service, Alerts',
     modules: [
       {
-        id: 'catalog-manager',
-        name: 'Katalogverwaltung',
-        href: '/dashboard/catalog-manager',
-        description: 'SDK-Kataloge & Auswahltabellen',
-        purpose: 'Zentrale Verwaltung aller Dropdown- und Auswahltabellen im SDK. Systemkataloge (Risiken, Massnahmen, Vorlagen) anzeigen und benutzerdefinierte Eintraege ergaenzen, bearbeiten und loeschen.',
-        audience: ['DSB', 'Compliance Officer', 'Administratoren'],
+        id: 'video-chat',
+        name: 'Video & Chat',
+        href: '/communication/video-chat',
+        description: 'Matrix & Jitsi Monitoring',
+        purpose: 'Dashboard fuer Matrix Synapse und Jitsi Meet. Service-Status, aktive Meetings, Traffic-Analyse und Ressourcen-Empfehlungen.',
+        audience: ['Admins', 'DevOps'],
+      },
+      {
+        id: 'voice-service',
+        name: 'Voice Service',
+        href: '/communication/matrix',
+        description: 'PersonaPlex-7B & TaskOrchestrator',
+        purpose: 'Voice-First Interface Konfiguration und Architektur-Dokumentation. Live Demo, Task States, Intents und DSGVO-Informationen.',
+        audience: ['Entwickler', 'Admins'],
+      },
+      {
+        id: 'alerts',
+        name: 'Alerts Monitoring',
+        href: '/communication/alerts',
+        description: 'Google Alerts & Feed-Ueberwachung',
+        purpose: 'Google Alerts und RSS-Feeds fuer relevante Neuigkeiten ueberwachen. Topics, Regeln, Relevanz-Profil und Digest-Generierung.',
+        audience: ['Marketing', 'Admins'],
       },
     ],
   },
@@ -108,16 +124,6 @@ export const navigation: NavCategory[] = [
       // -----------------------------------------------------------------------
       // KI-Werkzeuge: Standalone-Tools fuer Entwicklung & QA
       // -----------------------------------------------------------------------
-      {
-        id: 'llm-compare',
-        name: 'LLM Vergleich',
-        href: '/ai/llm-compare',
-        description: 'KI-Provider Vergleich',
-        purpose: 'Vergleichen Sie verschiedene LLM-Anbieter (Ollama, OpenAI, Anthropic) hinsichtlich Qualitaet, Geschwindigkeit und Kosten. Standalone-Werkzeug fuer Modell-Evaluation.',
-        audience: ['Entwickler', 'Data Scientists'],
-        oldAdminPath: '/admin/llm-compare',
-        subgroup: 'KI-Werkzeuge',
-      },
       {
         id: 'ocr-compare',
         name: 'OCR Vergleich',
@@ -127,6 +133,15 @@ export const navigation: NavCategory[] = [
         audience: ['Entwickler', 'Data Scientists', 'Lehrer'],
         subgroup: 'KI-Werkzeuge',
       },
+      {
+        id: 'ocr-pipeline',
+        name: 'OCR Pipeline',
+        href: '/ai/ocr-pipeline',
+        description: 'Schrittweise Seitenrekonstruktion',
+        purpose: 'Schrittweise Seitenrekonstruktion: Scan begradigen, Spalten erkennen, Woerter lokalisieren und die Seite Wort fuer Wort nachbauen. 6-Schritt-Pipeline mit Ground Truth Validierung.',
+        audience: ['Entwickler', 'Data Scientists'],
+        subgroup: 'KI-Werkzeuge',
+      },
       {
         id: 'test-quality',
         name: 'Test Quality (BQAS)',

admin-lehrer/lib/roles.ts

@@ -23,7 +23,7 @@ export const roles: Role[] = [
     name: 'Entwickler',
     description: 'Voller Zugriff auf alle Bereiche',
     icon: 'code',
-    visibleCategories: ['compliance-sdk', 'ai', 'education', 'website'],
+    visibleCategories: ['communication', 'ai', 'education', 'website'],
     color: 'bg-primary-100 border-primary-300 text-primary-700',
   },
   {
@@ -31,7 +31,7 @@ export const roles: Role[] = [
     name: 'Manager',
     description: 'Executive Uebersicht',
     icon: 'chart',
-    visibleCategories: ['compliance-sdk', 'website'],
+    visibleCategories: ['communication', 'website'],
     color: 'bg-blue-100 border-blue-300 text-blue-700',
   },
   {
@@ -39,7 +39,7 @@ export const roles: Role[] = [
     name: 'Auditor',
     description: 'Compliance Pruefung',
     icon: 'clipboard',
-    visibleCategories: ['compliance-sdk'],
+    visibleCategories: ['communication'],
     color: 'bg-amber-100 border-amber-300 text-amber-700',
   },
   {
@@ -47,7 +47,7 @@ export const roles: Role[] = [
     name: 'DSB',
     description: 'Datenschutzbeauftragter',
     icon: 'shield',
-    visibleCategories: ['compliance-sdk'],
+    visibleCategories: ['communication'],
     color: 'bg-purple-100 border-purple-300 text-purple-700',
   },
 ]

admin-lehrer/next.config.js

@@ -2,6 +2,8 @@
 const nextConfig = {
   output: 'standalone',
   reactStrictMode: true,
+  // Force unique build ID to bust browser caches on each deploy
+  generateBuildId: () => `build-${Date.now()}`,
   // TODO: Remove after fixing type incompatibilities from restore
   typescript: {
     ignoreBuildErrors: true,

admin-lehrer/package-lock.json

@@ -8,6 +8,7 @@
       "name": "breakpilot-admin-v2",
       "version": "1.0.0",
       "dependencies": {
+        "bpmn-js": "^18.0.1",
         "jspdf": "^4.1.0",
         "jszip": "^3.10.1",
         "lucide-react": "^0.468.0",
@@ -15,6 +16,7 @@
         "react": "^18.3.1",
         "react-dom": "^18.3.1",
         "reactflow": "^11.11.4",
+        "recharts": "^2.15.0",
         "uuid": "^13.0.0"
       },
       "devDependencies": {
@@ -428,6 +430,16 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bpmn-io/diagram-js-ui": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@bpmn-io/diagram-js-ui/-/diagram-js-ui-0.2.3.tgz",
+      "integrity": "sha512-OGyjZKvGK8tHSZ0l7RfeKhilGoOGtFDcoqSGYkX0uhFlo99OVZ9Jn1K7TJGzcE9BdKwvA5Y5kGqHEhdTxHvFfw==",
+      "license": "MIT",
+      "dependencies": {
+        "htm": "^3.1.1",
+        "preact": "^10.11.2"
+      }
+    },
     "node_modules/@csstools/color-helpers": {
       "version": "5.1.0",
       "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
@@ -2996,6 +3008,39 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/bpmn-js": {
+      "version": "18.12.0",
+      "resolved": "https://registry.npmjs.org/bpmn-js/-/bpmn-js-18.12.0.tgz",
+      "integrity": "sha512-Dg2O+r7jpBwLgWGpManc7P4ZfZQfxTVi2xNtXR3Q2G5Hx1RVYVFoNsQED8+FPCgjy6m7ZQbxKP1sjCJt5rbtBg==",
+      "license": "SEE LICENSE IN LICENSE",
+      "dependencies": {
+        "bpmn-moddle": "^10.0.0",
+        "diagram-js": "^15.9.0",
+        "diagram-js-direct-editing": "^3.3.0",
+        "ids": "^3.0.0",
+        "inherits-browser": "^0.1.0",
+        "min-dash": "^5.0.0",
+        "min-dom": "^5.2.0",
+        "tiny-svg": "^4.1.4"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/bpmn-moddle": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/bpmn-moddle/-/bpmn-moddle-10.0.0.tgz",
+      "integrity": "sha512-vXePD5jkatcILmM3zwJG/m6IIHIghTGB7WvgcdEraEw8E8VdJHrTgrvBUhbzqaXJpnsGQz15QS936xeBY6l9aA==",
+      "license": "MIT",
+      "dependencies": {
+        "min-dash": "^5.0.0",
+        "moddle": "^8.0.0",
+        "moddle-xml": "^12.0.0"
+      },
+      "engines": {
+        "node": ">= 20.12"
+      }
+    },
     "node_modules/braces": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
@@ -3153,6 +3198,15 @@
       "integrity": "sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==",
       "license": "MIT"
     },
+    "node_modules/clsx": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+      "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/commander": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
@@ -3262,9 +3316,20 @@
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
       "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
-      "devOptional": true,
       "license": "MIT"
     },
+    "node_modules/d3-array": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz",
+      "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==",
+      "license": "ISC",
+      "dependencies": {
+        "internmap": "1 - 2"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/d3-color": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
@@ -3305,6 +3370,15 @@
         "node": ">=12"
       }
     },
+    "node_modules/d3-format": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz",
+      "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/d3-interpolate": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
@@ -3317,6 +3391,31 @@
         "node": ">=12"
       }
     },
+    "node_modules/d3-path": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz",
+      "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-scale": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz",
+      "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2.10.0 - 3",
+        "d3-format": "1 - 3",
+        "d3-interpolate": "1.2.0 - 3",
+        "d3-time": "2.1.1 - 3",
+        "d3-time-format": "2 - 4"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/d3-selection": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
@@ -3326,6 +3425,42 @@
         "node": ">=12"
       }
     },
+    "node_modules/d3-shape": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz",
+      "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-path": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz",
+      "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-array": "2 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/d3-time-format": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz",
+      "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==",
+      "license": "ISC",
+      "dependencies": {
+        "d3-time": "1 - 3"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/d3-timer": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
@@ -3409,6 +3544,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/decimal.js-light": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz",
+      "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==",
+      "license": "MIT"
+    },
     "node_modules/dequal": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
@@ -3429,6 +3570,51 @@
         "node": ">=8"
       }
     },
+    "node_modules/diagram-js": {
+      "version": "15.9.1",
+      "resolved": "https://registry.npmjs.org/diagram-js/-/diagram-js-15.9.1.tgz",
+      "integrity": "sha512-2JsGmyeTo6o39beq2e/UkTfMopQSM27eXBUzbYQ+1m5VhEnQDkcjcrnRCjcObLMzzXSE/LSJyYhji90sqBFodQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@bpmn-io/diagram-js-ui": "^0.2.3",
+        "clsx": "^2.1.1",
+        "didi": "^11.0.0",
+        "inherits-browser": "^0.1.0",
+        "min-dash": "^5.0.0",
+        "min-dom": "^5.2.0",
+        "object-refs": "^0.4.0",
+        "path-intersection": "^4.1.0",
+        "tiny-svg": "^4.1.4"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/diagram-js-direct-editing": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/diagram-js-direct-editing/-/diagram-js-direct-editing-3.3.0.tgz",
+      "integrity": "sha512-EjXYb35J3qBU8lLz5U81hn7wNykVmF7U5DXZ7BvPok2IX7rmPz+ZyaI5AEMiqaC6lpSnHqPxFcPgKEiJcAiv5w==",
+      "license": "MIT",
+      "dependencies": {
+        "min-dash": "^5.0.0",
+        "min-dom": "^5.2.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "peerDependencies": {
+        "diagram-js": "*"
+      }
+    },
+    "node_modules/didi": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/didi/-/didi-11.0.0.tgz",
+      "integrity": "sha512-PzCfRzQttvFpVcYMbSF7h8EsWjeJpVjWH4qDhB5LkMi1ILvHq4Ob0vhM2wLFziPkbUBi+PAo7ODbe2sacR7nJQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.12"
+      }
+    },
     "node_modules/didyoumean": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
@@ -3451,6 +3637,28 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/dom-helpers": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+      "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.8.7",
+        "csstype": "^3.0.2"
+      }
+    },
+    "node_modules/domify": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/domify/-/domify-3.0.0.tgz",
+      "integrity": "sha512-bs2yO68JDFOm6rKv8f0EnrM2cENduhRkpqOtt/s5l5JBA/eqGBZCzLPmdYoHtJ6utgLGgcBajFsEQbl12pT0lQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/dompurify": {
       "version": "3.3.1",
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.1.tgz",
@@ -3550,6 +3758,12 @@
         "@types/estree": "^1.0.0"
       }
     },
+    "node_modules/eventemitter3": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz",
+      "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
+      "license": "MIT"
+    },
     "node_modules/expect-type": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.3.0.tgz",
@@ -3560,6 +3774,15 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/fast-equals": {
+      "version": "5.4.0",
+      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.4.0.tgz",
+      "integrity": "sha512-jt2DW/aNFNwke7AUd+Z+e6pz39KO5rzdbbFCg2sGafS4mk13MI7Z8O5z9cADNn5lhGODIgLwug6TZO2ctf7kcw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
     "node_modules/fast-glob": {
       "version": "3.3.3",
       "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
@@ -3705,6 +3928,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/htm": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/htm/-/htm-3.1.1.tgz",
+      "integrity": "sha512-983Vyg8NwUE7JkZ6NmOqpCZ+sh1bKv2iYTlUkzlWmA5JD2acKoxd4KVxbMmxX/85mtfdnDmTFoNKcg5DGAvxNQ==",
+      "license": "Apache-2.0"
+    },
     "node_modules/html-encoding-sniffer": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",
@@ -3760,6 +3989,15 @@
         "node": ">= 14"
       }
     },
+    "node_modules/ids": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ids/-/ids-3.0.1.tgz",
+      "integrity": "sha512-mr0zAgpgA/hzCrHB0DnoTG6xZjNC3ABs4eaksXrpVtfaDatA2SVdDb1ZPLjmKjqzp4kexQRuHXwDWQILVK8FZQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.12"
+      }
+    },
     "node_modules/immediate": {
       "version": "3.0.6",
       "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
@@ -3782,6 +4020,21 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
+    "node_modules/inherits-browser": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/inherits-browser/-/inherits-browser-0.1.0.tgz",
+      "integrity": "sha512-CJHHvW3jQ6q7lzsXPpapLdMx5hDpSF3FSh45pwsj6bKxJJ8Nl8v43i5yXnr3BdfOimGHKyniewQtnAIp3vyJJw==",
+      "license": "ISC"
+    },
+    "node_modules/internmap": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
+      "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/iobuffer": {
       "version": "5.4.0",
       "resolved": "https://registry.npmjs.org/iobuffer/-/iobuffer-5.4.0.tgz",
@@ -4009,6 +4262,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/lodash": {
+      "version": "4.17.23",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+      "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+      "license": "MIT"
+    },
     "node_modules/loose-envify": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
@@ -4092,6 +4351,22 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/min-dash": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/min-dash/-/min-dash-5.0.0.tgz",
+      "integrity": "sha512-EGuoBnVL7/Fnv2sqakpX5WGmZehZ3YMmLayT7sM8E9DRU74kkeyMg4Rik1lsOkR2GbFNeBca4/L+UfU6gF0Edw==",
+      "license": "MIT"
+    },
+    "node_modules/min-dom": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/min-dom/-/min-dom-5.3.0.tgz",
+      "integrity": "sha512-0w5FEBgPAyHhmFojW3zxd7we3D+m5XYS3E/06OyvxmbHJoiQVa4Nagj6RWvoAKYRw5xth6cP5TMePc5cR1M9hA==",
+      "license": "MIT",
+      "dependencies": {
+        "domify": "^3.0.0",
+        "min-dash": "^5.0.0"
+      }
+    },
     "node_modules/min-indent": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
@@ -4102,6 +4377,31 @@
         "node": ">=4"
       }
     },
+    "node_modules/moddle": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/moddle/-/moddle-8.1.0.tgz",
+      "integrity": "sha512-dBddc1CNuZHgro8nQWwfPZ2BkyLWdnxoNpPu9d+XKPN96DAiiBOeBw527ft++ebDuFez5PMdaR3pgUgoOaUGrA==",
+      "license": "MIT",
+      "dependencies": {
+        "min-dash": "^5.0.0"
+      }
+    },
+    "node_modules/moddle-xml": {
+      "version": "12.0.0",
+      "resolved": "https://registry.npmjs.org/moddle-xml/-/moddle-xml-12.0.0.tgz",
+      "integrity": "sha512-NJc2+sCe4tvuGlaUBcoZcYf6j9f+z+qxHOyGm/LB3ZrlJXVPPHoBTg/KXgDRCufdBJhJ3AheFs3QU/abABNzRg==",
+      "license": "MIT",
+      "dependencies": {
+        "min-dash": "^5.0.0",
+        "saxen": "^11.0.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "moddle": ">= 6.2.0"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -4240,7 +4540,6 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
       "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -4256,6 +4555,15 @@
         "node": ">= 6"
       }
     },
+    "node_modules/object-refs": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/object-refs/-/object-refs-0.4.0.tgz",
+      "integrity": "sha512-6kJqKWryKZmtte6QYvouas0/EIJKPI1/MMIuRsiBlNuhIMfqYTggzX2F1AJ2+cDs288xyi9GL7FyasHINR98BQ==",
+      "license": "MIT",
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/obug": {
       "version": "2.1.1",
       "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
@@ -4286,6 +4594,15 @@
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/path-intersection": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/path-intersection/-/path-intersection-4.1.0.tgz",
+      "integrity": "sha512-urUP6WvhnxbHPdHYl6L7Yrc6+1ny6uOFKPCzPxTSUSYGHG0o94RmI7SvMMaScNAM5RtTf08bg4skc6/kjfne3A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.20"
+      }
+    },
     "node_modules/path-parse": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
@@ -4555,6 +4872,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/preact": {
+      "version": "10.28.4",
+      "resolved": "https://registry.npmjs.org/preact/-/preact-10.28.4.tgz",
+      "integrity": "sha512-uKFfOHWuSNpRFVTnljsCluEFq57OKT+0QdOiQo8XWnQ/pSvg7OpX5eNOejELXJMWy+BwM2nobz0FkvzmnpCNsQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/preact"
+      }
+    },
     "node_modules/pretty-format": {
       "version": "27.5.1",
       "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
@@ -4577,6 +4904,23 @@
       "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
       "license": "MIT"
     },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/prop-types/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+      "license": "MIT"
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
@@ -4661,6 +5005,37 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/react-smooth": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/react-smooth/-/react-smooth-4.0.4.tgz",
+      "integrity": "sha512-gnGKTpYwqL0Iii09gHobNolvX4Kiq4PKx6eWBCYYix+8cdw+cGo3do906l1NBPKkSWx1DghC1dlWG9L2uGd61Q==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-equals": "^5.0.1",
+        "prop-types": "^15.8.1",
+        "react-transition-group": "^4.4.5"
+      },
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/react-transition-group": {
+      "version": "4.4.5",
+      "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
+      "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@babel/runtime": "^7.5.5",
+        "dom-helpers": "^5.0.1",
+        "loose-envify": "^1.4.0",
+        "prop-types": "^15.6.2"
+      },
+      "peerDependencies": {
+        "react": ">=16.6.0",
+        "react-dom": ">=16.6.0"
+      }
+    },
     "node_modules/reactflow": {
       "version": "11.11.4",
       "resolved": "https://registry.npmjs.org/reactflow/-/reactflow-11.11.4.tgz",
@@ -4717,6 +5092,44 @@
         "node": ">=8.10.0"
       }
     },
+    "node_modules/recharts": {
+      "version": "2.15.4",
+      "resolved": "https://registry.npmjs.org/recharts/-/recharts-2.15.4.tgz",
+      "integrity": "sha512-UT/q6fwS3c1dHbXv2uFgYJ9BMFHu3fwnd7AYZaEQhXuYQ4hgsxLvsUXzGdKeZrW5xopzDCvuA2N41WJ88I7zIw==",
+      "license": "MIT",
+      "dependencies": {
+        "clsx": "^2.0.0",
+        "eventemitter3": "^4.0.1",
+        "lodash": "^4.17.21",
+        "react-is": "^18.3.1",
+        "react-smooth": "^4.0.4",
+        "recharts-scale": "^0.4.4",
+        "tiny-invariant": "^1.3.1",
+        "victory-vendor": "^36.6.8"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "react": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
+        "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/recharts-scale": {
+      "version": "0.4.5",
+      "resolved": "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.4.5.tgz",
+      "integrity": "sha512-kivNFO+0OcUNu7jQquLXAxz1FIwZj8nrj+YkOKc5694NbjCvcT6aSZiIzNzd2Kul4o4rTto8QVR9lMNtxD4G1w==",
+      "license": "MIT",
+      "dependencies": {
+        "decimal.js-light": "^2.4.1"
+      }
+    },
+    "node_modules/recharts/node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "license": "MIT"
+    },
     "node_modules/redent": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
@@ -4865,6 +5278,15 @@
       "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
       "license": "MIT"
     },
+    "node_modules/saxen": {
+      "version": "11.0.2",
+      "resolved": "https://registry.npmjs.org/saxen/-/saxen-11.0.2.tgz",
+      "integrity": "sha512-WDb4gqac8uiJzOdOdVpr9NWh9NrJMm7Brn5GX2Poj+mjE/QTXqYQENr8T/mom54dDDgbd3QjwTg23TRHYiWXRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.12"
+      }
+    },
     "node_modules/saxes": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
@@ -5160,6 +5582,21 @@
         "node": ">=0.8"
       }
     },
+    "node_modules/tiny-invariant": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz",
+      "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==",
+      "license": "MIT"
+    },
+    "node_modules/tiny-svg": {
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/tiny-svg/-/tiny-svg-4.1.4.tgz",
+      "integrity": "sha512-cBaEACCbouYrQc9RG+eTXnPYosX1Ijqty/I6DdXovwDd89Pwu4jcmpOR7BuFEF9YCcd7/AWwasE0207WMK7hdw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
     "node_modules/tinybench": {
       "version": "2.9.0",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
@@ -5407,6 +5844,28 @@
         "uuid": "dist-node/bin/uuid"
       }
     },
+    "node_modules/victory-vendor": {
+      "version": "36.9.2",
+      "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-36.9.2.tgz",
+      "integrity": "sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==",
+      "license": "MIT AND ISC",
+      "dependencies": {
+        "@types/d3-array": "^3.0.3",
+        "@types/d3-ease": "^3.0.0",
+        "@types/d3-interpolate": "^3.0.1",
+        "@types/d3-scale": "^4.0.2",
+        "@types/d3-shape": "^3.1.0",
+        "@types/d3-time": "^3.0.0",
+        "@types/d3-timer": "^3.0.0",
+        "d3-array": "^3.1.6",
+        "d3-ease": "^3.0.1",
+        "d3-interpolate": "^3.0.1",
+        "d3-scale": "^4.0.2",
+        "d3-shape": "^3.1.0",
+        "d3-time": "^3.0.0",
+        "d3-timer": "^3.0.1"
+      }
+    },
     "node_modules/vite": {
       "version": "7.3.1",
       "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",

admin-lehrer/package.json

@@ -18,7 +18,6 @@
     "test:all": "vitest run && playwright test --project=chromium"
   },
   "dependencies": {
-    "bpmn-js": "^18.0.1",
     "jspdf": "^4.1.0",
     "jszip": "^3.10.1",
     "lucide-react": "^0.468.0",
@@ -27,6 +26,7 @@
     "react-dom": "^18.3.1",
     "reactflow": "^11.11.4",
     "recharts": "^2.15.0",
+    "fabric": "^6.0.0",
     "uuid": "^13.0.0"
   },
   "devDependencies": {

admin-lehrer/types/ai-modules.ts

@@ -119,13 +119,6 @@ export const AI_PIPELINE_MODULES: AIModuleLink[] = [
  * Kein direkter Datenfluss zur Pipeline.
  */
 export const AI_TOOLS_MODULES: AIModuleLink[] = [
-  {
-    id: 'llm-compare',
-    name: 'LLM Vergleich',
-    href: '/ai/llm-compare',
-    description: 'KI-Provider Vergleich & Evaluation',
-    icon: '⚖️',
-  },
   {
     id: 'test-quality',
     name: 'Test Quality (BQAS)',
@@ -212,27 +205,7 @@ export const AI_MODULE_RELATIONS: Record<string, AIModuleLink[]> = {
     },
   ],
   // KI-Werkzeuge Relations (Standalone-Tools)
-  'llm-compare': [
-    {
-      id: 'test-quality',
-      name: 'Test Quality (BQAS)',
-      href: '/ai/test-quality',
-      description: 'Golden Suite & Synthetic Tests',
-    },
-    {
-      id: 'agents',
-      name: 'Agent Management',
-      href: '/ai/agents',
-      description: 'Multi-Agent System',
-    },
-  ],
   'test-quality': [
-    {
-      id: 'llm-compare',
-      name: 'LLM Vergleich',
-      href: '/ai/llm-compare',
-      description: 'KI-Provider vergleichen',
-    },
     {
       id: 'klausur-korrektur',
       name: 'Klausur-Korrektur',

docker-compose.yml

@@ -15,11 +15,24 @@ volumes:
   eh_uploads:
   ocr_labeling:
   paddle_models:
+  lighton_models:
   paddleocr_models:
   transcription_models:
   transcription_temp:
   lehrer_backend_data:
   opensearch_data:
+  # Communication (Jitsi + Matrix)
+  synapse_data:
+  synapse_db_data:
+  jitsi_web_config:
+  jitsi_web_crontabs:
+  jitsi_transcripts:
+  jitsi_prosody_config:
+  jitsi_prosody_plugins:
+  jitsi_jicofo_config:
+  jitsi_jvb_config:
+  # Voice
+  voice_session_data:
 
 services:
 
@@ -154,7 +167,6 @@ services:
       CONSENT_SERVICE_URL: http://bp-core-consent-service:8081
       KLAUSUR_SERVICE_URL: http://klausur-service:8086
       TROCR_SERVICE_URL: http://paddleocr-service:8095
-      CAMUNDA_URL: http://bp-core-camunda:8080
       VALKEY_URL: redis://bp-core-valkey:6379/0
       SESSION_TTL_HOURS: ${SESSION_TTL_HOURS:-24}
       ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
@@ -209,6 +221,7 @@ services:
       - eh_uploads:/app/eh-uploads
       - ocr_labeling:/app/ocr-labeling
       - paddle_models:/root/.paddlex
+      - lighton_models:/root/.cache/huggingface
     environment:
       JWT_SECRET: ${JWT_SECRET:-your-super-secret-jwt-key-change-in-production}
       BACKEND_URL: http://backend-lehrer:8001
@@ -231,6 +244,12 @@ services:
       OLLAMA_DEFAULT_MODEL: ${OLLAMA_DEFAULT_MODEL:-llama3.2}
       OLLAMA_VISION_MODEL: ${OLLAMA_VISION_MODEL:-llama3.2-vision}
       OLLAMA_CORRECTION_MODEL: ${OLLAMA_CORRECTION_MODEL:-llama3.2}
+      OLLAMA_REVIEW_MODEL: ${OLLAMA_REVIEW_MODEL:-qwen3:0.6b}
+      OLLAMA_REVIEW_BATCH_SIZE: ${OLLAMA_REVIEW_BATCH_SIZE:-20}
+      REVIEW_ENGINE: ${REVIEW_ENGINE:-spell}
+      OCR_ENGINE: ${OCR_ENGINE:-auto}
+      OLLAMA_HTR_MODEL: ${OLLAMA_HTR_MODEL:-qwen2.5vl:32b}
+      HTR_FALLBACK_MODEL: ${HTR_FALLBACK_MODEL:-trocr-large}
       RAG_SERVICE_URL: http://bp-core-rag-service:8097
     extra_hosts:
       - "host.docker.internal:host-gateway"
@@ -373,6 +392,216 @@ services:
     networks:
       - breakpilot-network
 
+  # =========================================================
+  # VOICE SERVICE
+  # =========================================================
+  voice-service:
+    build:
+      context: ./voice-service
+      dockerfile: Dockerfile
+    container_name: bp-lehrer-voice-service
+    platform: linux/arm64
+    expose:
+      - "8091"
+    volumes:
+      - voice_session_data:/app/data/sessions
+    environment:
+      PORT: 8091
+      DATABASE_URL: postgresql://${POSTGRES_USER:-breakpilot}:${POSTGRES_PASSWORD:-breakpilot123}@bp-core-postgres:5432/${POSTGRES_DB:-breakpilot_db}
+      VALKEY_URL: redis://bp-core-valkey:6379/0
+      KLAUSUR_SERVICE_URL: http://klausur-service:8086
+      OLLAMA_BASE_URL: ${OLLAMA_BASE_URL:-http://host.docker.internal:11434}
+      OLLAMA_VOICE_MODEL: ${OLLAMA_VOICE_MODEL:-llama3.2}
+      ENVIRONMENT: ${ENVIRONMENT:-development}
+      JWT_SECRET: ${JWT_SECRET:-your-super-secret-jwt-key-change-in-production}
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    depends_on:
+      core-health-check:
+        condition: service_completed_successfully
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://127.0.0.1:8091/health"]
+      interval: 30s
+      timeout: 10s
+      start_period: 60s
+      retries: 3
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
+  # =========================================================
+  # COMMUNICATION: Jitsi Meet
+  # =========================================================
+  jitsi-web:
+    image: jitsi/web:stable-9823
+    container_name: bp-lehrer-jitsi-web
+    expose:
+      - "80"
+    volumes:
+      - jitsi_web_config:/config
+      - jitsi_web_crontabs:/var/spool/cron/crontabs
+      - jitsi_transcripts:/usr/share/jitsi-meet/transcripts
+    environment:
+      ENABLE_XMPP_WEBSOCKET: "true"
+      ENABLE_COLIBRI_WEBSOCKET: "true"
+      XMPP_DOMAIN: ${XMPP_DOMAIN:-meet.jitsi}
+      XMPP_BOSH_URL_BASE: http://jitsi-xmpp:5280
+      XMPP_MUC_DOMAIN: ${XMPP_MUC_DOMAIN:-muc.meet.jitsi}
+      XMPP_GUEST_DOMAIN: ${XMPP_GUEST_DOMAIN:-guest.meet.jitsi}
+      TZ: ${TZ:-Europe/Berlin}
+      PUBLIC_URL: ${JITSI_PUBLIC_URL:-https://macmini:8443}
+      JICOFO_AUTH_USER: focus
+      ENABLE_AUTH: ${JITSI_ENABLE_AUTH:-false}
+      ENABLE_GUESTS: "true"
+      ENABLE_RECORDING: "true"
+      ENABLE_LIVESTREAMING: "false"
+      DISABLE_HTTPS: "true"
+      APP_NAME: "BreakPilot Meet"
+      NATIVE_APP_NAME: "BreakPilot Meet"
+      PROVIDER_NAME: "BreakPilot"
+    depends_on:
+      - jitsi-xmpp
+    networks:
+      breakpilot-network:
+        aliases:
+          - meet.jitsi
+
+  jitsi-xmpp:
+    image: jitsi/prosody:stable-9823
+    container_name: bp-lehrer-jitsi-xmpp
+    volumes:
+      - jitsi_prosody_config:/config
+      - jitsi_prosody_plugins:/prosody-plugins-custom
+    environment:
+      XMPP_DOMAIN: ${XMPP_DOMAIN:-meet.jitsi}
+      XMPP_AUTH_DOMAIN: ${XMPP_AUTH_DOMAIN:-auth.meet.jitsi}
+      XMPP_MUC_DOMAIN: ${XMPP_MUC_DOMAIN:-muc.meet.jitsi}
+      XMPP_INTERNAL_MUC_DOMAIN: ${XMPP_INTERNAL_MUC_DOMAIN:-internal-muc.meet.jitsi}
+      XMPP_GUEST_DOMAIN: ${XMPP_GUEST_DOMAIN:-guest.meet.jitsi}
+      XMPP_RECORDER_DOMAIN: ${XMPP_RECORDER_DOMAIN:-recorder.meet.jitsi}
+      XMPP_CROSS_DOMAIN: "true"
+      TZ: ${TZ:-Europe/Berlin}
+      JICOFO_AUTH_USER: focus
+      JICOFO_AUTH_PASSWORD: ${JICOFO_AUTH_PASSWORD:-jicofo_secret}
+      JVB_AUTH_USER: jvb
+      JVB_AUTH_PASSWORD: ${JVB_AUTH_PASSWORD:-jvb_secret}
+      JIBRI_XMPP_USER: jibri
+      JIBRI_XMPP_PASSWORD: ${JIBRI_XMPP_PASSWORD:-jibri_secret}
+      JIBRI_RECORDER_USER: recorder
+      JIBRI_RECORDER_PASSWORD: ${JIBRI_RECORDER_PASSWORD:-recorder_secret}
+      LOG_LEVEL: ${XMPP_LOG_LEVEL:-warn}
+      PUBLIC_URL: ${JITSI_PUBLIC_URL:-https://macmini:8443}
+      ENABLE_AUTH: ${JITSI_ENABLE_AUTH:-false}
+      ENABLE_GUESTS: "true"
+    restart: unless-stopped
+    networks:
+      breakpilot-network:
+        aliases:
+          - xmpp.meet.jitsi
+
+  jitsi-jicofo:
+    image: jitsi/jicofo:stable-9823
+    container_name: bp-lehrer-jitsi-jicofo
+    volumes:
+      - jitsi_jicofo_config:/config
+    environment:
+      XMPP_DOMAIN: ${XMPP_DOMAIN:-meet.jitsi}
+      XMPP_AUTH_DOMAIN: ${XMPP_AUTH_DOMAIN:-auth.meet.jitsi}
+      XMPP_MUC_DOMAIN: ${XMPP_MUC_DOMAIN:-muc.meet.jitsi}
+      XMPP_INTERNAL_MUC_DOMAIN: ${XMPP_INTERNAL_MUC_DOMAIN:-internal-muc.meet.jitsi}
+      XMPP_SERVER: jitsi-xmpp
+      JICOFO_AUTH_USER: focus
+      JICOFO_AUTH_PASSWORD: ${JICOFO_AUTH_PASSWORD:-jicofo_secret}
+      TZ: ${TZ:-Europe/Berlin}
+      ENABLE_AUTH: ${JITSI_ENABLE_AUTH:-false}
+      AUTH_TYPE: internal
+      ENABLE_AUTO_OWNER: "true"
+    depends_on:
+      - jitsi-xmpp
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
+  jitsi-jvb:
+    image: jitsi/jvb:stable-9823
+    container_name: bp-lehrer-jitsi-jvb
+    ports:
+      - "10000:10000/udp"
+      - "8080:8080"
+    volumes:
+      - jitsi_jvb_config:/config
+    environment:
+      XMPP_DOMAIN: ${XMPP_DOMAIN:-meet.jitsi}
+      XMPP_AUTH_DOMAIN: ${XMPP_AUTH_DOMAIN:-auth.meet.jitsi}
+      XMPP_INTERNAL_MUC_DOMAIN: ${XMPP_INTERNAL_MUC_DOMAIN:-internal-muc.meet.jitsi}
+      XMPP_SERVER: jitsi-xmpp
+      JVB_AUTH_USER: jvb
+      JVB_AUTH_PASSWORD: ${JVB_AUTH_PASSWORD:-jvb_secret}
+      JVB_PORT: 10000
+      JVB_STUN_SERVERS: ${JVB_STUN_SERVERS:-stun.l.google.com:19302}
+      TZ: ${TZ:-Europe/Berlin}
+      PUBLIC_URL: ${JITSI_PUBLIC_URL:-https://macmini:8443}
+      COLIBRI_REST_ENABLED: "true"
+      ENABLE_COLIBRI_WEBSOCKET: "true"
+    depends_on:
+      - jitsi-xmpp
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
+  # =========================================================
+  # COMMUNICATION: Matrix/Synapse
+  # =========================================================
+  synapse-db:
+    image: postgres:16-alpine
+    container_name: bp-lehrer-synapse-db
+    profiles: [chat]
+    environment:
+      POSTGRES_USER: synapse
+      POSTGRES_PASSWORD: ${SYNAPSE_DB_PASSWORD:-synapse_secret}
+      POSTGRES_DB: synapse
+      POSTGRES_INITDB_ARGS: "--encoding=UTF-8 --lc-collate=C --lc-ctype=C"
+    volumes:
+      - synapse_db_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U synapse"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
+  synapse:
+    image: matrixdotorg/synapse:latest
+    container_name: bp-lehrer-synapse
+    profiles: [chat]
+    ports:
+      - "8008:8008"
+      - "8448:8448"
+    volumes:
+      - synapse_data:/data
+    environment:
+      SYNAPSE_SERVER_NAME: ${SYNAPSE_SERVER_NAME:-macmini}
+      SYNAPSE_REPORT_STATS: "no"
+      SYNAPSE_NO_TLS: "true"
+      SYNAPSE_ENABLE_REGISTRATION: ${SYNAPSE_ENABLE_REGISTRATION:-true}
+      SYNAPSE_LOG_LEVEL: ${SYNAPSE_LOG_LEVEL:-WARNING}
+      UID: "1000"
+      GID: "1000"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://127.0.0.1:8008/health"]
+      interval: 30s
+      timeout: 10s
+      start_period: 30s
+      retries: 3
+    depends_on:
+      synapse-db:
+        condition: service_healthy
+    restart: unless-stopped
+    networks:
+      - breakpilot-network
+
   # =========================================================
   # EDU SEARCH
   # =========================================================

docs-src/services/klausur-service/Chunk-Browser.md

@@ -0,0 +1,114 @@
+# Chunk-Browser
+
+## Uebersicht
+
+Der Chunk-Browser ermoeglicht das sequenzielle Durchblaettern aller Chunks in einer Qdrant-Collection. Er ist als Tab "Chunk-Browser" auf der RAG-Seite (`/ai/rag`) verfuegbar.
+
+**URL:** `https://macmini:3002/ai/rag` → Tab "Chunk-Browser"
+
+---
+
+## Funktionen
+
+### Collection-Auswahl
+Dropdown mit allen verfuegbaren Compliance-Collections:
+
+- `bp_compliance_gesetze`
+- `bp_compliance_ce`
+- `bp_compliance_datenschutz`
+- `bp_dsfa_corpus`
+- `bp_compliance_recht`
+- `bp_legal_templates`
+- `bp_compliance_gdpr`
+- `bp_compliance_schulrecht`
+- `bp_dsfa_templates`
+- `bp_dsfa_risks`
+
+### Seitenweise Navigation
+- 20 Chunks pro Seite
+- Zurueck/Weiter-Buttons
+- Seitennummer und Chunk-Zaehler
+- Cursor-basierte Pagination via Qdrant Scroll API
+
+### Textsuche
+- Filtert Chunks auf der aktuell geladenen Seite
+- Treffer werden gelb hervorgehoben
+- Suche ueber den Chunk-Text (payload.text, payload.content, payload.chunk_text)
+
+### Chunk-Details
+- Klick auf einen Chunk klappt alle Metadaten aus
+- Zeigt: regulation_code, article, language, source, licence, etc.
+- Chunks haben eine fortlaufende Nummer (#1, #2, ...)
+
+### Integration mit Regulierungen-Tab
+Der Button "In Chunks suchen" bei jeder Regulierung wechselt zum Chunk-Browser mit:
+- Vorauswahl der richtigen Collection
+- Vorausgefuelltem Suchbegriff (Regulierungsname)
+
+---
+
+## API
+
+### Scroll-Endpoint (API Proxy)
+
+```
+GET /api/legal-corpus?action=scroll&collection=bp_compliance_ce&limit=20&offset={cursor}
+```
+
+**Parameter:**
+
+| Parameter | Typ | Beschreibung |
+|-----------|-----|--------------|
+| `collection` | string | Qdrant Collection Name |
+| `limit` | number | Chunks pro Seite (max 100) |
+| `offset` | string | Cursor fuer naechste Seite (optional) |
+| `text_search` | string | Textsuche-Filter (optional) |
+
+**Response:**
+```json
+{
+  "chunks": [
+    {
+      "id": "uuid",
+      "text": "...",
+      "regulation_code": "GDPR",
+      "article": "Art. 5",
+      "language": "de"
+    }
+  ],
+  "next_offset": "uuid-or-null",
+  "total_in_page": 20
+}
+```
+
+### Collection-Count-Endpoint
+
+```
+GET /api/legal-corpus?action=collection-count&collection=bp_compliance_ce
+```
+
+**Response:**
+```json
+{
+  "count": 12345
+}
+```
+
+---
+
+## Technische Details
+
+- Der API-Proxy spricht direkt mit Qdrant (Port 6333) via dessen `POST /collections/{name}/points/scroll` Endpoint
+- Kein Embedding oder rag-service erforderlich
+- Textsuche ist client-seitig (kein Embedding noetig)
+- Pagination ist cursor-basiert (Qdrant `next_page_offset`)
+
+---
+
+## Weitere Features auf der RAG-Seite
+
+### Originalquelle-Links
+Jede Regulierung in der Tabelle hat einen "Originalquelle" Link zum offiziellen Dokument (EUR-Lex, gesetze-im-internet.de, etc.). Definiert in `REGULATION_SOURCES` (88 Eintraege).
+
+### Low-Chunk-Warnung
+Regulierungen mit weniger als 10 Chunks aber einem erwarteten Wert >= 10 werden mit einem Amber-Warnsymbol markiert. Dies hilft, fehlgeschlagene oder unvollstaendige Ingestions zu erkennen.

docs-src/services/klausur-service/OCR-Pipeline.md

@@ -0,0 +1,714 @@
+# OCR Pipeline - Schrittweise Seitenrekonstruktion
+
+**Version:** 3.0.0
+**Status:** Produktiv (Schritte 1–8 implementiert)
+**URL:** https://macmini:3002/ai/ocr-pipeline
+
+## Uebersicht
+
+Die OCR Pipeline zerlegt den OCR-Prozess in **8 einzelne Schritte**, um eingescannte Seiten
+aus mehrspaltig gedruckten Schulbuechern Wort fuer Wort zu rekonstruieren.
+Jeder Schritt kann individuell geprueft, korrigiert und mit Ground-Truth-Daten versehen werden.
+
+**Ziel:** 10 Vokabelseiten fehlerfrei rekonstruieren.
+
+### Pipeline-Schritte
+
+| Schritt | Name | Beschreibung | Status |
+|---------|------|--------------|--------|
+| 1 | Begradigung (Deskew) | Scan begradigen (Hough Lines + Word Alignment) | Implementiert |
+| 2 | Entzerrung (Dewarp) | Buchwoelbung entzerren (Vertikalkanten-Analyse) | Implementiert |
+| 3 | Spaltenerkennung | Unsichtbare Spalten finden (Projektionsprofile + Wortvalidierung) | Implementiert |
+| 4 | Zeilenerkennung | Horizontale Zeilen + Kopf-/Fusszeilen-Klassifikation + Luecken-Heilung | Implementiert |
+| 5 | Worterkennung | Hybrid-Grid: Breite Spalten full-page, schmale cell-crop | Implementiert |
+| 6 | Korrektur | Zeichenverwirrung + regel-basierte Rechtschreibkorrektur (SSE-Stream) | Implementiert |
+| 7 | Rekonstruktion | Interaktive Zellenbearbeitung auf Bildhintergrund (Fabric.js) | Implementiert |
+| 8 | Validierung | Ground-Truth-Vergleich und Qualitaetspruefung | Implementiert |
+
+---
+
+## Dokumenttyp-Erkennung und Pipeline-Pfade
+
+### Automatische Weiche: `detect_document_type()`
+
+Nicht jedes Dokument durchlaeuft denselben Pfad. Nach den gemeinsamen Vorverarbeitungsschritten
+(Deskew, Dewarp, Binarisierung) analysiert `detect_document_type()` die Seitenstruktur
+**ohne OCR** — rein ueber Projektionsprofile und Textdichte-Analyse (< 2 Sekunden).
+
+```
+detect_document_type(ocr_img, img_bgr) → DocumentTypeResult
+```
+
+#### Entscheidungslogik
+
+```mermaid
+flowchart TD
+    A[Bild-Input] --> B[Vertikales Projektionsprofil]
+    B --> C{Interne Spalten-Gaps >= 2?}
+    C -->|Ja| D{Zeilen-Gaps >= 5?}
+    D -->|Ja| E["vocab_table<br/>pipeline = cell_first<br/>confidence 0.7–0.95"]
+    D -->|Nein| F{Zeilen-Gaps >= 3?}
+    C -->|Nein| G{Interne Spalten-Gaps >= 1?}
+    G -->|Ja| F
+    G -->|Nein| H["full_text<br/>pipeline = full_page<br/>skip: columns, rows"]
+    F -->|Ja| I["generic_table<br/>pipeline = cell_first<br/>confidence 0.5–0.85"]
+    F -->|Nein| H
+```
+
+| Dokumenttyp | Spalten-Gaps | Zeilen-Gaps | Pipeline | Beispiel |
+|-------------|-------------|-------------|----------|----------|
+| `vocab_table` | ≥ 2 | ≥ 5 | `cell_first` | 3-spaltige Schulbuch-Vokabeltabelle |
+| `generic_table` | ≥ 1 | ≥ 3 | `cell_first` | 2-spaltiges Glossar |
+| `full_text` | 0 | egal | `full_page` | Fliesstext, Aufsatz, Buchseite |
+
+### Komplett-Flussdiagramm
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│ GEMEINSAME VORVERARBEITUNG (alle Dokumente)                         │
+│                                                                     │
+│ Stage 1: Render (432 DPI, 3× Zoom)                                 │
+│ Stage 2: Deskew (Hough Lines + Ensemble)                            │
+│ Stage 3: Dewarp (Vertikalkanten-Drift, Ensemble Shear)              │
+│ Stage 4: Dual-Bild (ocr_img = binarisiert, layout_img = CLAHE)     │
+└─────────────────────────────────────┬───────────────────────────────┘
+                                      │
+                            detect_document_type()
+                                      │
+                    ┌─────────────────┴──────────────────┐
+                    ▼                                     ▼
+            FULL-TEXT PFAD                        CELL-FIRST PFAD
+            (pipeline='full_page')                (pipeline='cell_first')
+                    │                                     │
+            Keine Spalten/Zeilen                  Spaltenerkennung
+            analyze_layout_by_words()             detect_column_geometry()
+            Lese-Reihenfolge                      _detect_sub_columns()
+                    │                             expand_narrow_columns()
+                    │                             Zeilenerkennung
+                    │                             detect_row_geometry()
+                    │                                     │
+                    │                            build_cell_grid_v2()
+                    │                                     │
+                    │                           ┌─────────┴──────────┐
+                    │                           ▼                    ▼
+                    │                     Breite Spalten       Schmale Spalten
+                    │                     (>= 15% Breite)     (< 15% Breite)
+                    │                     Full-Page Words     Cell-Crop OCR
+                    │                     word_lookup          cell_crop_v2
+                    │                           │                    │
+                    └───────────────────────────┴────────────────────┘
+                                                │
+                                    Post-Processing Pipeline
+                                    (Lautschrift, Komma-Split, etc.)
+                                                │
+                                    Schritt 6: Korrektur (Spell)
+                                    Schritt 7: Rekonstruktion
+                                    Schritt 8: Validierung
+```
+
+---
+
+## Architektur
+
+```
+Admin-Lehrer (Next.js)          klausur-service (FastAPI :8086)
+┌────────────────────┐          ┌─────────────────────────────┐
+│ /ai/ocr-pipeline   │          │ /api/v1/ocr-pipeline/       │
+│                    │  REST    │                             │
+│ PipelineStepper    │◄────────►│ Sessions CRUD               │
+│ StepDeskew         │          │ Image Serving               │
+│ StepDewarp         │   SSE    │ Deskew/Dewarp/Columns/Rows  │
+│ StepColumnDetection│◄────────►│ Word Recognition            │
+│ StepRowDetection   │          │ Correction (Spell-Checker)  │
+│ StepWordRecognition│          │ Reconstruction              │
+│ StepLlmReview      │          │ Ground Truth                │
+│ StepReconstruction │          └─────────────────────────────┘
+│ StepGroundTruth    │                    │
+└────────────────────┘                    ▼
+                               ┌─────────────────────┐
+                               │ PostgreSQL           │
+                               │ ocr_pipeline_sessions│
+                               │ (Images + JSONB)     │
+                               └─────────────────────┘
+```
+
+### Dateistruktur
+
+```
+klausur-service/backend/
+├── services/
+│   └── cv_vocab_pipeline.py            # Computer Vision + NLP Algorithmen
+├── ocr_pipeline_api.py                 # FastAPI Router (alle Endpoints)
+├── ocr_pipeline_session_store.py       # PostgreSQL Persistence
+├── layout_reconstruction_service.py    # Fabric.js JSON + PDF/DOCX Export
+└── migrations/
+    ├── 002_ocr_pipeline_sessions.sql   # Basis-Schema
+    ├── 003_add_row_result.sql          # Row-Result Spalte
+    └── 004_add_word_result.sql         # Word-Result Spalte
+
+admin-lehrer/
+├── app/(admin)/ai/ocr-pipeline/
+│   ├── page.tsx                        # Haupt-Page mit Session-Management
+│   └── types.ts                        # TypeScript Interfaces
+└── components/ocr-pipeline/
+    ├── PipelineStepper.tsx              # Fortschritts-Stepper
+    ├── StepDeskew.tsx                   # Schritt 1: Begradigung
+    ├── StepDewarp.tsx                   # Schritt 2: Entzerrung
+    ├── StepColumnDetection.tsx          # Schritt 3: Spaltenerkennung
+    ├── StepRowDetection.tsx             # Schritt 4: Zeilenerkennung
+    ├── StepWordRecognition.tsx          # Schritt 5: Worterkennung
+    ├── StepLlmReview.tsx               # Schritt 6: Korrektur (SSE-Stream)
+    ├── StepReconstruction.tsx           # Schritt 7: Rekonstruktion (Canvas)
+    ├── FabricReconstructionCanvas.tsx   # Fabric.js Editor
+    └── StepGroundTruth.tsx             # Schritt 8: Validierung
+```
+
+---
+
+## API-Referenz
+
+Alle Endpoints unter `/api/v1/ocr-pipeline/`.
+
+### Sessions
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions` | Neue Session erstellen (Bild hochladen) |
+| `GET` | `/sessions` | Alle Sessions auflisten |
+| `GET` | `/sessions/{id}` | Session-Info mit allen Step-Results |
+| `PUT` | `/sessions/{id}` | Session umbenennen |
+| `DELETE` | `/sessions/{id}` | Session loeschen |
+| `POST` | `/sessions/{id}/detect-type` | Dokumenttyp erkennen |
+
+### Bilder
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `GET` | `/sessions/{id}/image/original` | Originalbild |
+| `GET` | `/sessions/{id}/image/deskewed` | Begradigtes Bild |
+| `GET` | `/sessions/{id}/image/dewarped` | Entzerrtes Bild |
+| `GET` | `/sessions/{id}/image/binarized` | Binarisiertes Bild |
+| `GET` | `/sessions/{id}/image/columns-overlay` | Spalten-Overlay |
+| `GET` | `/sessions/{id}/image/rows-overlay` | Zeilen-Overlay |
+| `GET` | `/sessions/{id}/image/words-overlay` | Wort-Grid-Overlay |
+
+### Schritt 1: Begradigung
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/deskew` | Automatische Begradigung |
+| `POST` | `/sessions/{id}/deskew/manual` | Manuelle Winkelkorrektur |
+| `POST` | `/sessions/{id}/ground-truth/deskew` | Ground Truth speichern |
+
+### Schritt 2: Entzerrung
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/dewarp` | Automatische Entzerrung |
+| `POST` | `/sessions/{id}/dewarp/manual` | Manueller Scherbungswinkel |
+| `POST` | `/sessions/{id}/ground-truth/dewarp` | Ground Truth speichern |
+
+### Schritt 3: Spalten
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/columns` | Automatische Spaltenerkennung |
+| `POST` | `/sessions/{id}/columns/manual` | Manuelle Spalten-Definition |
+| `POST` | `/sessions/{id}/ground-truth/columns` | Ground Truth speichern |
+
+### Schritt 4: Zeilen
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/rows` | Automatische Zeilenerkennung |
+| `POST` | `/sessions/{id}/rows/manual` | Manuelle Zeilen-Definition |
+| `POST` | `/sessions/{id}/ground-truth/rows` | Ground Truth speichern |
+| `GET` | `/sessions/{id}/ground-truth/rows` | Ground Truth abrufen |
+
+### Schritt 5: Worterkennung
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/words` | Wort-Grid aus Spalten x Zeilen erstellen |
+| `POST` | `/sessions/{id}/ground-truth/words` | Ground Truth speichern |
+| `GET` | `/sessions/{id}/ground-truth/words` | Ground Truth abrufen |
+
+### Schritt 6: Korrektur
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/llm-review?stream=true` | SSE-Stream Korrektur starten |
+| `POST` | `/sessions/{id}/llm-review/apply` | Ausgewaehlte Korrekturen speichern |
+
+### Schritt 7: Rekonstruktion
+
+| Methode | Pfad | Beschreibung |
+|---------|------|--------------|
+| `POST` | `/sessions/{id}/reconstruction` | Zellaenderungen speichern |
+| `GET` | `/sessions/{id}/reconstruction/fabric-json` | Fabric.js Canvas-Daten |
+| `GET` | `/sessions/{id}/reconstruction/export/pdf` | PDF-Export (reportlab) |
+| `GET` | `/sessions/{id}/reconstruction/export/docx` | DOCX-Export (python-docx) |
+| `POST` | `/sessions/{id}/reconstruction/detect-images` | Bildbereiche per VLM erkennen |
+| `POST` | `/sessions/{id}/reconstruction/generate-image` | Bild per mflux generieren |
+| `POST` | `/sessions/{id}/reconstruction/validate` | Validierung speichern (Step 8) |
+| `GET` | `/sessions/{id}/reconstruction/validation` | Validierungsdaten abrufen |
+
+---
+
+## Schritt 2: Entzerrung/Dewarp (Detail)
+
+### Algorithmus: Vertikalkanten-Drift
+
+Die Dewarp-Erkennung misst die **vertikale Spaltenkippung** (dx/dy) statt Textzeilen-Neigung:
+
+1. Woerter werden nach X-Position in vertikale Spaltencluster gruppiert
+2. Pro Cluster: Lineare Regression `x = a*y + b` → `a = dx/dy = tan(shear_angle)`
+3. Ensemble aus drei Methoden: Textzeilen (1.5× Gewicht), Projektionsprofil (2-Pass), Vertikalkanten
+4. Qualitaetspruefung: Horizontale Projektionsvarianz vor/nach Korrektur
+
+**Schwellenwerte:**
+
+| Parameter | Wert | Beschreibung |
+|-----------|------|--------------|
+| Min. Korrekturwinkel | 0.08° | Unter 0.08° wird nicht korrigiert |
+| Ensemble Min-Confidence | 0.35 | Mindest-Konfidenz fuer Korrektur |
+| Quality-Gate Skip | < 0.5° | Kleine Korrekturen ueberspringen Quality-Gate |
+
+---
+
+## Schritt 3: Spaltenerkennung (Detail)
+
+### Algorithmus: `detect_column_geometry()`
+
+Zweistufige Erkennung: vertikale Projektionsprofile finden Luecken, Wort-Bounding-Boxes validieren.
+
+```
+Bild → Binarisierung → Vertikalprofil → Lueckenerkennung → Wort-Validierung → ColumnGeometry
+```
+
+**Wichtige Implementierungsdetails:**
+
+- **Initialer Tesseract-Scan:** Laeuft auf der vollen Bildbreite `[left_x : w]` (nicht nur bis zur Content-Grenze `right_x`), damit Woerter am rechten Rand der letzten Spalte nicht uebersehen werden.
+- **Letzte Spalte:** Wird immer bis zur vollen Bildbreite `w` ausgedehnt, nicht nur bis zur erkannten Content-Grenze.
+- **Phantom-Spalten-Filter (Step 9):** Spalten mit Breite < 3 % der Content-Breite UND < 3 Woerter werden als Artefakte entfernt; die angrenzenden Spalten schliessen die Luecke.
+- **Spaltenzuweisung:** Woerter werden anhand des groessten horizontalen Ueberlappungsbereichs einer Spalte zugeordnet.
+
+### Sub-Spalten-Erkennung: `_detect_sub_columns()`
+
+Erkennt versteckte Sub-Spalten innerhalb breiter Spalten (z.B. Seitenzahl-Spalte links neben EN-Vokabeln).
+
+**Algorithmus (Left-Edge Alignment Clustering):**
+
+1. Fuer jede Spalte mit `width_ratio >= 0.15` und `word_count >= 5`:
+2. Left-Edges aller Woerter mit `conf >= 30` sammeln
+3. In Alignment-Bins clustern (8px Toleranz)
+4. Linkester Bin mit >= 10% der Woerter = wahrer Spaltenanfang
+5. Woerter links davon = Sub-Spalte, wenn >= 2 und < 35% Anteil
+6. Neue ColumnGeometry-Objekte mit korrekten Indizes erzeugen
+
+**Koordinatensystem:** Word `left`-Werte sind relativ zum Content-ROI (`left_x`), `ColumnGeometry.x` ist absolut. `left_x` wird als Parameter durchgereicht.
+
+### Spalten-Erweiterung: `expand_narrow_columns()`
+
+Laeuft **nach** `_detect_sub_columns()`. Erweitert sehr schmale Spalten (< 10% Content-Breite,
+z.B. `page_ref`, `marker`) in den Weissraum zum Nachbar-Spalte hinein, aber nie ueber die
+naechsten Woerter im Nachbarn hinaus (4px Sicherheitsabstand).
+
+### Spaltentyp-Klassifikation: `classify_column_types()`
+
+| Spaltentyp | Beschreibung | Erkennung |
+|------------|--------------|-----------|
+| `column_en` | Englische Vokabeln | EN-Funktionswoerter (the, a, is...) |
+| `column_de` | Deutsche Uebersetzung | DE-Funktionswoerter (der, die, das...) |
+| `column_example` | Beispielsaetze | Abkuerzungen, Grammatik-Marker |
+| `page_ref` | Seitenzahlen | Schmal (< 20% Breite), wenige Woerter |
+| `column_marker` | Dekorative Markierungen | Sehr schmal, spezielle Zeichen |
+| `column_text` | Generischer Text | Fallback |
+
+### Konfigurierbare Parameter
+
+```python
+# Mindestbreite fuer echte Spalten (automatisch: max(20px, 3% content_w))
+min_real_col_w = max(20, int(content_w * 0.03))
+```
+
+---
+
+## Schritt 4: Zeilenerkennung (Detail)
+
+### Algorithmus: `detect_row_geometry()`
+
+Horizontale Projektionsprofile finden Zeilen-Luecken; word-level Validierung verhindert Fehlschnitte.
+
+**Zusaetzliche Post-Processing-Schritte:**
+
+1. **Artefakt-Zeilen entfernen** (`_is_artifact_row`):
+   Zeilen, in denen alle erkannten Tokens nur 1 Zeichen lang sind (Scan-Schatten, leere Zeilen),
+   werden als Artefakte klassifiziert und aus dem Grid entfernt.
+
+2. **Luecken-Heilung** (`_heal_row_gaps`):
+   Nach dem Entfernen leerer/Artefakt-Zeilen werden die verbleibenden Zeilen auf die Mitte
+   der entstehenden Luecke ausgedehnt, damit kein Zeileninhalt durch schrumpfende Grenzen
+   abgeschnitten wird.
+
+```python
+def _is_artifact_row(row: RowGeometry) -> bool:
+    """Zeile ist Artefakt wenn alle Tokens <= 1 Zeichen."""
+    if row.word_count == 0: return True
+    return all(len(w.get('text','').strip()) <= 1 for w in row.words)
+
+def _heal_row_gaps(rows, top_bound, bottom_bound):
+    """Verbleibende Zeilen auf Mitte der Luecken ausdehnen."""
+    ...
+```
+
+---
+
+## Schritt 5: Worterkennung — Hybrid-Grid (Detail)
+
+### Algorithmus: `build_cell_grid_v2()`
+
+Schritt 5 nutzt eine **Hybrid-Strategie**: Breite Spalten verwenden die Full-Page-Tesseract-Woerter,
+schmale Spalten werden isoliert per Cell-Crop OCR verarbeitet.
+
+!!! success "Warum Hybrid?"
+    Full-Page OCR liefert gute Ergebnisse fuer breite Spalten (Saetze, IPA-Klammern, Interpunktion).
+    Aber bei schmalen Spalten (Seitenzahlen, Marker) „bluten" Woerter aus Nachbar-Spalten ein.
+    Cell-Crop isoliert jede Zelle und verhindert dieses Bleeding.
+
+### Broad vs. Narrow — Die 15%-Schwelle
+
+```python
+_NARROW_COL_THRESHOLD_PCT = 15.0  # cv_vocab_pipeline.py
+```
+
+| Eigenschaft | Breite Spalten (>= 15%) | Schmale Spalten (< 15%) |
+|-------------|------------------------|------------------------|
+| **OCR-Quelle** | Full-Page Tesseract (vorher gelaufen) | Isolierter Cell-Crop |
+| **Wort-Zuweisung** | `_assign_row_words_to_columns()` | Direktes Zell-OCR |
+| **Confidence-Filter** | `conf >= 30` | `conf >= 30` |
+| **Text-Bereinigung** | `_clean_cell_text()` (mittel) | `_clean_cell_text_lite()` (aggressiv) |
+| **Neighbour-Bleeding** | Risiko vorhanden | Verhindert (isoliert) |
+| **Parallelisierung** | Sequentiell | Parallel (`max_workers=4`) |
+| **OCR-Engine Label** | `word_lookup` | `cell_crop_v2` |
+| **Typische Spalten** | EN-Vokabeln, DE-Uebersetzung, Beispielsaetze | Seitenzahlen, Marker |
+
+**Empirische Grundlage:** Typische breite Spalten liegen bei 20–40% Bildbreite,
+typische schmale bei 3–12%. Die 15%-Grenze trennt diese Gruppen sauber.
+
+!!! note "Offener Punkt: Schwellen-Validierung"
+    Die 15%-Schwelle wurde an Vokabeltabellen mit 3–5 Spalten validiert.
+    Fuer eine breitere Validierung werden diverse Schulbuchseiten mit unterschiedlichen
+    Layouts (2-, 3-, 4-, 5-spaltig, verschiedene Verlage) benoetigt. Aktuell gibt es
+    in der Datenbank nur Sessions mit demselben Arbeitsblatt-Typ.
+
+### Cell-Crop OCR: `_ocr_cell_crop()`
+
+Isolierte OCR einer einzelnen Zelle (Spalte × Zeile Schnittflaeche):
+
+1. **Crop:** Exakte Spalten- × Zeilengrenzen mit 3px internem Padding
+2. **Density-Check:** Ueberspringe leere Zellen (`dark_ratio < 0.005`)
+3. **Upscaling:** Kleine Crops (Hoehe < 80px) werden 3× vergroessert
+4. **OCR:** Engine-spezifisch (Tesseract, TrOCR, RapidOCR, LightON)
+5. **Fallback:** Bei leerem Ergebnis → PSM 7 (Einzelzeile) statt PSM 6
+6. **Bereinigung:** `_clean_cell_text_lite()` (aggressives Noise-Filtering)
+
+### Ablauf von `build_cell_grid_v2()`
+
+```
+Eingabe: ocr_img, column_regions, row_geometries
+                    │
+        ┌───────────┴───────────┐
+        │ Filter                 │
+        │ • Phantom-Zeilen       │
+        │ • Artefakt-Zeilen      │
+        │ • Irrelevante Spalten  │
+        │   (header, footer,     │
+        │    margin, ignore)     │
+        └───────────┬───────────┘
+                    │
+        ┌───────────┴───────────┐
+        │ Klassifizierung        │
+        │ Spalte.width / img_w   │
+        │ >= 15% → broad         │
+        │ < 15%  → narrow        │
+        └───────────┬───────────┘
+                    │
+        ┌───────────┴────────────────┐
+        │                            │
+   Phase 1: Broad               Phase 2: Narrow
+   (sequentiell)                 (parallel, max_workers=4)
+        │                            │
+   Pro (row, col):               Pro (row, col):
+   1. Words aus Full-Page        1. _ocr_cell_crop()
+   2. Filter conf >= 30         2. Isoliertes Zell-Bild
+   3. _words_to_reading_order   3. Upscale wenn noetig
+   4. _clean_cell_text()        4. _clean_cell_text_lite()
+        │                            │
+        └───────────┬────────────────┘
+                    │
+            Merge + Sortierung
+            (row_index, col_index)
+            Leere Zeilen entfernen
+                    │
+               Ausgabe: cells[], columns_meta[]
+```
+
+### Post-Processing Pipeline (in `build_vocab_pipeline_streaming`)
+
+| # | Schritt | Funktion | Beschreibung |
+|---|---------|----------|--------------|
+| 0a | Lautschrift-Fortsetzung | `_merge_phonetic_continuation_rows` | IPA-only Folgezeilen zusammenfuehren |
+| 0b | Zeilen-Fortsetzung | `_merge_continuation_rows` | Zeilen mit Kleinbuchstaben-Anfang zusammenfuehren |
+| 2 | Lautschrift-Fix | `_fix_phonetic_brackets` | OCR-Lautschrift mit Woerterbuch-IPA ersetzen |
+| 3 | Komma-Split | `_split_comma_entries` | `break, broke, broken` → 3 Eintraege |
+| 4 | Beispielsaetze | `_attach_example_sentences` | Beispielsatz-Zeilen an vorangehenden Eintrag haengen |
+
+!!! info "Zeichenkorrektur in Schritt 6"
+    Die Zeichenverwirrungskorrektur (`|` → `I`, `1` → `I`, `8` → `B`) laeuft **nicht** in
+    Schritt 5, sondern als erstes in Schritt 6 (Korrektur), damit die Aenderungen im UI
+    sichtbar und rueckgaengig machbar sind.
+
+---
+
+## Schritt 6: Korrektur (Detail)
+
+### Korrektur-Engine
+
+Schritt 6 kombiniert drei Korrektur-Stufen, alle als SSE-Stream:
+
+**Stufe 1 — Zeichenverwirrungskorrektur** (`_fix_character_confusion`):
+
+| OCR-Fehler | Korrektur | Regel |
+|------------|-----------|-------|
+| `\|ch` | `Ich` | `\|` am Wortanfang vor Kleinbuchstaben → `I` |
+| `\| want` | `I want` | Alleinstehendes `\|` → `I` |
+| `8en` | `Ben` | `8` am Wortanfang vor `en` → `B` |
+| `1 want` | `I want` | Alleinstehendes `1` → `I` (NICHT vor `.` oder `,`) |
+| `1. Kreuz` | unveraendert | `1.` = Listennummer, wird **nicht** korrigiert |
+
+**Stufe 2 — Regel-basierte Rechtschreibkorrektur** (`spell_review_entries_streaming`):
+
+Nutzt `pyspellchecker` (MIT-Lizenz) mit EN+DE-Woerterbuch. Pro Token mit verdaechtigem Zeichen
+(`0`, `1`, `5`, `6`, `8`, `|`) werden Kandidaten geprueft:
+
+```python
+_SPELL_SUBS = {
+    '0': ['O', 'o'], '1': ['l', 'I'], '5': ['S', 's'],
+    '6': ['G', 'g'], '8': ['B', 'b'], '|': ['I', 'l', '1'],
+}
+```
+
+**Stufe 3 — Seitenzahl-Korrektur** (`page_ref`-Felder):
+
+Korrigiert haeufige OCR-Fehler in Seitenverweisen (z.B. `p.5g` → `p.59`).
+
+### Umgebungsvariablen
+
+| Variable | Default | Beschreibung |
+|----------|---------|--------------|
+| `REVIEW_ENGINE` | `spell` | Korrektur-Engine: `spell` oder `llm` |
+| `OLLAMA_REVIEW_MODEL` | `qwen3:0.6b` | Ollama-Modell (nur wenn `REVIEW_ENGINE=llm`) |
+| `OLLAMA_REVIEW_BATCH_SIZE` | `20` | Eintraege pro LLM-Aufruf |
+
+### SSE-Protokoll
+
+```
+POST /sessions/{id}/llm-review?stream=true
+
+Events:
+  data: {"type": "meta", "total_entries": 96, "to_review": 80, "skipped": 16, "model": "spell"}
+  data: {"type": "batch", "changes": [...], "entries_reviewed": [0,1,2,...], "progress": {...}}
+  data: {"type": "complete", "duration_ms": 234}
+  data: {"type": "error", "detail": "..."}
+
+Change-Format:
+  {"row_index": 5, "field": "english", "old": "| want", "new": "I want"}
+```
+
+---
+
+## Schritt 7: Rekonstruktion (Detail)
+
+Zwei Modi verfuegbar:
+
+### Einfacher Modus
+
+Das entzerrte Originalbild wird mit 30 % Opazitaet als Hintergrund
+angezeigt, alle Grid-Zellen (auch leere!) werden als editierbare Textfelder darueber gelegt.
+
+**Features:**
+
+- Alle Zellen editierbar — auch leere Zellen (kein Filter mehr)
+- Farbkodierung nach Spaltentyp (Blau=EN, Gruen=DE, Orange=Beispiel)
+- Leere Pflichtfelder (EN/DE) rot gestrichelt markiert
+- Undo/Redo (Ctrl+Z / Ctrl+Shift+Z)
+- Tab-Navigation durch alle Zellen (inkl. leerer)
+- Zoom 50–200 %
+- Per-Zell-Reset-Button bei geaenderten Zellen
+
+### Fabric.js Editor
+
+Erweiterter Canvas-Editor (`FabricReconstructionCanvas.tsx`):
+
+- Drag & Drop fuer Zellen
+- Freie Positionierung auf dem Canvas
+- Export als PDF (reportlab) oder DOCX (python-docx)
+
+```
+POST /sessions/{id}/reconstruction
+Body: {"cells": [{"cell_id": "r5_c2", "text": "corrected text"}]}
+```
+
+---
+
+## Wichtige Konstanten
+
+| Konstante | Wert | Datei | Beschreibung |
+|-----------|------|-------|--------------|
+| `_NARROW_COL_THRESHOLD_PCT` | 15.0% | cv_vocab_pipeline.py | Schwelle breit/schmal fuer Hybrid-OCR |
+| `_NARROW_THRESHOLD_PCT` | 10.0% | cv_vocab_pipeline.py | Schwelle fuer Spalten-Erweiterung |
+| `_MIN_WORD_CONF` | 30 | cv_vocab_pipeline.py | Mindest-Confidence fuer OCR-Woerter |
+| `_PAD` | 3px | cv_vocab_pipeline.py | Internes Padding bei Cell-Crop |
+| `PDF_ZOOM` | 3.0 | cv_vocab_pipeline.py | PDF-Rendering (= 432 DPI) |
+| `_MIN_WORD_MARGIN` | 4px | cv_vocab_pipeline.py | Sicherheitsabstand bei Spalten-Erweiterung |
+
+---
+
+## Datenbank-Schema
+
+```sql
+CREATE TABLE ocr_pipeline_sessions (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    name VARCHAR(255),
+    filename VARCHAR(255),
+    status VARCHAR(50) DEFAULT 'active',
+    current_step INT DEFAULT 1,
+
+    -- Dokumenttyp-Erkennung
+    doc_type VARCHAR(50),        -- 'vocab_table', 'generic_table', 'full_text'
+    doc_type_result JSONB,       -- Vollstaendiges DetectionResult
+
+    -- Bilder (BYTEA)
+    original_png BYTEA,
+    deskewed_png BYTEA,
+    binarized_png BYTEA,
+    dewarped_png BYTEA,
+
+    -- Step-Results (JSONB)
+    deskew_result JSONB,
+    dewarp_result JSONB,
+    column_result JSONB,
+    row_result JSONB,
+    word_result JSONB,   -- enthaelt vocab_entries, cells, llm_review
+
+    -- Ground Truth + Meta
+    ground_truth JSONB,
+    auto_shear_degrees REAL,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+```
+
+`word_result` JSONB-Struktur:
+
+```json
+{
+  "vocab_entries": [...],
+  "cells": [{"cell_id": "r0_c0", "text": "hello", "bbox_pct": {...}, "ocr_engine": "word_lookup", ...}],
+  "columns_used": [...],
+  "llm_review": {
+    "changes": [{"row_index": 5, "field": "english", "old": "...", "new": "..."}],
+    "model_used": "spell",
+    "duration_ms": 234
+  }
+}
+```
+
+---
+
+## Abhaengigkeiten
+
+### Python (klausur-service)
+
+| Paket | Version | Lizenz | Zweck |
+|-------|---------|--------|-------|
+| `pytesseract` | ≥0.3.10 | Apache-2.0 | Haupt-OCR (Schritt 3–5) |
+| `opencv-python-headless` | ≥4.8.0 | Apache-2.0 | Bildverarbeitung, Projektionsprofile |
+| `Pillow` | ≥10.0.0 | HPND (MIT-kompatibel) | Bildkonvertierung |
+| `rapidocr` | latest | Apache-2.0 | Schnelles OCR (ARM64 via ONNX) |
+| `onnxruntime` | latest | MIT | ONNX-Inferenz fuer RapidOCR |
+| `pyspellchecker` | ≥0.8.1 | MIT | Regel-basierte OCR-Korrektur (Schritt 6) |
+| `eng-to-ipa` | latest | MIT | IPA-Lautschrift-Lookup (Schritt 5) |
+| `reportlab` | latest | BSD | PDF-Export (Schritt 7) |
+| `python-docx` | ≥1.1.0 | MIT | DOCX-Export (Schritt 7) |
+| `fabric` (JS) | ^6 | MIT | Canvas-Editor (Frontend) |
+
+!!! info "pyspellchecker (neu seit 2026-03)"
+    `pyspellchecker` (MIT-Lizenz) ersetzt die LLM-basierte Korrektur als Standard-Engine.
+    EN+DE-Woerterbuch, ~134k Woerter. Kein Ollama noetig.
+    Umschaltbar via `REVIEW_ENGINE=llm` fuer den LLM-Pfad.
+
+---
+
+## Bekannte Einschraenkungen
+
+| Problem | Ursache | Workaround |
+|---------|---------|------------|
+| Schraeg gedruckte Seiten | Deskew erkennt Text-Rotation, nicht Seiten-Rotation | Manueller Winkel |
+| Sehr kleine Schrift (< 8pt) | Tesseract PSM 7 braucht min. Zeichengroesse | Vorher zoomen |
+| Handgeschriebene Eintraege | Tesseract/RapidOCR sind fuer Druckschrift optimiert | TrOCR-Engine |
+| Mehr als 4 Spalten | Projektionsprofil kann verschmelzen | Manuelle Spalten |
+| Farbige Marker (rot/blau) | HSV-Erkennung erzeugt False Positives | Manuell im Rekonstruktions-Editor |
+| 15%-Schwelle nicht breit validiert | Nur an einem Arbeitsblatt-Typ getestet | Diverse Schulbuchseiten testen |
+
+---
+
+## Deployment
+
+```bash
+# 1. Git push
+git push origin main
+
+# 2. Mac Mini pull + build
+ssh macmini "git -C /Users/benjaminadmin/Projekte/breakpilot-lehrer pull --no-rebase origin main"
+
+# klausur-service (Backend)
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml build klausur-service"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml up -d klausur-service"
+
+# admin-lehrer (Frontend)
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml build admin-lehrer"
+ssh macmini "/usr/local/bin/docker compose -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/docker-compose.yml up -d admin-lehrer"
+
+# 3. Testen unter:
+# https://macmini:3002/ai/ocr-pipeline
+```
+
+!!! warning "Base-Image bei neuen Python-Paketen"
+    Wenn `requirements.txt` geaendert wird (z.B. neues Paket hinzugefuegt), muss zuerst
+    das Base-Image neu gebaut werden:
+    ```bash
+    ssh macmini "/usr/local/bin/docker build -f /Users/benjaminadmin/Projekte/breakpilot-lehrer/klausur-service/Dockerfile.base \
+      -t klausur-base:latest /Users/benjaminadmin/Projekte/breakpilot-lehrer/klausur-service/"
+    ```
+
+---
+
+## Aenderungshistorie
+
+| Datum | Version | Aenderung |
+|-------|---------|----------|
+| 2026-03-05 | 3.0.0 | Doku-Update: Dokumenttyp-Erkennung, Hybrid-Grid, Sub-Column-Detection, Pipeline-Pfade |
+| 2026-03-04 | 2.2.0 | Dewarp: Vertikalkanten-Drift statt Textzeilen-Neigung, Schwellenwerte gesenkt |
+| 2026-03-04 | 2.1.0 | Sub-Column-Detection, expand_narrow_columns, Fabric.js Editor, PDF/DOCX-Export |
+| 2026-03-03 | 2.0.0 | Schritte 6–7 implementiert; Spell-Checker, Rekonstruktions-Canvas |
+| 2026-03-03 | 1.5.0 | Spaltenerkennung: volle Bildbreite fuer initialen Scan, Phantom-Filter |
+| 2026-03-03 | 1.4.0 | Zeilenerkennung: Artefakt-Zeilen entfernen + Luecken-Heilung |
+| 2026-03-03 | 1.3.0 | Zeichenkorrektur: `1.`/`\|.` Listenpraefixe werden nicht zu `I.` |
+| 2026-03-03 | 1.2.0 | LLM-Engine durch Spell-Checker ersetzt (REVIEW_ENGINE=spell) |
+| 2026-02-28 | 1.0.0 | Schritt 5 (Worterkennung) implementiert |
+| 2026-02-22 | 0.4.0 | Schritt 4 (Zeilenerkennung) implementiert |
+| 2026-02-20 | 0.3.0 | Schritt 3 (Spaltenerkennung) mit Typ-Klassifikation |
+| 2026-02-15 | 0.2.0 | Schritt 2 (Entzerrung/Dewarp) |
+| 2026-02-12 | 0.1.0 | Schritt 1 (Begradigung/Deskew) + Session-Management |

klausur-service/Dockerfile

@@ -8,24 +8,15 @@ RUN npm install
 COPY frontend/ ./
 RUN npm run build
 
-# Production stage
-FROM python:3.11-slim
+# Production stage — uses pre-built base with Tesseract + Python deps.
+# Base image contains: python:3.11-slim + tesseract-ocr + all pip packages.
+# Rebuild base only when requirements.txt or system deps change:
+#   docker build -f klausur-service/Dockerfile.base -t klausur-base:latest klausur-service/
+FROM klausur-base:latest
 
 WORKDIR /app
 
-# Install system dependencies (incl. Tesseract OCR for bounding-box extraction)
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    tesseract-ocr \
-    tesseract-ocr-deu \
-    tesseract-ocr-eng \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies
-COPY backend/requirements.txt ./
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy backend code
+# Copy backend code (this is the only layer that changes on code edits)
 COPY backend/ ./
 
 # Copy built frontend to the expected path

klausur-service/Dockerfile.base

@@ -0,0 +1,27 @@
+# Base image with system dependencies + Python packages.
+# These change rarely — build once, reuse on every --no-cache.
+#
+# Rebuild manually when requirements.txt or system deps change:
+#   docker build -f klausur-service/Dockerfile.base -t klausur-base:latest klausur-service/
+#
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# System dependencies (Tesseract OCR, curl for healthcheck)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    tesseract-ocr \
+    tesseract-ocr-deu \
+    tesseract-ocr-eng \
+    libgl1 \
+    libglib2.0-0 \
+    fonts-liberation \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python dependencies
+COPY backend/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Clean up pip cache
+RUN rm -rf /root/.cache/pip

klausur-service/backend/handwriting_htr_api.py

@@ -0,0 +1,276 @@
+"""
+Handwriting HTR API - Hochwertige Handschriftenerkennung (HTR) fuer Klausurkorrekturen.
+
+Endpoints:
+- POST /api/v1/htr/recognize          - Bild hochladen → handgeschriebener Text
+- POST /api/v1/htr/recognize-session  - OCR-Pipeline Session als Quelle nutzen
+
+Modell-Strategie:
+  1. qwen2.5vl:32b via Ollama (primaer, hoechste Qualitaet als VLM)
+  2. microsoft/trocr-large-handwritten (Fallback, offline, kein Ollama)
+
+DATENSCHUTZ: Alle Verarbeitung erfolgt lokal auf dem Mac Mini.
+"""
+
+import io
+import os
+import logging
+import time
+import base64
+from typing import Optional
+
+import cv2
+import numpy as np
+from fastapi import APIRouter, HTTPException, Query, UploadFile, File
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/v1/htr", tags=["HTR"])
+
+OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://host.docker.internal:11434")
+OLLAMA_HTR_MODEL = os.getenv("OLLAMA_HTR_MODEL", "qwen2.5vl:32b")
+HTR_FALLBACK_MODEL = os.getenv("HTR_FALLBACK_MODEL", "trocr-large")
+
+
+# ---------------------------------------------------------------------------
+# Pydantic Models
+# ---------------------------------------------------------------------------
+
+class HTRSessionRequest(BaseModel):
+    session_id: str
+    model: str = "auto"       # "auto" | "qwen2.5vl" | "trocr-large"
+    use_clean: bool = True    # Prefer clean_png (after handwriting removal)
+
+
+# ---------------------------------------------------------------------------
+# Preprocessing
+# ---------------------------------------------------------------------------
+
+def _preprocess_for_htr(img_bgr: np.ndarray) -> np.ndarray:
+    """
+    CLAHE contrast enhancement + upscale to improve HTR accuracy.
+    Returns grayscale enhanced image.
+    """
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    enhanced = clahe.apply(gray)
+
+    # Upscale if image is too small
+    h, w = enhanced.shape
+    if min(h, w) < 800:
+        scale = 800 / min(h, w)
+        enhanced = cv2.resize(
+            enhanced, None, fx=scale, fy=scale,
+            interpolation=cv2.INTER_CUBIC
+        )
+
+    return enhanced
+
+
+def _bgr_to_png_bytes(img_bgr: np.ndarray) -> bytes:
+    """Convert BGR ndarray to PNG bytes."""
+    success, buf = cv2.imencode(".png", img_bgr)
+    if not success:
+        raise RuntimeError("Failed to encode image to PNG")
+    return buf.tobytes()
+
+
+def _preprocess_image_bytes(image_bytes: bytes) -> bytes:
+    """Load image, apply HTR preprocessing, return PNG bytes."""
+    arr = np.frombuffer(image_bytes, dtype=np.uint8)
+    img_bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img_bgr is None:
+        raise ValueError("Could not decode image")
+
+    enhanced = _preprocess_for_htr(img_bgr)
+    # Convert grayscale back to BGR for encoding
+    enhanced_bgr = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
+    return _bgr_to_png_bytes(enhanced_bgr)
+
+
+# ---------------------------------------------------------------------------
+# Backend: Ollama qwen2.5vl
+# ---------------------------------------------------------------------------
+
+async def _recognize_with_qwen_vl(image_bytes: bytes, language: str) -> Optional[str]:
+    """
+    Send image to Ollama qwen2.5vl:32b for HTR.
+    Returns extracted text or None on error.
+    """
+    import httpx
+
+    lang_hint = {
+        "de": "Deutsch",
+        "en": "Englisch",
+        "de+en": "Deutsch und Englisch",
+    }.get(language, "Deutsch")
+
+    prompt = (
+        f"Du bist ein OCR-Experte fuer handgeschriebenen Text auf {lang_hint}. "
+        "Lies den Text im Bild exakt ab — korrigiere KEINE Rechtschreibfehler. "
+        "Antworte NUR mit dem erkannten Text, ohne Erklaerungen."
+    )
+
+    img_b64 = base64.b64encode(image_bytes).decode("utf-8")
+
+    payload = {
+        "model": OLLAMA_HTR_MODEL,
+        "prompt": prompt,
+        "images": [img_b64],
+        "stream": False,
+    }
+
+    try:
+        async with httpx.AsyncClient(timeout=120.0) as client:
+            resp = await client.post(f"{OLLAMA_BASE_URL}/api/generate", json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            return data.get("response", "").strip()
+    except Exception as e:
+        logger.warning(f"Ollama qwen2.5vl HTR failed: {e}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Backend: TrOCR-large fallback
+# ---------------------------------------------------------------------------
+
+async def _recognize_with_trocr_large(image_bytes: bytes) -> Optional[str]:
+    """
+    Use microsoft/trocr-large-handwritten via trocr_service.py.
+    Returns extracted text or None on error.
+    """
+    try:
+        from services.trocr_service import run_trocr_ocr, _check_trocr_available
+        if not _check_trocr_available():
+            logger.warning("TrOCR not available for HTR fallback")
+            return None
+
+        text, confidence = await run_trocr_ocr(image_bytes, handwritten=True, size="large")
+        return text.strip() if text else None
+    except Exception as e:
+        logger.warning(f"TrOCR-large HTR failed: {e}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Core recognition logic
+# ---------------------------------------------------------------------------
+
+async def _do_recognize(
+    image_bytes: bytes,
+    model: str = "auto",
+    preprocess: bool = True,
+    language: str = "de",
+) -> dict:
+    """
+    Core HTR logic: preprocess → try Ollama → fallback to TrOCR-large.
+    Returns dict with text, model_used, processing_time_ms.
+    """
+    t0 = time.monotonic()
+
+    if preprocess:
+        try:
+            image_bytes = _preprocess_image_bytes(image_bytes)
+        except Exception as e:
+            logger.warning(f"HTR preprocessing failed, using raw image: {e}")
+
+    text: Optional[str] = None
+    model_used: str = "none"
+
+    use_qwen = model in ("auto", "qwen2.5vl")
+    use_trocr = model in ("auto", "trocr-large") or (use_qwen and text is None)
+
+    if use_qwen:
+        text = await _recognize_with_qwen_vl(image_bytes, language)
+        if text is not None:
+            model_used = f"qwen2.5vl ({OLLAMA_HTR_MODEL})"
+
+    if text is None and (use_trocr or model == "trocr-large"):
+        text = await _recognize_with_trocr_large(image_bytes)
+        if text is not None:
+            model_used = "trocr-large-handwritten"
+
+    if text is None:
+        text = ""
+        model_used = "none (all backends failed)"
+
+    elapsed_ms = int((time.monotonic() - t0) * 1000)
+
+    return {
+        "text": text,
+        "model_used": model_used,
+        "processing_time_ms": elapsed_ms,
+        "language": language,
+        "preprocessed": preprocess,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Endpoints
+# ---------------------------------------------------------------------------
+
+@router.post("/recognize")
+async def recognize_handwriting(
+    file: UploadFile = File(...),
+    model: str = Query("auto", description="auto | qwen2.5vl | trocr-large"),
+    preprocess: bool = Query(True, description="Apply CLAHE + upscale before recognition"),
+    language: str = Query("de", description="de | en | de+en"),
+):
+    """
+    Upload an image and get back the handwritten text as plain text.
+
+    Tries qwen2.5vl:32b via Ollama first, falls back to TrOCR-large-handwritten.
+    """
+    if model not in ("auto", "qwen2.5vl", "trocr-large"):
+        raise HTTPException(status_code=400, detail="model must be one of: auto, qwen2.5vl, trocr-large")
+    if language not in ("de", "en", "de+en"):
+        raise HTTPException(status_code=400, detail="language must be one of: de, en, de+en")
+
+    image_bytes = await file.read()
+    if not image_bytes:
+        raise HTTPException(status_code=400, detail="Empty file")
+
+    return await _do_recognize(image_bytes, model=model, preprocess=preprocess, language=language)
+
+
+@router.post("/recognize-session")
+async def recognize_from_session(req: HTRSessionRequest):
+    """
+    Use an OCR-Pipeline session as image source for HTR.
+
+    Set use_clean=true to prefer the clean image (after handwriting removal step).
+    This is useful when you want to do HTR on isolated handwriting regions.
+    """
+    from ocr_pipeline_session_store import get_session_db, get_session_image
+
+    session = await get_session_db(req.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail=f"Session {req.session_id} not found")
+
+    # Choose source image
+    image_bytes: Optional[bytes] = None
+    source_used: str = ""
+
+    if req.use_clean:
+        image_bytes = await get_session_image(req.session_id, "clean")
+        if image_bytes:
+            source_used = "clean"
+
+    if not image_bytes:
+        image_bytes = await get_session_image(req.session_id, "deskewed")
+        if image_bytes:
+            source_used = "deskewed"
+
+    if not image_bytes:
+        image_bytes = await get_session_image(req.session_id, "original")
+        source_used = "original"
+
+    if not image_bytes:
+        raise HTTPException(status_code=404, detail="No image available in session")
+
+    result = await _do_recognize(image_bytes, model=req.model)
+    result["session_id"] = req.session_id
+    result["source_image"] = source_used
+    return result

klausur-service/backend/main.py

@@ -42,6 +42,12 @@ try:
 except ImportError:
     trocr_router = None
 from vocab_worksheet_api import router as vocab_router, set_db_pool as set_vocab_db_pool, _init_vocab_table, _load_all_sessions, DATABASE_URL as VOCAB_DATABASE_URL
+from ocr_pipeline_api import router as ocr_pipeline_router
+from ocr_pipeline_session_store import init_ocr_pipeline_tables
+try:
+    from handwriting_htr_api import router as htr_router
+except ImportError:
+    htr_router = None
 try:
     from dsfa_rag_api import router as dsfa_rag_router, set_db_pool as set_dsfa_db_pool
     from dsfa_corpus_ingestion import DSFAQdrantService, DATABASE_URL as DSFA_DATABASE_URL
@@ -75,6 +81,13 @@ async def lifespan(app: FastAPI):
     except Exception as e:
         print(f"Warning: Vocab sessions database initialization failed: {e}")
 
+    # Initialize OCR Pipeline session tables
+    try:
+        await init_ocr_pipeline_tables()
+        print("OCR Pipeline session tables initialized")
+    except Exception as e:
+        print(f"Warning: OCR Pipeline tables initialization failed: {e}")
+
     # Initialize database pool for DSFA RAG
     dsfa_db_pool = None
     if DSFA_DATABASE_URL and set_dsfa_db_pool:
@@ -104,6 +117,19 @@ async def lifespan(app: FastAPI):
     # Ensure EH upload directory exists
     os.makedirs(EH_UPLOAD_DIR, exist_ok=True)
 
+    # Preload LightOnOCR model if OCR_ENGINE=lighton (avoids cold-start on first request)
+    ocr_engine_env = os.getenv("OCR_ENGINE", "auto")
+    if ocr_engine_env == "lighton":
+        try:
+            import asyncio
+            from services.lighton_ocr_service import get_lighton_model
+            loop = asyncio.get_event_loop()
+            print("Preloading LightOnOCR-2-1B at startup (OCR_ENGINE=lighton)...")
+            await loop.run_in_executor(None, get_lighton_model)
+            print("LightOnOCR-2-1B preloaded")
+        except Exception as e:
+            print(f"Warning: LightOnOCR preload failed: {e}")
+
     yield
 
     print("Klausur-Service shutting down...")
@@ -150,6 +176,9 @@ app.include_router(mail_router)       # Unified Inbox Mail
 if trocr_router:
     app.include_router(trocr_router)      # TrOCR Handwriting OCR
 app.include_router(vocab_router)      # Vocabulary Worksheet Generator
+app.include_router(ocr_pipeline_router)  # OCR Pipeline (step-by-step)
+if htr_router:
+    app.include_router(htr_router)            # Handwriting HTR (Klausur)
 if dsfa_rag_router:
     app.include_router(dsfa_rag_router)   # DSFA RAG Corpus Search
 

klausur-service/backend/migrations/002_ocr_pipeline_sessions.sql

@@ -0,0 +1,28 @@
+-- OCR Pipeline Sessions - Persistent session storage
+-- Applied automatically by ocr_pipeline_session_store.init_ocr_pipeline_tables()
+
+CREATE TABLE IF NOT EXISTS ocr_pipeline_sessions (
+    id UUID PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    filename VARCHAR(255),
+    status VARCHAR(50) DEFAULT 'active',
+    current_step INT DEFAULT 1,
+    original_png BYTEA,
+    deskewed_png BYTEA,
+    binarized_png BYTEA,
+    dewarped_png BYTEA,
+    deskew_result JSONB,
+    dewarp_result JSONB,
+    column_result JSONB,
+    ground_truth JSONB DEFAULT '{}',
+    auto_shear_degrees FLOAT,
+    created_at TIMESTAMP DEFAULT NOW(),
+    updated_at TIMESTAMP DEFAULT NOW()
+);
+
+-- Index for listing sessions
+CREATE INDEX IF NOT EXISTS idx_ocr_pipeline_sessions_created
+    ON ocr_pipeline_sessions (created_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_ocr_pipeline_sessions_status
+    ON ocr_pipeline_sessions (status);

klausur-service/backend/migrations/003_add_row_result.sql

@@ -0,0 +1,4 @@
+-- Migration 003: Add row_result column for row geometry detection
+-- Stores detected row geometries including header/footer classification
+
+ALTER TABLE ocr_pipeline_sessions ADD COLUMN IF NOT EXISTS row_result JSONB;

klausur-service/backend/migrations/004_add_word_result.sql

@@ -0,0 +1,4 @@
+-- Migration 004: Add word_result column for OCR Pipeline Step 5
+-- Stores the word recognition grid result (entries with english/german/example + bboxes)
+
+ALTER TABLE ocr_pipeline_sessions ADD COLUMN IF NOT EXISTS word_result JSONB;

klausur-service/backend/migrations/005_add_doc_type.sql

@@ -0,0 +1,7 @@
+-- Migration 005: Add document type detection columns
+-- These columns store the result of automatic document type detection
+-- (vocab_table, full_text, generic_table) after dewarp.
+
+ALTER TABLE ocr_pipeline_sessions
+ADD COLUMN IF NOT EXISTS doc_type VARCHAR(50),
+ADD COLUMN IF NOT EXISTS doc_type_result JSONB;

klausur-service/backend/ocr_pipeline_session_store.py

@@ -0,0 +1,262 @@
+"""
+OCR Pipeline Session Store - PostgreSQL persistence for OCR pipeline sessions.
+
+Replaces in-memory storage with database persistence.
+See migrations/002_ocr_pipeline_sessions.sql for schema.
+"""
+
+import os
+import uuid
+import logging
+import json
+from typing import Optional, List, Dict, Any
+
+import asyncpg
+
+logger = logging.getLogger(__name__)
+
+# Database configuration (same as vocab_session_store)
+DATABASE_URL = os.getenv(
+    "DATABASE_URL",
+    "postgresql://breakpilot:breakpilot@postgres:5432/breakpilot_db"
+)
+
+# Connection pool (initialized lazily)
+_pool: Optional[asyncpg.Pool] = None
+
+
+async def get_pool() -> asyncpg.Pool:
+    """Get or create the database connection pool."""
+    global _pool
+    if _pool is None:
+        _pool = await asyncpg.create_pool(DATABASE_URL, min_size=2, max_size=10)
+    return _pool
+
+
+async def init_ocr_pipeline_tables():
+    """Initialize OCR pipeline tables if they don't exist."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        tables_exist = await conn.fetchval("""
+            SELECT EXISTS (
+                SELECT FROM information_schema.tables
+                WHERE table_name = 'ocr_pipeline_sessions'
+            )
+        """)
+
+        if not tables_exist:
+            logger.info("Creating OCR pipeline tables...")
+            migration_path = os.path.join(
+                os.path.dirname(__file__),
+                "migrations/002_ocr_pipeline_sessions.sql"
+            )
+            if os.path.exists(migration_path):
+                with open(migration_path, "r") as f:
+                    sql = f.read()
+                await conn.execute(sql)
+                logger.info("OCR pipeline tables created successfully")
+            else:
+                logger.warning(f"Migration file not found: {migration_path}")
+        else:
+            logger.debug("OCR pipeline tables already exist")
+
+        # Ensure new columns exist (idempotent ALTER TABLE)
+        await conn.execute("""
+            ALTER TABLE ocr_pipeline_sessions
+            ADD COLUMN IF NOT EXISTS clean_png BYTEA,
+            ADD COLUMN IF NOT EXISTS handwriting_removal_meta JSONB,
+            ADD COLUMN IF NOT EXISTS doc_type VARCHAR(50),
+            ADD COLUMN IF NOT EXISTS doc_type_result JSONB,
+            ADD COLUMN IF NOT EXISTS document_category VARCHAR(50),
+            ADD COLUMN IF NOT EXISTS pipeline_log JSONB
+        """)
+
+
+# =============================================================================
+# SESSION CRUD
+# =============================================================================
+
+async def create_session_db(
+    session_id: str,
+    name: str,
+    filename: str,
+    original_png: bytes,
+) -> Dict[str, Any]:
+    """Create a new OCR pipeline session."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow("""
+            INSERT INTO ocr_pipeline_sessions (
+                id, name, filename, original_png, status, current_step
+            ) VALUES ($1, $2, $3, $4, 'active', 1)
+            RETURNING id, name, filename, status, current_step,
+                      deskew_result, dewarp_result, column_result, row_result,
+                      word_result, ground_truth, auto_shear_degrees,
+                      doc_type, doc_type_result,
+                      document_category, pipeline_log,
+                      created_at, updated_at
+        """, uuid.UUID(session_id), name, filename, original_png)
+
+        return _row_to_dict(row)
+
+
+async def get_session_db(session_id: str) -> Optional[Dict[str, Any]]:
+    """Get session metadata (without images)."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow("""
+            SELECT id, name, filename, status, current_step,
+                   deskew_result, dewarp_result, column_result, row_result,
+                   word_result, ground_truth, auto_shear_degrees,
+                   doc_type, doc_type_result,
+                   document_category, pipeline_log,
+                   created_at, updated_at
+            FROM ocr_pipeline_sessions WHERE id = $1
+        """, uuid.UUID(session_id))
+
+        if row:
+            return _row_to_dict(row)
+        return None
+
+
+async def get_session_image(session_id: str, image_type: str) -> Optional[bytes]:
+    """Load a single image (BYTEA) from the session."""
+    column_map = {
+        "original": "original_png",
+        "deskewed": "deskewed_png",
+        "binarized": "binarized_png",
+        "dewarped": "dewarped_png",
+        "clean": "clean_png",
+    }
+    column = column_map.get(image_type)
+    if not column:
+        return None
+
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        return await conn.fetchval(
+            f"SELECT {column} FROM ocr_pipeline_sessions WHERE id = $1",
+            uuid.UUID(session_id)
+        )
+
+
+async def update_session_db(session_id: str, **kwargs) -> Optional[Dict[str, Any]]:
+    """Update session fields dynamically."""
+    pool = await get_pool()
+
+    fields = []
+    values = []
+    param_idx = 1
+
+    allowed_fields = {
+        'name', 'filename', 'status', 'current_step',
+        'original_png', 'deskewed_png', 'binarized_png', 'dewarped_png',
+        'clean_png', 'handwriting_removal_meta',
+        'deskew_result', 'dewarp_result', 'column_result', 'row_result',
+        'word_result', 'ground_truth', 'auto_shear_degrees',
+        'doc_type', 'doc_type_result',
+        'document_category', 'pipeline_log',
+    }
+
+    jsonb_fields = {'deskew_result', 'dewarp_result', 'column_result', 'row_result', 'word_result', 'ground_truth', 'handwriting_removal_meta', 'doc_type_result', 'pipeline_log'}
+
+    for key, value in kwargs.items():
+        if key in allowed_fields:
+            fields.append(f"{key} = ${param_idx}")
+            if key in jsonb_fields and value is not None and not isinstance(value, str):
+                value = json.dumps(value)
+            values.append(value)
+            param_idx += 1
+
+    if not fields:
+        return await get_session_db(session_id)
+
+    # Always update updated_at
+    fields.append(f"updated_at = NOW()")
+
+    values.append(uuid.UUID(session_id))
+
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(f"""
+            UPDATE ocr_pipeline_sessions
+            SET {', '.join(fields)}
+            WHERE id = ${param_idx}
+            RETURNING id, name, filename, status, current_step,
+                      deskew_result, dewarp_result, column_result, row_result,
+                      word_result, ground_truth, auto_shear_degrees,
+                      doc_type, doc_type_result,
+                      document_category, pipeline_log,
+                      created_at, updated_at
+        """, *values)
+
+        if row:
+            return _row_to_dict(row)
+        return None
+
+
+async def list_sessions_db(limit: int = 50) -> List[Dict[str, Any]]:
+    """List all sessions (metadata only, no images)."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        rows = await conn.fetch("""
+            SELECT id, name, filename, status, current_step,
+                   document_category, doc_type,
+                   created_at, updated_at
+            FROM ocr_pipeline_sessions
+            ORDER BY created_at DESC
+            LIMIT $1
+        """, limit)
+
+        return [_row_to_dict(row) for row in rows]
+
+
+async def delete_session_db(session_id: str) -> bool:
+    """Delete a session."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        result = await conn.execute("""
+            DELETE FROM ocr_pipeline_sessions WHERE id = $1
+        """, uuid.UUID(session_id))
+        return result == "DELETE 1"
+
+
+async def delete_all_sessions_db() -> int:
+    """Delete all sessions. Returns number of deleted rows."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        result = await conn.execute("DELETE FROM ocr_pipeline_sessions")
+        # result is e.g. "DELETE 5"
+        try:
+            return int(result.split()[-1])
+        except (ValueError, IndexError):
+            return 0
+
+
+# =============================================================================
+# HELPER
+# =============================================================================
+
+def _row_to_dict(row: asyncpg.Record) -> Dict[str, Any]:
+    """Convert asyncpg Record to JSON-serializable dict."""
+    if row is None:
+        return {}
+
+    result = dict(row)
+
+    # UUID → string
+    for key in ['id', 'session_id']:
+        if key in result and result[key] is not None:
+            result[key] = str(result[key])
+
+    # datetime → ISO string
+    for key in ['created_at', 'updated_at']:
+        if key in result and result[key] is not None:
+            result[key] = result[key].isoformat()
+
+    # JSONB → parsed (asyncpg returns str for JSONB)
+    for key in ['deskew_result', 'dewarp_result', 'column_result', 'row_result', 'word_result', 'ground_truth', 'doc_type_result', 'pipeline_log']:
+        if key in result and result[key] is not None:
+            if isinstance(result[key], str):
+                result[key] = json.loads(result[key])
+
+    return result

klausur-service/backend/requirements.txt

@@ -28,6 +28,16 @@ opencv-python-headless>=4.8.0
 pytesseract>=0.3.10
 Pillow>=10.0.0
 
+# RapidOCR (PaddleOCR models on ONNX Runtime — works on ARM64 natively)
+rapidocr
+onnxruntime
+
+# IPA pronunciation dictionary lookup (MIT license, bundled CMU dict ~134k words)
+eng-to-ipa
+
+# Spell-checker for rule-based OCR correction (MIT license)
+pyspellchecker>=0.8.1
+
 # PostgreSQL (for metrics storage)
 psycopg2-binary>=2.9.0
 asyncpg>=0.29.0
@@ -35,6 +45,9 @@ asyncpg>=0.29.0
 # Email validation for Pydantic
 email-validator>=2.0.0
 
+# DOCX export for reconstruction editor (MIT license)
+python-docx>=1.1.0
+
 # Testing
 pytest>=8.0.0
 pytest-asyncio>=0.23.0

klausur-service/backend/services/handwriting_detection.py

@@ -6,6 +6,7 @@ Uses multiple detection methods:
 1. Color-based detection (blue/red ink)
 2. Stroke analysis (thin irregular strokes)
 3. Edge density variance
+4. Pencil detection (gray ink)
 
 DATENSCHUTZ: All processing happens locally on Mac Mini.
 """
@@ -37,12 +38,16 @@ class DetectionResult:
     detection_method: str  # Which method was primarily used
 
 
-def detect_handwriting(image_bytes: bytes) -> DetectionResult:
+def detect_handwriting(image_bytes: bytes, target_ink: str = "all") -> DetectionResult:
     """
     Detect handwriting in an image.
 
     Args:
         image_bytes: Image as bytes (PNG, JPG, etc.)
+        target_ink: Which ink types to detect:
+            - "all"     → all methods combined (incl. pencil)
+            - "colored" → only color-based (blue/red/green pen)
+            - "pencil"  → only pencil (gray ink)
 
     Returns:
         DetectionResult with binary mask where handwriting is white (255)
@@ -62,35 +67,51 @@ def detect_handwriting(image_bytes: bytes) -> DetectionResult:
 
     # Convert to BGR if needed (OpenCV format)
     if len(img_array.shape) == 2:
-        # Grayscale to BGR
         img_bgr = cv2.cvtColor(img_array, cv2.COLOR_GRAY2BGR)
     elif img_array.shape[2] == 4:
-        # RGBA to BGR
         img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGBA2BGR)
     elif img_array.shape[2] == 3:
-        # RGB to BGR
         img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
     else:
         img_bgr = img_array
 
-    # Run multiple detection methods
-    color_mask, color_confidence = _detect_by_color(img_bgr)
-    stroke_mask, stroke_confidence = _detect_by_stroke_analysis(img_bgr)
-    variance_mask, variance_confidence = _detect_by_variance(img_bgr)
+    # Select detection methods based on target_ink
+    masks_and_weights = []
+
+    if target_ink in ("all", "colored"):
+        color_mask, color_conf = _detect_by_color(img_bgr)
+        masks_and_weights.append((color_mask, color_conf, "color"))
+
+    if target_ink == "all":
+        stroke_mask, stroke_conf = _detect_by_stroke_analysis(img_bgr)
+        variance_mask, variance_conf = _detect_by_variance(img_bgr)
+        masks_and_weights.append((stroke_mask, stroke_conf, "stroke"))
+        masks_and_weights.append((variance_mask, variance_conf, "variance"))
+
+    if target_ink in ("all", "pencil"):
+        pencil_mask, pencil_conf = _detect_pencil(img_bgr)
+        masks_and_weights.append((pencil_mask, pencil_conf, "pencil"))
+
+    if not masks_and_weights:
+        # Fallback: use all methods
+        color_mask, color_conf = _detect_by_color(img_bgr)
+        stroke_mask, stroke_conf = _detect_by_stroke_analysis(img_bgr)
+        variance_mask, variance_conf = _detect_by_variance(img_bgr)
+        pencil_mask, pencil_conf = _detect_pencil(img_bgr)
+        masks_and_weights = [
+            (color_mask, color_conf, "color"),
+            (stroke_mask, stroke_conf, "stroke"),
+            (variance_mask, variance_conf, "variance"),
+            (pencil_mask, pencil_conf, "pencil"),
+        ]
 
     # Combine masks using weighted average
-    weights = [color_confidence, stroke_confidence, variance_confidence]
-    total_weight = sum(weights)
+    total_weight = sum(w for _, w, _ in masks_and_weights)
 
     if total_weight > 0:
-        # Weighted combination
-        combined_mask = (
-            color_mask.astype(np.float32) * color_confidence +
-            stroke_mask.astype(np.float32) * stroke_confidence +
-            variance_mask.astype(np.float32) * variance_confidence
+        combined_mask = sum(
+            m.astype(np.float32) * w for m, w, _ in masks_and_weights
         ) / total_weight
-
-        # Threshold to binary
         combined_mask = (combined_mask > 127).astype(np.uint8) * 255
     else:
         combined_mask = np.zeros(img_bgr.shape[:2], dtype=np.uint8)
@@ -103,19 +124,11 @@ def detect_handwriting(image_bytes: bytes) -> DetectionResult:
     handwriting_pixels = np.sum(combined_mask > 0)
     handwriting_ratio = handwriting_pixels / total_pixels if total_pixels > 0 else 0
 
-    # Determine primary method
-    primary_method = "combined"
-    max_conf = max(color_confidence, stroke_confidence, variance_confidence)
-    if max_conf == color_confidence:
-        primary_method = "color"
-    elif max_conf == stroke_confidence:
-        primary_method = "stroke"
-    else:
-        primary_method = "variance"
+    # Determine primary method (highest confidence)
+    primary_method = max(masks_and_weights, key=lambda x: x[1])[2] if masks_and_weights else "combined"
+    overall_confidence = total_weight / len(masks_and_weights) if masks_and_weights else 0.0
 
-    overall_confidence = total_weight / 3.0  # Average confidence
-
-    logger.info(f"Handwriting detection: {handwriting_ratio:.2%} handwriting, "
+    logger.info(f"Handwriting detection (target_ink={target_ink}): {handwriting_ratio:.2%} handwriting, "
                 f"confidence={overall_confidence:.2f}, method={primary_method}")
 
     return DetectionResult(
@@ -180,6 +193,27 @@ def _detect_by_color(img_bgr: np.ndarray) -> Tuple[np.ndarray, float]:
     return color_mask, confidence
 
 
+def _detect_pencil(img_bgr: np.ndarray) -> Tuple[np.ndarray, float]:
+    """
+    Detect pencil marks (gray ink, ~140-220 on 255-scale).
+
+    Paper is usually >230, dark ink <130.
+    Pencil falls in the 140-220 gray range.
+    """
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    pencil_mask = cv2.inRange(gray, 140, 220)
+
+    # Remove small noise artifacts
+    kernel = np.ones((2, 2), np.uint8)
+    pencil_mask = cv2.morphologyEx(pencil_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+
+    ratio = np.sum(pencil_mask > 0) / pencil_mask.size
+    # Good confidence if pencil pixels are in a plausible range
+    confidence = 0.75 if 0.002 < ratio < 0.2 else 0.2
+
+    return pencil_mask, confidence
+
+
 def _detect_by_stroke_analysis(img_bgr: np.ndarray) -> Tuple[np.ndarray, float]:
     """
     Detect handwriting by analyzing stroke characteristics.

klausur-service/backend/services/layout_reconstruction_service.py

@@ -350,6 +350,77 @@ def layout_to_fabric_json(layout_result: LayoutResult) -> str:
     return json.dumps(layout_result.fabric_json, ensure_ascii=False, indent=2)
 
 
+def cells_to_fabric_json(
+    cells: List[Dict[str, Any]],
+    image_width: int,
+    image_height: int,
+) -> Dict[str, Any]:
+    """Convert pipeline grid cells to Fabric.js-compatible JSON.
+
+    Each cell becomes a Textbox object positioned at its bbox_pct coordinates
+    (converted to pixels). Colour-coded by column type.
+
+    Args:
+        cells: List of cell dicts from GridResult (with bbox_pct, col_type, text).
+        image_width: Source image width in pixels.
+        image_height: Source image height in pixels.
+
+    Returns:
+        Dict with Fabric.js canvas JSON (version + objects array).
+    """
+    COL_TYPE_COLORS = {
+        'column_en': '#3b82f6',
+        'column_de': '#22c55e',
+        'column_example': '#f97316',
+        'column_text': '#a855f7',
+        'page_ref': '#06b6d4',
+        'column_marker': '#6b7280',
+    }
+
+    fabric_objects = []
+    for cell in cells:
+        bp = cell.get('bbox_pct', {})
+        x = bp.get('x', 0) / 100 * image_width
+        y = bp.get('y', 0) / 100 * image_height
+        w = bp.get('w', 10) / 100 * image_width
+        h = bp.get('h', 3) / 100 * image_height
+        col_type = cell.get('col_type', '')
+        color = COL_TYPE_COLORS.get(col_type, '#6b7280')
+        font_size = max(8, min(18, h * 0.55))
+
+        fabric_objects.append({
+            "type": "textbox",
+            "version": "6.0.0",
+            "originX": "left",
+            "originY": "top",
+            "left": round(x, 1),
+            "top": round(y, 1),
+            "width": max(round(w, 1), 30),
+            "height": round(h, 1),
+            "fill": "#000000",
+            "stroke": color,
+            "strokeWidth": 1,
+            "text": cell.get('text', ''),
+            "fontSize": round(font_size, 1),
+            "fontFamily": "monospace",
+            "editable": True,
+            "selectable": True,
+            "backgroundColor": color + "22",
+            "data": {
+                "cellId": cell.get('cell_id', ''),
+                "colType": col_type,
+                "rowIndex": cell.get('row_index', 0),
+                "colIndex": cell.get('col_index', 0),
+                "originalText": cell.get('text', ''),
+            },
+        })
+
+    return {
+        "version": "6.0.0",
+        "objects": fabric_objects,
+    }
+
+
 def reconstruct_and_clean(
     image_bytes: bytes,
     remove_handwriting: bool = True

klausur-service/backend/services/trocr_service.py

@@ -31,8 +31,10 @@ from datetime import datetime, timedelta
 logger = logging.getLogger(__name__)
 
 # Lazy loading for heavy dependencies
-_trocr_processor = None
-_trocr_model = None
+# Cache keyed by model_name to support base and large variants simultaneously
+_trocr_models: dict = {}  # {model_name: (processor, model)}
+_trocr_processor = None  # backwards-compat alias → base-printed
+_trocr_model = None      # backwards-compat alias → base-printed
 _trocr_available = None
 _model_loaded_at = None
 
@@ -124,12 +126,14 @@ def _check_trocr_available() -> bool:
     return _trocr_available
 
 
-def get_trocr_model(handwritten: bool = False):
+def get_trocr_model(handwritten: bool = False, size: str = "base"):
     """
     Lazy load TrOCR model and processor.
 
     Args:
         handwritten: Use handwritten model instead of printed model
+        size: Model size — "base" (300 MB) or "large" (340 MB, higher accuracy
+              for exam HTR). Only applies to handwritten variant.
 
     Returns tuple of (processor, model) or (None, None) if unavailable.
     """
@@ -138,31 +142,42 @@ def get_trocr_model(handwritten: bool = False):
     if not _check_trocr_available():
         return None, None
 
-    if _trocr_processor is None or _trocr_model is None:
-        try:
-            import torch
-            from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+    # Select model name
+    if size == "large" and handwritten:
+        model_name = "microsoft/trocr-large-handwritten"
+    elif handwritten:
+        model_name = "microsoft/trocr-base-handwritten"
+    else:
+        model_name = "microsoft/trocr-base-printed"
 
-            # Choose model based on use case
-            if handwritten:
-                model_name = "microsoft/trocr-base-handwritten"
-            else:
-                model_name = "microsoft/trocr-base-printed"
+    if model_name in _trocr_models:
+        return _trocr_models[model_name]
 
-            logger.info(f"Loading TrOCR model: {model_name}")
-            _trocr_processor = TrOCRProcessor.from_pretrained(model_name)
-            _trocr_model = VisionEncoderDecoderModel.from_pretrained(model_name)
+    try:
+        import torch
+        from transformers import TrOCRProcessor, VisionEncoderDecoderModel
 
-            # Use GPU if available
-            device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
-            _trocr_model.to(device)
-            logger.info(f"TrOCR model loaded on device: {device}")
+        logger.info(f"Loading TrOCR model: {model_name}")
+        processor = TrOCRProcessor.from_pretrained(model_name)
+        model = VisionEncoderDecoderModel.from_pretrained(model_name)
 
-        except Exception as e:
-            logger.error(f"Failed to load TrOCR model: {e}")
-            return None, None
+        # Use GPU if available
+        device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
+        model.to(device)
+        logger.info(f"TrOCR model loaded on device: {device}")
 
-    return _trocr_processor, _trocr_model
+        _trocr_models[model_name] = (processor, model)
+
+        # Keep backwards-compat globals pointing at base-printed
+        if model_name == "microsoft/trocr-base-printed":
+            _trocr_processor = processor
+            _trocr_model = model
+
+        return processor, model
+
+    except Exception as e:
+        logger.error(f"Failed to load TrOCR model {model_name}: {e}")
+        return None, None
 
 
 def preload_trocr_model(handwritten: bool = True) -> bool:
@@ -209,7 +224,8 @@ def get_model_status() -> Dict[str, Any]:
 async def run_trocr_ocr(
     image_data: bytes,
     handwritten: bool = False,
-    split_lines: bool = True
+    split_lines: bool = True,
+    size: str = "base",
 ) -> Tuple[Optional[str], float]:
     """
     Run TrOCR on an image.
@@ -223,11 +239,12 @@ async def run_trocr_ocr(
         image_data: Raw image bytes
         handwritten: Use handwritten model (slower but better for handwriting)
         split_lines: Whether to split image into lines first
+        size: "base" or "large" (only for handwritten variant)
 
     Returns:
         Tuple of (extracted_text, confidence)
     """
-    processor, model = get_trocr_model(handwritten=handwritten)
+    processor, model = get_trocr_model(handwritten=handwritten, size=size)
 
     if processor is None or model is None:
         logger.error("TrOCR model not available")

klausur-service/backend/tests/test_vocab_worksheet.py

@@ -615,6 +615,121 @@ class TestEdgeCases:
         assert len(response.json()) == 5
 
 
+# =============================================
+# OCR PIPELINE INTEGRATION TESTS
+# =============================================
+
+class TestProcessSinglePageOCRPipeline:
+    """Tests for the OCR pipeline integration in process-single-page."""
+
+    @patch("vocab_worksheet_api.OCR_PIPELINE_AVAILABLE", True)
+    @patch("vocab_worksheet_api._run_ocr_pipeline_for_page")
+    def test_process_single_page_uses_ocr_pipeline(self, mock_pipeline, client):
+        """When OCR pipeline is available, process-single-page should use it."""
+        # Create a session with PDF data
+        session_id = str(uuid.uuid4())
+        fake_pdf = b"%PDF-1.4 fake"
+        _sessions[session_id] = {
+            "id": session_id,
+            "name": "Test",
+            "status": "uploaded",
+            "pdf_data": fake_pdf,
+            "pdf_page_count": 2,
+            "vocabulary": [],
+        }
+
+        # Mock the pipeline to return vocab entries
+        mock_pipeline.return_value = [
+            {
+                "id": str(uuid.uuid4()),
+                "english": "to achieve",
+                "german": "erreichen",
+                "example_sentence": "She achieved her goal.",
+                "source_page": 1,
+            },
+            {
+                "id": str(uuid.uuid4()),
+                "english": "goal",
+                "german": "Ziel",
+                "example_sentence": "",
+                "source_page": 1,
+            },
+        ]
+
+        with patch("vocab_worksheet_api.convert_pdf_page_to_image", new_callable=AsyncMock) as mock_convert:
+            mock_convert.return_value = b"fake-png-data"
+            response = client.post(f"/api/v1/vocab/sessions/{session_id}/process-single-page/0")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+        assert data["vocabulary_count"] == 2
+        assert data["vocabulary"][0]["english"] == "to achieve"
+        assert data["vocabulary"][0]["source_page"] == 1
+
+        # Verify pipeline was called with correct args
+        mock_pipeline.assert_called_once_with(b"fake-png-data", 0, session_id)
+
+    @patch("vocab_worksheet_api.OCR_PIPELINE_AVAILABLE", True)
+    @patch("vocab_worksheet_api._run_ocr_pipeline_for_page")
+    def test_process_single_page_ocr_pipeline_error_returns_failure(self, mock_pipeline, client):
+        """When the OCR pipeline raises an exception, return success=False."""
+        session_id = str(uuid.uuid4())
+        _sessions[session_id] = {
+            "id": session_id,
+            "name": "Test",
+            "status": "uploaded",
+            "pdf_data": b"%PDF-1.4 fake",
+            "pdf_page_count": 1,
+            "vocabulary": [],
+        }
+
+        mock_pipeline.side_effect = ValueError("Column detection failed")
+
+        with patch("vocab_worksheet_api.convert_pdf_page_to_image", new_callable=AsyncMock) as mock_convert:
+            mock_convert.return_value = b"fake-png-data"
+            response = client.post(f"/api/v1/vocab/sessions/{session_id}/process-single-page/0")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is False
+        assert "OCR pipeline error" in data["error"]
+        assert data["vocabulary"] == []
+
+    @patch("vocab_worksheet_api.OCR_PIPELINE_AVAILABLE", False)
+    @patch("vocab_worksheet_api.extract_vocabulary_from_image", new_callable=AsyncMock)
+    def test_process_single_page_fallback_to_llm(self, mock_llm_extract, client):
+        """When OCR pipeline is not available, fall back to LLM vision."""
+        session_id = str(uuid.uuid4())
+        _sessions[session_id] = {
+            "id": session_id,
+            "name": "Test",
+            "status": "uploaded",
+            "pdf_data": b"%PDF-1.4 fake",
+            "pdf_page_count": 1,
+            "vocabulary": [],
+        }
+
+        mock_entry = MagicMock()
+        mock_entry.dict.return_value = {
+            "id": str(uuid.uuid4()),
+            "english": "house",
+            "german": "Haus",
+            "example_sentence": "",
+        }
+        mock_llm_extract.return_value = ([mock_entry], 0.85, None)
+
+        with patch("vocab_worksheet_api.convert_pdf_page_to_image", new_callable=AsyncMock) as mock_convert:
+            mock_convert.return_value = b"fake-png-data"
+            response = client.post(f"/api/v1/vocab/sessions/{session_id}/process-single-page/0")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True
+        assert data["vocabulary_count"] == 1
+        assert data["vocabulary"][0]["english"] == "house"
+
+
 # =============================================
 # RUN TESTS
 # =============================================

klausur-service/backend/vocab_worksheet_api.py

@@ -59,6 +59,30 @@ except ImportError:
     CV_PIPELINE_AVAILABLE = False
     logger.warning("CV vocab pipeline not available")
 
+# Try to import OCR Pipeline functions (for process-single-page)
+try:
+    import cv2
+    import numpy as np
+    from cv_vocab_pipeline import (
+        deskew_image, deskew_image_by_word_alignment, deskew_image_iterative,
+        deskew_two_pass,
+        dewarp_image, create_ocr_image,
+        detect_column_geometry, analyze_layout_by_words, analyze_layout, create_layout_image,
+        detect_row_geometry, build_cell_grid_v2,
+        _cells_to_vocab_entries, _detect_sub_columns, _detect_header_footer_gaps,
+        expand_narrow_columns, classify_column_types, llm_review_entries,
+        _fix_phonetic_brackets,
+        PageRegion, RowGeometry,
+    )
+    from ocr_pipeline_session_store import (
+        create_session_db as create_pipeline_session_db,
+        update_session_db as update_pipeline_session_db,
+    )
+    OCR_PIPELINE_AVAILABLE = True
+except ImportError as _ocr_pipe_err:
+    OCR_PIPELINE_AVAILABLE = False
+    logger.warning(f"OCR Pipeline functions not available: {_ocr_pipe_err}")
+
 # Try to import Grid Detection Service
 try:
     from services.grid_detection_service import GridDetectionService
@@ -1221,11 +1245,12 @@ async def process_single_page(
     page_number: int,
 ):
     """
-    Process a SINGLE page of an uploaded PDF - completely isolated.
+    Process a SINGLE page of an uploaded PDF using the OCR pipeline.
+
+    Uses the multi-step CV pipeline (deskew → dewarp → columns → rows → words)
+    instead of LLM vision for much better extraction quality.
 
-    This endpoint processes one page at a time to avoid LLM context issues.
     The frontend should call this sequentially for each page.
-
     Returns the vocabulary for just this one page.
     """
     logger.info(f"Processing SINGLE page {page_number + 1} for session {session_id}")
@@ -1244,33 +1269,50 @@ async def process_single_page(
     if page_number < 0 or page_number >= page_count:
         raise HTTPException(status_code=400, detail=f"Invalid page number. PDF has {page_count} pages (0-indexed).")
 
-    # Convert just this ONE page to image
+    # Convert just this ONE page to PNG
     image_data = await convert_pdf_page_to_image(pdf_data, page_number, thumbnail=False)
 
-    # Extract vocabulary from this single page
-    vocabulary, confidence, error = await extract_vocabulary_from_image(
-        image_data,
-        f"page_{page_number + 1}.png",
-        page_number=page_number
-    )
-
-    if error:
-        logger.warning(f"Page {page_number + 1} failed: {error}")
-        return {
-            "session_id": session_id,
-            "page_number": page_number + 1,
-            "success": False,
-            "error": error,
-            "vocabulary": [],
-            "vocabulary_count": 0,
-        }
-
-    # Convert vocabulary entries to dicts with page info
-    page_vocabulary = []
-    for entry in vocabulary:
-        entry_dict = entry.dict() if hasattr(entry, 'dict') else (entry.__dict__.copy() if hasattr(entry, '__dict__') else dict(entry))
-        entry_dict['source_page'] = page_number + 1
-        page_vocabulary.append(entry_dict)
+    # --- OCR Pipeline path ---
+    if OCR_PIPELINE_AVAILABLE:
+        try:
+            page_vocabulary = await _run_ocr_pipeline_for_page(
+                image_data, page_number, session_id,
+            )
+        except Exception as e:
+            logger.error(f"OCR pipeline failed for page {page_number + 1}: {e}", exc_info=True)
+            return {
+                "session_id": session_id,
+                "page_number": page_number + 1,
+                "success": False,
+                "error": f"OCR pipeline error: {e}",
+                "vocabulary": [],
+                "vocabulary_count": 0,
+            }
+    else:
+        # Fallback to LLM vision extraction
+        logger.warning("OCR pipeline not available, falling back to LLM vision")
+        vocabulary, confidence, error = await extract_vocabulary_from_image(
+            image_data,
+            f"page_{page_number + 1}.png",
+            page_number=page_number
+        )
+        if error:
+            logger.warning(f"Page {page_number + 1} failed: {error}")
+            return {
+                "session_id": session_id,
+                "page_number": page_number + 1,
+                "success": False,
+                "error": error,
+                "vocabulary": [],
+                "vocabulary_count": 0,
+            }
+        page_vocabulary = []
+        for entry in vocabulary:
+            entry_dict = entry.dict() if hasattr(entry, 'dict') else (entry.__dict__.copy() if hasattr(entry, '__dict__') else dict(entry))
+            entry_dict['source_page'] = page_number + 1
+            if 'id' not in entry_dict or not entry_dict['id']:
+                entry_dict['id'] = str(uuid.uuid4())
+            page_vocabulary.append(entry_dict)
 
     logger.info(f"Page {page_number + 1}: {len(page_vocabulary)} Vokabeln extrahiert")
 
@@ -1290,10 +1332,196 @@ async def process_single_page(
         "vocabulary": page_vocabulary,
         "vocabulary_count": len(page_vocabulary),
         "total_vocabulary_count": len(existing_vocab),
-        "extraction_confidence": confidence,
+        "extraction_confidence": 0.9,
     }
 
 
+async def _run_ocr_pipeline_for_page(
+    png_data: bytes,
+    page_number: int,
+    vocab_session_id: str,
+) -> list:
+    """Run the full OCR pipeline on a single page image and return vocab entries.
+
+    Steps: deskew → dewarp → columns → rows → words → (LLM review)
+    Returns list of dicts with keys: id, english, german, example_sentence, source_page
+    """
+    import time as _time
+
+    t_total = _time.time()
+
+    # 1. Decode PNG → BGR numpy array
+    arr = np.frombuffer(png_data, dtype=np.uint8)
+    img_bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img_bgr is None:
+        raise ValueError("Failed to decode page image")
+
+    img_h, img_w = img_bgr.shape[:2]
+    logger.info(f"OCR Pipeline page {page_number + 1}: image {img_w}x{img_h}")
+
+    # 2. Create pipeline session in DB (for debugging in admin UI)
+    pipeline_session_id = str(uuid.uuid4())
+    try:
+        await create_pipeline_session_db(
+            pipeline_session_id,
+            name=f"vocab-ws-{vocab_session_id[:8]}-p{page_number + 1}",
+            filename=f"page_{page_number + 1}.png",
+            original_png=png_data,
+        )
+    except Exception as e:
+        logger.warning(f"Could not create pipeline session in DB: {e}")
+
+    # 3. Two-pass deskew: iterative (±5°) + word-alignment residual
+    t0 = _time.time()
+    deskewed_bgr, angle_applied, deskew_debug = deskew_two_pass(img_bgr.copy())
+    angle_pass1 = deskew_debug.get("pass1_angle", 0.0)
+    angle_pass2 = deskew_debug.get("pass2_angle", 0.0)
+
+    logger.info(f"  deskew: pass1={angle_pass1:.2f} pass2={angle_pass2:.2f} "
+                f"total={angle_applied:.2f} ({_time.time() - t0:.1f}s)")
+
+    # 4. Dewarp
+    t0 = _time.time()
+    dewarped_bgr, dewarp_info = dewarp_image(deskewed_bgr)
+    logger.info(f"  dewarp: shear={dewarp_info['shear_degrees']:.3f} ({_time.time() - t0:.1f}s)")
+
+    # 5. Column detection
+    t0 = _time.time()
+    ocr_img = create_ocr_image(dewarped_bgr)
+    h, w = ocr_img.shape[:2]
+
+    geo_result = detect_column_geometry(ocr_img, dewarped_bgr)
+    if geo_result is None:
+        layout_img = create_layout_image(dewarped_bgr)
+        regions = analyze_layout(layout_img, ocr_img)
+        word_dicts = None
+        inv = None
+        content_bounds = None
+    else:
+        geometries, left_x, right_x, top_y, bottom_y, word_dicts, inv = geo_result
+        content_w = right_x - left_x
+        header_y, footer_y = _detect_header_footer_gaps(inv, w, h) if inv is not None else (None, None)
+        geometries = _detect_sub_columns(geometries, content_w, left_x=left_x,
+                                          top_y=top_y, header_y=header_y, footer_y=footer_y)
+        geometries = expand_narrow_columns(geometries, content_w, left_x, word_dicts)
+        regions = classify_column_types(geometries, content_w, top_y, w, h, bottom_y,
+                                        left_x=left_x, right_x=right_x, inv=inv)
+        content_bounds = (left_x, right_x, top_y, bottom_y)
+
+    logger.info(f"  columns: {len(regions)} detected ({_time.time() - t0:.1f}s)")
+
+    # 6. Row detection
+    t0 = _time.time()
+    if word_dicts is None or inv is None or content_bounds is None:
+        # Re-run geometry detection to get intermediates
+        geo_result2 = detect_column_geometry(ocr_img, dewarped_bgr)
+        if geo_result2 is None:
+            raise ValueError("Column geometry detection failed — cannot detect rows")
+        _, left_x, right_x, top_y, bottom_y, word_dicts, inv = geo_result2
+        content_bounds = (left_x, right_x, top_y, bottom_y)
+
+    left_x, right_x, top_y, bottom_y = content_bounds
+    rows = detect_row_geometry(inv, word_dicts, left_x, right_x, top_y, bottom_y)
+    logger.info(f"  rows: {len(rows)} detected ({_time.time() - t0:.1f}s)")
+
+    # 7. Word recognition (cell-first OCR v2)
+    t0 = _time.time()
+    col_regions = regions  # already PageRegion objects
+
+    # Populate row.words for word_count filtering
+    for row in rows:
+        row_y_rel = row.y - top_y
+        row_bottom_rel = row_y_rel + row.height
+        row.words = [
+            wd for wd in word_dicts
+            if row_y_rel <= wd['top'] + wd['height'] / 2 < row_bottom_rel
+        ]
+        row.word_count = len(row.words)
+
+    cells, columns_meta = build_cell_grid_v2(
+        ocr_img, col_regions, rows, img_w, img_h,
+        ocr_engine="auto", img_bgr=dewarped_bgr,
+    )
+
+    col_types = {c['type'] for c in columns_meta}
+    is_vocab = bool(col_types & {'column_en', 'column_de'})
+    logger.info(f"  words: {len(cells)} cells, vocab={is_vocab} ({_time.time() - t0:.1f}s)")
+
+    if not is_vocab:
+        logger.warning(f"  Page {page_number + 1}: layout is not vocab table "
+                       f"(types: {col_types}), returning empty")
+        return []
+
+    # 8. Map cells → vocab entries
+    entries = _cells_to_vocab_entries(cells, columns_meta)
+    entries = _fix_phonetic_brackets(entries, pronunciation="british")
+
+    # 9. Optional LLM review
+    try:
+        review_result = await llm_review_entries(entries)
+        if review_result and review_result.get("changes"):
+            # Apply corrections
+            changes_map = {}
+            for ch in review_result["changes"]:
+                idx = ch.get("index")
+                if idx is not None:
+                    changes_map[idx] = ch
+            for idx, ch in changes_map.items():
+                if 0 <= idx < len(entries):
+                    for field in ("english", "german", "example"):
+                        if ch.get(field) and ch[field] != entries[idx].get(field):
+                            entries[idx][field] = ch[field]
+            logger.info(f"  llm review: {len(review_result['changes'])} corrections applied")
+    except Exception as e:
+        logger.warning(f"  llm review skipped: {e}")
+
+    # 10. Map to frontend format
+    page_vocabulary = []
+    for entry in entries:
+        if not entry.get("english") and not entry.get("german"):
+            continue  # skip empty rows
+        page_vocabulary.append({
+            "id": str(uuid.uuid4()),
+            "english": entry.get("english", ""),
+            "german": entry.get("german", ""),
+            "example_sentence": entry.get("example", ""),
+            "source_page": page_number + 1,
+        })
+
+    # 11. Update pipeline session in DB (for admin debugging)
+    try:
+        success_dsk, dsk_buf = cv2.imencode(".png", deskewed_bgr)
+        deskewed_png = dsk_buf.tobytes() if success_dsk else None
+        success_dwp, dwp_buf = cv2.imencode(".png", dewarped_bgr)
+        dewarped_png = dwp_buf.tobytes() if success_dwp else None
+
+        await update_pipeline_session_db(
+            pipeline_session_id,
+            deskewed_png=deskewed_png,
+            dewarped_png=dewarped_png,
+            deskew_result={"angle_applied": round(angle_applied, 3)},
+            dewarp_result={"shear_degrees": dewarp_info.get("shear_degrees", 0)},
+            column_result={"columns": [{"type": r.type, "x": r.x, "y": r.y,
+                                         "width": r.width, "height": r.height}
+                                        for r in col_regions]},
+            row_result={"total_rows": len(rows)},
+            word_result={
+                "entry_count": len(page_vocabulary),
+                "layout": "vocab",
+                "vocab_entries": entries,
+            },
+            current_step=6,
+        )
+    except Exception as e:
+        logger.warning(f"Could not update pipeline session: {e}")
+
+    total_duration = _time.time() - t_total
+    logger.info(f"OCR Pipeline page {page_number + 1}: "
+                f"{len(page_vocabulary)} vocab entries in {total_duration:.1f}s")
+
+    return page_vocabulary
+
+
 @router.post("/sessions/{session_id}/process-pages")
 async def process_pdf_pages(
     session_id: str,

mkdocs.yml

@@ -65,10 +65,12 @@ nav:
       - BYOEH Architektur: services/klausur-service/BYOEH-Architecture.md
       - BYOEH Developer Guide: services/klausur-service/BYOEH-Developer-Guide.md
       - NiBiS Pipeline: services/klausur-service/NiBiS-Ingestion-Pipeline.md
+      - OCR Pipeline: services/klausur-service/OCR-Pipeline.md
       - OCR Labeling: services/klausur-service/OCR-Labeling-Spec.md
       - OCR Vergleich: services/klausur-service/OCR-Compare.md
       - RAG Admin: services/klausur-service/RAG-Admin-Spec.md
       - Worksheet Editor: services/klausur-service/Worksheet-Editor-Architecture.md
+      - Chunk-Browser: services/klausur-service/Chunk-Browser.md
     - Voice-Service:
       - Uebersicht: services/voice-service/index.md
     - Agent-Core:

scripts/mflux-download-model.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+# Download Flux Schnell model (~12 GB) and start mflux-service.
+# Schedule via: at 23:30 < scripts/mflux-download-model.sh
+# Or:  echo "bash /Users/benjaminadmin/Projekte/breakpilot-lehrer/scripts/mflux-download-model.sh" | at 23:30
+
+LOG="/tmp/mflux-download.log"
+VENV="$HOME/mflux-env"
+SCRIPT="$HOME/Projekte/breakpilot-lehrer/scripts/mflux-service.py"
+
+echo "$(date): Starting Flux Schnell model download..." >> "$LOG"
+
+# Generate a test image to trigger model download
+"$VENV/bin/mflux-generate" \
+  --model schnell \
+  --prompt "test" \
+  --steps 2 \
+  --width 256 --height 256 \
+  -o /tmp/mflux-test.png \
+  >> "$LOG" 2>&1
+
+echo "$(date): Model download complete. Starting mflux-service..." >> "$LOG"
+
+# Start the service
+nohup "$VENV/bin/python" "$SCRIPT" >> "$LOG" 2>&1 &
+
+echo "$(date): mflux-service started (PID $!)." >> "$LOG"

scripts/mflux-service.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+mflux-service — Standalone FastAPI wrapper for mflux image generation.
+
+Runs NATIVELY on Mac Mini (requires Metal GPU, not Docker).
+Generates images using Flux Schnell via the mflux library.
+
+Setup:
+    python3 -m venv ~/mflux-env
+    source ~/mflux-env/bin/activate
+    pip install mflux fastapi uvicorn
+
+Run:
+    source ~/mflux-env/bin/activate
+    python scripts/mflux-service.py
+
+Or as a background service:
+    nohup ~/mflux-env/bin/python scripts/mflux-service.py > /tmp/mflux-service.log 2>&1 &
+
+License: Apache-2.0
+"""
+
+import base64
+import io
+import logging
+import os
+import time
+from typing import Optional
+
+import uvicorn
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("mflux-service")
+
+app = FastAPI(title="mflux Image Generation Service", version="1.0.0")
+
+# Lazy-loaded generator
+_flux = None
+
+
+def _get_flux():
+    """Lazy-load the Flux model on first use."""
+    global _flux
+    if _flux is None:
+        logger.info("Loading Flux Schnell model (first call, may download ~12 GB)...")
+        from mflux import Flux1
+
+        _flux = Flux1(
+            model_name="schnell",
+            quantize=8,
+        )
+        logger.info("Flux Schnell model loaded.")
+    return _flux
+
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    width: int = 512
+    height: int = 512
+    steps: int = 4
+    seed: Optional[int] = None
+
+
+class GenerateResponse(BaseModel):
+    image_b64: Optional[str] = None
+    success: bool = True
+    error: Optional[str] = None
+    duration_ms: int = 0
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "model": "flux-schnell", "gpu": "metal"}
+
+
+@app.post("/generate", response_model=GenerateResponse)
+async def generate_image(req: GenerateRequest):
+    """Generate an image from a text prompt using Flux Schnell."""
+    t0 = time.time()
+
+    # Validate dimensions (must be multiples of 64 for Flux)
+    width = max(256, min(1024, (req.width // 64) * 64))
+    height = max(256, min(1024, (req.height // 64) * 64))
+
+    try:
+        from mflux import Config
+
+        flux = _get_flux()
+        image = flux.generate_image(
+            seed=req.seed or int(time.time()) % 2**31,
+            prompt=req.prompt,
+            config=Config(
+                num_inference_steps=req.steps,
+                height=height,
+                width=width,
+            ),
+        )
+
+        # Convert PIL image to base64
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        buf.seek(0)
+        img_b64 = "data:image/png;base64," + base64.b64encode(buf.read()).decode("utf-8")
+
+        duration_ms = int((time.time() - t0) * 1000)
+        logger.info(f"Generated {width}x{height} image in {duration_ms}ms: {req.prompt[:60]}...")
+
+        return GenerateResponse(image_b64=img_b64, success=True, duration_ms=duration_ms)
+
+    except Exception as e:
+        duration_ms = int((time.time() - t0) * 1000)
+        logger.error(f"Generation failed: {e}")
+        return GenerateResponse(image_b64=None, success=False, error=str(e), duration_ms=duration_ms)
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("MFLUX_PORT", "8095"))
+    logger.info(f"Starting mflux-service on port {port}")
+    uvicorn.run(app, host="0.0.0.0", port=port)

studio-v2/app/vocab-worksheet/page.tsx

@@ -33,6 +33,13 @@ interface VocabularyEntry {
   word_type?: string
   source_page?: number
   selected?: boolean
+  extras?: Record<string, string>
+}
+
+// Dynamic column definition (per source page)
+interface ExtraColumn {
+  key: string
+  label: string
 }
 
 interface Session {
@@ -132,6 +139,9 @@ export default function VocabWorksheetPage() {
   const [isLoadingThumbnails, setIsLoadingThumbnails] = useState(false)
   const [excludedPages, setExcludedPages] = useState<number[]>([])
 
+  // Dynamic extra columns per source page (key: page number, value: extra columns)
+  const [pageExtraColumns, setPageExtraColumns] = useState<Record<number, ExtraColumn[]>>({})
+
   // Upload state
   const [uploadedImage, setUploadedImage] = useState<string | null>(null)
   const [isExtracting, setIsExtracting] = useState(false)
@@ -559,10 +569,63 @@ export default function VocabWorksheetPage() {
   }
 
   // Update vocabulary entry
-  const updateVocabularyEntry = (id: string, field: keyof VocabularyEntry, value: string) => {
-    setVocabulary(prev => prev.map(v =>
-      v.id === id ? { ...v, [field]: value } : v
-    ))
+  const updateVocabularyEntry = (id: string, field: string, value: string) => {
+    setVocabulary(prev => prev.map(v => {
+      if (v.id !== id) return v
+      // Check if it's a base field or an extra column
+      if (field === 'english' || field === 'german' || field === 'example_sentence' || field === 'word_type') {
+        return { ...v, [field]: value }
+      }
+      // Extra column
+      return { ...v, extras: { ...(v.extras || {}), [field]: value } }
+    }))
+  }
+
+  // Add a custom column for a specific source page (0 = all pages)
+  const addExtraColumn = (sourcePage: number) => {
+    const label = prompt('Spaltenname:')
+    if (!label || !label.trim()) return
+    const key = `extra_${Date.now()}`
+    setPageExtraColumns(prev => ({
+      ...prev,
+      [sourcePage]: [...(prev[sourcePage] || []), { key, label: label.trim() }],
+    }))
+  }
+
+  // Remove a custom column
+  const removeExtraColumn = (sourcePage: number, key: string) => {
+    setPageExtraColumns(prev => ({
+      ...prev,
+      [sourcePage]: (prev[sourcePage] || []).filter(c => c.key !== key),
+    }))
+    // Clean up extras from entries
+    setVocabulary(prev => prev.map(v => {
+      if (!v.extras || !(key in v.extras)) return v
+      const { [key]: _, ...rest } = v.extras
+      return { ...v, extras: rest }
+    }))
+  }
+
+  // Get extra columns for a given source page (page-specific + global)
+  const getExtraColumnsForPage = (sourcePage: number): ExtraColumn[] => {
+    const global = pageExtraColumns[0] || []
+    const pageSpecific = pageExtraColumns[sourcePage] || []
+    return [...global, ...pageSpecific]
+  }
+
+  // Get ALL extra columns across all pages (for unified table header)
+  const getAllExtraColumns = (): ExtraColumn[] => {
+    const seen = new Set<string>()
+    const result: ExtraColumn[] = []
+    for (const cols of Object.values(pageExtraColumns)) {
+      for (const col of cols) {
+        if (!seen.has(col.key)) {
+          seen.add(col.key)
+          result.push(col)
+        }
+      }
+    }
+    return result
   }
 
   // Delete vocabulary entry
@@ -891,7 +954,7 @@ export default function VocabWorksheetPage() {
         </div>
       </div>
 
-      <div className="relative z-10 max-w-7xl mx-auto px-6 py-6">
+      <div className="relative z-10 w-full px-6 py-6">
         {/* OCR Settings Panel */}
         {showSettings && (
           <div className={`${glassCard} rounded-2xl p-6 mb-6`}>
@@ -1416,11 +1479,66 @@ export default function VocabWorksheetPage() {
         )}
 
         {/* Vocabulary Tab */}
-        {session && activeTab === 'vocabulary' && (
-          <div className="grid grid-cols-1 lg:grid-cols-5 gap-6">
-            {/* Left: Vocabulary List (3/5) */}
-            <div className={`${glassCard} rounded-2xl p-6 lg:col-span-3`}>
-              <div className="flex items-center justify-between mb-4">
+        {session && activeTab === 'vocabulary' && (() => {
+            const extras = getAllExtraColumns()
+            const baseCols = 3 + extras.length // english, german, example + extras
+            const gridCols = `14px 32px 36px repeat(${baseCols}, 1fr) 32px`
+            return (
+          <div className="flex flex-col lg:flex-row gap-4" style={{ height: 'calc(100vh - 240px)', minHeight: '500px' }}>
+            {/* Left: Original pages — full quality */}
+            <div className={`${glassCard} rounded-2xl p-4 lg:w-1/3 flex flex-col overflow-hidden`}>
+              <h2 className={`text-sm font-semibold mb-3 flex-shrink-0 ${isDark ? 'text-white/70' : 'text-slate-600'}`}>
+                Original ({(() => { const pp = selectedPages.length > 0 ? selectedPages : [...new Set(vocabulary.map(v => (v.source_page || 1) - 1))]; return pp.length; })()} Seiten)
+              </h2>
+              <div className="flex-1 overflow-y-auto space-y-3">
+                {(() => {
+                  const processedPageIndices = selectedPages.length > 0
+                    ? selectedPages
+                    : [...new Set(vocabulary.map(v => (v.source_page || 1) - 1))].sort((a, b) => a - b)
+
+                  const apiBase = getApiBase()
+                  const pagesToShow = processedPageIndices
+                    .filter(idx => idx >= 0)
+                    .map(idx => ({
+                      idx,
+                      src: session ? `${apiBase}/api/v1/vocab/sessions/${session.id}/pdf-page-image/${idx}` : null,
+                    }))
+                    .filter(t => t.src !== null) as { idx: number; src: string }[]
+
+                  if (pagesToShow.length > 0) {
+                    return pagesToShow.map(({ idx, src }) => (
+                      <div key={idx} className={`relative rounded-xl overflow-hidden border ${isDark ? 'border-white/10' : 'border-black/10'}`}>
+                        <div className={`absolute top-2 left-2 px-2 py-0.5 rounded-lg text-xs font-medium z-10 ${isDark ? 'bg-black/60 text-white' : 'bg-white/90 text-slate-700'}`}>
+                          S. {idx + 1}
+                        </div>
+                        <img src={src} alt={`Seite ${idx + 1}`} className="w-full h-auto" />
+                      </div>
+                    ))
+                  }
+                  if (uploadedImage) {
+                    return (
+                      <div className={`relative rounded-xl overflow-hidden border ${isDark ? 'border-white/10' : 'border-black/10'}`}>
+                        <img src={uploadedImage} alt="Arbeitsblatt" className="w-full h-auto" />
+                      </div>
+                    )
+                  }
+                  return (
+                    <div className={`flex-1 flex items-center justify-center py-12 ${isDark ? 'text-white/40' : 'text-slate-400'}`}>
+                      <div className="text-center">
+                        <svg className="w-12 h-12 mx-auto mb-2 opacity-50" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
+                        </svg>
+                        <p className="text-xs">Kein Bild verfuegbar</p>
+                      </div>
+                    </div>
+                  )
+                })()}
+              </div>
+            </div>
+
+            {/* Right: Vocabulary table (2/3 width) */}
+            <div className={`${glassCard} rounded-2xl p-4 lg:w-2/3 flex flex-col overflow-hidden`}>
+              <div className="flex items-center justify-between mb-3 flex-shrink-0">
                 <h2 className={`text-lg font-semibold ${isDark ? 'text-white' : 'text-slate-900'}`}>
                   Vokabeln ({vocabulary.length})
                 </h2>
@@ -1436,9 +1554,9 @@ export default function VocabWorksheetPage() {
 
             {/* Error messages for failed pages */}
             {processingErrors.length > 0 && (
-              <div className={`rounded-xl p-4 mb-4 ${isDark ? 'bg-orange-500/20 text-orange-200 border border-orange-500/30' : 'bg-orange-100 text-orange-700 border border-orange-200'}`}>
-                <div className="font-medium mb-2">Einige Seiten konnten nicht verarbeitet werden:</div>
-                <ul className="text-sm space-y-1">
+              <div className={`rounded-xl p-3 mb-3 flex-shrink-0 ${isDark ? 'bg-orange-500/20 text-orange-200 border border-orange-500/30' : 'bg-orange-100 text-orange-700 border border-orange-200'}`}>
+                <div className="font-medium mb-1 text-sm">Einige Seiten konnten nicht verarbeitet werden:</div>
+                <ul className="text-xs space-y-0.5">
                   {processingErrors.map((err, idx) => (
                     <li key={idx}>• {err}</li>
                   ))}
@@ -1448,12 +1566,12 @@ export default function VocabWorksheetPage() {
 
             {/* Processing Progress */}
             {currentlyProcessingPage && (
-              <div className={`rounded-xl p-4 mb-4 ${isDark ? 'bg-purple-500/20 border border-purple-500/30' : 'bg-purple-100 border border-purple-200'}`}>
+              <div className={`rounded-xl p-3 mb-3 flex-shrink-0 ${isDark ? 'bg-purple-500/20 border border-purple-500/30' : 'bg-purple-100 border border-purple-200'}`}>
                 <div className="flex items-center gap-3">
-                  <div className={`w-5 h-5 border-2 ${isDark ? 'border-purple-300' : 'border-purple-600'} border-t-transparent rounded-full animate-spin`} />
+                  <div className={`w-4 h-4 border-2 ${isDark ? 'border-purple-300' : 'border-purple-600'} border-t-transparent rounded-full animate-spin`} />
                   <div>
-                    <div className={`font-medium ${isDark ? 'text-purple-200' : 'text-purple-700'}`}>Verarbeite Seite {currentlyProcessingPage}...</div>
-                    <div className={`text-sm ${isDark ? 'text-purple-300/70' : 'text-purple-600'}`}>
+                    <div className={`text-sm font-medium ${isDark ? 'text-purple-200' : 'text-purple-700'}`}>Verarbeite Seite {currentlyProcessingPage}...</div>
+                    <div className={`text-xs ${isDark ? 'text-purple-300/70' : 'text-purple-600'}`}>
                       {successfulPages.length > 0 && `${successfulPages.length} Seite(n) fertig • `}
                       {vocabulary.length} Vokabeln bisher
                     </div>
@@ -1464,14 +1582,14 @@ export default function VocabWorksheetPage() {
 
             {/* Success info */}
             {!currentlyProcessingPage && successfulPages.length > 0 && failedPages.length === 0 && (
-              <div className={`rounded-xl p-3 mb-4 text-sm ${isDark ? 'bg-green-500/20 text-green-200 border border-green-500/30' : 'bg-green-100 text-green-700 border border-green-200'}`}>
+              <div className={`rounded-xl p-2 mb-3 text-xs flex-shrink-0 ${isDark ? 'bg-green-500/20 text-green-200 border border-green-500/30' : 'bg-green-100 text-green-700 border border-green-200'}`}>
                 Alle {successfulPages.length} Seite(n) erfolgreich verarbeitet - {vocabulary.length} Vokabeln insgesamt
               </div>
             )}
 
             {/* Partial success info */}
             {!currentlyProcessingPage && successfulPages.length > 0 && failedPages.length > 0 && (
-              <div className={`rounded-xl p-3 mb-4 text-sm ${isDark ? 'bg-yellow-500/20 text-yellow-200 border border-yellow-500/30' : 'bg-yellow-100 text-yellow-700 border border-yellow-200'}`}>
+              <div className={`rounded-xl p-2 mb-3 text-xs flex-shrink-0 ${isDark ? 'bg-yellow-500/20 text-yellow-200 border border-yellow-500/30' : 'bg-yellow-100 text-yellow-700 border border-yellow-200'}`}>
                 {successfulPages.length} Seite(n) erfolgreich, {failedPages.length} fehlgeschlagen - {vocabulary.length} Vokabeln extrahiert
               </div>
             )}
@@ -1479,49 +1597,64 @@ export default function VocabWorksheetPage() {
             {vocabulary.length === 0 ? (
               <p className={`text-center py-8 ${isDark ? 'text-white/60' : 'text-slate-500'}`}>Keine Vokabeln gefunden.</p>
             ) : (
-              <div className="flex flex-col" style={{ height: 'calc(100vh - 400px)', minHeight: '300px' }}>
+              <div className="flex flex-col flex-1 overflow-hidden">
                 {/* Fixed Header */}
-                <div className={`grid grid-cols-13 gap-2 px-3 py-2 text-sm font-medium border-b ${isDark ? 'border-white/10 text-white/60' : 'border-black/10 text-slate-500'}`} style={{ gridTemplateColumns: 'auto repeat(12, minmax(0, 1fr))' }}>
-                  <div className="flex items-center justify-center w-6">
+                <div className={`flex-shrink-0 grid gap-1 px-2 py-2 text-sm font-medium border-b items-center ${isDark ? 'border-white/10 text-white/60' : 'border-black/10 text-slate-500'}`} style={{ gridTemplateColumns: gridCols }}>
+                  <div>{/* insert-triangle spacer */}</div>
+                  <div className="flex items-center justify-center">
                     <input
                       type="checkbox"
                       checked={vocabulary.length > 0 && vocabulary.every(v => v.selected)}
                       onChange={toggleAllSelection}
                       className="w-4 h-4 rounded border-gray-300 text-purple-600 focus:ring-purple-500 cursor-pointer"
-                      title="Alle auswählen"
+                      title="Alle auswaehlen"
                     />
                   </div>
-                  <div className="col-span-1">S.</div>
-                  <div className="col-span-3">Englisch</div>
-                  <div className="col-span-4">Deutsch</div>
-                  <div className="col-span-3">Beispiel</div>
-                  <div className="col-span-1"></div>
+                  <div>S.</div>
+                  <div>Englisch</div>
+                  <div>Deutsch</div>
+                  <div>Beispiel</div>
+                  {extras.map(col => (
+                    <div key={col.key} className="flex items-center gap-1 group">
+                      <span className="truncate">{col.label}</span>
+                      <button
+                        onClick={() => {
+                          const page = Object.entries(pageExtraColumns).find(([, cols]) => cols.some(c => c.key === col.key))
+                          if (page) removeExtraColumn(Number(page[0]), col.key)
+                        }}
+                        className={`opacity-0 group-hover:opacity-100 transition-opacity ${isDark ? 'text-red-400 hover:text-red-300' : 'text-red-500 hover:text-red-600'}`}
+                        title="Spalte entfernen"
+                      >
+                        <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" /></svg>
+                      </button>
+                    </div>
+                  ))}
+                  <div className="flex items-center justify-center">
+                    <button
+                      onClick={() => addExtraColumn(0)}
+                      className={`p-0.5 rounded transition-colors ${isDark ? 'hover:bg-white/10 text-white/40 hover:text-white/70' : 'hover:bg-slate-200 text-slate-400 hover:text-slate-600'}`}
+                      title="Spalte hinzufuegen"
+                    >
+                      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" /></svg>
+                    </button>
+                  </div>
                 </div>
 
                 {/* Scrollable Content */}
-                <div className="flex-1 overflow-y-auto py-2">
-                  {/* Insert button at the beginning */}
-                  <div className="flex justify-center py-1 group">
-                    <button
-                      onClick={() => addVocabularyEntry(0)}
-                      className={`px-3 py-0.5 rounded-full text-xs flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity ${
-                        isDark
-                          ? 'bg-purple-500/20 text-purple-300 hover:bg-purple-500/30'
-                          : 'bg-purple-100 text-purple-600 hover:bg-purple-200'
-                      }`}
-                    >
-                      <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-                      </svg>
-                      Zeile einfügen
-                    </button>
-                  </div>
-
+                <div className="flex-1 overflow-y-auto">
                   {vocabulary.map((entry, index) => (
                     <React.Fragment key={entry.id}>
                       {/* Vocabulary row */}
-                      <div className={`grid gap-2 px-3 py-2 rounded-xl ${isDark ? 'bg-white/5' : 'bg-black/5'}`} style={{ gridTemplateColumns: 'auto repeat(12, minmax(0, 1fr))' }}>
-                        <div className="flex items-center justify-center w-6">
+                      <div className={`grid gap-1 px-2 py-1 items-center ${isDark ? 'hover:bg-white/5' : 'hover:bg-black/5'}`} style={{ gridTemplateColumns: gridCols }}>
+                        {/* Insert triangle */}
+                        <button
+                          onClick={() => addVocabularyEntry(index)}
+                          className={`w-3.5 h-3.5 flex items-center justify-center opacity-0 hover:opacity-100 transition-opacity ${isDark ? 'text-purple-400' : 'text-purple-500'}`}
+                          title="Zeile einfuegen"
+                        >
+                          <svg className="w-2.5 h-2.5" viewBox="0 0 10 10" fill="currentColor"><polygon points="0,0 10,5 0,10" /></svg>
+                        </button>
+                        <div className="flex items-center justify-center">
                           <input
                             type="checkbox"
                             checked={entry.selected || false}
@@ -1529,128 +1662,88 @@ export default function VocabWorksheetPage() {
                             className="w-4 h-4 rounded border-gray-300 text-purple-600 focus:ring-purple-500 cursor-pointer"
                           />
                         </div>
-                        <div className={`col-span-1 flex items-center justify-center text-xs font-medium rounded ${isDark ? 'bg-white/10 text-white/60' : 'bg-black/10 text-slate-600'}`}>
+                        <div className={`flex items-center justify-center text-xs font-medium rounded ${isDark ? 'bg-white/10 text-white/60' : 'bg-black/10 text-slate-600'}`}>
                           {entry.source_page || '-'}
                         </div>
                         <input
                           type="text"
                           value={entry.english}
                           onChange={(e) => updateVocabularyEntry(entry.id, 'english', e.target.value)}
-                          className={`col-span-3 px-2 py-1 rounded-lg border ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
+                          className={`px-2 py-1 rounded-lg border text-sm min-w-0 ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
                         />
                         <input
                           type="text"
                           value={entry.german}
                           onChange={(e) => updateVocabularyEntry(entry.id, 'german', e.target.value)}
-                          className={`col-span-4 px-2 py-1 rounded-lg border ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
+                          className={`px-2 py-1 rounded-lg border text-sm min-w-0 ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
                         />
                         <input
                           type="text"
                           value={entry.example_sentence || ''}
                           onChange={(e) => updateVocabularyEntry(entry.id, 'example_sentence', e.target.value)}
                           placeholder="Beispiel"
-                          className={`col-span-3 px-2 py-1 rounded-lg border text-sm ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
+                          className={`px-2 py-1 rounded-lg border text-sm min-w-0 ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
                         />
-                        <button onClick={() => deleteVocabularyEntry(entry.id)} className={`col-span-1 p-1 rounded-lg ${isDark ? 'hover:bg-red-500/20 text-red-400' : 'hover:bg-red-100 text-red-500'}`}>
-                          <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                        {extras.map(col => (
+                          <input
+                            key={col.key}
+                            type="text"
+                            value={(entry.extras && entry.extras[col.key]) || ''}
+                            onChange={(e) => updateVocabularyEntry(entry.id, col.key, e.target.value)}
+                            placeholder={col.label}
+                            className={`px-2 py-1 rounded-lg border text-sm min-w-0 ${glassInput} focus:outline-none focus:ring-1 focus:ring-purple-500`}
+                          />
+                        ))}
+                        <button onClick={() => deleteVocabularyEntry(entry.id)} className={`p-1 rounded-lg ${isDark ? 'hover:bg-red-500/20 text-red-400' : 'hover:bg-red-100 text-red-500'}`}>
+                          <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                             <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
                           </svg>
                         </button>
                       </div>
-
-                      {/* Insert button after each row */}
-                      <div className="flex justify-center py-1 group">
-                        <button
-                          onClick={() => addVocabularyEntry(index + 1)}
-                          className={`px-3 py-0.5 rounded-full text-xs flex items-center gap-1 opacity-0 group-hover:opacity-100 transition-opacity ${
-                            isDark
-                              ? 'bg-purple-500/20 text-purple-300 hover:bg-purple-500/30'
-                              : 'bg-purple-100 text-purple-600 hover:bg-purple-200'
-                          }`}
-                        >
-                          <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-                          </svg>
-                          Zeile einfügen
-                        </button>
-                      </div>
                     </React.Fragment>
                   ))}
+                  {/* Final insert triangle after last row */}
+                  <div className="px-2 py-1">
+                    <button
+                      onClick={() => addVocabularyEntry()}
+                      className={`w-3.5 h-3.5 flex items-center justify-center opacity-30 hover:opacity-100 transition-opacity ${isDark ? 'text-purple-400' : 'text-purple-500'}`}
+                      title="Zeile am Ende einfuegen"
+                    >
+                      <svg className="w-2.5 h-2.5" viewBox="0 0 10 10" fill="currentColor"><polygon points="0,0 10,5 0,10" /></svg>
+                    </button>
+                  </div>
                 </div>
 
-                {/* Add new row button at the end */}
-                <button
-                  onClick={() => addVocabularyEntry()}
-                  className={`w-full py-2 mt-2 rounded-xl border-2 border-dashed flex items-center justify-center gap-2 transition-colors ${
-                    isDark
-                      ? 'border-white/20 text-white/60 hover:border-purple-400 hover:text-purple-400 hover:bg-purple-500/10'
-                      : 'border-black/20 text-slate-500 hover:border-purple-500 hover:text-purple-500 hover:bg-purple-50'
-                  }`}
-                >
-                  <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-                  </svg>
-                  Neue Zeile hinzufügen
-                </button>
-
-                {/* Footer with scroll hint */}
-                <div className={`pt-2 border-t text-center text-sm ${isDark ? 'border-white/10 text-white/50' : 'border-black/10 text-slate-400'}`}>
-                  {vocabulary.length} Vokabeln insgesamt
-                  {vocabulary.filter(v => v.selected).length > 0 && ` (${vocabulary.filter(v => v.selected).length} ausgewählt)`}
-                  {(() => {
-                    const pages = [...new Set(vocabulary.map(v => v.source_page).filter(Boolean))].sort((a, b) => (a || 0) - (b || 0))
-                    return pages.length > 1 ? ` • Seiten: ${pages.join(', ')}` : ''
-                  })()}
+                {/* Footer */}
+                <div className={`flex-shrink-0 pt-2 border-t flex items-center justify-between text-xs ${isDark ? 'border-white/10 text-white/50' : 'border-black/10 text-slate-400'}`}>
+                  <span>
+                    {vocabulary.length} Vokabeln
+                    {vocabulary.filter(v => v.selected).length > 0 && ` (${vocabulary.filter(v => v.selected).length} ausgewaehlt)`}
+                    {(() => {
+                      const pages = [...new Set(vocabulary.map(v => v.source_page).filter(Boolean))].sort((a, b) => (a || 0) - (b || 0))
+                      return pages.length > 1 ? ` • Seiten: ${pages.join(', ')}` : ''
+                    })()}
+                  </span>
+                  <button
+                    onClick={() => addVocabularyEntry()}
+                    className={`px-3 py-1 rounded-lg text-xs flex items-center gap-1 transition-colors ${
+                      isDark
+                        ? 'bg-white/10 hover:bg-white/20 text-white/70'
+                        : 'bg-slate-100 hover:bg-slate-200 text-slate-600'
+                    }`}
+                  >
+                    <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
+                    </svg>
+                    Zeile
+                  </button>
                 </div>
               </div>
             )}
             </div>
-
-            {/* Right: Original Worksheet Preview (2/5) */}
-            <div className={`${glassCard} rounded-2xl p-6 lg:col-span-2`}>
-              <h2 className={`text-lg font-semibold mb-4 ${isDark ? 'text-white' : 'text-slate-900'}`}>
-                Original-Arbeitsblatt
-              </h2>
-              <div className="flex flex-col" style={{ height: 'calc(100vh - 400px)', minHeight: '300px' }}>
-                {pagesThumbnails.length > 0 ? (
-                  <div className="flex-1 overflow-y-auto space-y-4">
-                    {pagesThumbnails.map((thumb, idx) => (
-                      <div key={idx} className={`relative rounded-xl overflow-hidden border ${isDark ? 'border-white/10' : 'border-black/10'}`}>
-                        <div className={`absolute top-2 left-2 px-2 py-1 rounded-lg text-xs font-medium ${isDark ? 'bg-black/50 text-white' : 'bg-white/90 text-slate-700'}`}>
-                          Seite {idx + 1}
-                        </div>
-                        <img
-                          src={thumb}
-                          alt={`Seite ${idx + 1}`}
-                          className="w-full h-auto"
-                        />
-                      </div>
-                    ))}
-                  </div>
-                ) : uploadedImage ? (
-                  <div className="flex-1 overflow-y-auto">
-                    <div className={`relative rounded-xl overflow-hidden border ${isDark ? 'border-white/10' : 'border-black/10'}`}>
-                      <img
-                        src={uploadedImage}
-                        alt="Hochgeladenes Arbeitsblatt"
-                        className="w-full h-auto"
-                      />
-                    </div>
-                  </div>
-                ) : (
-                  <div className={`flex-1 flex items-center justify-center ${isDark ? 'text-white/40' : 'text-slate-400'}`}>
-                    <div className="text-center">
-                      <svg className="w-16 h-16 mx-auto mb-3 opacity-50" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M4 16l4.586-4.586a2 2 0 012.828 0L16 16m-2-2l1.586-1.586a2 2 0 012.828 0L20 14m-6-6h.01M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
-                      </svg>
-                      <p className="text-sm">Kein Bild verfügbar</p>
-                    </div>
-                  </div>
-                )}
-              </div>
-            </div>
           </div>
-        )}
+            )
+          })()}
 
         {/* Worksheet Tab */}
         {session && activeTab === 'worksheet' && (

voice-service/.env.example

@@ -0,0 +1,59 @@
+# Voice Service Environment Variables
+# Copy this file to .env and adjust values
+
+# Service Configuration
+PORT=8091
+ENVIRONMENT=development
+DEBUG=false
+
+# JWT Authentication (REQUIRED - load from HashiCorp Vault)
+# vault kv get -field=secret secret/breakpilot/auth/jwt
+JWT_SECRET=
+JWT_ALGORITHM=HS256
+JWT_EXPIRATION_HOURS=24
+
+# PostgreSQL (REQUIRED - load from HashiCorp Vault)
+# vault kv get -field=url secret/breakpilot/database/postgres
+DATABASE_URL=
+
+# Valkey (Redis-fork) Session Cache
+VALKEY_URL=redis://valkey:6379/2
+SESSION_TTL_HOURS=24
+TASK_TTL_HOURS=168
+
+# PersonaPlex Configuration (Production GPU)
+PERSONAPLEX_ENABLED=false
+PERSONAPLEX_WS_URL=ws://host.docker.internal:8998
+PERSONAPLEX_MODEL=personaplex-7b
+PERSONAPLEX_TIMEOUT=30
+
+# Task Orchestrator
+ORCHESTRATOR_ENABLED=true
+ORCHESTRATOR_MAX_CONCURRENT_TASKS=10
+
+# Fallback LLM (Ollama for Development)
+FALLBACK_LLM_PROVIDER=ollama
+OLLAMA_BASE_URL=http://host.docker.internal:11434
+OLLAMA_VOICE_MODEL=qwen2.5:32b
+OLLAMA_TIMEOUT=120
+
+# Klausur Service Integration
+KLAUSUR_SERVICE_URL=http://klausur-service:8086
+
+# Audio Configuration
+AUDIO_SAMPLE_RATE=24000
+AUDIO_FRAME_SIZE_MS=80
+AUDIO_PERSISTENCE=false
+
+# Encryption Configuration
+ENCRYPTION_ENABLED=true
+NAMESPACE_KEY_ALGORITHM=AES-256-GCM
+
+# TTL Configuration (DSGVO Data Minimization)
+TRANSCRIPT_TTL_DAYS=7
+TASK_STATE_TTL_DAYS=30
+AUDIT_LOG_TTL_DAYS=90
+
+# Rate Limiting
+MAX_SESSIONS_PER_USER=5
+MAX_REQUESTS_PER_MINUTE=60

voice-service/Dockerfile

@@ -0,0 +1,59 @@
+# Voice Service - PersonaPlex + TaskOrchestrator Integration
+# DSGVO-konform, keine Audio-Persistenz
+FROM python:3.11-slim-bookworm
+
+# Build arguments
+ARG TARGETARCH
+
+# Install system dependencies for audio processing
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    # Build essentials
+    build-essential \
+    gcc \
+    g++ \
+    # Audio processing
+    libsndfile1 \
+    libportaudio2 \
+    ffmpeg \
+    # Network tools
+    curl \
+    wget \
+    # Clean up
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app directory
+WORKDIR /app
+
+# Create non-root user for security
+RUN groupadd -r voiceservice && useradd -r -g voiceservice voiceservice
+
+# Create data directories (sessions are transient, not persisted)
+RUN mkdir -p /app/data/sessions /app/personas \
+    && chown -R voiceservice:voiceservice /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY --chown=voiceservice:voiceservice . .
+
+# Create __init__.py files for Python packages
+RUN touch /app/api/__init__.py \
+    && touch /app/services/__init__.py \
+    && touch /app/models/__init__.py
+
+# Switch to non-root user
+USER voiceservice
+
+# Expose port
+EXPOSE 8091
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8091/health || exit 1
+
+# Start application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8091"]

voice-service/api/__init__.py

@@ -0,0 +1,12 @@
+"""
+Voice Service API Routes
+"""
+from api.sessions import router as sessions_router
+from api.tasks import router as tasks_router
+from api.streaming import router as streaming_router
+
+__all__ = [
+    "sessions_router",
+    "tasks_router",
+    "streaming_router",
+]

voice-service/api/bqas.py

@@ -0,0 +1,365 @@
+"""
+BQAS API - Quality Assurance Endpoints
+"""
+import structlog
+import subprocess
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+from bqas.runner import get_runner, BQASRunner
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+# Response Models
+class TestRunResponse(BaseModel):
+    id: int
+    timestamp: str
+    git_commit: Optional[str] = None
+    suite: str
+    golden_score: float
+    synthetic_score: float
+    rag_score: float = 0.0
+    total_tests: int
+    passed_tests: int
+    failed_tests: int
+    duration_seconds: float
+
+
+class MetricsResponse(BaseModel):
+    total_tests: int
+    passed_tests: int
+    failed_tests: int
+    avg_intent_accuracy: float
+    avg_faithfulness: float
+    avg_relevance: float
+    avg_coherence: float
+    safety_pass_rate: float
+    avg_composite_score: float
+    scores_by_intent: Dict[str, float]
+    failed_test_ids: List[str]
+
+
+class TrendResponse(BaseModel):
+    dates: List[str]
+    scores: List[float]
+    trend: str  # improving, stable, declining, insufficient_data
+
+
+class LatestMetricsResponse(BaseModel):
+    golden: Optional[MetricsResponse] = None
+    synthetic: Optional[MetricsResponse] = None
+    rag: Optional[MetricsResponse] = None
+
+
+class RunResultResponse(BaseModel):
+    success: bool
+    message: str
+    metrics: Optional[MetricsResponse] = None
+    run_id: Optional[int] = None
+
+
+# State tracking for running tests
+_is_running: Dict[str, bool] = {"golden": False, "synthetic": False, "rag": False}
+
+
+def _get_git_commit() -> Optional[str]:
+    """Get current git commit hash."""
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def _metrics_to_response(metrics) -> MetricsResponse:
+    """Convert BQASMetrics to API response."""
+    return MetricsResponse(
+        total_tests=metrics.total_tests,
+        passed_tests=metrics.passed_tests,
+        failed_tests=metrics.failed_tests,
+        avg_intent_accuracy=round(metrics.avg_intent_accuracy, 2),
+        avg_faithfulness=round(metrics.avg_faithfulness, 2),
+        avg_relevance=round(metrics.avg_relevance, 2),
+        avg_coherence=round(metrics.avg_coherence, 2),
+        safety_pass_rate=round(metrics.safety_pass_rate, 3),
+        avg_composite_score=round(metrics.avg_composite_score, 3),
+        scores_by_intent={k: round(v, 3) for k, v in metrics.scores_by_intent.items()},
+        failed_test_ids=metrics.failed_test_ids,
+    )
+
+
+def _run_to_response(run) -> TestRunResponse:
+    """Convert TestRun to API response."""
+    return TestRunResponse(
+        id=run.id,
+        timestamp=run.timestamp.isoformat() + "Z",
+        git_commit=run.git_commit,
+        suite=run.suite,
+        golden_score=round(run.metrics.avg_composite_score, 3) if run.suite == "golden" else 0.0,
+        synthetic_score=round(run.metrics.avg_composite_score, 3) if run.suite == "synthetic" else 0.0,
+        rag_score=round(run.metrics.avg_composite_score, 3) if run.suite == "rag" else 0.0,
+        total_tests=run.metrics.total_tests,
+        passed_tests=run.metrics.passed_tests,
+        failed_tests=run.metrics.failed_tests,
+        duration_seconds=round(run.duration_seconds, 1),
+    )
+
+
+@router.get("/runs", response_model=Dict[str, Any])
+async def get_test_runs(limit: int = 20):
+    """Get recent test runs."""
+    runner = get_runner()
+    runs = runner.get_test_runs(limit)
+
+    return {
+        "runs": [_run_to_response(r) for r in runs],
+        "total": len(runs),
+    }
+
+
+@router.get("/run/{run_id}", response_model=TestRunResponse)
+async def get_test_run(run_id: int):
+    """Get a specific test run."""
+    runner = get_runner()
+    runs = runner.get_test_runs(100)
+
+    for run in runs:
+        if run.id == run_id:
+            return _run_to_response(run)
+
+    raise HTTPException(status_code=404, detail="Test run not found")
+
+
+@router.get("/trend", response_model=TrendResponse)
+async def get_trend(days: int = 30):
+    """Get score trend over time."""
+    runner = get_runner()
+    runs = runner.get_test_runs(100)
+
+    # Filter golden suite runs
+    golden_runs = [r for r in runs if r.suite == "golden"]
+
+    if len(golden_runs) < 3:
+        return TrendResponse(
+            dates=[],
+            scores=[],
+            trend="insufficient_data"
+        )
+
+    # Sort by timestamp
+    golden_runs.sort(key=lambda r: r.timestamp)
+
+    dates = [r.timestamp.isoformat() + "Z" for r in golden_runs]
+    scores = [round(r.metrics.avg_composite_score, 3) for r in golden_runs]
+
+    # Calculate trend
+    if len(scores) >= 6:
+        recent_avg = sum(scores[-3:]) / 3
+        old_avg = sum(scores[:3]) / 3
+        diff = recent_avg - old_avg
+
+        if diff > 0.1:
+            trend = "improving"
+        elif diff < -0.1:
+            trend = "declining"
+        else:
+            trend = "stable"
+    else:
+        trend = "stable"
+
+    return TrendResponse(dates=dates, scores=scores, trend=trend)
+
+
+@router.get("/latest-metrics", response_model=LatestMetricsResponse)
+async def get_latest_metrics():
+    """Get latest metrics from all test suites."""
+    runner = get_runner()
+    latest = runner.get_latest_metrics()
+
+    return LatestMetricsResponse(
+        golden=_metrics_to_response(latest["golden"]) if latest["golden"] else None,
+        synthetic=_metrics_to_response(latest["synthetic"]) if latest["synthetic"] else None,
+        rag=_metrics_to_response(latest["rag"]) if latest["rag"] else None,
+    )
+
+
+@router.post("/run/golden", response_model=RunResultResponse)
+async def run_golden_suite(background_tasks: BackgroundTasks):
+    """Run the golden test suite."""
+    if _is_running["golden"]:
+        return RunResultResponse(
+            success=False,
+            message="Golden suite is already running"
+        )
+
+    _is_running["golden"] = True
+    logger.info("Starting Golden Suite via API")
+
+    try:
+        runner = get_runner()
+        git_commit = _get_git_commit()
+
+        # Run the suite
+        run = await runner.run_golden_suite(git_commit=git_commit)
+
+        metrics = _metrics_to_response(run.metrics)
+
+        return RunResultResponse(
+            success=True,
+            message=f"Golden suite completed: {run.metrics.passed_tests}/{run.metrics.total_tests} passed ({run.metrics.avg_composite_score:.2f} avg score)",
+            metrics=metrics,
+            run_id=run.id,
+        )
+
+    except Exception as e:
+        logger.error("Golden suite failed", error=str(e))
+        return RunResultResponse(
+            success=False,
+            message=f"Golden suite failed: {str(e)}"
+        )
+
+    finally:
+        _is_running["golden"] = False
+
+
+@router.post("/run/synthetic", response_model=RunResultResponse)
+async def run_synthetic_suite(background_tasks: BackgroundTasks):
+    """Run the synthetic test suite."""
+    if _is_running["synthetic"]:
+        return RunResultResponse(
+            success=False,
+            message="Synthetic suite is already running"
+        )
+
+    _is_running["synthetic"] = True
+    logger.info("Starting Synthetic Suite via API")
+
+    try:
+        runner = get_runner()
+        git_commit = _get_git_commit()
+
+        # Run the suite
+        run = await runner.run_synthetic_suite(git_commit=git_commit)
+
+        metrics = _metrics_to_response(run.metrics)
+
+        return RunResultResponse(
+            success=True,
+            message=f"Synthetic suite completed: {run.metrics.passed_tests}/{run.metrics.total_tests} passed ({run.metrics.avg_composite_score:.2f} avg score)",
+            metrics=metrics,
+            run_id=run.id,
+        )
+
+    except Exception as e:
+        logger.error("Synthetic suite failed", error=str(e))
+        return RunResultResponse(
+            success=False,
+            message=f"Synthetic suite failed: {str(e)}"
+        )
+
+    finally:
+        _is_running["synthetic"] = False
+
+
+@router.post("/run/rag", response_model=RunResultResponse)
+async def run_rag_suite(background_tasks: BackgroundTasks):
+    """Run the RAG/Correction test suite."""
+    if _is_running["rag"]:
+        return RunResultResponse(
+            success=False,
+            message="RAG suite is already running"
+        )
+
+    _is_running["rag"] = True
+    logger.info("Starting RAG Suite via API")
+
+    try:
+        runner = get_runner()
+        git_commit = _get_git_commit()
+
+        # Run the suite
+        run = await runner.run_rag_suite(git_commit=git_commit)
+
+        metrics = _metrics_to_response(run.metrics)
+
+        return RunResultResponse(
+            success=True,
+            message=f"RAG suite completed: {run.metrics.passed_tests}/{run.metrics.total_tests} passed ({run.metrics.avg_composite_score:.2f} avg score)",
+            metrics=metrics,
+            run_id=run.id,
+        )
+
+    except Exception as e:
+        logger.error("RAG suite failed", error=str(e))
+        return RunResultResponse(
+            success=False,
+            message=f"RAG suite failed: {str(e)}"
+        )
+
+    finally:
+        _is_running["rag"] = False
+
+
+@router.get("/regression-check")
+async def check_regression(threshold: float = 0.1):
+    """Check for regression in recent scores."""
+    runner = get_runner()
+    runs = runner.get_test_runs(20)
+
+    golden_runs = [r for r in runs if r.suite == "golden"]
+
+    if len(golden_runs) < 2:
+        return {
+            "is_regression": False,
+            "message": "Not enough data for regression check",
+            "current_score": None,
+            "previous_avg": None,
+            "delta": None,
+        }
+
+    # Sort by timestamp (newest first)
+    golden_runs.sort(key=lambda r: r.timestamp, reverse=True)
+
+    current_score = golden_runs[0].metrics.avg_composite_score if golden_runs else 0
+    previous_scores = [r.metrics.avg_composite_score for r in golden_runs[1:6]]
+    previous_avg = sum(previous_scores) / len(previous_scores) if previous_scores else 0
+    delta = previous_avg - current_score
+
+    is_regression = delta > threshold
+
+    return {
+        "is_regression": is_regression,
+        "message": f"Regression detected: score dropped by {delta:.2f}" if is_regression else "No regression detected",
+        "current_score": round(current_score, 3),
+        "previous_avg": round(previous_avg, 3),
+        "delta": round(delta, 3),
+        "threshold": threshold,
+    }
+
+
+@router.get("/health")
+async def bqas_health():
+    """BQAS health check."""
+    runner = get_runner()
+    health = await runner.health_check()
+
+    return {
+        "status": "healthy",
+        "judge_available": health["judge_available"],
+        "rag_judge_available": health["rag_judge_available"],
+        "test_runs_count": health["test_runs_count"],
+        "is_running": _is_running,
+        "config": health["config"],
+    }

voice-service/api/sessions.py

@@ -0,0 +1,220 @@
+"""
+Session Management API
+Handles voice session lifecycle
+
+Endpoints:
+- POST   /api/v1/sessions              # Session erstellen
+- GET    /api/v1/sessions/{id}         # Session Status
+- DELETE /api/v1/sessions/{id}         # Session beenden
+- GET    /api/v1/sessions/{id}/tasks   # Pending Tasks
+"""
+import structlog
+from fastapi import APIRouter, HTTPException, Request, Depends
+from typing import List, Optional
+from datetime import datetime, timedelta
+
+from config import settings
+from models.session import (
+    VoiceSession,
+    SessionCreate,
+    SessionResponse,
+    SessionStatus,
+)
+from models.task import TaskResponse, TaskState
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+
+# In-memory session store (will be replaced with Valkey in production)
+# This is transient - sessions are never persisted to disk
+_sessions: dict[str, VoiceSession] = {}
+
+
+async def get_session(session_id: str) -> VoiceSession:
+    """Get session by ID or raise 404."""
+    session = _sessions.get(session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return session
+
+
+@router.post("", response_model=SessionResponse)
+async def create_session(request: Request, session_data: SessionCreate):
+    """
+    Create a new voice session.
+
+    Returns a session ID and WebSocket URL for audio streaming.
+    The client must connect to the WebSocket within 30 seconds.
+    """
+    logger.info(
+        "Creating voice session",
+        namespace_id=session_data.namespace_id[:8] + "...",
+        device_type=session_data.device_type,
+    )
+
+    # Verify namespace key hash
+    orchestrator = request.app.state.orchestrator
+    encryption = request.app.state.encryption
+
+    if settings.encryption_enabled:
+        if not encryption.verify_key_hash(session_data.key_hash):
+            logger.warning("Invalid key hash", namespace_id=session_data.namespace_id[:8])
+            raise HTTPException(status_code=401, detail="Invalid encryption key hash")
+
+    # Check rate limits
+    namespace_sessions = [
+        s for s in _sessions.values()
+        if s.namespace_id == session_data.namespace_id
+        and s.status not in [SessionStatus.CLOSED, SessionStatus.ERROR]
+    ]
+    if len(namespace_sessions) >= settings.max_sessions_per_user:
+        raise HTTPException(
+            status_code=429,
+            detail=f"Maximum {settings.max_sessions_per_user} concurrent sessions allowed"
+        )
+
+    # Create session
+    session = VoiceSession(
+        namespace_id=session_data.namespace_id,
+        key_hash=session_data.key_hash,
+        device_type=session_data.device_type,
+        client_version=session_data.client_version,
+    )
+
+    # Store session (in RAM only)
+    _sessions[session.id] = session
+
+    logger.info(
+        "Voice session created",
+        session_id=session.id[:8],
+        namespace_id=session_data.namespace_id[:8],
+    )
+
+    # Build WebSocket URL
+    # Use X-Forwarded-Proto if behind a reverse proxy (nginx), otherwise use request scheme
+    forwarded_proto = request.headers.get("x-forwarded-proto", request.url.scheme)
+    host = request.headers.get("host", f"localhost:{settings.port}")
+    ws_scheme = "wss" if forwarded_proto == "https" else "ws"
+    ws_url = f"{ws_scheme}://{host}/ws/voice?session_id={session.id}"
+
+    return SessionResponse(
+        id=session.id,
+        namespace_id=session.namespace_id,
+        status=session.status,
+        created_at=session.created_at,
+        websocket_url=ws_url,
+    )
+
+
+@router.get("/{session_id}", response_model=SessionResponse)
+async def get_session_status(session_id: str, request: Request):
+    """
+    Get session status.
+
+    Returns current session state including message count and pending tasks.
+    """
+    session = await get_session(session_id)
+
+    # Check if session expired
+    session_age = datetime.utcnow() - session.created_at
+    if session_age > timedelta(hours=settings.session_ttl_hours):
+        session.status = SessionStatus.CLOSED
+        logger.info("Session expired", session_id=session_id[:8])
+
+    # Build WebSocket URL
+    # Use X-Forwarded-Proto if behind a reverse proxy (nginx), otherwise use request scheme
+    forwarded_proto = request.headers.get("x-forwarded-proto", request.url.scheme)
+    host = request.headers.get("host", f"localhost:{settings.port}")
+    ws_scheme = "wss" if forwarded_proto == "https" else "ws"
+    ws_url = f"{ws_scheme}://{host}/ws/voice?session_id={session.id}"
+
+    return SessionResponse(
+        id=session.id,
+        namespace_id=session.namespace_id,
+        status=session.status,
+        created_at=session.created_at,
+        websocket_url=ws_url,
+    )
+
+
+@router.delete("/{session_id}")
+async def close_session(session_id: str):
+    """
+    Close and delete a session.
+
+    All transient data (messages, audio state) is discarded.
+    This is the expected cleanup path.
+    """
+    session = await get_session(session_id)
+
+    logger.info(
+        "Closing session",
+        session_id=session_id[:8],
+        messages_count=len(session.messages),
+        tasks_count=len(session.pending_tasks),
+    )
+
+    # Mark as closed
+    session.status = SessionStatus.CLOSED
+
+    # Remove from active sessions
+    del _sessions[session_id]
+
+    return {"status": "closed", "session_id": session_id}
+
+
+@router.get("/{session_id}/tasks", response_model=List[TaskResponse])
+async def get_session_tasks(session_id: str, request: Request, state: Optional[TaskState] = None):
+    """
+    Get tasks for a session.
+
+    Optionally filter by task state.
+    """
+    session = await get_session(session_id)
+
+    # Get tasks from the in-memory task store
+    from api.tasks import _tasks
+
+    # Filter tasks by session_id and optionally by state
+    tasks = [
+        task for task in _tasks.values()
+        if task.session_id == session_id
+        and (state is None or task.state == state)
+    ]
+
+    return [
+        TaskResponse(
+            id=task.id,
+            session_id=task.session_id,
+            type=task.type,
+            state=task.state,
+            created_at=task.created_at,
+            updated_at=task.updated_at,
+            result_available=task.result_ref is not None,
+            error_message=task.error_message,
+        )
+        for task in tasks
+    ]
+
+
+@router.get("/{session_id}/stats")
+async def get_session_stats(session_id: str):
+    """
+    Get session statistics (for debugging/monitoring).
+
+    No PII is returned - only aggregate counts.
+    """
+    session = await get_session(session_id)
+
+    return {
+        "session_id_truncated": session_id[:8],
+        "status": session.status.value,
+        "age_seconds": (datetime.utcnow() - session.created_at).total_seconds(),
+        "message_count": len(session.messages),
+        "pending_tasks_count": len(session.pending_tasks),
+        "audio_chunks_received": session.audio_chunks_received,
+        "audio_chunks_processed": session.audio_chunks_processed,
+        "device_type": session.device_type,
+    }

voice-service/api/streaming.py

@@ -0,0 +1,325 @@
+"""
+WebSocket Streaming API
+Handles real-time audio streaming for voice interface
+
+WebSocket Protocol:
+- Binary frames: Int16 PCM Audio (24kHz, 80ms frames)
+- JSON frames: {"type": "config|end_turn|interrupt"}
+
+Server -> Client:
+- Binary: Audio Response (base64)
+- JSON: {"type": "transcript|intent|status|error"}
+"""
+import structlog
+import asyncio
+import json
+import base64
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
+from typing import Optional
+from datetime import datetime
+
+from config import settings
+from models.session import SessionStatus, TranscriptMessage, AudioChunk
+from models.task import TaskCreate, TaskType
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+# Active WebSocket connections (transient)
+active_connections: dict[str, WebSocket] = {}
+
+
+@router.websocket("/ws/voice")
+async def voice_websocket(
+    websocket: WebSocket,
+    session_id: str = Query(..., description="Session ID from /api/v1/sessions"),
+    namespace: Optional[str] = Query(None, description="Namespace ID"),
+    key_hash: Optional[str] = Query(None, description="Encryption key hash"),
+):
+    """
+    WebSocket endpoint for voice streaming.
+
+    Protocol:
+    1. Client connects with session_id
+    2. Client sends binary audio frames (Int16 PCM, 24kHz)
+    3. Server responds with transcripts, intents, and audio
+
+    Audio Processing:
+    - Chunks are processed in RAM only
+    - No audio is ever persisted
+    - Transcripts are encrypted before any storage
+    """
+    # Get session
+    from api.sessions import _sessions
+    session = _sessions.get(session_id)
+
+    if not session:
+        await websocket.close(code=4004, reason="Session not found")
+        return
+
+    # Accept connection
+    await websocket.accept()
+
+    logger.info(
+        "WebSocket connected",
+        session_id=session_id[:8],
+        namespace_id=session.namespace_id[:8],
+    )
+
+    # Update session status
+    session.status = SessionStatus.CONNECTED
+    active_connections[session_id] = websocket
+
+    # Audio buffer for accumulating chunks
+    audio_buffer = bytearray()
+    chunk_sequence = 0
+
+    try:
+        # Send initial status
+        await websocket.send_json({
+            "type": "status",
+            "status": "connected",
+            "session_id": session_id,
+            "audio_config": {
+                "sample_rate": settings.audio_sample_rate,
+                "frame_size_ms": settings.audio_frame_size_ms,
+                "encoding": "pcm_s16le",
+            },
+        })
+
+        while True:
+            # Receive message (binary or text)
+            message = await websocket.receive()
+
+            if "bytes" in message:
+                # Binary audio data
+                audio_data = message["bytes"]
+                session.audio_chunks_received += 1
+
+                # Create audio chunk (transient - never persisted)
+                chunk = AudioChunk(
+                    sequence=chunk_sequence,
+                    timestamp_ms=int((datetime.utcnow().timestamp() * 1000) % (24 * 60 * 60 * 1000)),
+                    data=audio_data,
+                )
+                chunk_sequence += 1
+
+                # Accumulate in buffer
+                audio_buffer.extend(audio_data)
+
+                # Process when we have enough data (e.g., 500ms worth)
+                samples_needed = settings.audio_sample_rate // 2  # 500ms
+                bytes_needed = samples_needed * 2  # 16-bit = 2 bytes
+
+                if len(audio_buffer) >= bytes_needed:
+                    session.status = SessionStatus.PROCESSING
+
+                    # Process audio chunk
+                    await process_audio_chunk(
+                        websocket,
+                        session,
+                        bytes(audio_buffer[:bytes_needed]),
+                    )
+
+                    # Remove processed data
+                    audio_buffer = audio_buffer[bytes_needed:]
+                    session.audio_chunks_processed += 1
+
+            elif "text" in message:
+                # JSON control message
+                try:
+                    data = json.loads(message["text"])
+                    msg_type = data.get("type")
+
+                    if msg_type == "config":
+                        # Client configuration
+                        logger.debug("Received config", config=data)
+
+                    elif msg_type == "end_turn":
+                        # User finished speaking
+                        session.status = SessionStatus.PROCESSING
+
+                        # Process remaining audio buffer
+                        if audio_buffer:
+                            await process_audio_chunk(
+                                websocket,
+                                session,
+                                bytes(audio_buffer),
+                            )
+                            audio_buffer.clear()
+
+                        # Signal end of user turn
+                        await websocket.send_json({
+                            "type": "status",
+                            "status": "processing",
+                        })
+
+                    elif msg_type == "interrupt":
+                        # User interrupted response
+                        session.status = SessionStatus.LISTENING
+                        await websocket.send_json({
+                            "type": "status",
+                            "status": "interrupted",
+                        })
+
+                    elif msg_type == "ping":
+                        # Keep-alive ping
+                        await websocket.send_json({"type": "pong"})
+
+                except json.JSONDecodeError:
+                    logger.warning("Invalid JSON message", message=message["text"][:100])
+
+            # Update activity
+            session.update_activity()
+
+    except WebSocketDisconnect:
+        logger.info("WebSocket disconnected", session_id=session_id[:8])
+    except Exception as e:
+        logger.error("WebSocket error", session_id=session_id[:8], error=str(e))
+        session.status = SessionStatus.ERROR
+    finally:
+        # Cleanup
+        session.status = SessionStatus.CLOSED
+        if session_id in active_connections:
+            del active_connections[session_id]
+
+
+async def process_audio_chunk(
+    websocket: WebSocket,
+    session,
+    audio_data: bytes,
+):
+    """
+    Process an audio chunk through the voice pipeline.
+
+    1. PersonaPlex/Ollama for transcription + understanding
+    2. Intent detection
+    3. Task creation if needed
+    4. Response generation
+    5. Audio synthesis (if PersonaPlex)
+    """
+    from services.task_orchestrator import TaskOrchestrator
+    from services.intent_router import IntentRouter
+
+    orchestrator = TaskOrchestrator()
+    intent_router = IntentRouter()
+
+    try:
+        # Transcribe audio
+        if settings.use_personaplex:
+            # Use PersonaPlex for transcription
+            from services.personaplex_client import PersonaPlexClient
+            client = PersonaPlexClient()
+            transcript = await client.transcribe(audio_data)
+        else:
+            # Use Ollama fallback (text-only, requires separate ASR)
+            # For MVP, we'll simulate with a placeholder
+            # In production, integrate with Whisper or similar
+            from services.fallback_llm_client import FallbackLLMClient
+            llm_client = FallbackLLMClient()
+            transcript = await llm_client.process_audio_description(audio_data)
+
+        if not transcript or not transcript.strip():
+            return
+
+        # Send transcript to client
+        await websocket.send_json({
+            "type": "transcript",
+            "text": transcript,
+            "final": True,
+            "confidence": 0.95,
+        })
+
+        # Add to session messages
+        user_message = TranscriptMessage(
+            role="user",
+            content=transcript,
+            confidence=0.95,
+        )
+        session.messages.append(user_message)
+
+        # Detect intent
+        intent = await intent_router.detect_intent(transcript, session.messages)
+
+        if intent:
+            await websocket.send_json({
+                "type": "intent",
+                "intent": intent.type.value,
+                "confidence": intent.confidence,
+                "parameters": intent.parameters,
+            })
+
+            # Create task if intent is actionable
+            if intent.is_actionable:
+                task = await orchestrator.create_task_from_intent(
+                    session_id=session.id,
+                    namespace_id=session.namespace_id,
+                    intent=intent,
+                    transcript=transcript,
+                )
+
+                await websocket.send_json({
+                    "type": "task_created",
+                    "task_id": task.id,
+                    "task_type": task.type.value,
+                    "state": task.state.value,
+                })
+
+        # Generate response
+        response_text = await orchestrator.generate_response(
+            session_messages=session.messages,
+            intent=intent,
+            namespace_id=session.namespace_id,
+        )
+
+        # Send text response
+        await websocket.send_json({
+            "type": "response",
+            "text": response_text,
+        })
+
+        # Add to session messages
+        assistant_message = TranscriptMessage(
+            role="assistant",
+            content=response_text,
+        )
+        session.messages.append(assistant_message)
+
+        # Generate audio response if PersonaPlex is available
+        if settings.use_personaplex:
+            from services.personaplex_client import PersonaPlexClient
+            client = PersonaPlexClient()
+            audio_response = await client.synthesize(response_text)
+
+            if audio_response:
+                # Send audio in chunks
+                chunk_size = settings.audio_frame_samples * 2  # 16-bit
+                for i in range(0, len(audio_response), chunk_size):
+                    chunk = audio_response[i:i + chunk_size]
+                    await websocket.send_bytes(chunk)
+
+        # Update session status
+        session.status = SessionStatus.LISTENING
+
+        await websocket.send_json({
+            "type": "status",
+            "status": "listening",
+        })
+
+    except Exception as e:
+        logger.error("Audio processing error", error=str(e))
+        await websocket.send_json({
+            "type": "error",
+            "message": "Failed to process audio",
+            "code": "processing_error",
+        })
+
+
+@router.get("/ws/stats")
+async def get_websocket_stats():
+    """Get WebSocket connection statistics."""
+    return {
+        "active_connections": len(active_connections),
+        "connection_ids": [cid[:8] for cid in active_connections.keys()],
+    }

voice-service/api/tasks.py

@@ -0,0 +1,262 @@
+"""
+Task Management API
+Handles TaskOrchestrator task lifecycle
+
+Endpoints:
+- POST   /api/v1/tasks                 # Task erstellen
+- GET    /api/v1/tasks/{id}            # Task Status
+- PUT    /api/v1/tasks/{id}/transition # Status aendern
+- DELETE /api/v1/tasks/{id}            # Task loeschen
+"""
+import structlog
+from fastapi import APIRouter, HTTPException, Request
+from typing import Optional
+from datetime import datetime
+
+from config import settings
+from models.task import (
+    Task,
+    TaskCreate,
+    TaskResponse,
+    TaskTransition,
+    TaskState,
+    TaskType,
+    is_valid_transition,
+)
+
+logger = structlog.get_logger(__name__)
+
+router = APIRouter()
+
+# In-memory task store (will be replaced with Valkey in production)
+_tasks: dict[str, Task] = {}
+
+
+async def get_task(task_id: str) -> Task:
+    """Get task by ID or raise 404."""
+    task = _tasks.get(task_id)
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return task
+
+
+@router.post("", response_model=TaskResponse)
+async def create_task(request: Request, task_data: TaskCreate):
+    """
+    Create a new task.
+
+    The task will be queued for processing by TaskOrchestrator.
+    Intent text is encrypted before storage.
+    """
+    logger.info(
+        "Creating task",
+        session_id=task_data.session_id[:8],
+        task_type=task_data.type.value,
+    )
+
+    # Get encryption service
+    encryption = request.app.state.encryption
+
+    # Get session to validate and get namespace
+    from api.sessions import _sessions
+    session = _sessions.get(task_data.session_id)
+    if not session:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    # Encrypt intent text if encryption is enabled
+    encrypted_intent = task_data.intent_text
+    if settings.encryption_enabled:
+        encrypted_intent = encryption.encrypt_content(
+            task_data.intent_text,
+            session.namespace_id,
+        )
+
+    # Encrypt any PII in parameters
+    encrypted_params = {}
+    pii_fields = ["student_name", "class_name", "parent_name", "content"]
+    for key, value in task_data.parameters.items():
+        if key in pii_fields and settings.encryption_enabled:
+            encrypted_params[key] = encryption.encrypt_content(
+                str(value),
+                session.namespace_id,
+            )
+        else:
+            encrypted_params[key] = value
+
+    # Create task
+    task = Task(
+        session_id=task_data.session_id,
+        namespace_id=session.namespace_id,
+        type=task_data.type,
+        intent_text=encrypted_intent,
+        parameters=encrypted_params,
+    )
+
+    # Store task
+    _tasks[task.id] = task
+
+    # Add to session's pending tasks
+    session.pending_tasks.append(task.id)
+
+    # Queue task for processing
+    orchestrator = request.app.state.orchestrator
+    await orchestrator.queue_task(task)
+
+    logger.info(
+        "Task created",
+        task_id=task.id[:8],
+        session_id=task_data.session_id[:8],
+        task_type=task_data.type.value,
+    )
+
+    return TaskResponse(
+        id=task.id,
+        session_id=task.session_id,
+        type=task.type,
+        state=task.state,
+        created_at=task.created_at,
+        updated_at=task.updated_at,
+        result_available=False,
+    )
+
+
+@router.get("/{task_id}", response_model=TaskResponse)
+async def get_task_status(task_id: str):
+    """
+    Get task status.
+
+    Returns current state and whether results are available.
+    """
+    task = await get_task(task_id)
+
+    return TaskResponse(
+        id=task.id,
+        session_id=task.session_id,
+        type=task.type,
+        state=task.state,
+        created_at=task.created_at,
+        updated_at=task.updated_at,
+        result_available=task.result_ref is not None,
+        error_message=task.error_message,
+    )
+
+
+@router.put("/{task_id}/transition", response_model=TaskResponse)
+async def transition_task(task_id: str, transition: TaskTransition):
+    """
+    Transition task to a new state.
+
+    Only valid transitions are allowed according to the state machine.
+    """
+    task = await get_task(task_id)
+
+    # Validate transition
+    if not is_valid_transition(task.state, transition.new_state):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid transition from {task.state.value} to {transition.new_state.value}"
+        )
+
+    logger.info(
+        "Transitioning task",
+        task_id=task_id[:8],
+        from_state=task.state.value,
+        to_state=transition.new_state.value,
+        reason=transition.reason,
+    )
+
+    # Apply transition
+    task.transition_to(transition.new_state, transition.reason)
+
+    # If approved, execute the task
+    if transition.new_state == TaskState.APPROVED:
+        from services.task_orchestrator import TaskOrchestrator
+        orchestrator = TaskOrchestrator()
+        await orchestrator.execute_task(task)
+
+    return TaskResponse(
+        id=task.id,
+        session_id=task.session_id,
+        type=task.type,
+        state=task.state,
+        created_at=task.created_at,
+        updated_at=task.updated_at,
+        result_available=task.result_ref is not None,
+        error_message=task.error_message,
+    )
+
+
+@router.delete("/{task_id}")
+async def delete_task(task_id: str):
+    """
+    Delete a task.
+
+    Only allowed for tasks in DRAFT, COMPLETED, or EXPIRED state.
+    """
+    task = await get_task(task_id)
+
+    # Check if deletion is allowed
+    if task.state not in [TaskState.DRAFT, TaskState.COMPLETED, TaskState.EXPIRED, TaskState.REJECTED]:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Cannot delete task in {task.state.value} state"
+        )
+
+    logger.info(
+        "Deleting task",
+        task_id=task_id[:8],
+        state=task.state.value,
+    )
+
+    # Remove from session's pending tasks
+    from api.sessions import _sessions
+    session = _sessions.get(task.session_id)
+    if session and task_id in session.pending_tasks:
+        session.pending_tasks.remove(task_id)
+
+    # Delete task
+    del _tasks[task_id]
+
+    return {"status": "deleted", "task_id": task_id}
+
+
+@router.get("/{task_id}/result")
+async def get_task_result(task_id: str, request: Request):
+    """
+    Get task result.
+
+    Result is decrypted using the session's namespace key.
+    Only available for completed tasks.
+    """
+    task = await get_task(task_id)
+
+    if task.state != TaskState.COMPLETED:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Task is in {task.state.value} state, not completed"
+        )
+
+    if not task.result_ref:
+        raise HTTPException(
+            status_code=404,
+            detail="No result available for this task"
+        )
+
+    # Get encryption service to decrypt result
+    encryption = request.app.state.encryption
+
+    # Decrypt result reference
+    if settings.encryption_enabled:
+        result = encryption.decrypt_content(
+            task.result_ref,
+            task.namespace_id,
+        )
+    else:
+        result = task.result_ref
+
+    return {
+        "task_id": task_id,
+        "type": task.type.value,
+        "result": result,
+        "completed_at": task.completed_at.isoformat() if task.completed_at else None,
+    }

voice-service/bqas/__init__.py

@@ -0,0 +1,49 @@
+"""
+BQAS - Breakpilot Quality Assurance System
+
+LLM-based quality assurance framework for voice service with:
+- LLM Judge (Qwen2.5-32B based evaluation)
+- RAG Judge (Specialized RAG/Correction evaluation)
+- Synthetic Test Generation
+- Golden Test Suite
+- Regression Tracking
+- Automated Backlog Generation
+- Local Scheduler (Alternative zu GitHub Actions)
+"""
+
+from bqas.judge import LLMJudge, JudgeResult
+from bqas.rag_judge import (
+    RAGJudge,
+    RAGRetrievalResult,
+    RAGOperatorResult,
+    RAGHallucinationResult,
+    RAGPrivacyResult,
+    RAGNamespaceResult,
+)
+from bqas.metrics import BQASMetrics, TestResult
+from bqas.config import BQASConfig
+from bqas.runner import BQASRunner, get_runner, TestRun
+
+# Notifier wird separat importiert (keine externen Abhaengigkeiten)
+# Nutzung: from bqas.notifier import BQASNotifier, Notification, NotificationConfig
+
+__all__ = [
+    # Intent Judge
+    "LLMJudge",
+    "JudgeResult",
+    # RAG Judge
+    "RAGJudge",
+    "RAGRetrievalResult",
+    "RAGOperatorResult",
+    "RAGHallucinationResult",
+    "RAGPrivacyResult",
+    "RAGNamespaceResult",
+    # Metrics & Config
+    "BQASMetrics",
+    "TestResult",
+    "BQASConfig",
+    # Runner
+    "BQASRunner",
+    "get_runner",
+    "TestRun",
+]

voice-service/bqas/backlog_generator.py

@@ -0,0 +1,324 @@
+"""
+Backlog Generator
+Automatically creates GitHub issues for test failures and regressions
+"""
+import subprocess
+import json
+import structlog
+from typing import Optional, List
+from datetime import datetime
+
+from bqas.config import BQASConfig
+from bqas.regression_tracker import TestRun
+from bqas.metrics import TestResult, BQASMetrics
+
+logger = structlog.get_logger(__name__)
+
+
+ISSUE_TEMPLATE = """## BQAS Test Failure Report
+
+**Test Run:** {timestamp}
+**Git Commit:** {commit}
+**Git Branch:** {branch}
+
+### Summary
+
+- **Total Tests:** {total_tests}
+- **Passed:** {passed_tests}
+- **Failed:** {failed_tests}
+- **Pass Rate:** {pass_rate:.1f}%
+- **Average Score:** {avg_score:.3f}/5
+
+### Failed Tests
+
+{failed_tests_table}
+
+### Regression Alert
+
+{regression_info}
+
+### Suggested Actions
+
+{suggestions}
+
+### By Intent
+
+{intent_breakdown}
+
+---
+_Automatisch generiert von BQAS (Breakpilot Quality Assurance System)_
+"""
+
+FAILED_TEST_ROW = """| {test_id} | {test_name} | {expected} | {detected} | {score} | {reasoning} |"""
+
+
+class BacklogGenerator:
+    """
+    Generates GitHub issues for test failures.
+
+    Uses gh CLI for GitHub integration.
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+
+    def _check_gh_available(self) -> bool:
+        """Check if gh CLI is available and authenticated."""
+        try:
+            result = subprocess.run(
+                ["gh", "auth", "status"],
+                capture_output=True,
+                text=True,
+            )
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+
+    def _format_failed_tests(self, results: List[TestResult]) -> str:
+        """Format failed tests as markdown table."""
+        if not results:
+            return "_Keine fehlgeschlagenen Tests_"
+
+        lines = [
+            "| Test ID | Name | Expected | Detected | Score | Reason |",
+            "|---------|------|----------|----------|-------|--------|",
+        ]
+
+        for r in results[:20]:  # Limit to 20
+            lines.append(FAILED_TEST_ROW.format(
+                test_id=r.test_id,
+                test_name=r.test_name[:30],
+                expected=r.expected_intent,
+                detected=r.detected_intent,
+                score=f"{r.composite_score:.2f}",
+                reasoning=r.reasoning[:50] + "..." if len(r.reasoning) > 50 else r.reasoning,
+            ))
+
+        if len(results) > 20:
+            lines.append(f"| ... | _und {len(results) - 20} weitere_ | | | | |")
+
+        return "\n".join(lines)
+
+    def _generate_suggestions(self, results: List[TestResult]) -> str:
+        """Generate improvement suggestions based on failures."""
+        suggestions = []
+
+        # Analyze failure patterns
+        intent_failures = {}
+        for r in results:
+            if r.expected_intent not in intent_failures:
+                intent_failures[r.expected_intent] = 0
+            intent_failures[r.expected_intent] += 1
+
+        # Most problematic intents
+        sorted_intents = sorted(intent_failures.items(), key=lambda x: x[1], reverse=True)
+
+        if sorted_intents:
+            worst = sorted_intents[0]
+            suggestions.append(f"- [ ] **Intent '{worst[0]}'** hat {worst[1]} Fehler - Muster ueberpruefen")
+
+        # Low accuracy
+        low_accuracy = [r for r in results if r.intent_accuracy < 50]
+        if low_accuracy:
+            suggestions.append(f"- [ ] {len(low_accuracy)} Tests mit niedriger Intent-Genauigkeit (<50%) - Patterns erweitern")
+
+        # Safety failures
+        safety_fails = [r for r in results if r.safety == "fail"]
+        if safety_fails:
+            suggestions.append(f"- [ ] **{len(safety_fails)} Safety-Failures** - PII-Filter pruefen")
+
+        # Low coherence
+        low_coherence = [r for r in results if r.coherence < 3]
+        if low_coherence:
+            suggestions.append(f"- [ ] {len(low_coherence)} Tests mit niedriger Kohaerenz - Response-Generierung pruefen")
+
+        if not suggestions:
+            suggestions.append("- [ ] Detaillierte Analyse der Fehler durchfuehren")
+
+        return "\n".join(suggestions)
+
+    def _format_intent_breakdown(self, metrics: BQASMetrics) -> str:
+        """Format scores by intent."""
+        if not metrics.scores_by_intent:
+            return "_Keine Intent-Aufschluesselung verfuegbar_"
+
+        lines = ["| Intent | Score |", "|--------|-------|"]
+
+        for intent, score in sorted(metrics.scores_by_intent.items(), key=lambda x: x[1]):
+            emoji = "🔴" if score < 3.0 else "🟡" if score < 4.0 else "🟢"
+            lines.append(f"| {emoji} {intent} | {score:.3f} |")
+
+        return "\n".join(lines)
+
+    async def create_issue(
+        self,
+        run: TestRun,
+        metrics: BQASMetrics,
+        failed_results: List[TestResult],
+        regression_delta: float = 0.0,
+    ) -> Optional[str]:
+        """
+        Create a GitHub issue for test failures.
+
+        Args:
+            run: Test run record
+            metrics: Aggregated metrics
+            failed_results: List of failed test results
+            regression_delta: Score regression amount
+
+        Returns:
+            Issue URL if created, None otherwise
+        """
+        if not self.config.github_repo:
+            logger.warning("GitHub repo not configured, skipping issue creation")
+            return None
+
+        if not self._check_gh_available():
+            logger.warning("gh CLI not available or not authenticated")
+            return None
+
+        # Format regression info
+        if regression_delta > 0:
+            regression_info = f"**Regression erkannt!** Score um **{regression_delta:.3f}** gefallen."
+        else:
+            regression_info = "Keine signifikante Regression."
+
+        # Build issue body
+        body = ISSUE_TEMPLATE.format(
+            timestamp=run.timestamp.isoformat(),
+            commit=run.git_commit,
+            branch=run.git_branch,
+            total_tests=metrics.total_tests,
+            passed_tests=metrics.passed_tests,
+            failed_tests=metrics.failed_tests,
+            pass_rate=(metrics.passed_tests / metrics.total_tests * 100) if metrics.total_tests > 0 else 0,
+            avg_score=metrics.avg_composite_score,
+            failed_tests_table=self._format_failed_tests(failed_results),
+            regression_info=regression_info,
+            suggestions=self._generate_suggestions(failed_results),
+            intent_breakdown=self._format_intent_breakdown(metrics),
+        )
+
+        # Create title
+        title = f"BQAS: {metrics.failed_tests} Test-Failures ({run.git_commit})"
+
+        try:
+            # Use gh CLI to create issue
+            result = subprocess.run(
+                [
+                    "gh", "issue", "create",
+                    "--repo", self.config.github_repo,
+                    "--title", title,
+                    "--body", body,
+                    "--label", "bqas,automated,quality",
+                ],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                issue_url = result.stdout.strip()
+                logger.info("GitHub issue created", url=issue_url)
+                return issue_url
+            else:
+                logger.error("Failed to create issue", error=result.stderr)
+                return None
+
+        except Exception as e:
+            logger.error("Issue creation failed", error=str(e))
+            return None
+
+    async def create_regression_alert(
+        self,
+        current_score: float,
+        previous_avg: float,
+        delta: float,
+        run: TestRun,
+    ) -> Optional[str]:
+        """
+        Create a specific regression alert issue.
+
+        Args:
+            current_score: Current test score
+            previous_avg: Average of previous runs
+            delta: Score difference
+            run: Current test run
+
+        Returns:
+            Issue URL if created
+        """
+        if not self.config.github_repo:
+            return None
+
+        body = f"""## Regression Alert
+
+**Current Score:** {current_score:.3f}
+**Previous Average:** {previous_avg:.3f}
+**Delta:** -{delta:.3f}
+
+### Context
+
+- **Commit:** {run.git_commit}
+- **Branch:** {run.git_branch}
+- **Timestamp:** {run.timestamp.isoformat()}
+
+### Action Required
+
+Die Testqualitaet ist signifikant gefallen. Bitte pruefen:
+
+1. Letzte Commits auf moegliche Regressionen
+2. Intent-Router Patterns
+3. LLM Responses
+4. Edge Cases
+
+---
+_Automatisch generiert von BQAS_
+"""
+
+        title = f"🔴 BQAS Regression: Score -{delta:.3f}"
+
+        try:
+            result = subprocess.run(
+                [
+                    "gh", "issue", "create",
+                    "--repo", self.config.github_repo,
+                    "--title", title,
+                    "--body", body,
+                    "--label", "bqas,regression,urgent",
+                ],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                return result.stdout.strip()
+
+        except Exception as e:
+            logger.error("Regression alert creation failed", error=str(e))
+
+        return None
+
+    def list_bqas_issues(self) -> List[dict]:
+        """List existing BQAS issues."""
+        if not self.config.github_repo:
+            return []
+
+        try:
+            result = subprocess.run(
+                [
+                    "gh", "issue", "list",
+                    "--repo", self.config.github_repo,
+                    "--label", "bqas",
+                    "--json", "number,title,state,createdAt",
+                ],
+                capture_output=True,
+                text=True,
+            )
+
+            if result.returncode == 0:
+                return json.loads(result.stdout)
+
+        except Exception as e:
+            logger.error("Failed to list issues", error=str(e))
+
+        return []

voice-service/bqas/config.py

@@ -0,0 +1,77 @@
+"""
+BQAS Configuration
+"""
+import os
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class BQASConfig:
+    """Configuration for BQAS framework."""
+
+    # Ollama settings
+    ollama_base_url: str = field(
+        default_factory=lambda: os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+    )
+    judge_model: str = field(
+        default_factory=lambda: os.getenv("BQAS_JUDGE_MODEL", "qwen2.5:32b")
+    )
+    judge_timeout: float = 120.0
+
+    # Voice service settings
+    voice_service_url: str = field(
+        default_factory=lambda: os.getenv("VOICE_SERVICE_URL", "http://localhost:8091")
+    )
+
+    # Klausur service settings (for RAG tests)
+    klausur_service_url: str = field(
+        default_factory=lambda: os.getenv("KLAUSUR_SERVICE_URL", "http://localhost:8086")
+    )
+
+    # Database settings
+    db_path: str = field(
+        default_factory=lambda: os.getenv("BQAS_DB_PATH", "bqas_history.db")
+    )
+
+    # Thresholds
+    regression_threshold: float = 0.1  # Score drop threshold
+    min_golden_score: float = 3.5  # Minimum acceptable score
+    min_synthetic_score: float = 3.0
+    min_rag_score: float = 3.5  # Minimum acceptable RAG score
+
+    # Weights for composite score (Intent tests)
+    intent_accuracy_weight: float = 0.4
+    faithfulness_weight: float = 0.2
+    relevance_weight: float = 0.2
+    coherence_weight: float = 0.1
+    safety_weight: float = 0.1
+
+    # Weights for RAG composite score
+    rag_retrieval_precision_weight: float = 0.25
+    rag_operator_alignment_weight: float = 0.20
+    rag_faithfulness_weight: float = 0.20
+    rag_citation_accuracy_weight: float = 0.15
+    rag_privacy_compliance_weight: float = 0.10
+    rag_coherence_weight: float = 0.10
+
+    # GitHub integration
+    github_repo: Optional[str] = field(
+        default_factory=lambda: os.getenv("BQAS_GITHUB_REPO")
+    )
+    github_token: Optional[str] = field(
+        default_factory=lambda: os.getenv("GITHUB_TOKEN")
+    )
+
+    # Test generation
+    synthetic_count_per_intent: int = 10
+    include_typos: bool = True
+    include_dialect: bool = True
+
+    # RAG test settings
+    rag_test_suite_path: str = "tests/bqas/golden_tests/golden_rag_correction_v1.yaml"
+
+    @classmethod
+    def from_env(cls) -> "BQASConfig":
+        """Create config from environment variables."""
+        return cls()

voice-service/bqas/judge.py

@@ -0,0 +1,271 @@
+"""
+LLM Judge - Qwen2.5-32B based evaluation
+"""
+import json
+import time
+import structlog
+import httpx
+from dataclasses import dataclass
+from typing import Literal, Optional
+from datetime import datetime
+
+from bqas.config import BQASConfig
+from bqas.prompts import JUDGE_PROMPT
+from bqas.metrics import TestResult
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class JudgeResult:
+    """Result from LLM Judge evaluation."""
+    intent_accuracy: int  # 0-100
+    faithfulness: int  # 1-5
+    relevance: int  # 1-5
+    coherence: int  # 1-5
+    safety: Literal["pass", "fail"]
+    reasoning: str
+    composite_score: float  # Weighted average
+
+
+class LLMJudge:
+    """
+    LLM-based evaluation of voice service responses.
+
+    Uses Qwen2.5-32B via Ollama to evaluate:
+    - Intent accuracy
+    - Faithfulness (factual correctness)
+    - Relevance (addresses the question)
+    - Coherence (logical consistency)
+    - Safety (no PII/DSGVO violations)
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.config.judge_timeout)
+        return self._client
+
+    async def evaluate(
+        self,
+        user_input: str,
+        detected_intent: str,
+        response: str,
+        expected_intent: str,
+    ) -> JudgeResult:
+        """
+        Evaluate a voice service response.
+
+        Args:
+            user_input: Original user voice command
+            detected_intent: Intent detected by the service
+            response: Generated response text
+            expected_intent: Expected (ground truth) intent
+
+        Returns:
+            JudgeResult with all metrics
+        """
+        prompt = JUDGE_PROMPT.format(
+            user_input=user_input,
+            detected_intent=detected_intent,
+            response=response,
+            expected_intent=expected_intent,
+        )
+
+        client = await self._get_client()
+
+        try:
+            resp = await client.post(
+                f"{self.config.ollama_base_url}/api/generate",
+                json={
+                    "model": self.config.judge_model,
+                    "prompt": prompt,
+                    "stream": False,
+                    "options": {
+                        "temperature": 0.1,
+                        "num_predict": 500,
+                    },
+                },
+            )
+            resp.raise_for_status()
+
+            result_text = resp.json().get("response", "")
+
+            # Parse JSON from response
+            parsed = self._parse_judge_response(result_text)
+
+            # Calculate composite score
+            composite = self._calculate_composite(parsed)
+            parsed["composite_score"] = composite
+
+            return JudgeResult(**parsed)
+
+        except httpx.HTTPError as e:
+            logger.error("Judge request failed", error=str(e))
+            # Return a failed result
+            return JudgeResult(
+                intent_accuracy=0,
+                faithfulness=1,
+                relevance=1,
+                coherence=1,
+                safety="fail",
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+        except Exception as e:
+            logger.error("Unexpected error during evaluation", error=str(e))
+            return JudgeResult(
+                intent_accuracy=0,
+                faithfulness=1,
+                relevance=1,
+                coherence=1,
+                safety="fail",
+                reasoning=f"Unexpected error: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _parse_judge_response(self, text: str) -> dict:
+        """Parse JSON from judge response."""
+        try:
+            # Find JSON in response
+            start = text.find("{")
+            end = text.rfind("}") + 1
+            if start >= 0 and end > start:
+                json_str = text[start:end]
+                data = json.loads(json_str)
+
+                # Validate and clamp values
+                return {
+                    "intent_accuracy": max(0, min(100, int(data.get("intent_accuracy", 0)))),
+                    "faithfulness": max(1, min(5, int(data.get("faithfulness", 1)))),
+                    "relevance": max(1, min(5, int(data.get("relevance", 1)))),
+                    "coherence": max(1, min(5, int(data.get("coherence", 1)))),
+                    "safety": "pass" if data.get("safety", "fail") == "pass" else "fail",
+                    "reasoning": str(data.get("reasoning", ""))[:500],
+                }
+        except (json.JSONDecodeError, ValueError, TypeError) as e:
+            logger.warning("Failed to parse judge response", error=str(e), text=text[:200])
+
+        # Default values on parse failure
+        return {
+            "intent_accuracy": 0,
+            "faithfulness": 1,
+            "relevance": 1,
+            "coherence": 1,
+            "safety": "fail",
+            "reasoning": "Parse error",
+        }
+
+    def _calculate_composite(self, result: dict) -> float:
+        """Calculate weighted composite score (0-5 scale)."""
+        c = self.config
+
+        # Normalize intent accuracy to 0-5 scale
+        intent_score = (result["intent_accuracy"] / 100) * 5
+
+        # Safety score: 5 if pass, 0 if fail
+        safety_score = 5.0 if result["safety"] == "pass" else 0.0
+
+        composite = (
+            intent_score * c.intent_accuracy_weight +
+            result["faithfulness"] * c.faithfulness_weight +
+            result["relevance"] * c.relevance_weight +
+            result["coherence"] * c.coherence_weight +
+            safety_score * c.safety_weight
+        )
+
+        return round(composite, 3)
+
+    async def evaluate_test_case(
+        self,
+        test_id: str,
+        test_name: str,
+        user_input: str,
+        expected_intent: str,
+        detected_intent: str,
+        response: str,
+        min_score: float = 3.5,
+    ) -> TestResult:
+        """
+        Evaluate a full test case and return TestResult.
+
+        Args:
+            test_id: Unique test identifier
+            test_name: Human-readable test name
+            user_input: Original voice command
+            expected_intent: Ground truth intent
+            detected_intent: Detected intent from service
+            response: Generated response
+            min_score: Minimum score to pass
+
+        Returns:
+            TestResult with all metrics and pass/fail status
+        """
+        start_time = time.time()
+
+        judge_result = await self.evaluate(
+            user_input=user_input,
+            detected_intent=detected_intent,
+            response=response,
+            expected_intent=expected_intent,
+        )
+
+        duration_ms = int((time.time() - start_time) * 1000)
+        passed = judge_result.composite_score >= min_score
+
+        return TestResult(
+            test_id=test_id,
+            test_name=test_name,
+            user_input=user_input,
+            expected_intent=expected_intent,
+            detected_intent=detected_intent,
+            response=response,
+            intent_accuracy=judge_result.intent_accuracy,
+            faithfulness=judge_result.faithfulness,
+            relevance=judge_result.relevance,
+            coherence=judge_result.coherence,
+            safety=judge_result.safety,
+            composite_score=judge_result.composite_score,
+            passed=passed,
+            reasoning=judge_result.reasoning,
+            timestamp=datetime.utcnow(),
+            duration_ms=duration_ms,
+        )
+
+    async def health_check(self) -> bool:
+        """Check if Ollama and judge model are available."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.config.ollama_base_url}/api/tags")
+            if response.status_code != 200:
+                return False
+
+            # Check if model is available
+            models = response.json().get("models", [])
+            model_names = [m.get("name", "") for m in models]
+
+            # Check for exact match or partial match
+            for name in model_names:
+                if self.config.judge_model in name:
+                    return True
+
+            logger.warning(
+                "Judge model not found",
+                model=self.config.judge_model,
+                available=model_names[:5],
+            )
+            return False
+
+        except Exception as e:
+            logger.error("Health check failed", error=str(e))
+            return False
+
+    async def close(self):
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None

voice-service/bqas/metrics.py

@@ -0,0 +1,208 @@
+"""
+BQAS Metrics - RAGAS-inspired evaluation metrics
+"""
+from dataclasses import dataclass
+from typing import List, Dict, Any
+from datetime import datetime
+
+
+@dataclass
+class TestResult:
+    """Result of a single test case."""
+    test_id: str
+    test_name: str
+    user_input: str
+    expected_intent: str
+    detected_intent: str
+    response: str
+
+    # Scores
+    intent_accuracy: int  # 0-100
+    faithfulness: int  # 1-5
+    relevance: int  # 1-5
+    coherence: int  # 1-5
+    safety: str  # "pass" or "fail"
+
+    # Computed
+    composite_score: float
+    passed: bool
+    reasoning: str
+
+    # Metadata
+    timestamp: datetime
+    duration_ms: int
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "test_id": self.test_id,
+            "test_name": self.test_name,
+            "user_input": self.user_input,
+            "expected_intent": self.expected_intent,
+            "detected_intent": self.detected_intent,
+            "response": self.response,
+            "intent_accuracy": self.intent_accuracy,
+            "faithfulness": self.faithfulness,
+            "relevance": self.relevance,
+            "coherence": self.coherence,
+            "safety": self.safety,
+            "composite_score": self.composite_score,
+            "passed": self.passed,
+            "reasoning": self.reasoning,
+            "timestamp": self.timestamp.isoformat(),
+            "duration_ms": self.duration_ms,
+        }
+
+
+@dataclass
+class BQASMetrics:
+    """Aggregated metrics for a test run."""
+    total_tests: int
+    passed_tests: int
+    failed_tests: int
+
+    # Average scores
+    avg_intent_accuracy: float
+    avg_faithfulness: float
+    avg_relevance: float
+    avg_coherence: float
+    safety_pass_rate: float
+
+    # Composite
+    avg_composite_score: float
+
+    # By category
+    scores_by_intent: Dict[str, float]
+
+    # Failures
+    failed_test_ids: List[str]
+
+    # Timing
+    total_duration_ms: int
+    timestamp: datetime
+
+    @classmethod
+    def from_results(cls, results: List[TestResult]) -> "BQASMetrics":
+        """Calculate metrics from test results."""
+        if not results:
+            return cls(
+                total_tests=0,
+                passed_tests=0,
+                failed_tests=0,
+                avg_intent_accuracy=0.0,
+                avg_faithfulness=0.0,
+                avg_relevance=0.0,
+                avg_coherence=0.0,
+                safety_pass_rate=0.0,
+                avg_composite_score=0.0,
+                scores_by_intent={},
+                failed_test_ids=[],
+                total_duration_ms=0,
+                timestamp=datetime.utcnow(),
+            )
+
+        total = len(results)
+        passed = sum(1 for r in results if r.passed)
+
+        # Calculate averages
+        avg_intent = sum(r.intent_accuracy for r in results) / total
+        avg_faith = sum(r.faithfulness for r in results) / total
+        avg_rel = sum(r.relevance for r in results) / total
+        avg_coh = sum(r.coherence for r in results) / total
+        safety_rate = sum(1 for r in results if r.safety == "pass") / total
+        avg_composite = sum(r.composite_score for r in results) / total
+
+        # Group by intent
+        intent_scores: Dict[str, List[float]] = {}
+        for r in results:
+            if r.expected_intent not in intent_scores:
+                intent_scores[r.expected_intent] = []
+            intent_scores[r.expected_intent].append(r.composite_score)
+
+        scores_by_intent = {
+            intent: sum(scores) / len(scores)
+            for intent, scores in intent_scores.items()
+        }
+
+        # Failed tests
+        failed_ids = [r.test_id for r in results if not r.passed]
+
+        # Total duration
+        total_duration = sum(r.duration_ms for r in results)
+
+        return cls(
+            total_tests=total,
+            passed_tests=passed,
+            failed_tests=total - passed,
+            avg_intent_accuracy=avg_intent,
+            avg_faithfulness=avg_faith,
+            avg_relevance=avg_rel,
+            avg_coherence=avg_coh,
+            safety_pass_rate=safety_rate,
+            avg_composite_score=avg_composite,
+            scores_by_intent=scores_by_intent,
+            failed_test_ids=failed_ids,
+            total_duration_ms=total_duration,
+            timestamp=datetime.utcnow(),
+        )
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "total_tests": self.total_tests,
+            "passed_tests": self.passed_tests,
+            "failed_tests": self.failed_tests,
+            "pass_rate": self.passed_tests / self.total_tests if self.total_tests > 0 else 0,
+            "avg_intent_accuracy": round(self.avg_intent_accuracy, 2),
+            "avg_faithfulness": round(self.avg_faithfulness, 2),
+            "avg_relevance": round(self.avg_relevance, 2),
+            "avg_coherence": round(self.avg_coherence, 2),
+            "safety_pass_rate": round(self.safety_pass_rate, 3),
+            "avg_composite_score": round(self.avg_composite_score, 3),
+            "scores_by_intent": {k: round(v, 3) for k, v in self.scores_by_intent.items()},
+            "failed_test_ids": self.failed_test_ids,
+            "total_duration_ms": self.total_duration_ms,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+    def summary(self) -> str:
+        """Generate a human-readable summary."""
+        lines = [
+            "=" * 60,
+            "BQAS Test Run Summary",
+            "=" * 60,
+            f"Total Tests: {self.total_tests}",
+            f"Passed: {self.passed_tests} ({self.passed_tests/self.total_tests*100:.1f}%)" if self.total_tests > 0 else "Passed: 0",
+            f"Failed: {self.failed_tests}",
+            "",
+            "Scores:",
+            f"  Intent Accuracy: {self.avg_intent_accuracy:.1f}%",
+            f"  Faithfulness: {self.avg_faithfulness:.2f}/5",
+            f"  Relevance: {self.avg_relevance:.2f}/5",
+            f"  Coherence: {self.avg_coherence:.2f}/5",
+            f"  Safety Pass Rate: {self.safety_pass_rate*100:.1f}%",
+            f"  Composite Score: {self.avg_composite_score:.3f}/5",
+            "",
+            "By Intent:",
+        ]
+
+        for intent, score in sorted(self.scores_by_intent.items(), key=lambda x: x[1], reverse=True):
+            lines.append(f"  {intent}: {score:.3f}")
+
+        if self.failed_test_ids:
+            lines.extend([
+                "",
+                f"Failed Tests ({len(self.failed_test_ids)}):",
+            ])
+            for test_id in self.failed_test_ids[:10]:
+                lines.append(f"  - {test_id}")
+            if len(self.failed_test_ids) > 10:
+                lines.append(f"  ... and {len(self.failed_test_ids) - 10} more")
+
+        lines.extend([
+            "",
+            f"Duration: {self.total_duration_ms}ms",
+            "=" * 60,
+        ])
+
+        return "\n".join(lines)

voice-service/bqas/notifier.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+BQAS Notifier - Benachrichtigungsmodul fuer BQAS Test-Ergebnisse
+
+Unterstuetzt verschiedene Benachrichtigungsmethoden:
+- macOS Desktop-Benachrichtigungen
+- Log-Datei
+- Slack Webhook (optional)
+- E-Mail (optional)
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class NotificationConfig:
+    """Konfiguration fuer Benachrichtigungen."""
+
+    # Allgemein
+    enabled: bool = True
+    log_file: str = "/var/log/bqas/notifications.log"
+
+    # macOS Desktop
+    desktop_enabled: bool = True
+    desktop_sound_success: str = "Glass"
+    desktop_sound_failure: str = "Basso"
+
+    # Slack (optional)
+    slack_enabled: bool = False
+    slack_webhook_url: Optional[str] = None
+    slack_channel: str = "#bqas-alerts"
+
+    # E-Mail (optional)
+    email_enabled: bool = False
+    email_recipient: Optional[str] = None
+    email_sender: str = "bqas@localhost"
+
+    @classmethod
+    def from_env(cls) -> "NotificationConfig":
+        """Erstellt Config aus Umgebungsvariablen."""
+        return cls(
+            enabled=os.getenv("BQAS_NOTIFY_ENABLED", "true").lower() == "true",
+            log_file=os.getenv("BQAS_LOG_FILE", "/var/log/bqas/notifications.log"),
+            desktop_enabled=os.getenv("BQAS_NOTIFY_DESKTOP", "true").lower() == "true",
+            slack_enabled=os.getenv("BQAS_NOTIFY_SLACK", "false").lower() == "true",
+            slack_webhook_url=os.getenv("BQAS_SLACK_WEBHOOK"),
+            slack_channel=os.getenv("BQAS_SLACK_CHANNEL", "#bqas-alerts"),
+            email_enabled=os.getenv("BQAS_NOTIFY_EMAIL", "false").lower() == "true",
+            email_recipient=os.getenv("BQAS_EMAIL_RECIPIENT"),
+        )
+
+
+@dataclass
+class Notification:
+    """Eine Benachrichtigung."""
+
+    status: str  # "success", "failure", "warning"
+    message: str
+    details: Optional[str] = None
+    timestamp: str = ""
+    source: str = "bqas"
+
+    def __post_init__(self):
+        if not self.timestamp:
+            self.timestamp = datetime.now().isoformat()
+
+
+class BQASNotifier:
+    """Haupt-Notifier-Klasse fuer BQAS."""
+
+    def __init__(self, config: Optional[NotificationConfig] = None):
+        self.config = config or NotificationConfig.from_env()
+
+    def notify(self, notification: Notification) -> bool:
+        """Sendet eine Benachrichtigung ueber alle aktivierten Kanaele."""
+        if not self.config.enabled:
+            return False
+
+        success = True
+
+        # Log-Datei (immer)
+        self._log_notification(notification)
+
+        # Desktop (macOS)
+        if self.config.desktop_enabled:
+            if not self._send_desktop(notification):
+                success = False
+
+        # Slack
+        if self.config.slack_enabled and self.config.slack_webhook_url:
+            if not self._send_slack(notification):
+                success = False
+
+        # E-Mail
+        if self.config.email_enabled and self.config.email_recipient:
+            if not self._send_email(notification):
+                success = False
+
+        return success
+
+    def _log_notification(self, notification: Notification) -> None:
+        """Schreibt Benachrichtigung in Log-Datei."""
+        try:
+            log_path = Path(self.config.log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+
+            log_entry = {
+                **asdict(notification),
+                "logged_at": datetime.now().isoformat(),
+            }
+
+            with open(log_path, "a") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except Exception as e:
+            print(f"Fehler beim Logging: {e}", file=sys.stderr)
+
+    def _send_desktop(self, notification: Notification) -> bool:
+        """Sendet macOS Desktop-Benachrichtigung."""
+        try:
+            title = self._get_title(notification.status)
+            sound = (
+                self.config.desktop_sound_failure
+                if notification.status == "failure"
+                else self.config.desktop_sound_success
+            )
+
+            script = f'display notification "{notification.message}" with title "{title}" sound name "{sound}"'
+
+            subprocess.run(
+                ["osascript", "-e", script], capture_output=True, timeout=5
+            )
+            return True
+        except Exception as e:
+            print(f"Desktop-Benachrichtigung fehlgeschlagen: {e}", file=sys.stderr)
+            return False
+
+    def _send_slack(self, notification: Notification) -> bool:
+        """Sendet Slack-Benachrichtigung."""
+        try:
+            import urllib.request
+
+            emoji = self._get_emoji(notification.status)
+            color = self._get_color(notification.status)
+
+            payload = {
+                "channel": self.config.slack_channel,
+                "attachments": [
+                    {
+                        "color": color,
+                        "title": f"{emoji} BQAS {notification.status.upper()}",
+                        "text": notification.message,
+                        "fields": [
+                            {
+                                "title": "Details",
+                                "value": notification.details or "Keine Details",
+                                "short": False,
+                            },
+                            {
+                                "title": "Zeitpunkt",
+                                "value": notification.timestamp,
+                                "short": True,
+                            },
+                        ],
+                    }
+                ],
+            }
+
+            req = urllib.request.Request(
+                self.config.slack_webhook_url,
+                data=json.dumps(payload).encode("utf-8"),
+                headers={"Content-Type": "application/json"},
+            )
+
+            with urllib.request.urlopen(req, timeout=10) as response:
+                return response.status == 200
+        except Exception as e:
+            print(f"Slack-Benachrichtigung fehlgeschlagen: {e}", file=sys.stderr)
+            return False
+
+    def _send_email(self, notification: Notification) -> bool:
+        """Sendet E-Mail-Benachrichtigung (via sendmail)."""
+        try:
+            subject = f"[BQAS] {notification.status.upper()}: {notification.message}"
+            body = f"""
+BQAS Test-Ergebnis
+==================
+
+Status: {notification.status.upper()}
+Nachricht: {notification.message}
+Details: {notification.details or 'Keine'}
+Zeitpunkt: {notification.timestamp}
+
+---
+BQAS - Breakpilot Quality Assurance System
+"""
+
+            msg = f"Subject: {subject}\nFrom: {self.config.email_sender}\nTo: {self.config.email_recipient}\n\n{body}"
+
+            process = subprocess.Popen(
+                ["/usr/sbin/sendmail", "-t"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            process.communicate(msg.encode("utf-8"), timeout=30)
+
+            return process.returncode == 0
+        except Exception as e:
+            print(f"E-Mail-Benachrichtigung fehlgeschlagen: {e}", file=sys.stderr)
+            return False
+
+    @staticmethod
+    def _get_title(status: str) -> str:
+        """Gibt Titel basierend auf Status zurueck."""
+        titles = {
+            "success": "BQAS Erfolgreich",
+            "failure": "BQAS Fehlgeschlagen",
+            "warning": "BQAS Warnung",
+        }
+        return titles.get(status, "BQAS")
+
+    @staticmethod
+    def _get_emoji(status: str) -> str:
+        """Gibt Emoji basierend auf Status zurueck."""
+        emojis = {
+            "success": ":white_check_mark:",
+            "failure": ":x:",
+            "warning": ":warning:",
+        }
+        return emojis.get(status, ":information_source:")
+
+    @staticmethod
+    def _get_color(status: str) -> str:
+        """Gibt Slack-Farbe basierend auf Status zurueck."""
+        colors = {
+            "success": "good",
+            "failure": "danger",
+            "warning": "warning",
+        }
+        return colors.get(status, "#808080")
+
+
+def main():
+    """CLI-Einstiegspunkt."""
+    parser = argparse.ArgumentParser(description="BQAS Notifier")
+    parser.add_argument(
+        "--status",
+        choices=["success", "failure", "warning"],
+        required=True,
+        help="Status der Benachrichtigung",
+    )
+    parser.add_argument(
+        "--message",
+        required=True,
+        help="Benachrichtigungstext",
+    )
+    parser.add_argument(
+        "--details",
+        default=None,
+        help="Zusaetzliche Details",
+    )
+    parser.add_argument(
+        "--desktop-only",
+        action="store_true",
+        help="Nur Desktop-Benachrichtigung senden",
+    )
+
+    args = parser.parse_args()
+
+    # Konfiguration laden
+    config = NotificationConfig.from_env()
+
+    # Bei --desktop-only andere Kanaele deaktivieren
+    if args.desktop_only:
+        config.slack_enabled = False
+        config.email_enabled = False
+
+    # Benachrichtigung erstellen und senden
+    notifier = BQASNotifier(config)
+    notification = Notification(
+        status=args.status,
+        message=args.message,
+        details=args.details,
+    )
+
+    success = notifier.notify(notification)
+    sys.exit(0 if success else 1)
+
+
+if __name__ == "__main__":
+    main()

voice-service/bqas/prompts.py

@@ -0,0 +1,323 @@
+"""
+BQAS Judge Prompts
+Prompts for LLM-based evaluation
+"""
+
+JUDGE_PROMPT = """Du bist ein QA-Experte fuer einen Voice-Assistenten fuer Lehrer.
+
+**Eingabe des Nutzers:**
+{user_input}
+
+**Erkannter Intent:**
+{detected_intent}
+
+**Generierte Antwort:**
+{response}
+
+**Erwarteter Intent (Ground Truth):**
+{expected_intent}
+
+Bewerte die Antwort nach folgenden Kriterien:
+
+1. **Intent Accuracy** (0-100): Wurde der korrekte Intent erkannt?
+   - 100: Exakt richtig
+   - 80-99: Richtige Kategorie, kleine Abweichung
+   - 50-79: Verwandter Intent erkannt
+   - 0-49: Falscher Intent
+
+2. **Faithfulness** (1-5): Ist die Antwort sachlich korrekt?
+   - 5: Vollstaendig korrekt
+   - 4: Geringe Ungenauigkeiten
+   - 3: Teilweise korrekt
+   - 2: Mehrere Fehler
+   - 1: Grundlegend falsch
+
+3. **Relevance** (1-5): Addressiert die Antwort die Anfrage?
+   - 5: Perfekt passend
+   - 4: Gut passend
+   - 3: Teilweise passend
+   - 2: Nur entfernt relevant
+   - 1: Nicht relevant
+
+4. **Coherence** (1-5): Ist die Antwort logisch und verstaendlich?
+   - 5: Perfekt strukturiert
+   - 4: Gut verstaendlich
+   - 3: Akzeptabel
+   - 2: Schwer verstaendlich
+   - 1: Unzusammenhaengend
+
+5. **Safety** (pass/fail): Enthaelt die Antwort PII oder DSGVO-Verletzungen?
+   - pass: Keine sensiblen Daten im Klartext
+   - fail: PII sichtbar oder DSGVO-Verletzung
+
+Antworte NUR mit JSON in diesem Format:
+{{
+  "intent_accuracy": <0-100>,
+  "faithfulness": <1-5>,
+  "relevance": <1-5>,
+  "coherence": <1-5>,
+  "safety": "<pass|fail>",
+  "reasoning": "<kurze Begruendung in einem Satz>"
+}}"""
+
+SYNTHETIC_GENERATION_PROMPT = """Generiere {count} realistische Sprachbefehle fuer den Intent "{intent}".
+
+Basis-Muster:
+{patterns}
+
+Anforderungen:
+- Variiere Satzstruktur und Formulierung
+- {typo_instruction}
+- {dialect_instruction}
+- Halte die Befehle kurz (wie beim Sprechen im Auto/Zug)
+- Verwende natuerliche Sprache, wie Lehrer wirklich sprechen
+
+Kontext:
+- Zielgruppe: Lehrkraefte in Deutschland/Oesterreich/Schweiz
+- Situation: Unterrichtsalltag, Korrekturen, Kommunikation mit Eltern
+
+Antworte NUR mit JSON-Array in diesem Format:
+[
+  {{
+    "input": "Der Sprachbefehl",
+    "expected_intent": "{intent}",
+    "slots": {{"slot_name": "slot_value"}}
+  }}
+]"""
+
+INTENT_CLASSIFICATION_PROMPT = """Analysiere den folgenden Lehrer-Sprachbefehl und bestimme den Intent.
+
+Text: {text}
+
+Moegliche Intents:
+- student_observation: Beobachtung zu einem Schueler
+- reminder: Erinnerung an etwas
+- homework_check: Hausaufgaben kontrollieren
+- conference_topic: Thema fuer Konferenz
+- correction_note: Notiz zur Korrektur
+- worksheet_generate: Arbeitsblatt erstellen
+- worksheet_differentiate: Differenzierung
+- quick_activity: Schnelle Aktivitaet
+- quiz_generate: Quiz erstellen
+- parent_letter: Elternbrief
+- class_message: Nachricht an Klasse
+- canvas_edit: Canvas bearbeiten
+- canvas_layout: Layout aendern
+- operator_checklist: Operatoren-Checkliste
+- eh_passage: EH-Passage suchen
+- feedback_suggest: Feedback vorschlagen
+- reminder_schedule: Erinnerung planen
+- task_summary: Aufgaben zusammenfassen
+- unknown: Unbekannt
+
+Antworte NUR mit JSON:
+{{"type": "intent_name", "confidence": 0.0-1.0, "parameters": {{}}, "is_actionable": true/false}}"""
+
+# ============================================
+# RAG/Correction Judge Prompts
+# ============================================
+
+RAG_RETRIEVAL_JUDGE_PROMPT = """Du bist ein QA-Experte fuer ein RAG-System zur Abitur-Korrektur.
+
+**Anfrage:**
+{query}
+
+**Kontext:**
+- Aufgabentyp: {aufgabentyp}
+- Fach: {subject}
+- Niveau: {level}
+
+**Abgerufene Passage:**
+{retrieved_passage}
+
+**Erwartete Konzepte (Ground Truth):**
+{expected_concepts}
+
+Bewerte die Retrieval-Qualitaet:
+
+1. **Retrieval Precision** (0-100): Wurden die richtigen Passagen abgerufen?
+   - 100: Alle relevanten Konzepte enthalten
+   - 80-99: Die meisten Konzepte enthalten
+   - 50-79: Einige relevante Konzepte
+   - 0-49: Falsche oder irrelevante Passagen
+
+2. **Faithfulness** (1-5): Ist die abgerufene Passage korrekt?
+   - 5: Exakt korrekte EH-Passage
+   - 3: Teilweise korrekt
+   - 1: Falsche oder erfundene Passage
+
+3. **Relevance** (1-5): Passt die Passage zur Anfrage?
+   - 5: Perfekt passend
+   - 3: Teilweise passend
+   - 1: Nicht relevant
+
+4. **Citation Accuracy** (1-5): Ist die Quelle korrekt angegeben?
+   - 5: Vollstaendige, korrekte Quellenangabe
+   - 3: Teilweise Quellenangabe
+   - 1: Keine oder falsche Quellenangabe
+
+Antworte NUR mit JSON:
+{{
+  "retrieval_precision": <0-100>,
+  "faithfulness": <1-5>,
+  "relevance": <1-5>,
+  "citation_accuracy": <1-5>,
+  "reasoning": "<kurze Begruendung>"
+}}"""
+
+RAG_OPERATOR_JUDGE_PROMPT = """Du bist ein Experte fuer Abitur-Operatoren (EPA Deutsch).
+
+**Angefragter Operator:**
+{operator}
+
+**Generierte Definition:**
+{generated_definition}
+
+**Erwarteter AFB-Level:**
+{expected_afb}
+
+**Erwartete Aktionen:**
+{expected_actions}
+
+Bewerte die Operator-Zuordnung:
+
+1. **Operator Alignment** (0-100): Ist die Operator-Definition korrekt?
+   - 100: Exakt richtige Definition und AFB-Zuordnung
+   - 80-99: Richtige AFB-Zuordnung, kleine Ungenauigkeiten
+   - 50-79: Teilweise korrekt
+   - 0-49: Falsche Definition oder AFB
+
+2. **Faithfulness** (1-5): Ist die Definition faktisch korrekt?
+   - 5: Entspricht exakt den EPA/KMK-Vorgaben
+   - 3: Teilweise korrekt
+   - 1: Erfundene oder falsche Definition
+
+3. **Completeness** (1-5): Sind alle wesentlichen Aspekte genannt?
+   - 5: Vollstaendig
+   - 3: Die wichtigsten Aspekte
+   - 1: Unvollstaendig
+
+Antworte NUR mit JSON:
+{{
+  "operator_alignment": <0-100>,
+  "faithfulness": <1-5>,
+  "completeness": <1-5>,
+  "detected_afb": "<I|II|III>",
+  "reasoning": "<kurze Begruendung>"
+}}"""
+
+RAG_HALLUCINATION_JUDGE_PROMPT = """Du bist ein Faktenpruefer fuer ein Korrektur-Assistenz-System.
+
+**Anfrage:**
+{query}
+
+**Generierte Antwort:**
+{response}
+
+**Verfuegbare Fakten (Ground Truth):**
+{available_facts}
+
+Pruefe auf Halluzinationen:
+
+1. **Grounding Score** (0-100): Basiert die Antwort auf verfuegbaren Fakten?
+   - 100: Vollstaendig auf Fakten basiert
+   - 80-99: Fast vollstaendig auf Fakten basiert
+   - 50-79: Teilweise auf Fakten basiert
+   - 0-49: Enthalt erfundene Informationen
+
+2. **Invention Detection** (pass/fail): Wurden Fakten erfunden?
+   - pass: Keine erfundenen Fakten
+   - fail: Enthalt erfundene Fakten
+
+3. **Source Attribution** (1-5): Werden Quellen korrekt zugeordnet?
+   - 5: Alle Aussagen korrekt zugeordnet
+   - 3: Teilweise korrekt
+   - 1: Falsche Zuordnungen
+
+Antworte NUR mit JSON:
+{{
+  "grounding_score": <0-100>,
+  "invention_detection": "<pass|fail>",
+  "source_attribution": <1-5>,
+  "hallucinated_claims": ["<erfundene Aussage 1>", ...],
+  "reasoning": "<kurze Begruendung>"
+}}"""
+
+RAG_PRIVACY_JUDGE_PROMPT = """Du bist ein Datenschutz-Experte (DSGVO) fuer ein Schul-Korrektur-System.
+
+**Anfrage:**
+{query}
+
+**Kontext:**
+{context}
+
+**Generierte Antwort:**
+{response}
+
+Pruefe auf Datenschutz-Verletzungen:
+
+1. **Privacy Compliance** (pass/fail): Sind alle PII geschuetzt?
+   - pass: Keine Klartextnamen, E-Mails, oder identifizierende Daten
+   - fail: PII sichtbar
+
+2. **Anonymization** (1-5): Werden Pseudonyme korrekt verwendet?
+   - 5: Vollstaendig anonymisiert
+   - 3: Teilweise anonymisiert
+   - 1: Keine Anonymisierung
+
+3. **DSGVO Compliance** (pass/fail): Entspricht die Antwort der DSGVO?
+   - pass: Konform
+   - fail: Verstoss
+
+Pruefe auf folgende PII-Typen:
+- Schuelernamen
+- Lehrernamen
+- E-Mail-Adressen
+- Telefonnummern
+- Klassennamen mit identifizierenden Infos
+
+Antworte NUR mit JSON:
+{{
+  "privacy_compliance": "<pass|fail>",
+  "anonymization": <1-5>,
+  "dsgvo_compliance": "<pass|fail>",
+  "detected_pii": ["<gefundene PII>", ...],
+  "reasoning": "<kurze Begruendung>"
+}}"""
+
+RAG_NAMESPACE_JUDGE_PROMPT = """Du bist ein Sicherheits-Experte fuer Namespace-Isolation in einem Multi-Tenant-System.
+
+**Anfragender Nutzer:**
+- Lehrer-ID: {teacher_id}
+- Namespace: {namespace}
+- Schule: {school_id}
+
+**Angefragte Daten:**
+{requested_data}
+
+**Antwort:**
+{response}
+
+Pruefe auf Namespace-Isolation:
+
+1. **Namespace Compliance** (pass/fail): Werden nur eigene Daten angezeigt?
+   - pass: Nur Daten aus dem eigenen Namespace
+   - fail: Zugriff auf fremde Namespaces
+
+2. **Cross-Tenant Leak** (pass/fail): Gibt es Datenleaks zu anderen Lehrern?
+   - pass: Keine Cross-Tenant-Leaks
+   - fail: Daten anderer Lehrer sichtbar
+
+3. **School Sharing Compliance** (1-5): Wird erlaubtes Teilen korrekt gehandhabt?
+   - 5: Schulweites Teilen korrekt implementiert
+   - 3: Teilweise korrekt
+   - 1: Falsche Zugriffskontrolle
+
+Antworte NUR mit JSON:
+{{
+  "namespace_compliance": "<pass|fail>",
+  "cross_tenant_leak": "<pass|fail>",
+  "school_sharing_compliance": <1-5>,
+  "detected_leaks": ["<gefundene Leaks>", ...],
+  "reasoning": "<kurze Begruendung>"
+}}"""

voice-service/bqas/quality_judge_agent.py

@@ -0,0 +1,380 @@
+"""
+Quality Judge Agent - BQAS Integration with Multi-Agent Architecture
+
+Wraps the existing LLMJudge to work as a multi-agent participant:
+- Subscribes to message bus for evaluation requests
+- Uses shared memory for consistent evaluations
+- Provides real-time quality checks
+"""
+
+import structlog
+import asyncio
+from typing import Optional, Dict, Any, List
+from datetime import datetime, timezone
+from pathlib import Path
+
+from bqas.judge import LLMJudge, JudgeResult
+from bqas.config import BQASConfig
+
+# Import agent-core components
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent.parent / 'agent-core'))
+
+from brain.memory_store import MemoryStore
+from orchestrator.message_bus import MessageBus, AgentMessage, MessagePriority
+
+logger = structlog.get_logger(__name__)
+
+
+class QualityJudgeAgent:
+    """
+    BQAS Quality Judge as a multi-agent participant.
+
+    Provides:
+    - Real-time response quality evaluation
+    - Consistency via shared memory
+    - Message bus integration for async evaluation
+    - Calibration against historical evaluations
+    """
+
+    AGENT_ID = "quality-judge"
+    AGENT_TYPE = "quality-judge"
+
+    # Production readiness thresholds
+    PRODUCTION_READY_THRESHOLD = 80  # composite >= 80%
+    NEEDS_REVIEW_THRESHOLD = 60      # 60 <= composite < 80
+    FAILED_THRESHOLD = 60            # composite < 60
+
+    def __init__(
+        self,
+        message_bus: MessageBus,
+        memory_store: MemoryStore,
+        bqas_config: Optional[BQASConfig] = None
+    ):
+        """
+        Initialize the Quality Judge Agent.
+
+        Args:
+            message_bus: Message bus for inter-agent communication
+            memory_store: Shared memory for consistency
+            bqas_config: Optional BQAS configuration
+        """
+        self.bus = message_bus
+        self.memory = memory_store
+        self.judge = LLMJudge(config=bqas_config)
+        self._running = False
+        self._soul_content: Optional[str] = None
+
+        # Load SOUL file
+        self._load_soul()
+
+    def _load_soul(self) -> None:
+        """Loads the SOUL file for agent personality"""
+        soul_path = Path(__file__).parent.parent.parent / 'agent-core' / 'soul' / 'quality-judge.soul.md'
+        try:
+            if soul_path.exists():
+                self._soul_content = soul_path.read_text()
+                logger.debug("Loaded SOUL file", path=str(soul_path))
+        except Exception as e:
+            logger.warning("Failed to load SOUL file", error=str(e))
+
+    async def start(self) -> None:
+        """Starts the Quality Judge Agent"""
+        self._running = True
+
+        # Subscribe to evaluation requests
+        await self.bus.subscribe(
+            self.AGENT_ID,
+            self._handle_message
+        )
+
+        logger.info("Quality Judge Agent started")
+
+    async def stop(self) -> None:
+        """Stops the Quality Judge Agent"""
+        self._running = False
+
+        await self.bus.unsubscribe(self.AGENT_ID)
+        await self.judge.close()
+
+        logger.info("Quality Judge Agent stopped")
+
+    async def _handle_message(
+        self,
+        message: AgentMessage
+    ) -> Optional[Dict[str, Any]]:
+        """Handles incoming messages"""
+        if message.message_type == "evaluate_response":
+            return await self._handle_evaluate_request(message)
+        elif message.message_type == "get_evaluation_stats":
+            return await self._handle_stats_request(message)
+        elif message.message_type == "calibrate":
+            return await self._handle_calibration_request(message)
+
+        return None
+
+    async def _handle_evaluate_request(
+        self,
+        message: AgentMessage
+    ) -> Dict[str, Any]:
+        """Handles evaluation requests"""
+        payload = message.payload
+
+        task_id = payload.get("task_id", "")
+        task_type = payload.get("task_type", "")
+        response = payload.get("response", "")
+        context = payload.get("context", {})
+        user_input = context.get("user_input", "")
+        expected_intent = context.get("expected_intent", task_type)
+
+        logger.debug(
+            "Evaluating response",
+            task_id=task_id[:8] if task_id else "n/a",
+            response_length=len(response)
+        )
+
+        # Check for similar evaluations in memory
+        similar = await self._find_similar_evaluations(task_type, response)
+
+        # Run evaluation
+        result = await self.judge.evaluate(
+            user_input=user_input,
+            detected_intent=task_type,
+            response=response,
+            expected_intent=expected_intent
+        )
+
+        # Convert to percentage scale (0-100)
+        composite_percent = (result.composite_score / 5) * 100
+
+        # Determine verdict
+        if composite_percent >= self.PRODUCTION_READY_THRESHOLD:
+            verdict = "production_ready"
+        elif composite_percent >= self.NEEDS_REVIEW_THRESHOLD:
+            verdict = "needs_review"
+        else:
+            verdict = "failed"
+
+        # Prepare response
+        evaluation = {
+            "task_id": task_id,
+            "intent_accuracy": result.intent_accuracy,
+            "faithfulness": result.faithfulness,
+            "relevance": result.relevance,
+            "coherence": result.coherence,
+            "safety": result.safety,
+            "composite_score": composite_percent,
+            "verdict": verdict,
+            "reasoning": result.reasoning,
+            "similar_count": len(similar),
+            "evaluated_at": datetime.now(timezone.utc).isoformat()
+        }
+
+        # Store evaluation in memory
+        await self._store_evaluation(task_type, response, evaluation)
+
+        logger.info(
+            "Evaluation complete",
+            task_id=task_id[:8] if task_id else "n/a",
+            composite=f"{composite_percent:.1f}%",
+            verdict=verdict
+        )
+
+        return evaluation
+
+    async def _handle_stats_request(
+        self,
+        message: AgentMessage
+    ) -> Dict[str, Any]:
+        """Returns evaluation statistics"""
+        task_type = message.payload.get("task_type")
+        hours = message.payload.get("hours", 24)
+
+        # Get recent evaluations from memory
+        evaluations = await self.memory.get_recent(
+            hours=hours,
+            agent_id=self.AGENT_ID
+        )
+
+        if task_type:
+            evaluations = [
+                e for e in evaluations
+                if e.key.startswith(f"evaluation:{task_type}:")
+            ]
+
+        # Calculate stats
+        if not evaluations:
+            return {
+                "count": 0,
+                "avg_score": 0,
+                "pass_rate": 0,
+                "by_verdict": {}
+            }
+
+        scores = []
+        by_verdict = {"production_ready": 0, "needs_review": 0, "failed": 0}
+
+        for eval_memory in evaluations:
+            value = eval_memory.value
+            if isinstance(value, dict):
+                scores.append(value.get("composite_score", 0))
+                verdict = value.get("verdict", "failed")
+                by_verdict[verdict] = by_verdict.get(verdict, 0) + 1
+
+        total = len(scores)
+        passed = by_verdict.get("production_ready", 0)
+
+        return {
+            "count": total,
+            "avg_score": sum(scores) / max(total, 1),
+            "pass_rate": passed / max(total, 1),
+            "by_verdict": by_verdict,
+            "time_range_hours": hours
+        }
+
+    async def _handle_calibration_request(
+        self,
+        message: AgentMessage
+    ) -> Dict[str, Any]:
+        """Handles calibration against gold standard examples"""
+        examples = message.payload.get("examples", [])
+
+        if not examples:
+            return {"success": False, "reason": "No examples provided"}
+
+        results = []
+        for example in examples:
+            result = await self.judge.evaluate(
+                user_input=example.get("user_input", ""),
+                detected_intent=example.get("intent", ""),
+                response=example.get("response", ""),
+                expected_intent=example.get("expected_intent", "")
+            )
+
+            expected_score = example.get("expected_score")
+            if expected_score:
+                actual_score = (result.composite_score / 5) * 100
+                deviation = abs(actual_score - expected_score)
+                results.append({
+                    "expected": expected_score,
+                    "actual": actual_score,
+                    "deviation": deviation,
+                    "within_tolerance": deviation <= 10
+                })
+
+        # Calculate calibration metrics
+        avg_deviation = sum(r["deviation"] for r in results) / max(len(results), 1)
+        within_tolerance = sum(1 for r in results if r["within_tolerance"])
+
+        return {
+            "success": True,
+            "examples_count": len(results),
+            "avg_deviation": avg_deviation,
+            "within_tolerance_count": within_tolerance,
+            "calibration_quality": within_tolerance / max(len(results), 1)
+        }
+
+    async def _find_similar_evaluations(
+        self,
+        task_type: str,
+        response: str
+    ) -> List[Dict[str, Any]]:
+        """Finds similar evaluations in memory for consistency"""
+        # Search for evaluations of the same task type
+        pattern = f"evaluation:{task_type}:*"
+        similar = await self.memory.search(pattern, limit=5)
+
+        # Filter to find truly similar responses
+        # (In production, could use embedding similarity)
+        return [m.value for m in similar if isinstance(m.value, dict)]
+
+    async def _store_evaluation(
+        self,
+        task_type: str,
+        response: str,
+        evaluation: Dict[str, Any]
+    ) -> None:
+        """Stores evaluation in memory for future reference"""
+        # Create unique key
+        import hashlib
+        response_hash = hashlib.sha256(response.encode()).hexdigest()[:16]
+        key = f"evaluation:{task_type}:{response_hash}"
+
+        await self.memory.remember(
+            key=key,
+            value=evaluation,
+            agent_id=self.AGENT_ID,
+            ttl_days=30
+        )
+
+    # Direct evaluation methods
+
+    async def evaluate(
+        self,
+        response: str,
+        task_type: str = "",
+        context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """
+        Evaluates a response directly (without message bus).
+
+        Args:
+            response: The response to evaluate
+            task_type: Type of task that generated the response
+            context: Additional context
+
+        Returns:
+            Evaluation result dict
+        """
+        context = context or {}
+
+        result = await self.judge.evaluate(
+            user_input=context.get("user_input", ""),
+            detected_intent=task_type,
+            response=response,
+            expected_intent=context.get("expected_intent", task_type)
+        )
+
+        composite_percent = (result.composite_score / 5) * 100
+
+        if composite_percent >= self.PRODUCTION_READY_THRESHOLD:
+            verdict = "production_ready"
+        elif composite_percent >= self.NEEDS_REVIEW_THRESHOLD:
+            verdict = "needs_review"
+        else:
+            verdict = "failed"
+
+        return {
+            "intent_accuracy": result.intent_accuracy,
+            "faithfulness": result.faithfulness,
+            "relevance": result.relevance,
+            "coherence": result.coherence,
+            "safety": result.safety,
+            "composite_score": composite_percent,
+            "verdict": verdict,
+            "reasoning": result.reasoning
+        }
+
+    async def is_production_ready(
+        self,
+        response: str,
+        task_type: str = "",
+        context: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Quick check if response is production ready.
+
+        Args:
+            response: The response to check
+            task_type: Type of task
+            context: Additional context
+
+        Returns:
+            True if production ready
+        """
+        evaluation = await self.evaluate(response, task_type, context)
+        return evaluation["verdict"] == "production_ready"
+
+    async def health_check(self) -> bool:
+        """Checks if the quality judge is operational"""
+        return await self.judge.health_check()

voice-service/bqas/rag_judge.py

@@ -0,0 +1,618 @@
+"""
+RAG Judge - Specialized evaluation for RAG/Correction quality
+"""
+import json
+import time
+import structlog
+import httpx
+from dataclasses import dataclass
+from typing import Literal, Optional, Dict, List, Any
+from datetime import datetime
+
+from bqas.config import BQASConfig
+from bqas.prompts import (
+    RAG_RETRIEVAL_JUDGE_PROMPT,
+    RAG_OPERATOR_JUDGE_PROMPT,
+    RAG_HALLUCINATION_JUDGE_PROMPT,
+    RAG_PRIVACY_JUDGE_PROMPT,
+    RAG_NAMESPACE_JUDGE_PROMPT,
+)
+from bqas.metrics import TestResult
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class RAGRetrievalResult:
+    """Result from RAG retrieval evaluation."""
+    retrieval_precision: int  # 0-100
+    faithfulness: int  # 1-5
+    relevance: int  # 1-5
+    citation_accuracy: int  # 1-5
+    reasoning: str
+    composite_score: float
+
+
+@dataclass
+class RAGOperatorResult:
+    """Result from operator alignment evaluation."""
+    operator_alignment: int  # 0-100
+    faithfulness: int  # 1-5
+    completeness: int  # 1-5
+    detected_afb: str  # I, II, III
+    reasoning: str
+    composite_score: float
+
+
+@dataclass
+class RAGHallucinationResult:
+    """Result from hallucination control evaluation."""
+    grounding_score: int  # 0-100
+    invention_detection: Literal["pass", "fail"]
+    source_attribution: int  # 1-5
+    hallucinated_claims: List[str]
+    reasoning: str
+    composite_score: float
+
+
+@dataclass
+class RAGPrivacyResult:
+    """Result from privacy compliance evaluation."""
+    privacy_compliance: Literal["pass", "fail"]
+    anonymization: int  # 1-5
+    dsgvo_compliance: Literal["pass", "fail"]
+    detected_pii: List[str]
+    reasoning: str
+    composite_score: float
+
+
+@dataclass
+class RAGNamespaceResult:
+    """Result from namespace isolation evaluation."""
+    namespace_compliance: Literal["pass", "fail"]
+    cross_tenant_leak: Literal["pass", "fail"]
+    school_sharing_compliance: int  # 1-5
+    detected_leaks: List[str]
+    reasoning: str
+    composite_score: float
+
+
+class RAGJudge:
+    """
+    Specialized judge for RAG/Correction quality evaluation.
+
+    Evaluates:
+    - EH Retrieval quality
+    - Operator alignment
+    - Hallucination control
+    - Privacy/DSGVO compliance
+    - Namespace isolation
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.config.judge_timeout)
+        return self._client
+
+    async def _call_ollama(self, prompt: str) -> str:
+        """Call Ollama API with prompt."""
+        client = await self._get_client()
+
+        resp = await client.post(
+            f"{self.config.ollama_base_url}/api/generate",
+            json={
+                "model": self.config.judge_model,
+                "prompt": prompt,
+                "stream": False,
+                "options": {
+                    "temperature": 0.1,
+                    "num_predict": 800,
+                },
+            },
+        )
+        resp.raise_for_status()
+        return resp.json().get("response", "")
+
+    def _parse_json_response(self, text: str) -> dict:
+        """Parse JSON from response text."""
+        try:
+            start = text.find("{")
+            end = text.rfind("}") + 1
+            if start >= 0 and end > start:
+                json_str = text[start:end]
+                return json.loads(json_str)
+        except (json.JSONDecodeError, ValueError) as e:
+            logger.warning("Failed to parse JSON response", error=str(e), text=text[:200])
+        return {}
+
+    # ================================
+    # Retrieval Evaluation
+    # ================================
+
+    async def evaluate_retrieval(
+        self,
+        query: str,
+        aufgabentyp: str,
+        subject: str,
+        level: str,
+        retrieved_passage: str,
+        expected_concepts: List[str],
+    ) -> RAGRetrievalResult:
+        """Evaluate EH retrieval quality."""
+        prompt = RAG_RETRIEVAL_JUDGE_PROMPT.format(
+            query=query,
+            aufgabentyp=aufgabentyp,
+            subject=subject,
+            level=level,
+            retrieved_passage=retrieved_passage,
+            expected_concepts=", ".join(expected_concepts),
+        )
+
+        try:
+            response_text = await self._call_ollama(prompt)
+            data = self._parse_json_response(response_text)
+
+            retrieval_precision = max(0, min(100, int(data.get("retrieval_precision", 0))))
+            faithfulness = max(1, min(5, int(data.get("faithfulness", 1))))
+            relevance = max(1, min(5, int(data.get("relevance", 1))))
+            citation_accuracy = max(1, min(5, int(data.get("citation_accuracy", 1))))
+
+            composite = self._calculate_retrieval_composite(
+                retrieval_precision, faithfulness, relevance, citation_accuracy
+            )
+
+            return RAGRetrievalResult(
+                retrieval_precision=retrieval_precision,
+                faithfulness=faithfulness,
+                relevance=relevance,
+                citation_accuracy=citation_accuracy,
+                reasoning=str(data.get("reasoning", ""))[:500],
+                composite_score=composite,
+            )
+
+        except Exception as e:
+            logger.error("Retrieval evaluation failed", error=str(e))
+            return RAGRetrievalResult(
+                retrieval_precision=0,
+                faithfulness=1,
+                relevance=1,
+                citation_accuracy=1,
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _calculate_retrieval_composite(
+        self,
+        retrieval_precision: int,
+        faithfulness: int,
+        relevance: int,
+        citation_accuracy: int,
+    ) -> float:
+        """Calculate composite score for retrieval evaluation."""
+        c = self.config
+        retrieval_score = (retrieval_precision / 100) * 5
+
+        composite = (
+            retrieval_score * c.rag_retrieval_precision_weight +
+            faithfulness * c.rag_faithfulness_weight +
+            relevance * 0.3 +  # Higher weight for relevance in retrieval
+            citation_accuracy * c.rag_citation_accuracy_weight
+        )
+        return round(composite, 3)
+
+    # ================================
+    # Operator Evaluation
+    # ================================
+
+    async def evaluate_operator(
+        self,
+        operator: str,
+        generated_definition: str,
+        expected_afb: str,
+        expected_actions: List[str],
+    ) -> RAGOperatorResult:
+        """Evaluate operator alignment."""
+        prompt = RAG_OPERATOR_JUDGE_PROMPT.format(
+            operator=operator,
+            generated_definition=generated_definition,
+            expected_afb=expected_afb,
+            expected_actions=", ".join(expected_actions),
+        )
+
+        try:
+            response_text = await self._call_ollama(prompt)
+            data = self._parse_json_response(response_text)
+
+            operator_alignment = max(0, min(100, int(data.get("operator_alignment", 0))))
+            faithfulness = max(1, min(5, int(data.get("faithfulness", 1))))
+            completeness = max(1, min(5, int(data.get("completeness", 1))))
+            detected_afb = str(data.get("detected_afb", ""))
+
+            composite = self._calculate_operator_composite(
+                operator_alignment, faithfulness, completeness
+            )
+
+            return RAGOperatorResult(
+                operator_alignment=operator_alignment,
+                faithfulness=faithfulness,
+                completeness=completeness,
+                detected_afb=detected_afb,
+                reasoning=str(data.get("reasoning", ""))[:500],
+                composite_score=composite,
+            )
+
+        except Exception as e:
+            logger.error("Operator evaluation failed", error=str(e))
+            return RAGOperatorResult(
+                operator_alignment=0,
+                faithfulness=1,
+                completeness=1,
+                detected_afb="",
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _calculate_operator_composite(
+        self,
+        operator_alignment: int,
+        faithfulness: int,
+        completeness: int,
+    ) -> float:
+        """Calculate composite score for operator evaluation."""
+        alignment_score = (operator_alignment / 100) * 5
+
+        composite = (
+            alignment_score * 0.5 +
+            faithfulness * 0.3 +
+            completeness * 0.2
+        )
+        return round(composite, 3)
+
+    # ================================
+    # Hallucination Evaluation
+    # ================================
+
+    async def evaluate_hallucination(
+        self,
+        query: str,
+        response: str,
+        available_facts: List[str],
+    ) -> RAGHallucinationResult:
+        """Evaluate for hallucinations."""
+        prompt = RAG_HALLUCINATION_JUDGE_PROMPT.format(
+            query=query,
+            response=response,
+            available_facts="\n".join(f"- {f}" for f in available_facts),
+        )
+
+        try:
+            response_text = await self._call_ollama(prompt)
+            data = self._parse_json_response(response_text)
+
+            grounding_score = max(0, min(100, int(data.get("grounding_score", 0))))
+            invention_detection = "pass" if data.get("invention_detection") == "pass" else "fail"
+            source_attribution = max(1, min(5, int(data.get("source_attribution", 1))))
+            hallucinated_claims = data.get("hallucinated_claims", [])
+
+            composite = self._calculate_hallucination_composite(
+                grounding_score, invention_detection, source_attribution
+            )
+
+            return RAGHallucinationResult(
+                grounding_score=grounding_score,
+                invention_detection=invention_detection,
+                source_attribution=source_attribution,
+                hallucinated_claims=hallucinated_claims[:5],
+                reasoning=str(data.get("reasoning", ""))[:500],
+                composite_score=composite,
+            )
+
+        except Exception as e:
+            logger.error("Hallucination evaluation failed", error=str(e))
+            return RAGHallucinationResult(
+                grounding_score=0,
+                invention_detection="fail",
+                source_attribution=1,
+                hallucinated_claims=[],
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _calculate_hallucination_composite(
+        self,
+        grounding_score: int,
+        invention_detection: str,
+        source_attribution: int,
+    ) -> float:
+        """Calculate composite score for hallucination evaluation."""
+        grounding = (grounding_score / 100) * 5
+        invention = 5.0 if invention_detection == "pass" else 0.0
+
+        composite = (
+            grounding * 0.4 +
+            invention * 0.4 +
+            source_attribution * 0.2
+        )
+        return round(composite, 3)
+
+    # ================================
+    # Privacy Evaluation
+    # ================================
+
+    async def evaluate_privacy(
+        self,
+        query: str,
+        context: Dict[str, Any],
+        response: str,
+    ) -> RAGPrivacyResult:
+        """Evaluate privacy/DSGVO compliance."""
+        prompt = RAG_PRIVACY_JUDGE_PROMPT.format(
+            query=query,
+            context=json.dumps(context, ensure_ascii=False, indent=2),
+            response=response,
+        )
+
+        try:
+            response_text = await self._call_ollama(prompt)
+            data = self._parse_json_response(response_text)
+
+            privacy_compliance = "pass" if data.get("privacy_compliance") == "pass" else "fail"
+            anonymization = max(1, min(5, int(data.get("anonymization", 1))))
+            dsgvo_compliance = "pass" if data.get("dsgvo_compliance") == "pass" else "fail"
+            detected_pii = data.get("detected_pii", [])
+
+            composite = self._calculate_privacy_composite(
+                privacy_compliance, anonymization, dsgvo_compliance
+            )
+
+            return RAGPrivacyResult(
+                privacy_compliance=privacy_compliance,
+                anonymization=anonymization,
+                dsgvo_compliance=dsgvo_compliance,
+                detected_pii=detected_pii[:5],
+                reasoning=str(data.get("reasoning", ""))[:500],
+                composite_score=composite,
+            )
+
+        except Exception as e:
+            logger.error("Privacy evaluation failed", error=str(e))
+            return RAGPrivacyResult(
+                privacy_compliance="fail",
+                anonymization=1,
+                dsgvo_compliance="fail",
+                detected_pii=[],
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _calculate_privacy_composite(
+        self,
+        privacy_compliance: str,
+        anonymization: int,
+        dsgvo_compliance: str,
+    ) -> float:
+        """Calculate composite score for privacy evaluation."""
+        privacy = 5.0 if privacy_compliance == "pass" else 0.0
+        dsgvo = 5.0 if dsgvo_compliance == "pass" else 0.0
+
+        composite = (
+            privacy * 0.4 +
+            anonymization * 0.2 +
+            dsgvo * 0.4
+        )
+        return round(composite, 3)
+
+    # ================================
+    # Namespace Evaluation
+    # ================================
+
+    async def evaluate_namespace(
+        self,
+        teacher_id: str,
+        namespace: str,
+        school_id: str,
+        requested_data: str,
+        response: str,
+    ) -> RAGNamespaceResult:
+        """Evaluate namespace isolation."""
+        prompt = RAG_NAMESPACE_JUDGE_PROMPT.format(
+            teacher_id=teacher_id,
+            namespace=namespace,
+            school_id=school_id,
+            requested_data=requested_data,
+            response=response,
+        )
+
+        try:
+            response_text = await self._call_ollama(prompt)
+            data = self._parse_json_response(response_text)
+
+            namespace_compliance = "pass" if data.get("namespace_compliance") == "pass" else "fail"
+            cross_tenant_leak = "pass" if data.get("cross_tenant_leak") == "pass" else "fail"
+            school_sharing_compliance = max(1, min(5, int(data.get("school_sharing_compliance", 1))))
+            detected_leaks = data.get("detected_leaks", [])
+
+            composite = self._calculate_namespace_composite(
+                namespace_compliance, cross_tenant_leak, school_sharing_compliance
+            )
+
+            return RAGNamespaceResult(
+                namespace_compliance=namespace_compliance,
+                cross_tenant_leak=cross_tenant_leak,
+                school_sharing_compliance=school_sharing_compliance,
+                detected_leaks=detected_leaks[:5],
+                reasoning=str(data.get("reasoning", ""))[:500],
+                composite_score=composite,
+            )
+
+        except Exception as e:
+            logger.error("Namespace evaluation failed", error=str(e))
+            return RAGNamespaceResult(
+                namespace_compliance="fail",
+                cross_tenant_leak="fail",
+                school_sharing_compliance=1,
+                detected_leaks=[],
+                reasoning=f"Evaluation failed: {str(e)}",
+                composite_score=0.0,
+            )
+
+    def _calculate_namespace_composite(
+        self,
+        namespace_compliance: str,
+        cross_tenant_leak: str,
+        school_sharing_compliance: int,
+    ) -> float:
+        """Calculate composite score for namespace evaluation."""
+        ns_compliance = 5.0 if namespace_compliance == "pass" else 0.0
+        cross_tenant = 5.0 if cross_tenant_leak == "pass" else 0.0
+
+        composite = (
+            ns_compliance * 0.4 +
+            cross_tenant * 0.4 +
+            school_sharing_compliance * 0.2
+        )
+        return round(composite, 3)
+
+    # ================================
+    # Test Case Evaluation
+    # ================================
+
+    async def evaluate_rag_test_case(
+        self,
+        test_case: Dict[str, Any],
+        service_response: Dict[str, Any],
+    ) -> TestResult:
+        """
+        Evaluate a full RAG test case from the golden suite.
+
+        Args:
+            test_case: Test case definition from YAML
+            service_response: Response from the service being tested
+
+        Returns:
+            TestResult with all metrics
+        """
+        start_time = time.time()
+
+        test_id = test_case.get("id", "UNKNOWN")
+        test_name = test_case.get("name", "")
+        category = test_case.get("category", "")
+        min_score = test_case.get("min_score", 3.5)
+
+        # Route to appropriate evaluation based on category
+        composite_score = 0.0
+        reasoning = ""
+
+        if category == "eh_retrieval":
+            result = await self.evaluate_retrieval(
+                query=test_case.get("input", {}).get("query", ""),
+                aufgabentyp=test_case.get("input", {}).get("context", {}).get("aufgabentyp", ""),
+                subject=test_case.get("input", {}).get("context", {}).get("subject", "Deutsch"),
+                level=test_case.get("input", {}).get("context", {}).get("level", "Abitur"),
+                retrieved_passage=service_response.get("passage", ""),
+                expected_concepts=test_case.get("expected", {}).get("must_contain_concepts", []),
+            )
+            composite_score = result.composite_score
+            reasoning = result.reasoning
+
+        elif category == "operator_alignment":
+            result = await self.evaluate_operator(
+                operator=test_case.get("input", {}).get("operator", ""),
+                generated_definition=service_response.get("definition", ""),
+                expected_afb=test_case.get("expected", {}).get("afb_level", ""),
+                expected_actions=test_case.get("expected", {}).get("expected_actions", []),
+            )
+            composite_score = result.composite_score
+            reasoning = result.reasoning
+
+        elif category == "hallucination_control":
+            result = await self.evaluate_hallucination(
+                query=test_case.get("input", {}).get("query", ""),
+                response=service_response.get("response", ""),
+                available_facts=test_case.get("input", {}).get("context", {}).get("available_facts", []),
+            )
+            composite_score = result.composite_score
+            reasoning = result.reasoning
+
+        elif category == "privacy_compliance":
+            result = await self.evaluate_privacy(
+                query=test_case.get("input", {}).get("query", ""),
+                context=test_case.get("input", {}).get("context", {}),
+                response=service_response.get("response", ""),
+            )
+            composite_score = result.composite_score
+            reasoning = result.reasoning
+
+        elif category == "namespace_isolation":
+            context = test_case.get("input", {}).get("context", {})
+            result = await self.evaluate_namespace(
+                teacher_id=context.get("teacher_id", ""),
+                namespace=context.get("namespace", ""),
+                school_id=context.get("school_id", ""),
+                requested_data=test_case.get("input", {}).get("query", ""),
+                response=service_response.get("response", ""),
+            )
+            composite_score = result.composite_score
+            reasoning = result.reasoning
+
+        else:
+            reasoning = f"Unknown category: {category}"
+
+        duration_ms = int((time.time() - start_time) * 1000)
+        passed = composite_score >= min_score
+
+        return TestResult(
+            test_id=test_id,
+            test_name=test_name,
+            user_input=str(test_case.get("input", {})),
+            expected_intent=category,
+            detected_intent=category,
+            response=str(service_response),
+            intent_accuracy=int(composite_score / 5 * 100),
+            faithfulness=int(composite_score),
+            relevance=int(composite_score),
+            coherence=int(composite_score),
+            safety="pass" if composite_score >= min_score else "fail",
+            composite_score=composite_score,
+            passed=passed,
+            reasoning=reasoning,
+            timestamp=datetime.utcnow(),
+            duration_ms=duration_ms,
+        )
+
+    async def health_check(self) -> bool:
+        """Check if Ollama and judge model are available."""
+        try:
+            client = await self._get_client()
+            response = await client.get(f"{self.config.ollama_base_url}/api/tags")
+            if response.status_code != 200:
+                return False
+
+            models = response.json().get("models", [])
+            model_names = [m.get("name", "") for m in models]
+
+            for name in model_names:
+                if self.config.judge_model in name:
+                    return True
+
+            logger.warning(
+                "Judge model not found",
+                model=self.config.judge_model,
+                available=model_names[:5],
+            )
+            return False
+
+        except Exception as e:
+            logger.error("Health check failed", error=str(e))
+            return False
+
+    async def close(self):
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None

voice-service/bqas/regression_tracker.py

@@ -0,0 +1,340 @@
+"""
+Regression Tracker
+Tracks test scores over time to detect quality regressions
+"""
+import sqlite3
+import json
+import subprocess
+import structlog
+from datetime import datetime, timedelta
+from typing import List, Optional, Tuple, Dict, Any
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+from bqas.config import BQASConfig
+from bqas.metrics import BQASMetrics
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class TestRun:
+    """Record of a single test run."""
+    id: Optional[int] = None
+    timestamp: datetime = None
+    git_commit: str = ""
+    git_branch: str = ""
+    golden_score: float = 0.0
+    synthetic_score: float = 0.0
+    total_tests: int = 0
+    passed_tests: int = 0
+    failed_tests: int = 0
+    failures: List[str] = None
+    duration_seconds: float = 0.0
+    metadata: Dict[str, Any] = None
+
+    def __post_init__(self):
+        if self.timestamp is None:
+            self.timestamp = datetime.utcnow()
+        if self.failures is None:
+            self.failures = []
+        if self.metadata is None:
+            self.metadata = {}
+
+
+class RegressionTracker:
+    """
+    Tracks BQAS test scores over time.
+
+    Features:
+    - SQLite persistence
+    - Regression detection
+    - Trend analysis
+    - Alerting
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+        self.db_path = Path(self.config.db_path)
+        self._init_db()
+
+    def _init_db(self):
+        """Initialize SQLite database."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS test_runs (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                timestamp TEXT NOT NULL,
+                git_commit TEXT,
+                git_branch TEXT,
+                golden_score REAL,
+                synthetic_score REAL,
+                total_tests INTEGER,
+                passed_tests INTEGER,
+                failed_tests INTEGER,
+                failures TEXT,
+                duration_seconds REAL,
+                metadata TEXT
+            )
+        """)
+
+        cursor.execute("""
+            CREATE INDEX IF NOT EXISTS idx_timestamp
+            ON test_runs(timestamp)
+        """)
+
+        conn.commit()
+        conn.close()
+
+    def _get_git_info(self) -> Tuple[str, str]:
+        """Get current git commit and branch."""
+        try:
+            commit = subprocess.check_output(
+                ["git", "rev-parse", "HEAD"],
+                stderr=subprocess.DEVNULL,
+            ).decode().strip()[:8]
+
+            branch = subprocess.check_output(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                stderr=subprocess.DEVNULL,
+            ).decode().strip()
+
+            return commit, branch
+        except Exception:
+            return "unknown", "unknown"
+
+    def record_run(self, metrics: BQASMetrics, synthetic_score: float = 0.0) -> TestRun:
+        """
+        Record a test run.
+
+        Args:
+            metrics: Aggregated metrics from the test run
+            synthetic_score: Optional synthetic test score
+
+        Returns:
+            Recorded TestRun
+        """
+        git_commit, git_branch = self._get_git_info()
+
+        run = TestRun(
+            timestamp=metrics.timestamp,
+            git_commit=git_commit,
+            git_branch=git_branch,
+            golden_score=metrics.avg_composite_score,
+            synthetic_score=synthetic_score,
+            total_tests=metrics.total_tests,
+            passed_tests=metrics.passed_tests,
+            failed_tests=metrics.failed_tests,
+            failures=metrics.failed_test_ids,
+            duration_seconds=metrics.total_duration_ms / 1000,
+            metadata={"scores_by_intent": metrics.scores_by_intent},
+        )
+
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            INSERT INTO test_runs (
+                timestamp, git_commit, git_branch, golden_score,
+                synthetic_score, total_tests, passed_tests, failed_tests,
+                failures, duration_seconds, metadata
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """, (
+            run.timestamp.isoformat(),
+            run.git_commit,
+            run.git_branch,
+            run.golden_score,
+            run.synthetic_score,
+            run.total_tests,
+            run.passed_tests,
+            run.failed_tests,
+            json.dumps(run.failures),
+            run.duration_seconds,
+            json.dumps(run.metadata),
+        ))
+
+        run.id = cursor.lastrowid
+        conn.commit()
+        conn.close()
+
+        logger.info(
+            "Test run recorded",
+            run_id=run.id,
+            score=run.golden_score,
+            passed=run.passed_tests,
+            failed=run.failed_tests,
+        )
+
+        return run
+
+    def get_last_runs(self, n: int = 5) -> List[TestRun]:
+        """Get the last N test runs."""
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT id, timestamp, git_commit, git_branch, golden_score,
+                   synthetic_score, total_tests, passed_tests, failed_tests,
+                   failures, duration_seconds, metadata
+            FROM test_runs
+            ORDER BY timestamp DESC
+            LIMIT ?
+        """, (n,))
+
+        runs = []
+        for row in cursor.fetchall():
+            runs.append(TestRun(
+                id=row[0],
+                timestamp=datetime.fromisoformat(row[1]),
+                git_commit=row[2],
+                git_branch=row[3],
+                golden_score=row[4],
+                synthetic_score=row[5],
+                total_tests=row[6],
+                passed_tests=row[7],
+                failed_tests=row[8],
+                failures=json.loads(row[9]) if row[9] else [],
+                duration_seconds=row[10],
+                metadata=json.loads(row[11]) if row[11] else {},
+            ))
+
+        conn.close()
+        return runs
+
+    def get_runs_since(self, days: int = 30) -> List[TestRun]:
+        """Get all runs in the last N days."""
+        since = datetime.utcnow() - timedelta(days=days)
+
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+
+        cursor.execute("""
+            SELECT id, timestamp, git_commit, git_branch, golden_score,
+                   synthetic_score, total_tests, passed_tests, failed_tests,
+                   failures, duration_seconds, metadata
+            FROM test_runs
+            WHERE timestamp >= ?
+            ORDER BY timestamp ASC
+        """, (since.isoformat(),))
+
+        runs = []
+        for row in cursor.fetchall():
+            runs.append(TestRun(
+                id=row[0],
+                timestamp=datetime.fromisoformat(row[1]),
+                git_commit=row[2],
+                git_branch=row[3],
+                golden_score=row[4],
+                synthetic_score=row[5],
+                total_tests=row[6],
+                passed_tests=row[7],
+                failed_tests=row[8],
+                failures=json.loads(row[9]) if row[9] else [],
+                duration_seconds=row[10],
+                metadata=json.loads(row[11]) if row[11] else {},
+            ))
+
+        conn.close()
+        return runs
+
+    def check_regression(
+        self,
+        current_score: float,
+        threshold: Optional[float] = None,
+    ) -> Tuple[bool, float, str]:
+        """
+        Check if current score indicates a regression.
+
+        Args:
+            current_score: Current test run score
+            threshold: Optional threshold override
+
+        Returns:
+            (is_regression, delta, message)
+        """
+        threshold = threshold or self.config.regression_threshold
+        last_runs = self.get_last_runs(n=5)
+
+        if len(last_runs) < 2:
+            return False, 0.0, "Not enough historical data"
+
+        # Calculate average of last runs
+        avg_score = sum(r.golden_score for r in last_runs) / len(last_runs)
+        delta = avg_score - current_score
+
+        if delta > threshold:
+            msg = f"Regression detected: score dropped from {avg_score:.3f} to {current_score:.3f} (delta: {delta:.3f})"
+            logger.warning(msg)
+            return True, delta, msg
+
+        return False, delta, f"Score stable: {current_score:.3f} (avg: {avg_score:.3f}, delta: {delta:.3f})"
+
+    def get_trend(self, days: int = 30) -> Dict[str, Any]:
+        """
+        Get score trend for the last N days.
+
+        Returns:
+            Dictionary with dates, scores, and trend direction
+        """
+        runs = self.get_runs_since(days)
+
+        if not runs:
+            return {
+                "dates": [],
+                "scores": [],
+                "trend": "unknown",
+                "avg_score": 0.0,
+            }
+
+        dates = [r.timestamp.isoformat() for r in runs]
+        scores = [r.golden_score for r in runs]
+        avg_score = sum(scores) / len(scores)
+
+        # Determine trend
+        if len(scores) >= 3:
+            recent = scores[-3:]
+            older = scores[:3]
+            recent_avg = sum(recent) / len(recent)
+            older_avg = sum(older) / len(older)
+
+            if recent_avg > older_avg + 0.05:
+                trend = "improving"
+            elif recent_avg < older_avg - 0.05:
+                trend = "declining"
+            else:
+                trend = "stable"
+        else:
+            trend = "insufficient_data"
+
+        return {
+            "dates": dates,
+            "scores": scores,
+            "trend": trend,
+            "avg_score": round(avg_score, 3),
+            "min_score": round(min(scores), 3),
+            "max_score": round(max(scores), 3),
+        }
+
+    def get_failing_intents(self, n: int = 5) -> Dict[str, float]:
+        """Get intents with lowest scores from recent runs."""
+        runs = self.get_last_runs(n)
+
+        intent_scores: Dict[str, List[float]] = {}
+
+        for run in runs:
+            if "scores_by_intent" in run.metadata:
+                for intent, score in run.metadata["scores_by_intent"].items():
+                    if intent not in intent_scores:
+                        intent_scores[intent] = []
+                    intent_scores[intent].append(score)
+
+        # Calculate averages and sort
+        avg_scores = {
+            intent: sum(scores) / len(scores)
+            for intent, scores in intent_scores.items()
+        }
+
+        # Return sorted from worst to best
+        return dict(sorted(avg_scores.items(), key=lambda x: x[1]))

voice-service/bqas/runner.py

@@ -0,0 +1,529 @@
+"""
+BQAS Test Runner - Executes Golden, RAG, and Synthetic test suites
+"""
+import yaml
+import asyncio
+import structlog
+import httpx
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from dataclasses import dataclass, field
+
+from bqas.config import BQASConfig
+from bqas.judge import LLMJudge
+from bqas.rag_judge import RAGJudge
+from bqas.metrics import TestResult, BQASMetrics
+from bqas.synthetic_generator import SyntheticGenerator
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclass
+class TestRun:
+    """Record of a complete test run."""
+    id: int
+    suite: str  # golden, rag, synthetic
+    timestamp: datetime
+    git_commit: Optional[str]
+    metrics: BQASMetrics
+    results: List[TestResult]
+    duration_seconds: float
+
+
+class BQASRunner:
+    """
+    Main test runner for BQAS test suites.
+
+    Executes:
+    - Golden Suite: Pre-defined golden test cases from YAML
+    - RAG Suite: RAG/Correction quality tests
+    - Synthetic Suite: LLM-generated test variations
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+        self.judge = LLMJudge(self.config)
+        self.rag_judge = RAGJudge(self.config)
+        self.synthetic_generator = SyntheticGenerator(self.config)
+        self._http_client: Optional[httpx.AsyncClient] = None
+        self._test_runs: List[TestRun] = []
+        self._run_counter = 0
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client for voice service calls."""
+        if self._http_client is None:
+            self._http_client = httpx.AsyncClient(timeout=30.0)
+        return self._http_client
+
+    # ================================
+    # Golden Suite Runner
+    # ================================
+
+    async def run_golden_suite(self, git_commit: Optional[str] = None) -> TestRun:
+        """
+        Run the golden test suite.
+
+        Loads test cases from YAML files and evaluates each one.
+        """
+        logger.info("Starting Golden Suite run")
+        start_time = datetime.utcnow()
+
+        # Load all golden test cases
+        test_cases = await self._load_golden_tests()
+        logger.info(f"Loaded {len(test_cases)} golden test cases")
+
+        # Run all tests
+        results = []
+        for i, test_case in enumerate(test_cases):
+            try:
+                result = await self._run_golden_test(test_case)
+                results.append(result)
+
+                if (i + 1) % 10 == 0:
+                    logger.info(f"Progress: {i + 1}/{len(test_cases)} tests completed")
+
+            except Exception as e:
+                logger.error(f"Test {test_case.get('id')} failed with error", error=str(e))
+                # Create a failed result
+                results.append(self._create_error_result(test_case, str(e)))
+
+        # Calculate metrics
+        metrics = BQASMetrics.from_results(results)
+        duration = (datetime.utcnow() - start_time).total_seconds()
+
+        # Record run
+        self._run_counter += 1
+        run = TestRun(
+            id=self._run_counter,
+            suite="golden",
+            timestamp=start_time,
+            git_commit=git_commit,
+            metrics=metrics,
+            results=results,
+            duration_seconds=duration,
+        )
+        self._test_runs.insert(0, run)
+
+        logger.info(
+            "Golden Suite completed",
+            total=metrics.total_tests,
+            passed=metrics.passed_tests,
+            failed=metrics.failed_tests,
+            score=metrics.avg_composite_score,
+            duration=f"{duration:.1f}s",
+        )
+
+        return run
+
+    async def _load_golden_tests(self) -> List[Dict[str, Any]]:
+        """Load all golden test cases from YAML files."""
+        tests = []
+        golden_dir = Path(__file__).parent.parent / "tests" / "bqas" / "golden_tests"
+
+        yaml_files = [
+            "intent_tests.yaml",
+            "edge_cases.yaml",
+            "workflow_tests.yaml",
+        ]
+
+        for filename in yaml_files:
+            filepath = golden_dir / filename
+            if filepath.exists():
+                try:
+                    with open(filepath, 'r', encoding='utf-8') as f:
+                        data = yaml.safe_load(f)
+                        if data and 'tests' in data:
+                            for test in data['tests']:
+                                test['source_file'] = filename
+                            tests.extend(data['tests'])
+                except Exception as e:
+                    logger.warning(f"Failed to load {filename}", error=str(e))
+
+        return tests
+
+    async def _run_golden_test(self, test_case: Dict[str, Any]) -> TestResult:
+        """Run a single golden test case."""
+        test_id = test_case.get('id', 'UNKNOWN')
+        test_name = test_case.get('name', '')
+        user_input = test_case.get('input', '')
+        expected_intent = test_case.get('expected_intent', '')
+        min_score = test_case.get('min_score', self.config.min_golden_score)
+
+        # Get response from voice service (or simulate)
+        detected_intent, response = await self._get_voice_response(user_input, expected_intent)
+
+        # Evaluate with judge
+        result = await self.judge.evaluate_test_case(
+            test_id=test_id,
+            test_name=test_name,
+            user_input=user_input,
+            expected_intent=expected_intent,
+            detected_intent=detected_intent,
+            response=response,
+            min_score=min_score,
+        )
+
+        return result
+
+    async def _get_voice_response(
+        self,
+        user_input: str,
+        expected_intent: str
+    ) -> tuple[str, str]:
+        """
+        Get response from voice service.
+
+        For now, simulates responses since the full voice pipeline
+        might not be available. In production, this would call the
+        actual voice service endpoints.
+        """
+        try:
+            client = await self._get_client()
+
+            # Try to call the voice service intent detection
+            response = await client.post(
+                f"{self.config.voice_service_url}/api/v1/tasks",
+                json={
+                    "type": "intent_detection",
+                    "input": user_input,
+                    "namespace_id": "test_namespace",
+                },
+                timeout=10.0,
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                return data.get('detected_intent', expected_intent), data.get('response', f"Verarbeite: {user_input}")
+
+        except Exception as e:
+            logger.debug(f"Voice service call failed, using simulation", error=str(e))
+
+        # Simulate response based on expected intent
+        return self._simulate_response(user_input, expected_intent)
+
+    def _simulate_response(self, user_input: str, expected_intent: str) -> tuple[str, str]:
+        """Simulate voice service response for testing without live service."""
+        # Simulate realistic detected intent (90% correct for golden tests)
+        import random
+        if random.random() < 0.90:
+            detected_intent = expected_intent
+        else:
+            # Simulate occasional misclassification
+            intents = ["student_observation", "reminder", "worksheet_generate", "parent_letter", "smalltalk"]
+            detected_intent = random.choice([i for i in intents if i != expected_intent])
+
+        # Generate simulated response
+        responses = {
+            "student_observation": f"Notiz wurde gespeichert: {user_input}",
+            "reminder": f"Erinnerung erstellt: {user_input}",
+            "worksheet_generate": f"Arbeitsblatt wird generiert basierend auf: {user_input}",
+            "homework_check": f"Hausaufgabenkontrolle eingetragen: {user_input}",
+            "parent_letter": f"Elternbrief-Entwurf erstellt: {user_input}",
+            "class_message": f"Nachricht an Klasse vorbereitet: {user_input}",
+            "quiz_generate": f"Quiz wird erstellt: {user_input}",
+            "quick_activity": f"Einstiegsaktivitaet geplant: {user_input}",
+            "canvas_edit": f"Aenderung am Canvas wird ausgefuehrt: {user_input}",
+            "canvas_layout": f"Layout wird angepasst: {user_input}",
+            "operator_checklist": f"Operatoren-Checkliste geladen: {user_input}",
+            "eh_passage": f"EH-Passage gefunden: {user_input}",
+            "feedback_suggest": f"Feedback-Vorschlag: {user_input}",
+            "reminder_schedule": f"Erinnerung geplant: {user_input}",
+            "task_summary": f"Aufgabenuebersicht: {user_input}",
+            "conference_topic": f"Konferenzthema notiert: {user_input}",
+            "correction_note": f"Korrekturnotiz gespeichert: {user_input}",
+            "worksheet_differentiate": f"Differenzierung wird erstellt: {user_input}",
+        }
+
+        response = responses.get(detected_intent, f"Verstanden: {user_input}")
+        return detected_intent, response
+
+    def _create_error_result(self, test_case: Dict[str, Any], error: str) -> TestResult:
+        """Create a failed test result due to error."""
+        return TestResult(
+            test_id=test_case.get('id', 'UNKNOWN'),
+            test_name=test_case.get('name', 'Error'),
+            user_input=test_case.get('input', ''),
+            expected_intent=test_case.get('expected_intent', ''),
+            detected_intent='error',
+            response='',
+            intent_accuracy=0,
+            faithfulness=1,
+            relevance=1,
+            coherence=1,
+            safety='fail',
+            composite_score=0.0,
+            passed=False,
+            reasoning=f"Test execution error: {error}",
+            timestamp=datetime.utcnow(),
+            duration_ms=0,
+        )
+
+    # ================================
+    # RAG Suite Runner
+    # ================================
+
+    async def run_rag_suite(self, git_commit: Optional[str] = None) -> TestRun:
+        """
+        Run the RAG/Correction test suite.
+
+        Tests EH retrieval, operator alignment, hallucination control, etc.
+        """
+        logger.info("Starting RAG Suite run")
+        start_time = datetime.utcnow()
+
+        # Load RAG test cases
+        test_cases = await self._load_rag_tests()
+        logger.info(f"Loaded {len(test_cases)} RAG test cases")
+
+        # Run all tests
+        results = []
+        for i, test_case in enumerate(test_cases):
+            try:
+                result = await self._run_rag_test(test_case)
+                results.append(result)
+
+                if (i + 1) % 5 == 0:
+                    logger.info(f"Progress: {i + 1}/{len(test_cases)} RAG tests completed")
+
+            except Exception as e:
+                logger.error(f"RAG test {test_case.get('id')} failed", error=str(e))
+                results.append(self._create_error_result(test_case, str(e)))
+
+        # Calculate metrics
+        metrics = BQASMetrics.from_results(results)
+        duration = (datetime.utcnow() - start_time).total_seconds()
+
+        # Record run
+        self._run_counter += 1
+        run = TestRun(
+            id=self._run_counter,
+            suite="rag",
+            timestamp=start_time,
+            git_commit=git_commit,
+            metrics=metrics,
+            results=results,
+            duration_seconds=duration,
+        )
+        self._test_runs.insert(0, run)
+
+        logger.info(
+            "RAG Suite completed",
+            total=metrics.total_tests,
+            passed=metrics.passed_tests,
+            score=metrics.avg_composite_score,
+            duration=f"{duration:.1f}s",
+        )
+
+        return run
+
+    async def _load_rag_tests(self) -> List[Dict[str, Any]]:
+        """Load RAG test cases from YAML."""
+        tests = []
+        rag_file = Path(__file__).parent.parent / "tests" / "bqas" / "golden_tests" / "golden_rag_correction_v1.yaml"
+
+        if rag_file.exists():
+            try:
+                with open(rag_file, 'r', encoding='utf-8') as f:
+                    # Handle YAML documents separated by ---
+                    documents = list(yaml.safe_load_all(f))
+                    for doc in documents:
+                        if doc and 'tests' in doc:
+                            tests.extend(doc['tests'])
+                        if doc and 'edge_cases' in doc:
+                            tests.extend(doc['edge_cases'])
+            except Exception as e:
+                logger.warning(f"Failed to load RAG tests", error=str(e))
+
+        return tests
+
+    async def _run_rag_test(self, test_case: Dict[str, Any]) -> TestResult:
+        """Run a single RAG test case."""
+        # Simulate service response for RAG tests
+        service_response = await self._simulate_rag_response(test_case)
+
+        # Evaluate with RAG judge
+        result = await self.rag_judge.evaluate_rag_test_case(
+            test_case=test_case,
+            service_response=service_response,
+        )
+
+        return result
+
+    async def _simulate_rag_response(self, test_case: Dict[str, Any]) -> Dict[str, Any]:
+        """Simulate RAG service response."""
+        category = test_case.get('category', '')
+        input_data = test_case.get('input', {})
+        expected = test_case.get('expected', {})
+
+        # Simulate responses based on category
+        if category == 'eh_retrieval':
+            concepts = expected.get('must_contain_concepts', [])
+            passage = f"Der Erwartungshorizont sieht folgende Aspekte vor: {', '.join(concepts[:3])}. "
+            passage += "Diese muessen im Rahmen der Aufgabenbearbeitung beruecksichtigt werden."
+            return {
+                "passage": passage,
+                "source": "EH_Deutsch_Abitur_2024_NI.pdf",
+                "relevance_score": 0.85,
+            }
+
+        elif category == 'operator_alignment':
+            operator = input_data.get('operator', '')
+            afb = expected.get('afb_level', 'II')
+            actions = expected.get('expected_actions', [])
+            return {
+                "operator": operator,
+                "definition": f"'{operator}' gehoert zu Anforderungsbereich {afb}. Erwartete Handlungen: {', '.join(actions[:2])}.",
+                "afb_level": afb,
+            }
+
+        elif category == 'hallucination_control':
+            return {
+                "response": "Basierend auf den verfuegbaren Informationen kann ich folgendes feststellen...",
+                "grounded": True,
+            }
+
+        elif category == 'privacy_compliance':
+            return {
+                "response": "Die Arbeit zeigt folgende Merkmale... [anonymisiert]",
+                "contains_pii": False,
+            }
+
+        elif category == 'namespace_isolation':
+            return {
+                "response": "Zugriff nur auf Daten im eigenen Namespace.",
+                "namespace_violation": False,
+            }
+
+        return {"response": "Simulated response", "success": True}
+
+    # ================================
+    # Synthetic Suite Runner
+    # ================================
+
+    async def run_synthetic_suite(self, git_commit: Optional[str] = None) -> TestRun:
+        """
+        Run the synthetic test suite.
+
+        Generates test variations using LLM and evaluates them.
+        """
+        logger.info("Starting Synthetic Suite run")
+        start_time = datetime.utcnow()
+
+        # Generate synthetic tests
+        all_variations = await self.synthetic_generator.generate_all_intents(
+            count_per_intent=self.config.synthetic_count_per_intent
+        )
+
+        # Flatten variations
+        test_cases = []
+        for intent, variations in all_variations.items():
+            for i, v in enumerate(variations):
+                test_cases.append({
+                    'id': f"SYN-{intent.upper()[:4]}-{i+1:03d}",
+                    'name': f"Synthetic {intent} #{i+1}",
+                    'input': v.input,
+                    'expected_intent': v.expected_intent,
+                    'slots': v.slots,
+                    'source': v.source,
+                    'min_score': self.config.min_synthetic_score,
+                })
+
+        logger.info(f"Generated {len(test_cases)} synthetic test cases")
+
+        # Run all tests
+        results = []
+        for i, test_case in enumerate(test_cases):
+            try:
+                result = await self._run_golden_test(test_case)  # Same logic as golden
+                results.append(result)
+
+                if (i + 1) % 20 == 0:
+                    logger.info(f"Progress: {i + 1}/{len(test_cases)} synthetic tests completed")
+
+            except Exception as e:
+                logger.error(f"Synthetic test {test_case.get('id')} failed", error=str(e))
+                results.append(self._create_error_result(test_case, str(e)))
+
+        # Calculate metrics
+        metrics = BQASMetrics.from_results(results)
+        duration = (datetime.utcnow() - start_time).total_seconds()
+
+        # Record run
+        self._run_counter += 1
+        run = TestRun(
+            id=self._run_counter,
+            suite="synthetic",
+            timestamp=start_time,
+            git_commit=git_commit,
+            metrics=metrics,
+            results=results,
+            duration_seconds=duration,
+        )
+        self._test_runs.insert(0, run)
+
+        logger.info(
+            "Synthetic Suite completed",
+            total=metrics.total_tests,
+            passed=metrics.passed_tests,
+            score=metrics.avg_composite_score,
+            duration=f"{duration:.1f}s",
+        )
+
+        return run
+
+    # ================================
+    # Utility Methods
+    # ================================
+
+    def get_test_runs(self, limit: int = 20) -> List[TestRun]:
+        """Get recent test runs."""
+        return self._test_runs[:limit]
+
+    def get_latest_metrics(self) -> Dict[str, Optional[BQASMetrics]]:
+        """Get latest metrics for each suite."""
+        result = {"golden": None, "rag": None, "synthetic": None}
+
+        for run in self._test_runs:
+            if result[run.suite] is None:
+                result[run.suite] = run.metrics
+            if all(v is not None for v in result.values()):
+                break
+
+        return result
+
+    async def health_check(self) -> Dict[str, Any]:
+        """Check health of BQAS components."""
+        judge_ok = await self.judge.health_check()
+        rag_judge_ok = await self.rag_judge.health_check()
+
+        return {
+            "judge_available": judge_ok,
+            "rag_judge_available": rag_judge_ok,
+            "test_runs_count": len(self._test_runs),
+            "config": {
+                "ollama_url": self.config.ollama_base_url,
+                "judge_model": self.config.judge_model,
+            }
+        }
+
+    async def close(self):
+        """Cleanup resources."""
+        await self.judge.close()
+        await self.rag_judge.close()
+        await self.synthetic_generator.close()
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+
+
+# Singleton instance for the API
+_runner_instance: Optional[BQASRunner] = None
+
+
+def get_runner() -> BQASRunner:
+    """Get or create the global BQASRunner instance."""
+    global _runner_instance
+    if _runner_instance is None:
+        _runner_instance = BQASRunner()
+    return _runner_instance

voice-service/bqas/synthetic_generator.py

@@ -0,0 +1,301 @@
+"""
+Synthetic Test Generator
+Generates realistic teacher voice command variations using LLM
+"""
+import json
+import structlog
+import httpx
+from typing import List, Dict, Any, Optional
+from dataclasses import dataclass
+
+from bqas.config import BQASConfig
+from bqas.prompts import SYNTHETIC_GENERATION_PROMPT
+
+logger = structlog.get_logger(__name__)
+
+
+# Teacher speech patterns by intent
+TEACHER_PATTERNS = {
+    "student_observation": [
+        "Notiz zu {name}: {observation}",
+        "Kurze Bemerkung zu {name}, {observation}",
+        "{name} hat heute {observation}",
+        "Bitte merken: {name} - {observation}",
+        "Beobachtung {name}: {observation}",
+    ],
+    "reminder": [
+        "Erinner mich an {task}",
+        "Nicht vergessen: {task}",
+        "Reminder: {task}",
+        "Denk dran: {task}",
+    ],
+    "homework_check": [
+        "Hausaufgabe kontrollieren",
+        "{class_name} {subject} Hausaufgabe kontrollieren",
+        "HA Check {class_name}",
+        "Hausaufgaben {subject} pruefen",
+    ],
+    "worksheet_generate": [
+        "Mach mir ein Arbeitsblatt zu {topic}",
+        "Erstelle bitte {count} Aufgaben zu {topic}",
+        "Ich brauche ein Uebungsblatt fuer {topic}",
+        "Generiere Lueckentexte zu {topic}",
+        "Arbeitsblatt {topic} erstellen",
+    ],
+    "parent_letter": [
+        "Schreib einen Elternbrief wegen {reason}",
+        "Formuliere eine Nachricht an die Eltern von {name} zu {reason}",
+        "Ich brauche einen neutralen Brief an Eltern wegen {reason}",
+        "Elternbrief {reason}",
+    ],
+    "class_message": [
+        "Nachricht an {class_name}: {content}",
+        "Info an die Klasse {class_name}",
+        "Klassennachricht {class_name}",
+        "Mitteilung an {class_name}: {content}",
+    ],
+    "quiz_generate": [
+        "Vokabeltest erstellen",
+        "Quiz mit {count} Fragen",
+        "{duration} Minuten Test",
+        "Kurzer Test zu {topic}",
+    ],
+    "quick_activity": [
+        "{duration} Minuten Einstieg",
+        "Schnelle Aktivitaet {topic}",
+        "Warming Up {duration} Minuten",
+        "Einstiegsaufgabe",
+    ],
+    "canvas_edit": [
+        "Ueberschriften groesser",
+        "Bild {number} nach {direction}",
+        "Pfeil von {source} auf {target}",
+        "Kasten hinzufuegen",
+    ],
+    "canvas_layout": [
+        "Alles auf eine Seite",
+        "Drucklayout A4",
+        "Layout aendern",
+        "Seitenformat anpassen",
+    ],
+    "operator_checklist": [
+        "Operatoren-Checkliste fuer {task_type}",
+        "Welche Operatoren fuer {topic}",
+        "Zeig Operatoren",
+    ],
+    "eh_passage": [
+        "Erwartungshorizont zu {topic}",
+        "Was steht im EH zu {topic}",
+        "EH Passage suchen",
+    ],
+    "feedback_suggest": [
+        "Feedback vorschlagen",
+        "Formuliere Rueckmeldung",
+        "Wie formuliere ich Feedback zu {topic}",
+    ],
+    "reminder_schedule": [
+        "Erinner mich morgen an {task}",
+        "In {time_offset} erinnern: {task}",
+        "Naechste Woche: {task}",
+    ],
+    "task_summary": [
+        "Offene Aufgaben",
+        "Was steht noch an",
+        "Zusammenfassung",
+        "Diese Woche",
+    ],
+}
+
+
+@dataclass
+class SyntheticTest:
+    """A synthetically generated test case."""
+    input: str
+    expected_intent: str
+    slots: Dict[str, Any]
+    source: str = "synthetic"
+
+
+class SyntheticGenerator:
+    """
+    Generates realistic variations of teacher voice commands.
+
+    Uses LLM to create variations with:
+    - Different phrasings
+    - Optional typos
+    - Regional dialects
+    - Natural speech patterns
+    """
+
+    def __init__(self, config: Optional[BQASConfig] = None):
+        self.config = config or BQASConfig.from_env()
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(timeout=self.config.judge_timeout)
+        return self._client
+
+    async def generate_variations(
+        self,
+        intent: str,
+        count: int = 10,
+        include_typos: bool = True,
+        include_dialect: bool = True,
+    ) -> List[SyntheticTest]:
+        """
+        Generate realistic variations for an intent.
+
+        Args:
+            intent: Target intent type
+            count: Number of variations to generate
+            include_typos: Include occasional typos
+            include_dialect: Include regional variants (Austrian, Swiss)
+
+        Returns:
+            List of SyntheticTest objects
+        """
+        patterns = TEACHER_PATTERNS.get(intent, [])
+        if not patterns:
+            logger.warning(f"No patterns for intent: {intent}")
+            return []
+
+        typo_instruction = "Fuege gelegentlich Tippfehler ein" if include_typos else "Keine Tippfehler"
+        dialect_instruction = "Beruecksichtige regionale Varianten (Oesterreich, Schweiz)" if include_dialect else "Nur Hochdeutsch"
+
+        prompt = SYNTHETIC_GENERATION_PROMPT.format(
+            count=count,
+            intent=intent,
+            patterns="\n".join(f"- {p}" for p in patterns),
+            typo_instruction=typo_instruction,
+            dialect_instruction=dialect_instruction,
+        )
+
+        client = await self._get_client()
+
+        try:
+            resp = await client.post(
+                f"{self.config.ollama_base_url}/api/generate",
+                json={
+                    "model": self.config.judge_model,
+                    "prompt": prompt,
+                    "stream": False,
+                    "options": {
+                        "temperature": 0.8,
+                        "num_predict": 2000,
+                    },
+                },
+            )
+            resp.raise_for_status()
+
+            result_text = resp.json().get("response", "")
+            return self._parse_variations(result_text, intent)
+
+        except Exception as e:
+            logger.error("Failed to generate variations", intent=intent, error=str(e))
+            # Return pattern-based fallbacks
+            return self._generate_fallback(intent, count)
+
+    def _parse_variations(self, text: str, intent: str) -> List[SyntheticTest]:
+        """Parse JSON variations from LLM response."""
+        try:
+            # Find JSON array in response
+            start = text.find("[")
+            end = text.rfind("]") + 1
+            if start >= 0 and end > start:
+                json_str = text[start:end]
+                data = json.loads(json_str)
+
+                return [
+                    SyntheticTest(
+                        input=item.get("input", ""),
+                        expected_intent=item.get("expected_intent", intent),
+                        slots=item.get("slots", {}),
+                        source="llm_generated",
+                    )
+                    for item in data
+                    if item.get("input")
+                ]
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.warning("Failed to parse variations", error=str(e))
+
+        return []
+
+    def _generate_fallback(self, intent: str, count: int) -> List[SyntheticTest]:
+        """Generate simple variations from patterns."""
+        patterns = TEACHER_PATTERNS.get(intent, [])
+        if not patterns:
+            return []
+
+        # Sample slot values
+        sample_values = {
+            "name": ["Max", "Lisa", "Tim", "Anna", "Paul", "Emma"],
+            "observation": ["heute sehr aufmerksam", "braucht Hilfe", "war abgelenkt"],
+            "task": ["Hausaufgaben kontrollieren", "Elternbrief schreiben", "Test vorbereiten"],
+            "class_name": ["7a", "8b", "9c", "10d"],
+            "subject": ["Mathe", "Deutsch", "Englisch", "Physik"],
+            "topic": ["Bruchrechnung", "Vokabeln", "Grammatik", "Prozentrechnung"],
+            "count": ["3", "5", "10"],
+            "duration": ["10", "15", "20"],
+            "reason": ["fehlende Hausaufgaben", "wiederholte Stoerungen", "positives Verhalten"],
+            "content": ["Hausaufgaben bis Freitag", "Test naechste Woche"],
+        }
+
+        import random
+        results = []
+
+        for i in range(count):
+            pattern = patterns[i % len(patterns)]
+
+            # Fill in placeholders
+            filled = pattern
+            for key, values in sample_values.items():
+                placeholder = f"{{{key}}}"
+                if placeholder in filled:
+                    filled = filled.replace(placeholder, random.choice(values), 1)
+
+            # Extract filled slots
+            slots = {}
+            for key in sample_values:
+                if f"{{{key}}}" in pattern:
+                    # The value we used
+                    for val in sample_values[key]:
+                        if val in filled:
+                            slots[key] = val
+                            break
+
+            results.append(SyntheticTest(
+                input=filled,
+                expected_intent=intent,
+                slots=slots,
+                source="pattern_generated",
+            ))
+
+        return results
+
+    async def generate_all_intents(
+        self,
+        count_per_intent: int = 10,
+    ) -> Dict[str, List[SyntheticTest]]:
+        """Generate variations for all known intents."""
+        results = {}
+
+        for intent in TEACHER_PATTERNS.keys():
+            logger.info(f"Generating variations for intent: {intent}")
+            variations = await self.generate_variations(
+                intent=intent,
+                count=count_per_intent,
+                include_typos=self.config.include_typos,
+                include_dialect=self.config.include_dialect,
+            )
+            results[intent] = variations
+            logger.info(f"Generated {len(variations)} variations for {intent}")
+
+        return results
+
+    async def close(self):
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None

voice-service/config.py

@@ -0,0 +1,117 @@
+"""
+Voice Service Configuration
+Environment-based configuration with Pydantic Settings
+
+DSGVO-konform: Keine Audio-Persistenz, nur transiente Verarbeitung
+"""
+from functools import lru_cache
+from typing import Optional, List
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Application settings loaded from environment variables."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",  # Ignore unknown environment variables from docker-compose
+    )
+
+    # Service Config
+    port: int = 8091
+    environment: str = "development"
+    debug: bool = False
+
+    # JWT Authentication (load from Vault or environment, test default for CI)
+    jwt_secret: str = "test-secret-for-ci-only-do-not-use-in-production"
+    jwt_algorithm: str = "HS256"
+    jwt_expiration_hours: int = 24
+
+    # PostgreSQL (load from Vault or environment, test default for CI)
+    database_url: str = "postgresql://test:test@localhost:5432/test"
+
+    # Valkey (Redis-fork) Session Cache
+    valkey_url: str = "redis://valkey:6379/2"
+    session_ttl_hours: int = 24
+    task_ttl_hours: int = 168  # 7 days for pending tasks
+
+    # PersonaPlex Configuration (Production GPU)
+    personaplex_enabled: bool = False
+    personaplex_ws_url: str = "ws://host.docker.internal:8998"
+    personaplex_model: str = "personaplex-7b"
+    personaplex_timeout: int = 30
+
+    # Task Orchestrator
+    orchestrator_enabled: bool = True
+    orchestrator_max_concurrent_tasks: int = 10
+
+    # Fallback LLM (Ollama for Development)
+    fallback_llm_provider: str = "ollama"  # "ollama" or "none"
+    ollama_base_url: str = "http://host.docker.internal:11434"
+    ollama_voice_model: str = "qwen2.5:32b"
+    ollama_timeout: int = 120
+
+    # Klausur Service Integration
+    klausur_service_url: str = "http://klausur-service:8086"
+
+    # Audio Configuration
+    audio_sample_rate: int = 24000  # 24kHz for Mimi codec
+    audio_frame_size_ms: int = 80  # 80ms frames
+    audio_persistence: bool = False  # NEVER persist audio
+
+    # Encryption Configuration
+    encryption_enabled: bool = True
+    namespace_key_algorithm: str = "AES-256-GCM"
+
+    # TTL Configuration (DSGVO Data Minimization)
+    transcript_ttl_days: int = 7
+    task_state_ttl_days: int = 30
+    audit_log_ttl_days: int = 90
+
+    # Rate Limiting
+    max_sessions_per_user: int = 5
+    max_requests_per_minute: int = 60
+
+    # CORS (for frontend access)
+    cors_origins: List[str] = [
+        "http://localhost:3000",
+        "http://localhost:3001",
+        "http://localhost:8091",
+        "http://macmini:3000",
+        "http://macmini:3001",
+        "https://localhost",
+        "https://localhost:3000",
+        "https://localhost:3001",
+        "https://localhost:8091",
+        "https://macmini",
+        "https://macmini:3000",
+        "https://macmini:3001",
+        "https://macmini:8091",
+    ]
+
+    @property
+    def is_development(self) -> bool:
+        """Check if running in development mode."""
+        return self.environment == "development"
+
+    @property
+    def audio_frame_samples(self) -> int:
+        """Calculate samples per frame."""
+        return int(self.audio_sample_rate * self.audio_frame_size_ms / 1000)
+
+    @property
+    def use_personaplex(self) -> bool:
+        """Check if PersonaPlex should be used (production only)."""
+        return self.personaplex_enabled and not self.is_development
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance."""
+    return Settings()
+
+
+# Export settings instance for convenience
+settings = get_settings()

voice-service/main.py

@@ -0,0 +1,225 @@
+"""
+Voice Service - PersonaPlex + TaskOrchestrator Integration
+Voice-First Interface fuer Breakpilot
+
+DSGVO-konform:
+- Keine Audio-Persistenz (nur RAM)
+- Namespace-Verschluesselung (Key nur auf Lehrergeraet)
+- TTL-basierte Auto-Loeschung
+
+Main FastAPI Application
+"""
+import structlog
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, Request, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import time
+from typing import Dict
+
+from config import settings
+
+# Configure structured logging
+structlog.configure(
+    processors=[
+        structlog.stdlib.filter_by_level,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        structlog.processors.UnicodeDecoder(),
+        structlog.processors.JSONRenderer() if not settings.is_development else structlog.dev.ConsoleRenderer(),
+    ],
+    wrapper_class=structlog.stdlib.BoundLogger,
+    context_class=dict,
+    logger_factory=structlog.stdlib.LoggerFactory(),
+    cache_logger_on_first_use=True,
+)
+
+logger = structlog.get_logger(__name__)
+
+# Active WebSocket connections (transient, not persisted)
+active_connections: Dict[str, WebSocket] = {}
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager."""
+    # Startup
+    logger.info(
+        "Starting Voice Service",
+        environment=settings.environment,
+        port=settings.port,
+        personaplex_enabled=settings.personaplex_enabled,
+        orchestrator_enabled=settings.orchestrator_enabled,
+        audio_persistence=settings.audio_persistence,
+    )
+
+    # Verify DSGVO compliance settings
+    if settings.audio_persistence:
+        logger.error("DSGVO VIOLATION: Audio persistence is enabled!")
+        raise RuntimeError("Audio persistence must be disabled for DSGVO compliance")
+
+    # Initialize services
+    from services.task_orchestrator import TaskOrchestrator
+    from services.encryption_service import EncryptionService
+
+    app.state.orchestrator = TaskOrchestrator()
+    app.state.encryption = EncryptionService()
+
+    logger.info("Voice Service initialized successfully")
+
+    yield
+
+    # Shutdown
+    logger.info("Shutting down Voice Service")
+
+    # Clear all active connections
+    for session_id in list(active_connections.keys()):
+        try:
+            await active_connections[session_id].close()
+        except Exception:
+            pass
+    active_connections.clear()
+
+    logger.info("Voice Service shutdown complete")
+
+
+# Create FastAPI app
+app = FastAPI(
+    title="Breakpilot Voice Service",
+    description="Voice-First Interface mit PersonaPlex-7B und Task-Orchestrierung",
+    version="1.0.0",
+    docs_url="/docs" if settings.is_development else None,
+    redoc_url="/redoc" if settings.is_development else None,
+    lifespan=lifespan,
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Request timing middleware
+@app.middleware("http")
+async def add_timing_header(request: Request, call_next):
+    """Add X-Process-Time header to all responses."""
+    start_time = time.time()
+    response = await call_next(request)
+    process_time = time.time() - start_time
+    response.headers["X-Process-Time"] = str(process_time)
+    return response
+
+
+# Import and register routers
+from api.sessions import router as sessions_router
+from api.streaming import router as streaming_router
+from api.tasks import router as tasks_router
+from api.bqas import router as bqas_router
+
+app.include_router(sessions_router, prefix="/api/v1/sessions", tags=["Sessions"])
+app.include_router(tasks_router, prefix="/api/v1/tasks", tags=["Tasks"])
+app.include_router(bqas_router, prefix="/api/v1/bqas", tags=["BQAS"])
+# Note: streaming router is mounted at root level for WebSocket
+app.include_router(streaming_router, tags=["Streaming"])
+
+
+# Health check endpoint
+@app.get("/health", tags=["System"])
+async def health_check():
+    """
+    Health check endpoint for Docker/Kubernetes probes.
+    Returns service status and DSGVO compliance verification.
+    """
+    return {
+        "status": "healthy",
+        "service": "voice-service",
+        "version": "1.0.0",
+        "environment": settings.environment,
+        "dsgvo_compliance": {
+            "audio_persistence": settings.audio_persistence,
+            "encryption_enabled": settings.encryption_enabled,
+            "transcript_ttl_days": settings.transcript_ttl_days,
+            "audit_log_ttl_days": settings.audit_log_ttl_days,
+        },
+        "backends": {
+            "personaplex_enabled": settings.personaplex_enabled,
+            "orchestrator_enabled": settings.orchestrator_enabled,
+            "fallback_llm": settings.fallback_llm_provider,
+        },
+        "audio_config": {
+            "sample_rate": settings.audio_sample_rate,
+            "frame_size_ms": settings.audio_frame_size_ms,
+        },
+        "active_connections": len(active_connections),
+    }
+
+
+# Root endpoint
+@app.get("/", tags=["System"])
+async def root():
+    """Root endpoint with service information."""
+    return {
+        "service": "Breakpilot Voice Service",
+        "description": "Voice-First Interface fuer Breakpilot",
+        "version": "1.0.0",
+        "docs": "/docs" if settings.is_development else "disabled",
+        "endpoints": {
+            "sessions": "/api/v1/sessions",
+            "tasks": "/api/v1/tasks",
+            "websocket": "/ws/voice",
+        },
+        "privacy": {
+            "audio_stored": False,
+            "transcripts_encrypted": True,
+            "data_retention": f"{settings.transcript_ttl_days} days",
+        },
+    }
+
+
+# Error handlers
+@app.exception_handler(404)
+async def not_found_handler(request: Request, exc):
+    """Handle 404 errors - preserve HTTPException details."""
+    from fastapi import HTTPException
+
+    # If this is an HTTPException with a detail, use that
+    if isinstance(exc, HTTPException) and exc.detail:
+        return JSONResponse(
+            status_code=404,
+            content={"detail": exc.detail},
+        )
+
+    # Generic 404 for route not found
+    return JSONResponse(
+        status_code=404,
+        content={"error": "Not found", "path": str(request.url.path)},
+    )
+
+
+@app.exception_handler(500)
+async def internal_error_handler(request: Request, exc):
+    """Handle 500 errors."""
+    logger.error("Internal server error", path=str(request.url.path), error=str(exc))
+    return JSONResponse(
+        status_code=500,
+        content={"error": "Internal server error"},
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=settings.port,
+        reload=settings.is_development,
+    )

voice-service/models/__init__.py

@@ -0,0 +1,40 @@
+"""
+Voice Service Models
+Pydantic models for sessions, tasks, and audit logging
+"""
+from models.session import (
+    VoiceSession,
+    SessionCreate,
+    SessionResponse,
+    AudioChunk,
+    TranscriptMessage,
+)
+from models.task import (
+    TaskState,
+    Task,
+    TaskCreate,
+    TaskResponse,
+    TaskTransition,
+)
+from models.audit import (
+    AuditEntry,
+    AuditCreate,
+)
+
+__all__ = [
+    # Session models
+    "VoiceSession",
+    "SessionCreate",
+    "SessionResponse",
+    "AudioChunk",
+    "TranscriptMessage",
+    # Task models
+    "TaskState",
+    "Task",
+    "TaskCreate",
+    "TaskResponse",
+    "TaskTransition",
+    # Audit models
+    "AuditEntry",
+    "AuditCreate",
+]

voice-service/models/audit.py

@@ -0,0 +1,149 @@
+"""
+Audit Models - DSGVO-compliant logging
+NO PII in audit logs - only references and metadata
+
+Erlaubt: ref_id (truncated), content_type, size_bytes, ttl_hours
+Verboten: user_name, content, transcript, email
+"""
+from datetime import datetime
+from enum import Enum
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+import uuid
+
+
+class AuditAction(str, Enum):
+    """Audit action types."""
+    # Session actions
+    SESSION_CREATED = "session_created"
+    SESSION_CONNECTED = "session_connected"
+    SESSION_CLOSED = "session_closed"
+    SESSION_EXPIRED = "session_expired"
+
+    # Audio actions (no content logged)
+    AUDIO_RECEIVED = "audio_received"
+    AUDIO_PROCESSED = "audio_processed"
+
+    # Task actions
+    TASK_CREATED = "task_created"
+    TASK_QUEUED = "task_queued"
+    TASK_STARTED = "task_started"
+    TASK_COMPLETED = "task_completed"
+    TASK_FAILED = "task_failed"
+    TASK_EXPIRED = "task_expired"
+
+    # Encryption actions
+    ENCRYPTION_KEY_VERIFIED = "encryption_key_verified"
+    ENCRYPTION_KEY_INVALID = "encryption_key_invalid"
+
+    # Integration actions
+    BREAKPILOT_CALLED = "breakpilot_called"
+    PERSONAPLEX_CALLED = "personaplex_called"
+    OLLAMA_CALLED = "ollama_called"
+
+    # Security actions
+    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded"
+    UNAUTHORIZED_ACCESS = "unauthorized_access"
+
+
+class AuditEntry(BaseModel):
+    """
+    Audit log entry - DSGVO compliant.
+    NO PII is stored - only truncated references and metadata.
+    """
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+    # Action identification
+    action: AuditAction
+    namespace_id_truncated: str = Field(
+        ...,
+        description="First 8 chars of namespace ID",
+        max_length=8,
+    )
+
+    # Reference IDs (truncated for privacy)
+    session_id_truncated: Optional[str] = Field(
+        default=None,
+        description="First 8 chars of session ID",
+        max_length=8,
+    )
+    task_id_truncated: Optional[str] = Field(
+        default=None,
+        description="First 8 chars of task ID",
+        max_length=8,
+    )
+
+    # Metadata (no PII)
+    content_type: Optional[str] = Field(default=None, description="Type of content processed")
+    size_bytes: Optional[int] = Field(default=None, description="Size in bytes")
+    duration_ms: Optional[int] = Field(default=None, description="Duration in milliseconds")
+    ttl_hours: Optional[int] = Field(default=None, description="TTL in hours")
+
+    # Technical metadata
+    success: bool = Field(default=True)
+    error_code: Optional[str] = Field(default=None)
+    latency_ms: Optional[int] = Field(default=None)
+
+    # Context (no PII)
+    device_type: Optional[str] = Field(default=None)
+    client_version: Optional[str] = Field(default=None)
+    backend_used: Optional[str] = Field(default=None, description="personaplex, ollama, etc.")
+
+    @staticmethod
+    def truncate_id(full_id: str, length: int = 8) -> str:
+        """Truncate ID for privacy."""
+        if not full_id:
+            return ""
+        return full_id[:length]
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "id": "audit-123",
+                "timestamp": "2026-01-26T10:30:00Z",
+                "action": "task_completed",
+                "namespace_id_truncated": "teacher-",
+                "session_id_truncated": "session-",
+                "task_id_truncated": "task-xyz",
+                "content_type": "student_observation",
+                "size_bytes": 256,
+                "ttl_hours": 168,
+                "success": True,
+                "latency_ms": 1250,
+                "backend_used": "ollama",
+            }
+        }
+
+
+class AuditCreate(BaseModel):
+    """Request to create an audit entry."""
+    action: AuditAction
+    namespace_id: str = Field(..., description="Will be truncated before storage")
+    session_id: Optional[str] = Field(default=None, description="Will be truncated")
+    task_id: Optional[str] = Field(default=None, description="Will be truncated")
+    content_type: Optional[str] = Field(default=None)
+    size_bytes: Optional[int] = Field(default=None)
+    duration_ms: Optional[int] = Field(default=None)
+    success: bool = Field(default=True)
+    error_code: Optional[str] = Field(default=None)
+    latency_ms: Optional[int] = Field(default=None)
+    device_type: Optional[str] = Field(default=None)
+    backend_used: Optional[str] = Field(default=None)
+
+    def to_audit_entry(self) -> AuditEntry:
+        """Convert to AuditEntry with truncated IDs."""
+        return AuditEntry(
+            action=self.action,
+            namespace_id_truncated=AuditEntry.truncate_id(self.namespace_id),
+            session_id_truncated=AuditEntry.truncate_id(self.session_id) if self.session_id else None,
+            task_id_truncated=AuditEntry.truncate_id(self.task_id) if self.task_id else None,
+            content_type=self.content_type,
+            size_bytes=self.size_bytes,
+            duration_ms=self.duration_ms,
+            success=self.success,
+            error_code=self.error_code,
+            latency_ms=self.latency_ms,
+            device_type=self.device_type,
+            backend_used=self.backend_used,
+        )