┌─────────────────────────────────────────────────────────────────┐
│                    GOVERNANCE-EBENEN                             │
├─────────────────────────────────────────────────────────────────┤
│ Ebene 5: Business-Governance                                     │
│    - Use-Case-Genehmigung, Risikobewertung, Wertvalidierung     │
├─────────────────────────────────────────────────────────────────┤
│ Ebene 4: Policy-Ebene                                            │
│    - Regeln, Constraints, Guardrails, Compliance-Policies       │
├─────────────────────────────────────────────────────────────────┤
│ Ebene 3: Control Plane                                           │
│    - Enforcement, Monitoring, Interventionsmöglichkeiten         │
├─────────────────────────────────────────────────────────────────┤
│ Ebene 2: Runtime-Sicherheit                                      │
│    - Sandboxing, Isolation, sichere Ausführung                   │
├─────────────────────────────────────────────────────────────────┤
│ Ebene 1: Identity & Access                                      │
│    - Authentifizierung, Autorisierung, Credential-Management   │
└─────────────────────────────────────────────────────────────────┘

# Zero-Trust Agent-Konfiguration
agent_identity:
  authentication:
    method: mTLS_with_JWT
    token_lifetime: 15m
    refresh_window: 5m
  
  authorization:
    model: RBAC_with_ABAC
    dynamic_scopes: true
    context_aware: true
  
  credential_rotation:
    frequency: 24h
    automatic: true
    grace_period: 5m

network_security:
  segmentation:
    agent_vlans: isolated
    egress_filtering: strict
    east_west_inspection: enabled
  
  mTLS:
    mutual_verification: required
    cert_pinning: enabled
    revocation_check: ocsp_stapling

Globale Policies (Unternehmensweit)
    ↓
Domänen-Policies (Finanzen, HR, Engineering)
    ↓
Workflow-Policies (Spezifische Agent-Fähigkeiten)
    ↓
Runtime-Policies (Ausführungszeit-Constraints)

{
  "policy_id": "finance-agent-v1",
  "version": "1.2.0",
  "applies_to": ["agent:finance-*", "workflow:invoice-processing"],
  "rules": [
    {
      "name": "no_unapproved_transfers",
      "type": "action_block",
      "condition": "action.type == 'bank_transfer' && !action.approved_by",
      "effect": "DENY",
      "message": "Banküberweisungen erfordern menschliche Genehmigung"
    },
    {
      "name": "pii_protection",
      "type": "data_filter",
      "condition": "data.contains_pii && destination.external",
      "effect": "REDACT",
      "message": "PII vor externer Übertragung entfernt"
    },
    {
      "name": "spend_limits",
      "type": "quota",
      "condition": "monthly_spend > 1000",
      "effect": "ALERT_AND_QUEUE",
      "message": "Monatliches Ausgabenlimit erreicht, Genehmigung ausstehend"
    }
  ],
  "enforcement_mode": "ACTIVE",
  "audit_level": "FULL"
}

// Policy-Enforcement-Middleware
async function enforcePolicy(context, action) {
  const policies = await loadApplicablePolicies(context.agent);
  
  for (const policy of policies) {
    const result = await evaluatePolicy(policy, context, action);
    
    if (result.effect === 'DENY') {
      await logPolicyViolation(context, action, policy);
      throw new PolicyViolationError(result.message);
    }
    
    if (result.effect === 'ALERT') {
      await notifyComplianceTeam(context, action, policy);
    }
  }
  
  return true; // Alle Policies bestanden
}

# Ausführungsmonitoring-Dekorator
@policy_monitored(policy_id="financial-workflow")
async def process_invoice(invoice_data):
    # Check mid-execution policies
    await checkpoint_policy_check()
    
    # If policy violation detected, pause for review
    if policy_state.requires_review:
        await request_human_approval()
    
    continue_processing()

# Audit-Pipeline-Konfiguration
post_execution_audit:
  triggers:
    - workflow_complete
    - exception_raised
    - manual_review_requested
  
  analyzers:
    - pattern_detection
    - anomaly_scoring
    - compliance_validation
  
  actions:
    high_risk:
      - notify_security_team
      - create_incident_ticket
      - preserve_logs
    
    medium_risk:
      - add_to_review_queue
      - notify_manager
    
    low_risk:
      - log_only

service://agent/{domain}/{agent_name}/{instance_id}

Beispiele:
- service://agent/finance/invoice-processor/prod-001
- service://agent/support/ticket-classifier/prod-003
- service://agent/ops/system-monitor/prod-002

# Agent-Rollen-Definitionen
roles:
  invoice_processor:
    permissions:
      - read:erp:invoices
      - write:erp:invoice_status
      - execute:workflow:approval_request
    constraints:
      max_daily_operations: 1000
      allowed_hours: ["08:00-18:00"]
      allowed_regions: ["us-east-1", "eu-west-1"]
  
  customer_support_agent:
    permissions:
      - read:crm:customer_data
      - write:crm:tickets
      - execute:tool:email_send
    constraints:
      requires_human_oversight: true
      pii_access: redacted

# ABAC Policy-Evaluation
def evaluate_access(agent, resource, action, context):
    attributes = {
        'agent.clearance_level': agent.clearance,
        'agent.department': agent.department,
        'resource.classification': resource.classification,
        'resource.owner_department': resource.owner,
        'context.time_of_day': context.timestamp.hour,
        'context.risk_score': context.risk_score,
        'action.sensitivity': action.sensitivity
    }
    
    # Policy: Agenten können auf Ressourcen in ihrer Abteilung zugreifen
    # während Geschäftszeiten, wenn der Risiko-Score niedrig ist
    if (attributes['agent.department'] == attributes['resource.owner_department'] and
        9 <= attributes['context.time_of_day'] <= 17 and
        attributes['context.risk_score'] < 0.7):
        return AccessDecision.GRANT
    
    return AccessDecision.DENY

// Credential-Rotation-Service
interface CredentialRotation {
  // Neue Credentials generieren
  async rotate(agentId: string): Promise<Credentials>;
  
  // Graceful Transition
  async transition(agentId: string, gracePeriod: number): Promise<void>;
  
  // Emergency-Revocation
  async revoke(agentId: string, reason: string): Promise<void>;
}

// Implementierung mit automatischer Rotation
class ManagedCredentials implements CredentialRotation {
  async rotate(agentId: string): Promise<Credentials> {
    const newCreds = await this.vault.generate(agentId, {
      ttl: '15m',           // 15-Minuten-Lebensdauer
      renewable: true,      // Kann während Aktivität erneuert werden
      max_ttl: '1h'         // Zwangsumstellung nach 1 Stunde
    });
    
    // Agent mit neuen Credentials aktualisieren
    await this.agentManager.updateCredentials(agentId, newCreds);
    
    // Nächste Rotation planen
    this.scheduler.schedule(`rotate-${agentId}`, '14m', () => {
      this.rotate(agentId);
    });
    
    return newCreds;
  }
}

# Kubernetes Secret-Injection für Agenten
apiVersion: apps/v1
kind: Deployment
metadata:
  name: agent-processor
spec:
  template:
    spec:
      containers:
      - name: agent
        env:
        - name: API_KEY
          valueFrom:
            secretKeyRef:
              name: agent-credentials
              key: api-key
        volumeMounts:
        - name: certs
          mountPath: /etc/agent/certs
          readOnly: true
      volumes:
      - name: certs
        csi:
          driver: secrets-store.csi.k8s.io
          readOnly: true
          volumeAttributes:
            secretProviderClass: agent-mtls-certs

