[split-required] Split final 43 files (500-668 LOC) to complete refactoring

klausur-service (11 files):
- cv_gutter_repair, ocr_pipeline_regression, upload_api
- ocr_pipeline_sessions, smart_spell, nru_worksheet_generator
- ocr_pipeline_overlays, mail/aggregator, zeugnis_api
- cv_syllable_detect, self_rag

backend-lehrer (17 files):
- classroom_engine/suggestions, generators/quiz_generator
- worksheets_api, llm_gateway/comparison, state_engine_api
- classroom/models (→ 4 submodules), services/file_processor
- alerts_agent/api/wizard+digests+routes, content_generators/pdf
- classroom/routes/sessions, llm_gateway/inference
- classroom_engine/analytics, auth/keycloak_auth
- alerts_agent/processing/rule_engine, ai_processor/print_versions

agent-core (5 files):
- brain/memory_store, brain/knowledge_graph, brain/context_manager
- orchestrator/supervisor, sessions/session_manager

admin-lehrer (5 components):
- GridOverlay, StepGridReview, DevOpsPipelineSidebar
- DataFlowDiagram, sbom/wizard/page

website (2 files):
- DependencyMap, lehrer/abitur-archiv

Other: nibis_ingestion, grid_detection_service, export-doclayout-onnx

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

agent-core/brain/knowledge_graph.py

@@ -9,109 +9,20 @@ Provides entity and relationship management:
 """
 
 from typing import Dict, Any, List, Optional, Set, Tuple
-from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from enum import Enum
 import json
 import logging
 
+from agent_core.brain.knowledge_models import (
+    EntityType,
+    RelationshipType,
+    Entity,
+    Relationship,
+)
+
 logger = logging.getLogger(__name__)
 
 
-class EntityType(Enum):
-    """Types of entities in the knowledge graph"""
-    STUDENT = "student"
-    TEACHER = "teacher"
-    CLASS = "class"
-    SUBJECT = "subject"
-    ASSIGNMENT = "assignment"
-    EXAM = "exam"
-    TOPIC = "topic"
-    CONCEPT = "concept"
-    RESOURCE = "resource"
-    CUSTOM = "custom"
-
-
-class RelationshipType(Enum):
-    """Types of relationships between entities"""
-    BELONGS_TO = "belongs_to"        # Student belongs to class
-    TEACHES = "teaches"              # Teacher teaches subject
-    ASSIGNED_TO = "assigned_to"      # Assignment assigned to student
-    COVERS = "covers"                # Exam covers topic
-    REQUIRES = "requires"            # Topic requires concept
-    RELATED_TO = "related_to"        # General relationship
-    PARENT_OF = "parent_of"          # Hierarchical relationship
-    CREATED_BY = "created_by"        # Creator relationship
-    GRADED_BY = "graded_by"          # Grading relationship
-
-
-@dataclass
-class Entity:
-    """Represents an entity in the knowledge graph"""
-    id: str
-    entity_type: EntityType
-    name: str
-    properties: Dict[str, Any] = field(default_factory=dict)
-    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-    updated_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "id": self.id,
-            "entity_type": self.entity_type.value,
-            "name": self.name,
-            "properties": self.properties,
-            "created_at": self.created_at.isoformat(),
-            "updated_at": self.updated_at.isoformat()
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Entity":
-        return cls(
-            id=data["id"],
-            entity_type=EntityType(data["entity_type"]),
-            name=data["name"],
-            properties=data.get("properties", {}),
-            created_at=datetime.fromisoformat(data["created_at"]),
-            updated_at=datetime.fromisoformat(data["updated_at"])
-        )
-
-
-@dataclass
-class Relationship:
-    """Represents a relationship between two entities"""
-    id: str
-    source_id: str
-    target_id: str
-    relationship_type: RelationshipType
-    properties: Dict[str, Any] = field(default_factory=dict)
-    weight: float = 1.0
-    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "id": self.id,
-            "source_id": self.source_id,
-            "target_id": self.target_id,
-            "relationship_type": self.relationship_type.value,
-            "properties": self.properties,
-            "weight": self.weight,
-            "created_at": self.created_at.isoformat()
-        }
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "Relationship":
-        return cls(
-            id=data["id"],
-            source_id=data["source_id"],
-            target_id=data["target_id"],
-            relationship_type=RelationshipType(data["relationship_type"]),
-            properties=data.get("properties", {}),
-            weight=data.get("weight", 1.0),
-            created_at=datetime.fromisoformat(data["created_at"])
-        )
-
-
 class KnowledgeGraph:
     """
     Knowledge graph for managing entity relationships.