# Kern-Agent-Metriken
AGENT_METRICS = {
    # Ausführungsmetriken
    'agent_execution_duration': Histogram(
        'agent_execution_duration_seconds',
        'Zeit für Agent-Workflow-Ausführung',
        ['agent_type', 'workflow_id']
    ),
    'agent_steps_completed': Counter(
        'agent_steps_completed_total',
        'Anzahl abgeschlossener Workflow-Schritte',
        ['agent_type', 'status']
    ),
    
    # LLM-Metriken
    'llm_tokens_used': Counter(
        'llm_tokens_used_total',
        'Gesamte von LLM-Calls verbrauchte Tokens',
        ['model', 'agent_type']
    ),
    'llm_latency': Histogram(
        'llm_latency_seconds',
        'LLM API-Antwortzeit',
        ['model', 'operation']
    ),
    
    # Tool-Usage-Metriken
    'tool_calls_total': Counter(
        'tool_calls_total',
        'Gesamte Tool-Aufrufe',
        ['tool_name', 'agent_type']
    ),
    'tool_error_rate': Gauge(
        'tool_error_rate',
        'Prozentsatz fehlgeschlagener Tool-Calls',
        ['tool_name']
    ),
    
    # Kostenmetriken
    'agent_cost_usd': Counter(
        'agent_cost_usd_total',
        'Gesamtkosten der Agent-Ausführung',
        ['agent_type', 'model']
    )
}

# Business-Outcome-Metriken
BUSINESS_METRICS = {
    'tasks_completed': Counter(
        'business_tasks_completed_total',
        'Erfolgreich abgeschlossene Aufgaben',
        ['task_type', 'priority']
    ),
    'time_saved_minutes': Counter(
        'business_time_saved_minutes',
        'Geschätzte durch Automatisierung eingesparte Zeit',
        ['process_type']
    ),
    'human_escalations': Counter(
        'business_human_escalations_total',
        'An Menschen eskalierte Fälle',
        ['reason', 'urgency']
    ),
    'customer_satisfaction': Gauge(
        'business_csat_score',
        'Kundenzufriedenheitsbewertung',
        ['channel', 'agent_type']
    )
}

{
  "timestamp": "2026-06-28T09:45:32.123Z",
  "level": "INFO",
  "trace_id": "abc123-def456-ghi789",
  "span_id": "span123",
  "parent_span_id": "span000",
  "service": "agent-orchestrator",
  "agent": {
    "id": "finance-processor-001",
    "type": "invoice_automation",
    "version": "2.3.1"
  },
  "event": {
    "type": "tool_execution",
    "tool": "erp_api",
    "operation": "fetch_invoice",
    "status": "success",
    "duration_ms": 245
  },
  "context": {
    "workflow_id": "wf-invoice-12345",
    "user_id": "[email protected]",
    "tenant_id": "tenant-001"
  },
  "security": {
    "identity_verified": true,
    "permissions_checked": ["read:erp:invoices"],
    "data_classification": "internal"
  },
  "payload": {
    "invoice_id": "INV-2026-001",
    "amount": 5000.00,
    "currency": "USD"
  }
}

# Agent-Workflow-Tracing
from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode

tracer = trace.get_tracer("agent.tracer")

class TracedAgent:
    async def execute_workflow(self, input_data):
        with tracer.start_as_current_span(
            name="agent_workflow",
            attributes={
                "agent.id": self.agent_id,
                "agent.type": self.agent_type,
                "workflow.input_size": len(input_data)
            }
        ) as workflow_span:
            try:
                # Step 1: Datenvalidierung
                with tracer.start_span("step_validation") as validation_span:
                    validated_data = await self.validate(input_data)
                    validation_span.set_attribute("validation.errors", 0)
                
                # Step 2: LLM-Reasoning
                with tracer.start_span("llm_reasoning") as llm_span:
                    plan = await self.llm.generate_plan(validated_data)
                    llm_span.set_attribute("llm.tokens_input", plan.tokens_input)
                    llm_span.set_attribute("llm.tokens_output", plan.tokens_output)
                    llm_span.set_attribute("llm.model", plan.model)
                
                # Step 3: Tool-Ausführung
                for idx, tool_call in enumerate(plan.tools):
                    with tracer.start_span(f"tool_{tool_call.name}") as tool_span:
                        tool_span.set_attribute("tool.name", tool_call.name)
                        tool_span.set_attribute("tool.args", str(tool_call.args))
                        
                        result = await self.execute_tool(tool_call)
                        
                        tool_span.set_attribute("tool.status", result.status)
                        tool_span.set_attribute("tool.duration_ms", result.duration)
                
                # Step 4: Antwortgenerierung
                with tracer.start_span("generate_response") as response_span:
                    response = await self.generate_response(results)
                
                workflow_span.set_status(Status(StatusCode.OK))
                return response
                
            except Exception as e:
                workflow_span.set_status(
                    Status(StatusCode.ERROR, str(e))
                )
                workflow_span.record_exception(e)
                raise

# Trace-Context durch asynchrone Grenzen propagieren
import contextvars

trace_context = contextvars.ContextVar('trace_context')

async def execute_subagent(parent_context, task):
    # Trace-Context für Subagent setzen
    trace_context.set(parent_context)
    
    # Subagent erbt automatisch die Trace-ID des Parents
    with tracer.start_span(
        name="subagent_execution",
        context=trace_context.get()
    ):
        return await subagent.execute(task)

# Kryptografisch signiertes Audit-Log
import hashlib
import json
from datetime import datetime

class ImmutableAuditLog:
    def __init__(self, storage_backend):
        self.storage = storage_backend
        self.previous_hash = self._get_last_hash()
    
    async def record_event(self, event: AuditEvent):
        # Event mit Metadaten erstellen
        audit_entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event_type": event.type,
            "event_data": event.data,
            "actor": event.actor,
            "resource": event.resource,
            "action": event.action,
            "result": event.result,
            "previous_hash": self.previous_hash,
            "sequence_number": await self._get_next_sequence()
        }
        
        # Hash berechnen
        entry_json = json.dumps(audit_entry, sort_keys=True)
        entry_hash = hashlib.sha256(entry_json.encode()).hexdigest()
        audit_entry["hash"] = entry_hash
        
        # Mit HSM signieren, falls verfügbar
        if self.hsm_available:
            audit_entry["signature"] = await self._sign_with_hsm(entry_hash)
        
        # Mit Write-Once-Garantie speichern
        await self.storage.append(audit_entry)
        
        # Chain aktualisieren
        self.previous_hash = entry_hash
        
        return entry_hash
    
    async def verify_integrity(self):
        """Die gesamte Audit-Chain verifizieren."""
        entries = await self.storage.read_all()
        
        for i, entry in enumerate(entries):
            # Hash-Chain verifizieren
            if i > 0:
                expected_previous = entries[i-1]["hash"]
                if entry["previous_hash"] != expected_previous:
                    raise AuditIntegrityError(
                        f"Chain broken at entry {i}"
                    )
            
            # Entry-Hash verifizieren
            entry_copy = {k: v for k, v in entry.items() if k != "hash"}
            expected_hash = hashlib.sha256(
                json.dumps(entry_copy, sort_keys=True).encode()
            ).hexdigest()
            
            if entry["hash"] != expected_hash:
                raise AuditIntegrityError(
                    f"Hash mismatch at entry {i}"
                )
        
        return True

# Echtzeit-Tamper-Erkennung
class TamperDetector:
    def __init__(self, audit_log, alert_service):
        self.audit = audit_log
        self.alerts = alert_service
        self.last_verified_hash = None
    
    async def continuous_verification(self):
        """Hintergrund-Task für kontinuierliche Integritätsprüfungen."""
        while True:
            await asyncio.sleep(60)  # Jede Minute prüfen
            
            try:
                current_hash = await self.audit.get_latest_hash()
                
                if self.last_verified_hash and \
                   current_hash != self.last_verified_hash:
                    # Prüfen, ob dies legitime neue Daten sind
                    is_valid = await self.audit.verify_integrity()
                    
                    if not is_valid:
                        await self.alerts.send_critical(
                            "AUDIT_TAMPER_DETECTED",
                            "Audit-Log-Integritätsprüfung fehlgeschlagen"
                        )
                
                self.last_verified_hash = current_hash
                
            except Exception as e:
                await self.alerts.send_critical(
                    "AUDIT_VERIFICATION_FAILED",
                    f"Audit-Verifizierungsfehler: {str(e)}"
                )

# Compliance-Event-Schema
events:
  AGENT_DEPLOYED:
    category: lifecycle
    retention: 7_years
    fields:
      - agent_id
      - agent_type
      - deployed_by
      - permissions_granted
      - approval_ticket
  
  POLICY_VIOLATION:
    category: security
    retention: 7_years
    fields:
      - policy_id
      - violation_type
      - agent_id
      - attempted_action
      - enforcement_result
      - remediation_action
  
  DATA_ACCESSED:
    category: data_governance
    retention: 3_years
    fields:
      - data_classification
      - access_purpose
      - agent_id
      - data_subject_id  # Für DSGVO
      - legal_basis
  
  HUMAN_APPROVAL_REQUESTED:
    category: workflow
    retention: 5_years
    fields:
      - request_type
      - requested_by
      - approver
      - approval_deadline
      - escalation_path
  
  LLM_INVOCATION:
    category: ai_operations
    retention: 1_year
    fields:
      - model_provider
      - model_version
      - tokens_input
      - tokens_output
      - cost_usd
      - data_sent_externally
      - pii_detected

# Compliance-Report-Generator
class ComplianceReporter:
    def __init__(self, audit_log, event_store):
        self.audit = audit_log
        self.events = event_store
    
    async def generate_gdpr_report(
        self,
        data_subject_id: str,
        start_date: datetime,
        end_date: datetime
    ) -> GDPRReport:
        """DSGVO Artikel 15 Datensubjekt-Zugriffsbericht generieren."""
        
        # Alle Events abfragen, die dieses Datensubjekt betreffen
        events = await self.events.query({
            "data_subject_id": data_subject_id,
            "timestamp": {
                "$gte": start_date,
                "$lte": end_date
            }
        })
        
        report = GDPRReport(
            data_subject_id=data_subject_id,
            report_period=(start_date, end_date),
            generated_at=datetime.utcnow()
        )
        
        # Verarbeitungsaktivitäten kategorisieren
        for event in events:
            if event.type == "DATA_ACCESSED":
                report.add_processing_activity(
                    purpose=event.access_purpose,
                    legal_basis=event.legal_basis,
                    data_categories=event.data_categories,
                    recipients=event.recipients,
                    retention_period=event.retention_period
                )
            
            elif event.type == "DATA_SHARED":
                report.add_third_party_disclosure(
                    recipient=event.recipient,
                    data_categories=event.data_categories,
                    legal_basis=event.legal_basis,
                    safeguards=event.safeguards
                )
        
        # Automatisierte Entscheidungsfälle berechnen
        automated_decisions = await self.events.count({
            "data_subject_id": data_subject_id,
            "type": "AUTOMATED_DECISION",
            "human_review": False
        })
        report.automated_decisions = automated_decisions
        
        return report
    
    async def generate_soc2_evidence(
        self,
        control_id: str,
        period: DateRange
    ) -> SOCTwoEvidence:
        """SOC 2 Type II Control-Evidenz generieren."""
        
        evidence = SOCTwoEvidence(control_id=control_id)
        
        # CC6.1 - Logischer Zugriffsschutz
        if control_id == "CC6.1":
            access_events = await self.events.query({
                "type": {"$in": ["ACCESS_GRANTED", "ACCESS_REVOKED"]},
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(access_events)
            
            # Zugriffsüberprüfungs-Evidenz hinzufügen
            reviews = await self.events.query({
                "type": "ACCESS_REVIEW_COMPLETED",
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(reviews)
        
        # CC7.1 - Sicherheitsmonitoring
        elif control_id == "CC7.1":
            monitoring_events = await self.events.query({
                "type": {"$in": ["THREAT_DETECTED", "ALERT_TRIGGERED"]},
                "timestamp": {"$gte": period.start, "$lte": period.end}
            })
            evidence.add_samples(monitoring_events)
        
        return evidence

# Alert-Schweregrad-Klassifizierung
class AlertSeverity:
    CRITICAL = "critical"      # Sofortige Reaktion erforderlich
    HIGH = "high"              # Reaktion innerhalb 15 Minuten
    MEDIUM = "medium"          # Reaktion innerhalb 1 Stunde
    LOW = "low"                # Reaktion innerhalb 24 Stunden
    INFO = "info"              # Nur loggen, keine Aktion erforderlich

# Alert-Routing-Regeln
ALERT_ROUTING = {
    "policy_violation": {
        "critical": ["security_team", "compliance_officer"],
        "high": ["security_team"]
    },
    "anomaly_detected": {
        "critical": ["ml_team", "ops_team"],
        "high": ["ops_team"]
    },
    "cost_threshold": {
        "critical": ["finance_team", "cto"],
        "high": ["finance_team"]
    },
    "system_error": {
        "critical": ["ops_team", "on_call"],
        "high": ["ops_team"]
    }
}

# Alert-Deduplizierung und -Gruppierung
class AlertManager:
    def __init__(self):
        self.recent_alerts = TTLCache(maxsize=1000, ttl=300)
        self.alert_groups = {}
    
    async def process_alert(self, alert: Alert):
        # Auf Duplikate prüfen
        alert_key = self._generate_key(alert)
        if alert_key in self.recent_alerts:
            # Zähler erhöhen statt neuem Alert
            await self._update_existing_alert(alert_key, alert)
            return
        
        # Auf verwandte Alerts prüfen, um zu gruppieren
        group_key = self._find_group_key(alert)
        if group_key:
            await self._add_to_group(group_key, alert)
            return
        
        # Rate-Limiting
        if await self._is_rate_limited(alert.type):
            await self._queue_alert(alert)
            return
        
        # Neuen Alert senden
        await self._dispatch_alert(alert)
        self.recent_alerts[alert_key] = alert
    
    def _generate_key(self, alert: Alert) -> str:
        """Eindeutigen Schlüssel für Deduplizierung generieren."""
        return hashlib.md5(
            f"{alert.type}:{alert.agent_id}:{alert.error_code}".encode()
        ).hexdigest()
    
    async def _dispatch_alert(self, alert: Alert):
        # Schweregrad bestimmen
        severity = self._classify_severity(alert)
        
        # Routing-Regeln abrufen
        recipients = ALERT_ROUTING.get(alert.type, {}).get(severity, [])
        
        # Mit Kontext anreichern
        enriched_alert = await self._enrich_alert(alert)
        
        # Über geeignete Kanäle senden
        for recipient in recipients:
            channel = self._get_channel(recipient)
            await channel.send(enriched_alert)

# Echtzeit-Dashboard-Daten-Pipeline
class DashboardPipeline:
    def __init__(self, websocket_manager):
        self.websocket = websocket_manager
        self.metrics_buffer = []
    
    async def stream_metrics(self):
        """Echtzeit-Metriken an Dashboard streamen."""
        while True:
            metrics = await self._collect_current_metrics()
            
            dashboard_update = {
                "timestamp": datetime.utcnow().isoformat(),
                "agents": {
                    "active": metrics.active_agents,
                    "healthy": metrics.healthy_agents,
                    "degraded": metrics.degraded_agents,
                    "failed": metrics.failed_agents
                },
                "executions": {
                    "per_minute": metrics.executions_per_minute,
                    "success_rate": metrics.success_rate,
                    "avg_duration_ms": metrics.avg_duration
                },
                "costs": {
                    "hourly_usd": metrics.hourly_cost,
                    "projected_daily_usd": metrics.projected_daily_cost
                },
                "alerts": {
                    "critical": metrics.critical_alerts,
                    "open_incidents": metrics.open_incidents
                }
            }
            
            await self.websocket.broadcast("metrics", dashboard_update)
            await asyncio.sleep(5)  # Alle 5 Sekunden aktualisieren
    
    async def _collect_current_metrics(self):
        """Aktuelle Systemmetriken sammeln."""
        return AgentMetrics(
            active_agents=await self._count_active_agents(),
            healthy_agents=await self._count_healthy_agents(),
            executions_per_minute=await self._calculate_execution_rate(),
            hourly_cost=await self._calculate_hourly_cost(),
            critical_alerts=await self._count_critical_alerts()
        )

# Token-Budget-Hierarchie
budgets:
  organization:
    daily_tokens: 10_000_000
    monthly_usd: 50_000
    alerts:
      - threshold: 80%
        notify: ["finance_team"]
      - threshold: 95%
        action: "throttle"
        notify: ["cto", "finance_team"]
  
  departments:
    engineering:
      daily_tokens: 4_000_000
      monthly_usd: 20_000
      
    support:
      daily_tokens: 3_000_000
      monthly_usd: 15_000
      
    marketing:
      daily_tokens: 2_000_000
      monthly_usd: 10_000
      
    operations:
      daily_tokens: 1_000_000
      monthly_usd: 5_000
  
  projects:
    invoice_automation:
      daily_tokens: 500_000
      model_tier: "standard"  # GPT-4o
      
    customer_chat:
      daily_tokens: 1_000_000
      model_tier: "fast"  # GPT-4o-mini
      
    code_review:
      daily_tokens: 200_000
      model_tier: "premium"  # GPT-5

# Token-Usage-Tracker
class TokenBudgetManager:
    def __init__(self, redis_client):
        self.redis = redis_client
        self.budgets = self._load_budgets()
    
    async def track_usage(
        self,
        agent_id: str,
        tokens_used: int,
        cost_usd: float,
        model: str
    ):
        """Token-Usage gegen Budgets tracken."""
        
        timestamp = datetime.utcnow()
        
        # Counter aktualisieren
        pipeline = self.redis.pipeline()
        
        # Tages-Counter
        daily_key = f"tokens:daily:{timestamp.strftime('%Y-%m-%d')}:{agent_id}"
        pipeline.incrby(daily_key, tokens_used)
        pipeline.expire(daily_key, 86400 * 2)  # 2 Tage behalten
        
        # Stunden-Counter für Rate-Limiting
        hourly_key = f"tokens:hourly:{timestamp.strftime('%Y-%m-%d-%H')}:{agent_id}"
        pipeline.incrby(hourly_key, tokens_used)
        pipeline.expire(hourly_key, 7200)
        
        # Kosten-Tracking
        cost_key = f"cost:daily:{timestamp.strftime('%Y-%m')}"
        pipeline.incrbyfloat(cost_key, cost_usd)
        
        await pipeline.execute()
        
        # Budget-Schwellen prüfen
        await self._check_budgets(agent_id, tokens_used)
    
    async def _check_budgets(self, agent_id: str, tokens_used: int):
        """Prüfen, ob Usage Budget-Schwellen überschreitet."""
        
        agent_budget = self.budgets.get_agent_budget(agent_id)
        current_usage = await self._get_current_usage(agent_id)
        
        utilization = current_usage / agent_budget.daily_tokens
        
        if utilization >= 0.95:
            await self._enforce_throttle(agent_id)
            await self._alert_budget_exceeded(agent_id, utilization)
        elif utilization >= 0.80:
            await self._alert_budget_warning(agent_id, utilization)
    
    async def can_execute(
        self,
        agent_id: str,
        estimated_tokens: int
    ) -> BudgetCheckResult:
        """Prüfen, ob Ausführung unter aktuellem Budget erlaubt ist."""
        
        agent_budget = self.budgets.get_agent_budget(agent_id)
        current_usage = await self._get_current_usage(agent_id)
        
        if current_usage + estimated_tokens > agent_budget.daily_tokens:
            return BudgetCheckResult(
                allowed=False,
                reason="Tägliches Token-Budget überschritten",
                current_usage=current_usage,
                budget_limit=agent_budget.daily_tokens
            )
        
        return BudgetCheckResult(allowed=True)

# Dynamische Modellauswahl basierend auf Task-Komplexität
class ModelRouter:
    def __init__(self):
        self.models = {
            "gpt-4o-mini": {"cost_per_1k": 0.0006, "capability": "basic"},
            "gpt-4o": {"cost_per_1k": 0.005, "capability": "advanced"},
            "gpt-5": {"cost_per_1k": 0.015, "capability": "expert"}
        }
    
    async def select_model(
        self,
        task: Task,
        required_quality: QualityLevel
    ) -> ModelSelection:
        """Optimales Modell basierend auf Task und Qualitätsanforderungen auswählen."""
        
        # Task-Komplexität analysieren
        complexity = await self._analyze_complexity(task)
        
        # Verfügbares Budget abrufen
        budget = await self._get_remaining_budget(task.agent_id)
        
        # Qualität-Kosten-Tradeoff
        if required_quality == QualityLevel.MINIMUM:
            return ModelSelection(
                model="gpt-4o-mini",
                reasoning="Minimale Qualität akzeptabel, Kosteneinsparungen maximieren"
            )
        
        elif required_quality == QualityLevel.BALANCED:
            if complexity < 0.5 and budget.utilization < 0.7:
                return ModelSelection(
                    model="gpt-4o-mini",
                    reasoning="Niedrige Task-Komplexität, Budget verfügbar"
                )
            else:
                return ModelSelection(
                    model="gpt-4o",
                    reasoning="Höhere Komplexität erfordert besseres Modell"
                )
        
        elif required_quality == QualityLevel.MAXIMUM:
            return ModelSelection(
                model="gpt-5",
                reasoning="Maximale Qualität erforderlich"
            )

# n8n-Sicherheits-Umgebungsvariablen
environment:
  # Authentifizierung
  N8N_BASIC_AUTH_ACTIVE: "true"
  N8N_BASIC_AUTH_USER: "${N8N_ADMIN_USER}"
  N8N_BASIC_AUTH_PASSWORD: "${N8N_ADMIN_PASSWORD}"
  
  # Security-Header
  N8N_SECURITY_HEADERS: "true"
  N8N_SECURITY_ACCESS_CONTROL_ALLOW_ORIGIN: "https://tropical-media.work"
  
  # Ausführungseinstellungen
  N8N_EXECUTIONS_MODE: "queue"  # Separate Worker-Prozesse
  N8N_EXECUTIONS_TIMEOUT: "300"  # 5-Minuten-Timeout
  N8N_EXECUTIONS_TIMEOUT_MAX: "7200"  # 2-Stunden-Maximum
  
  # Audit-Logging
  N8N_LOG_OUTPUT: "file"
  N8N_LOG_FILE_LOCATION: "/var/log/n8n/"
  N8N_LOG_FILE_COUNT: "30"
  
  # Credential-Sicherheit
  N8N_ENCRYPTION_KEY: "${N8N_ENCRYPTION_KEY}"
  
  # Workflow-Beschränkungen
  N8N_BLOCK_ENV_ACCESS_IN_NODE: "true"
  N8N_NODE_ALLOW_LIST: ".n8n/nodes/allowed.json"

// n8n Governance-Check-Node
const policyService = require('./services/policyService');
const auditService = require('./services/auditService');

// Pre-execution Policy-Check
async function execute() {
    const workflowContext = {
        workflowId: $workflow.id,
        executionId: $execution.id,
        userId: $execution.userId,
        nodes: $workflow.nodes
    };
    
    // Prüfen, ob Workflow ausgeführt werden darf
    const policyCheck = await policyService.evaluateWorkflow(workflowContext);
    
    if (!policyCheck.allowed) {
        // Policy-Verstoß loggen
        await auditService.logEvent({
            type: 'WORKFLOW_BLOCKED',
            workflowId: workflowContext.workflowId,
            reason: policyCheck.reason,
            violatedPolicies: policyCheck.violatedPolicies
        });
        
        return [{ 
            json: { 
                error: 'Workflow-Ausführung durch Policy blockiert',
                reason: policyCheck.reason 
            } 
        }];
    }
    
    // Genehmigte Ausführung loggen
    await auditService.logEvent({
        type: 'WORKFLOW_APPROVED',
        workflowId: workflowContext.workflowId,
        policiesChecked: policyCheck.checkedPolicies
    });
    
    return [{ json: { approved: true } }];
}

module.exports = { execute };

// n8n Custom Metrics Node
const prometheus = require('prom-client');

// Metriken definieren
const workflowDuration = new prometheus.Histogram({
    name: 'n8n_workflow_duration_seconds',
    help: 'Dauer der Workflow-Ausführung',
    labelNames: ['workflow_id', 'status'],
    buckets: [0.1, 0.5, 1, 2, 5, 10, 30, 60]
});

const nodeExecutions = new prometheus.Counter({
    name: 'n8n_node_executions_total',
    help: 'Gesamte Node-Ausführungen',
    labelNames: ['workflow_id', 'node_type', 'status']
});

async function execute() {
    const startTime = Date.now();
    const workflowId = $workflow.id;
    
    try {
        // Node-Ausführung tracken
        nodeExecutions.inc({
            workflow_id: workflowId,
            node_type: 'custom_metrics',
            status: 'success'
        });
        
        // Dauer berechnen und aufzeichnen
        const duration = (Date.now() - startTime) / 1000;
        workflowDuration.observe(
            { workflow_id: workflowId, status: 'success' },
            duration
        );
        
        // An Prometheus pushen
        await prometheus.pushAdd({
            jobName: 'n8n-workflows',
            groupings: { workflow_id: workflowId }
        }, 'http://prometheus-pushgateway:9091');
        
        return [{ json: { metrics_pushed: true } }];
        
    } catch (error) {
        nodeExecutions.inc({
            workflow_id: workflowId,
            node_type: 'custom_metrics',
            status: 'error'
        });
        throw error;
    }
}

module.exports = { execute };

# OpenClaw Agent-Sicherheitskonfiguration
agent_security:
  authentication:
    require_approval_for:
      - external_api_calls
      - database_writes
      - file_system_access
      - email_sending
    
    mcp_server_security:
      verify_signatures: true
      allowed_origins:
        - "https://mcp.tropical-media.work"
        - "https://internal-mcp.local"
      
      rate_limits:
        requests_per_minute: 60
        burst_allowance: 10
  
  execution_sandbox:
    mode: "restricted"
    network_access: "outbound_only"
    file_system: "read_only"
    environment_variables: "whitelisted"
    
  audit:
    log_all_tool_calls: true
    log_llm_prompts: true
    log_reasoning: true
    retention_days: 90

# OpenClaw Governance-Integration
from openclaw import Agent, PolicyEnforcer

class GovernedOpenClawAgent:
    def __init__(self, agent_config):
        self.agent = Agent(agent_config)
        self.policy_enforcer = PolicyEnforcer()
        self.audit_logger = AuditLogger()
    
    async def execute_with_governance(self, task):
        """Agent-Task mit vollständigen Governance-Kontrollen ausführen."""
        
        # Ausführungskontext generieren
        context = ExecutionContext(
            agent_id=self.agent.id,
            user_id=task.user_id,
            session_id=task.session_id,
            timestamp=datetime.utcnow(),
            request_id=generate_uuid()
        )
        
        # Pre-Execution Policy-Check
        policy_result = await self.policy_enforcer.check(
            context=context,
            action=task.action,
            resources=task.resources
        )
        
        if not policy_result.allowed:
            await self.audit_logger.log_policy_violation(
                context=context,
                task=task,
                violation=policy_result
            )
            raise PolicyViolationError(policy_result.reason)
        
        # Mit Monitoring ausführen
        with self._create_span(context) as span:
            try:
                result = await self.agent.execute(task)
                
                # Post-Execution Audit
                await self.audit_logger.log_success(
                    context=context,
                    task=task,
                    result=result,
                    duration=span.duration
                )
                
                return result
                
            except Exception as e:
                await self.audit_logger.log_failure(
                    context=context,
                    task=task,
                    error=e
                )
                raise

# OpenClaw Agent-Monitoring
class OpenClawMonitor:
    def __init__(self, metrics_collector):
        self.metrics = metrics_collector
    
    def instrument_agent(self, agent: Agent):
        """Observability-Instrumentierung zu OpenClaw-Agent hinzufügen."""
        
        # Tool-Ausführung wrappen
        original_execute_tool = agent.execute_tool
        
        async def monitored_execute_tool(tool_name, params):
            start_time = time.time()
            
            try:
                result = await original_execute_tool(tool_name, params)
                
                # Erfolgsmetriken aufzeichnen
                self.metrics.record_tool_execution(
                    tool=tool_name,
                    status="success",
                    duration=time.time() - start_time
                )
                
                return result
                
            except Exception as e:
                # Fehlermetriken aufzeichnen
                self.metrics.record_tool_execution(
                    tool=tool_name,
                    status="error",
                    duration=time.time() - start_time,
                    error_type=type(e).__name__
                )
                raise
        
        agent.execute_tool = monitored_execute_tool
        
        # LLM-Calls wrappen
        original_llm_call = agent.llm.complete
        
        async def monitored_llm_call(prompt, **kwargs):
            start_time = time.time()
            
            result = await original_llm_call(prompt, **kwargs)
            
            # LLM-Metriken aufzeichnen
            self.metrics.record_llm_invocation(
                model=kwargs.get('model', 'default'),
                tokens_input=result.usage.prompt_tokens,
                tokens_output=result.usage.completion_tokens,
                duration=time.time() - start_time,
                cost=result.usage.total_cost
            )
            
            return result
        
        agent.llm.complete = monitored_llm_call
        
        return agent

┌─────────────────────────────────────────────────────────────────┐
│                    GOVERNANCE-DASHBOARD                        │
├─────────────────────────────────────────────────────────────────┤
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ Agent Health │  │ Compliance   │  │ Cost Tracking│          │
│  │ Status       │  │ Overview     │  │ & Budgets    │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                 ECHTZEIT-AKTIVITÄT                     │   │
│  │  • Aktive Workflows      • Aktuelle Ausführungen        │   │
│  │  • Tool-Usage Heatmap    │ Kosten pro Stunde            │   │
│  └─────────────────────────────────────────────────────────┘   │
├─────────────────────────────────────────────────────────────────┤
│  ┌───────────────────┐  ┌──────────────────────────────────┐   │
│  │   ALERTS          │  │   NEUESTE AUDIT-EVENTS         │   │
│  │  • Kritisch: 2    │  │  • Policy-Verstoß - Finanzen   │   │
│  │  • Hoch: 5        │  │  • Zugriff gewährt - DevOps    │   │
│  │  • Offene Incidents │  │  • Kostenschwelle überschritten│   │
│  └───────────────────┘  └──────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

# FastAPI Governance-Dashboard-Backend
from fastapi import FastAPI, WebSocket
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI(title="KI-Governance-Dashboard")

# CORS für Dashboard-Zugriff
app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://governance.tropical-media.work"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Dashboard-Daten-Endpunkte
@app.get("/api/dashboard/overview")
async def get_dashboard_overview():
    """High-Level-Dashboard-Metriken abrufen."""
    return {
        "agents": {
            "total": await agent_registry.count(),
            "healthy": await health_checker.count_healthy(),
            "degraded": await health_checker.count_degraded(),
            "failed": await health_checker.count_failed()
        },
        "executions": {
            "last_hour": await execution_store.count_last_hour(),
            "success_rate": await execution_store.calculate_success_rate(),
            "avg_duration_ms": await execution_store.avg_duration()
        },
        "compliance": {
            "overall_score": await compliance_calculator.score(),
            "open_findings": await compliance_store.count_open_findings(),
            "last_audit": await audit_log.last_audit_date()
        },
        "costs": {
            "today_usd": await cost_tracker.today(),
            "mtd_usd": await cost_tracker.month_to_date(),
            "projected_month_usd": await cost_tracker.projected_month()
        }
    }

@app.get("/api/agents/{agent_id}/details")
async def get_agent_details(agent_id: str):
    """Detaillierte Informationen zu einem spezifischen Agenten abrufen."""
    agent = await agent_registry.get(agent_id)
    
    return {
        "metadata": agent.metadata,
        "health": await health_checker.check(agent_id),
        "recent_executions": await execution_store.recent(agent_id, limit=20),
        "cost_breakdown": await cost_tracker.breakdown(agent_id),
        "compliance_status": await compliance_calculator.agent_score(agent_id),
        "policy_violations": await audit_log.violations(agent_id, days=30)
    }

@app.websocket("/ws/realtime")
async def realtime_websocket(websocket: WebSocket):
    """WebSocket für Echtzeit-Dashboard-Updates."""
    await websocket.accept()
    
    try:
        while True:
            # Echtzeit-Metriken sammeln
            update = {
                "timestamp": datetime.utcnow().isoformat(),
                "active_executions": await execution_store.active_count(),
                "current_throughput": await metrics_collector.current_tps(),
                "alerts": await alert_manager.recent(5)
            }
            
            await websocket.send_json(update)
            await asyncio.sleep(5)
            
    except Exception:
        await websocket.close()

# Audit-Log-Query-Endpunkt
@app.get("/api/audit/search")
async def search_audit_logs(
    start_date: datetime,
    end_date: datetime,
    event_type: Optional[str] = None,
    agent_id: Optional[str] = None,
    severity: Optional[str] = None,
    limit: int = 100
):
    """Audit-Logs durchsuchen und filtern."""
    query = AuditQuery(
        start_date=start_date,
        end_date=end_date,
        event_type=event_type,
        agent_id=agent_id,
        severity=severity,
        limit=limit
    )
    
    results = await audit_log.search(query)
    return {"results": results, "total": len(results)}

# SOC 2 Common Criteria Implementierung
soc2_controls:
  CC6.1:  # Logischer Zugriffsschutz
    implementations:
      - name: "Agent Identity Management"
        description: "Alle Agenten haben eindeutige Service-Identities"
        evidence_sources:
          - agent_registry
          - identity_provider
        
      - name: "Role-Based Access Control"
        description: "RBAC für alle Agent-Operationen erzwungen"
        evidence_sources:
          - policy_engine
          - access_control_logs
    
  CC6.2:  # Vor dem Zugriff
    implementations:
      - name: "Pre-Execution Policy Check"
        description: "Alle Agent-Aktionen vor Ausführung validiert"
        evidence_sources:
          - policy_enforcement_logs
          - approval_workflows
  
  CC7.1:  # Sicherheitsmonitoring
    implementations:
      - name: "Echtzeit-Agent-Monitoring"
        description: "Kontinuierliches Monitoring des Agent-Verhaltens"
        evidence_sources:
          - metrics_collector
          - alert_manager
      
      - name: "Anomalie-Erkennung"
        description: "KI-basierte Erkennung ungewöhnlichen Agent-Verhaltens"
        evidence_sources:
          - anomaly_detector
          - incident_response_logs
  
  CC7.2:  # Incident-Erkennung
    implementations:
      - name: "Automatisiertes Alerting"
        description: "Echtzeit-Alerts für Sicherheitsereignisse"
        evidence_sources:
          - alert_manager
          - notification_logs
  
  A1.2:  # Verfügbarkeit
    implementations:
      - name: "Agent Health Checks"
        description: "Kontinuierliche Health-Überwachung und Failover"
        evidence_sources:
          - health_checker
          - uptime_metrics

# Automatisierte SOC 2 Evidenz-Sammlung
class SOC2EvidenceCollector:
    def __init__(self):
        self.evidence_store = EvidenceStore()
    
    async def collect_cc61_evidence(self, period: DateRange):
        """Evidenz für CC6.1 - Logischer Zugriff sammeln."""
        
        evidence = {
            "control": "CC6.1",
            "period": period,
            "collected_at": datetime.utcnow(),
            "samples": []
        }
        
        # Sample 1: Agent-Identity-Konfigurationen
        agent_configs = await self._sample_agent_configs(period, n=50)
        evidence["samples"].append({
            "type": "agent_identities",
            "description": "Service-Identity-Konfigurationen für Agenten",
            "data": agent_configs,
            "count": len(agent_configs)
        })
        
        # Sample 2: Zugriffskontroll-Entscheidungen
        access_decisions = await self._sample_access_decisions(period, n=100)
        evidence["samples"].append({
            "type": "access_control_logs",
            "description": "Autorisierungsentscheidungen geloggt",
            "data": access_decisions,
            "count": len(access_decisions)
        })
        
        # Sample 3: Credential-Rotation-Evidenz
        credential_rotations = await self._get_credential_rotations(period)
        evidence["samples"].append({
            "type": "credential_rotations",
            "description": "Automatisierte Credential-Rotation-Events",
            "data": credential_rotations,
            "count": len(credential_rotations)
        })
        
        await self.evidence_store.store(evidence)
        return evidence

# DSGVO Datensubjekt-Rechte Implementierung
class GDPRAgentCompliance:
    def __init__(self, data_inventory, audit_log):
        self.data_inventory = data_inventory
        self.audit = audit_log
    
    async def handle_access_request(
        self,
        data_subject_id: str
    ) -> DataSubjectAccessReport:
        """DSGVO Artikel 15 Zugriffsanfrage behandeln."""
        
        # Alle Daten identifizieren, die dieses Subjekt betreffen
        data_locations = await self.data_inventory.find_by_subject(
            data_subject_id
        )
        
        report = DataSubjectAccessReport(
            subject_id=data_subject_id,
            request_date=datetime.utcnow()
        )
        
        for location in data_locations:
            # Daten aus jedem System sammeln
            data = await self._collect_from_location(location, data_subject_id)
            report.add_data_source(location, data)
            
            # Sammlung für Audit loggen
            await self.audit.log_event({
                "type": "GDPR_DATA_ACCESSED",
                "data_subject_id": data_subject_id,
                "system": location.system,
                "purpose": "access_request",
                "legal_basis": "GDPR_Article_15"
            })
        
        return report
    
    async def handle_deletion_request(
        self,
        data_subject_id: str
    ) -> DeletionConfirmation:
        """DSGVO Artikel 17 Löschanfrage behandeln."""
        
        deletion_report = DeletionConfirmation(
            subject_id=data_subject_id,
            initiated_at=datetime.utcnow()
        )
        
        # Alle Daten-Locations finden
        locations = await self.data_inventory.find_by_subject(data_subject_id)
        
        for location in locations:
            try:
                # Löschung versuchen
                result = await self._delete_from_location(
                    location,
                    data_subject_id
                )
                
                deletion_report.add_success(location, result)
                
            except Exception as e:
                # Fehler loggen, erfordert möglicherweise manuelle Überprüfung
                deletion_report.add_failure(location, str(e))
        
        # In jede Agent-Memory propagieren
        await self._purge_from_agent_memory(data_subject_id)
        
        # Abschluss loggen
        await self.audit.log_event({
            "type": "GDPR_DELETION_COMPLETED",
            "data_subject_id": data_subject_id,
            "systems_affected": len(locations),
            "timestamp": datetime.utcnow()
        })
        
        return deletion_report
    
    async def _purge_from_agent_memory(self, data_subject_id: str):
        """Datensubjekt-Informationen aus Agent-Memory-Systemen entfernen."""
        
        # Alle Memory-Stores prüfen
        memory_stores = [
            "conversation_memory",
            "vector_store",
            "episodic_memory",
            "semantic_memory"
        ]
        
        for store in memory_stores:
            entries = await self._find_in_memory(store, data_subject_id)
            
            for entry in entries:
                await self._redact_memory_entry(store, entry)
                
                await self.audit.log_event({
                    "type": "MEMORY_REDACTED",
                    "data_subject_id": data_subject_id,
                    "memory_store": store,
                    "entry_id": entry.id
                })

# KI-Agent Incident-Klassifizierung
class IncidentClassifier:
    SEVERITY_MATRIX = {
        # (impact, urgency) -> severity
        ("high", "immediate"): "CRITICAL",
        ("high", "high"): "HIGH",
        ("medium", "immediate"): "HIGH",
        ("high", "medium"): "MEDIUM",
        ("medium", "high"): "MEDIUM",
        ("low", "immediate"): "MEDIUM",
        ("medium", "medium"): "LOW",
        ("low", "high"): "LOW",
        ("low", "medium"): "INFO",
    }
    
    def classify(self, incident: AgentIncident) -> IncidentClassification:
        """Agent-Incident-Schweregrad klassifizieren."""
        
        # Impact bestimmen
        impact = self._assess_impact(incident)
        
        # Dringlichkeit bestimmen
        urgency = self._assess_urgency(incident)
        
        # Schweregrad abrufen
        severity = self.SEVERITY_MATRIX.get(
            (impact, urgency),
            "LOW"
        )
        
        return IncidentClassification(
            severity=severity,
            impact=impact,
            urgency=urgency,
            recommended_response_time=self._response_time(severity)
        )
    
    def _assess_impact(self, incident: AgentIncident) -> str:
        """Business-Impact des Incidents bewerten."""
        
        # Auf Datenbruch-Indikatoren prüfen
        if incident.type in ["DATA_EXFILTRATION", "UNAUTHORIZED_ACCESS"]:
            if incident.data_classification == "confidential":
                return "high"
        
        # Auf finanziellen Impact prüfen
        if incident.estimated_cost_usd and incident.estimated_cost_usd > 10000:
            return "high"
        
        # Auf operativen Impact prüfen
        if incident.affected_agents and len(incident.affected_agents) > 10:
            return "high"
        
        if incident.workflow_downtime_minutes and incident.workflow_downtime_minutes > 30:
            return "medium"
        
        return "low"

# Incident-Response-Playbooks
playbooks:
  policy_violation_detected:
    triggers:
      - event: POLICY_VIOLATION
        severity: [high, critical]
    
    steps:
      - action: isolate_agent
        description: "Verstoßenden Agenten sofort isolieren"
        timeout: 30s
      
      - action: preserve_logs
        description: "Alle relevanten Logs erfassen und sichern"
        timeout: 60s
      
      - action: notify_security
        description: "Sicherheitsteam alarmieren"
        channels: [slack, pagerduty]
      
      - action: create_incident_ticket
        description: "Tracking-Ticket erstellen"
        system: jira
      
      - action: await_human_review
        description: "Für menschliche Untersuchung pausieren"
        condition: severity == "critical"
  
  anomalous_cost_spike:
    triggers:
      - event: COST_THRESHOLD_EXCEEDED
        threshold_percent: 200
    
    steps:
      - action: throttle_agent
        description: "Agent-Ausführungsrate reduzieren"
        rate_limit: "10%"
      
      - action: analyze_spike
        description: "Ursache der Kostensteigerung identifizieren"
        timeout: 5m
      
      - action: notify_finance
        description: "Finanzteam alarmieren"
        
      - action: conditional_escalate
        description: "Eskalieren wenn >$1000 über Budget"
        condition: overage_usd > 1000
  
  agent_loop_detected:
    triggers:
      - event: INFINITE_LOOP_DETECTED
    
    steps:
      - action: terminate_execution
        description: "Looping-Workflow beenden"
        force: true
      
      - action: capture_state
        description: "Ausführungszustand für Debugging sichern"
      
      - action: alert_engineering
        description: "Engineering-Team benachrichtigen"
      
      - action: block_temporarily
        description: "Agent bis zur Behebung blockieren"
        duration: "1h"

# Automatisierte Incident-Response
class IncidentResponder:
    def __init__(self):
        self.playbooks = self._load_playbooks()
        self.orchestrator = ResponseOrchestrator()
    
    async def handle_incident(self, incident: AgentIncident):
        """Automatisch auf Agent-Incident reagieren."""
        
        # Incident klassifizieren
        classification = self.classifier.classify(incident)
        
        # Passendes Playbook auswählen
        playbook = self._select_playbook(incident, classification)
        
        if not playbook:
            # Keine automatische Response, an Menschen eskalieren
            await self._escalate_to_human(incident, classification)
            return
        
        # Playbook ausführen
        execution_context = {
            "incident": incident,
            "classification": classification,
            "start_time": datetime.utcnow()
        }
        
        for step in playbook.steps:
            try:
                result = await self._execute_step(step, execution_context)
                
                if step.condition and not self._evaluate_condition(
                    step.condition,
                    execution_context
                ):
                    continue
                
                # Schrittausführung loggen
                await self._log_step(incident, step, result)
                
            except Exception as e:
                # Schritt fehlgeschlagen, eskalieren
                await self._escalate_step_failure(incident, step, e)
                break
        
        # Incident-Status aktualisieren
        await self._update_incident_status(incident, "responded")
    
    async def _execute_step(
        self,
        step: PlaybookStep,
        context: Dict
    ) -> StepResult:
        """Einen einzelnen Response-Schritt ausführen."""
        
        action_handlers = {
            "isolate_agent": self._isolate_agent,
            "preserve_logs": self._preserve_logs,
            "notify_security": self._notify_security,
            "throttle_agent": self._throttle_agent,
            "terminate_execution": self._terminate_execution
        }
        
        handler = action_handlers.get(step.action)
        if not handler:
            raise ValueError(f"Unbekannte Aktion: {step.action}")
        
        return await handler(context, step.parameters)

# Prompt-Injection-Erkennung und -Prävention
class PromptInjectionGuard:
    def __init__(self):
        self.classifier = self._load_injection_classifier()
        self.content_filter = ContentFilter()
    
    async def validate_input(self, user_input: str) -> ValidationResult:
        """User-Input auf Prompt-Injection-Versuche validieren."""
        
        # KI-basierte Klassifizierung
        injection_score = await self.classifier.score(user_input)
        
        if injection_score > 0.8:
            return ValidationResult(
                valid=False,
                reason="High-Confidence Prompt-Injection erkannt",
                confidence=injection_score,
                action="BLOCK"
            )
        
        if injection_score > 0.5:
            return ValidationResult(
                valid=False,
                reason="Verdächtiges Input-Muster",
                confidence=injection_score,
                action="REQUIRE_REVIEW"
            )
        
        # Zusätzliche heuristische Checks
        heuristics_result = self._check_heuristics(user_input)
        if heuristics_result.suspicious:
            return ValidationResult(
                valid=False,
                reason=heuristics_result.reason,
                action="REQUIRE_REVIEW"
            )
        
        return ValidationResult(valid=True)
    
    def _check_heuristics(self, text: str) -> HeuristicResult:
        """Heuristische Checks auf Injection-Patterns anwenden."""
        
        patterns = [
            r"ignore (previous|above|earlier)",  # Anweisungs-Überschreibung
            r"system(?: prompt)?[:\s]*",  # System-Prompt-Zugriff
            r"you are now.*?:",  # Rollen-Manipulation
            r"\{\{.*system.*\}\}",  # Template-Injection
            r"new instructions?:",  # Anweisungs-Injection
            r"disregard (all|previous).*constraint",  # Constraint-Umgehung
        ]
        
        for pattern in patterns:
            if re.search(pattern, text, re.IGNORECASE):
                return HeuristicResult(
                    suspicious=True,
                    reason=f"Gemustert übereinstimmend: {pattern}"
                )
        
        return HeuristicResult(suspicious=False)

# Agent-Output-Sanitisierung
class OutputSanitizer:
    def __init__(self):
        self.pii_detector = PIIDetector()
        self.code_validator = CodeValidator()
    
    async def sanitize(
        self,
        agent_output: str,
        output_type: str,
        destination: str
    ) -> SanitizationResult:
        """Agent-Output vor Verwendung sanitisieren."""
        
        sanitized = agent_output
        actions_taken = []
        
        # Auf PII prüfen
        pii_findings = await self.pii_detector.scan(sanitized)
        if pii_findings:
            if destination == "external":
                # PII für externe Ziele redacten
                sanitized = await self._redact_pii(sanitized, pii_findings)
                actions_taken.append(f"{len(pii_findings)} PII-Instanzen redacted")
            else:
                actions_taken.append(
                    f"Warnung: {len(pii_findings)} PII-Instanzen erkannt"
                )
        
        # Code validieren, falls vorhanden
        if output_type == "code":
            code_validation = await self.code_validator.validate(sanitized)
            if not code_validation.safe:
                return SanitizationResult(
                    safe=False,
                    reason=f"Unsicherer Code erkannt: {code_validation.issues}",
                    output=None
                )
        
        # Auf Injection-Patterns im Output prüfen
        if self._contains_injection_patterns(sanitized):
            return SanitizationResult(
                safe=False,
                reason="Output enthält potenzielle Injection-Patterns",
                output=None
            )
        
        return SanitizationResult(
            safe=True,
            output=sanitized,
            actions_taken=actions_taken
        )

# Blue-Green Agent-Deployment
deployment:
  strategy: blue_green
  
  blue:
    version: "2.3.1"
    traffic_percent: 100
    agent_pool:
      replicas: 5
      resources:
        cpu: "2"
        memory: "4Gi"
    
  green:
    version: "2.4.0"
    traffic_percent: 0
    agent_pool:
      replicas: 5
      resources:
        cpu: "2"
        memory: "4Gi"
  
  promotion:
    health_checks:
      - metric: error_rate
        threshold: "< 0.01"
        duration: 5m
      - metric: latency_p99
        threshold: "< 500ms"
        duration: 5m
    
    canary_steps:
      - traffic: 5
        duration: 10m
      - traffic: 25
        duration: 15m
      - traffic: 50
        duration: 15m
      - traffic: 100
        duration: 0
  
  rollback:
    automatic_on:
      - error_rate > 0.05
      - latency_p99 > 2000ms
      - policy_violations > 0

# Agent-Deployment-Orchestrator
class AgentDeploymentOrchestrator:
    def __init__(self):
        self.k8s = KubernetesClient()
        self.metrics = MetricsCollector()
        self.governance = GovernanceValidator()
    
    async def deploy_agent(
        self,
        agent_config: AgentConfig,
        deployment_config: DeploymentConfig
    ) -> DeploymentResult:
        """Agent mit Governance-Validierung deployen."""
        
        # Pre-Deployment Governance-Check
        governance_result = await self.governance.validate_deployment(
            agent_config
        )
        
        if not governance_result.approved:
            return DeploymentResult(
                success=False,
                reason=governance_result.reason,
                blocked_policies=governance_result.violated_policies
            )
        
        # Blue-Green-Deployment ausführen
        if deployment_config.strategy == "blue_green":
            return await self._blue_green_deploy(agent_config, deployment_config)
        
        elif deployment_config.strategy == "canary":
            return await self._canary_deploy(agent_config, deployment_config)
        
        else:
            return await self._standard_deploy(agent_config, deployment_config)
    
    async def _blue_green_deploy(
        self,
        agent_config: AgentConfig,
        config: DeploymentConfig
    ) -> DeploymentResult:
        """Blue-Green-Deployment ausführen."""
        
        # Green-Version deployen
        await self.k8s.deploy(
            name=f"{agent_config.name}-green",
            config=agent_config,
            replicas=config.green.replicas
        )
        
        # Smoke-Tests ausführen
        smoke_result = await self._run_smoke_tests(
            f"{agent_config.name}-green"
        )
        
        if not smoke_result.success:
            await self.k8s.delete(f"{agent_config.name}-green")
            return DeploymentResult(
                success=False,
                reason=f"Smoke-Tests fehlgeschlagen: {smoke_result.errors}"
            )
        
        # Gradueller Traffic-Shift
        for step in config.promotion.canary_steps:
            await self._shift_traffic(agent_config.name, step.traffic)
            
            # Während Schritt überwachen
            await asyncio.sleep(step.duration * 60)
            
            health = await self._check_health(agent_config.name)
            if not health.healthy:
                await self._rollback(agent_config.name)
                return DeploymentResult(
                    success=False,
                    reason=f"Health-Check bei {step.traffic}% Traffic fehlgeschlagen"
                )
        
        # Green zu Blue promoten
        await self._promote_green_to_blue(agent_config.name)
        
        return DeploymentResult(
            success=True,
            version_deployed=agent_config.version
        )

# Agent-Disaster-Recovery-Konfiguration
disaster_recovery:
  backup:
    frequency: hourly
    retention: 30d
    destinations:
      - s3://tropical-media-agent-backups/primary
      - s3://tropical-media-agent-backups-dr/secondary
    
    contents:
      - agent_configurations
      - workflow_definitions
      - execution_history
      - audit_logs
      - memory_snapshots
  
  rto: 15m  # Recovery Time Objective
  rpo: 5m   # Recovery Point Objective
  
  failover:
    regions:
      primary: us-east-1
      secondary: us-west-2
      tertiary: eu-west-1
    
    trigger_conditions:
      - primary_region_unavailable
      - error_rate > 0.5
      - latency_p99 > 5000ms
  
  testing:
    frequency: monthly
    scope: full_failover
    validation:
      - workflow_execution
      - data_integrity
      - performance_benchmark