C4-META System v1.0.0 (Forschungsprototyp)

Forschungsprototyp für mehrschichtige KI-Abwehr: C4-Erklärbarkeit, Ensemble-Klassifikatoren, Deobfuskierung, O₂-Sicherheits-Engine, ThoughtVirus-Abwehr und SVETILO-Werteausrichtung. Alpha-Status — intern validiert, externes Audit ausstehend.

Version: 1.0.0-alpha | Status: Forschungsprototyp | Lizenz: BSL 1.1 (nicht-produktiv kostenlos; Produktion → kommerziell)

Autor: I.G. Selyutin. C4-META-Modell-Koautor: N.I. Kovalev.
Produktidentität (2026-08): BSL-Forschungsprototyp mit kommerzieller Tiefe eines schwereren mehrschichtigen C4-Abwehr-Stacks (Ensemble, O₂-Scaffolding, Red-Team-Labor), basierend auf Apache-2.0 c4protocol.
Kein zweites offenes Protokoll. Keine zertifizierte AGI-Abwehr für die Produktion. Nicht „v8 FINAL“.
Ehrlichkeits-Audit: docs/AUDIT-c4-meta-system-2026-08.md.
Hochstufungspfad: docs/PROMOTE-FROM-PROTOCOL.md (c4protocol konsumieren/pinnen; kein Ensemble-Dump in das dünne SDK).
GitLab Pages = public/ (EN + public/ru/). Nachweis für offene Laufzeit: make conformance in c4protocol.

🎯 Überblick

C4-META System ist ein Forschungsprototyp für mehrschichtige KI-Abwehr, der Folgendes implementiert:

4-Schichten-Abwehrarchitektur

Input Sanitization → Semantic Analysis → Behavioral Analysis → Meta-Observer (O₂)

• Schicht 1 — Eingabebereinigung: Deobfuskierungs-Pipeline (Leetspeak, 90+ Unicode-Homoglyphen, Zero-Width-Zeichen, RTL-Override, Base64/ROT13)
• Schicht 2 — Semantische Analyse: 4-Klassifikator-Ensemble-Abstimmung (ONNX BERT + RuleBased + Heuristik + LLM-Semantik)
• Schicht 3 — Verhaltensanalyse: AoC-Abwehrmodule, Mustererkennung, Erkennung von Trajektorien-Anomalien
• Schicht 4 — Meta-Beobachter (O₂): Transferentropie, BFT-Konsens, semantische Verschränkung, Analyse kausaler Graphen

Hauptfunktionen

• 4-Klassifikator-Ensemble-Abstimmung — ONNX BERT + RuleBased (80+ Muster) + Heuristik (32 Gefahrenwörter) + LLM-Semantik (Ollama/DeepSeek)
• Duale Klassifikator-ODER-Logik: BERT-semantisch + RuleBased-Schlüsselwortklassifikator mit ODER-Fallback — kein Single Point of Failure
• 16 AoC-Abwehrmodule — 11 klassische + 5 erweiterte (heuristisch/Labor; kein Anspruch darauf, „alle Multi-Agenten-Fehler gelöst zu haben“)
• ThoughtVirus-Abwehr — Zweischichtige Abwehr (Regex-Mustererkennung + C4-Trajektorienanalyse). Inspiriert von arXiv:2603.00131 (Multi-Agent Security Initiative; nicht Microsoft)(https://arxiv.org/abs/2603.00131)
• SVETILO — 7 heuristische Siegel über value_verification.py (kein trainiertes Ethikmodell)
• C4-Erklärbarkeit (T,S,A) — Analyse kognitiver Koordinaten über quantisiertes ONNX-Modell (737KB, ~50ms)
• O₂-Scaffolding — Forschungsmodule; der BFT-Pfad ist eine beratende Simulation, keine produktive byzantinische FT
• Deobfuskierung — Leetspeak, 90+ Unicode-Homoglyphen, Zero-Width-Zeichen, RTL-Override, Base64/ROT13
• Red-Team-Labor — Wissenschaftliches Kontroll-/Behandlungsdesign, exakter Fisher-Test, Cohens d, Bootstrap-Konfidenzintervall
• Scanner für subliminale Inhalte — Erkennt Token→Konzept-Zuordnungen
• Multi-Turn-Jailbreak-Erkennung — Sitzungsbasierte Eskalationsverfolgung
• Docker/K8s-Bereitstellung — Containerisierte Multi-Node-Bereitstellung

🏗 Architektur

┌──────────────────────────────────────────────┐
│  LAYER 1: Input Sanitization                 │
│  Deobfuscation (homoglyphs, leetspeak, etc.) │
├──────────────────────────────────────────────┤
│  LAYER 2: Semantic Analysis                  │
│  4-Classifier Ensemble: ONNX_BERT (~50ms)    │
│  + RuleBased + Heuristic + LLM_SEMANTIC      │
│  Dual classifier OR-logic (BERT+RuleBased)   │
├──────────────────────────────────────────────┤
│  LAYER 3: Behavioral Analysis                │
│  16 AoC Defense Modules (11 original + 5     │
│  extended), Pattern matching, Trajectory     │
│  anomaly detection, ThoughtVirus defense     │
├──────────────────────────────────────────────┤
│  LAYER 4: Meta-Observer (O₂)                 │
│  Transfer entropy, BFT consensus,            │
│  semantic entanglement, causal graphs,       │
│  Kill-Switch, SVETILO value verification     │
├──────────────────────────────────────────────┤
│  C4 Core Engine (Z₃³)                        │
│  pipeline_orchestrator.py, event_bus.py      │
│  c4_meta_monitor.py — self-awareness deque  │
├──────────────────────────────────────────────┤
│  Defenses: Anti-Deadlock, Anti-Emergence,    │
│  Anti-Hijack, Circuit Breaker, O₂ Kill-Switch│
├──────────────────────────────────────────────┤
│  Red Team Lab: AOC scenarios, experiment     │
│  runner, LLM client, adapters                │
├──────────────────────────────────────────────┤
│  Routing: Smart Router, Quarantine,          │
│  Antifragile Scoring (capped growth)         │
└──────────────────────────────────────────────┘

4 Klassifikatoren stimmen ab:

• ONNX_BERT: C4-kognitive Koordinaten (T,S,A) über quantisiertes Modell (737KB, ~50ms)
• RuleBased: 80+ Regex-Muster für Injection, Jailbreak, Rollenspiel, Autoritätsumgehung
• Heuristik: 32 Gefahrenwörter + C4-Achsenanalyse + Metrik für semantische Dichte
• LLM_SEMANTIC: Ollama/DeepSeek — semantische Angriffsklassifizierung (~300ms)

Duale Klassifikator-ODER-Logik: BERT + RuleBased fungieren als primäres Tor mit ODER-Fallback — wenn einer der beiden die Eingabe markiert, wird sie an die Abwehrschichten weitergeleitet. Kein einzelner Klassifikator ist ein Engpass.

📁 Projektstruktur

c4-meta-system/
├── v4_1/
│   ├── core/
│   │   ├── pipeline.py                  # Main entry points (re-exports)
│   │   ├── __main__.py                  # HTTP server entrypoint for Docker
│   │   ├── pipeline_stages.py           # Individual processing stages
│   │   ├── pipeline_orchestrator.py      # Main orchestration (thread-safe)
│   │   ├── result_factory.py             # Standardized C4v4Result factory
│   │   ├── event_bus.py                  # Organic event bus (atexit cleanup)
│   │   └── c4_meta_monitor.py            # Z³ self-awareness (deque bounded)
│   ├── security/
│   │   ├── o2_engine.py                  # O₂ defense (kill-switch self-DoS fixed)
│   │   ├── explainable_o2.py             # O₂ explainability (sampling inverted)
│   │   ├── o2_shared.py                  # Window structures (@mention comms)
│   │   ├── semantic_detector.py          # Concept graphs (normalized entanglement)
│   │   ├── secure_debug_endpoints.py     # Debug endpoints (UTC + rate limits)
│   │   ├── hardening.py                  # Model signing / admin token verification
│   │   ├── behavioral_profiler.py        # Drift detection (thread-safe singleton)
│   │   ├── distributed_o2.py             # SQLite/Redis backend (BEGIN IMMEDIATE)
│   │   ├── swarm_orchestrator.py         # Anti-virus swarm
│   │   └── ...
│   ├── defenses/
│   │   ├── anti_deadlock.py              # Resource deadlock prevention
│   │   ├── anti_emergence.py             # State convergence (async release fixed)
│   │   └── ...
│   ├── redteam/
│   │   ├── orchestrator.py              # Main orchestrator (target_callback parsing)
│   │   ├── scenario_manager.py           # AOC scenarios management
│   │   ├── adapters/                     # LLM backend adapters
│   │   ├── experiment_executor.py        # Async execution (FPR logic fixed)
│   │   ├── experiment_services.py       # Service locator
│   │   ├── experiment_runner.py         # Web UI + REST API
│   │   ├── llm_client.py                 # Async-safe LLM client (empty choices guarded)
│   │   └── ...
│   ├── classifiers/                      # 4-classifier ensemble
│   ├── config/                           # Configuration management
│   ├── access/                           # Access control
│   ├── explainability/                   # C4 explainability
│   ├── learning/                         # Learning loop
│   ├── plugins/                          # Plugin system
│   ├── quarantine/                       # Quarantine management
│   ├── router/                           # Smart routing
│   ├── scoring/                          # Antifragile scoring
│   └── tests/                            # 240 tests (19 test files)
├── formal/                               # TLA+ specifications
├── models/                               # ONNX model + tokenizer
├── archive/Dockerfile.prepared          # Multi-stage production build (archived)
├── Dockerfile.distroless                # Distroless-ready builder pattern
├── archive/docker-compose.yml.prepared  # Full stack (Ollama + UI + Monitoring) (archived)
├── .dockerignore                        # Security-hardened exclusion list
├── infra/k8s/                           # Kubernetes manifests (hardened)
└── README.md                            # This file

🐳 Docker-Bereitstellung

Das System ist vollständig für die Containerisierung mit umgebungsbewusster Konfiguration vorbereitet.

Bereitstellungsoptionen:

# Full stack (C4-META + Ollama + UI)
docker compose --profile experiment up -d

# Build image
docker build -t c4-meta-system -f archive/Dockerfile.prepared .

# Run with local Ollama
OLLAMA_BASE_URL=http://host.docker.internal:11434 docker run -p 8080:8080 c4-meta-system

# Red Team runner
docker build -t c4-redteam -f redteam/Dockerfile.redteam.prepared .
docker run -p 8081:8081 c4-redteam

Health-Endpunkte

• Kerncontainer: GET /health auf Port 8080
• Red-Team-Runner: GET /health auf Port 8081

🚀 Schnellstart

Installation

pip install -r requirements.txt
# Optional Docker deps
pip install -r requirements-docker.txt

Kernserver ausführen

python -m v4_1.core
# or explicitly
python -m v4_1.core.__main__

Red-Team-Dashboard ausführen

python -m v4_1.redteam.experiment_runner --web --port 8080

🏗️ Bugfix-Historie

Wichtige Bugfixes (60 über Audit-Runden gelöst)

1. Kill-Switch-Self-DoS — o2_engine.py blockiert nicht mehr den gesamten Datenverkehr, wenn O2 deaktiviert ist.
2. BFT-Sperrkonflikt — Der BFT-Konsens läuft außerhalb des kritischen Abschnitts und verhindert Head-of-Line-Blocking.
3. Event-Bus-Leaks — ThreadPoolExecutor räumt jetzt über atexit auf; asynchrone Callbacks verwenden run_coroutine_threadsafe().
4. O2-Sampling-Invertierung — explainable_o2.py sampelt jetzt korrekt den sample_rate-Anteil statt 1 - sample_rate.
5. Falsches Kommunikationsnetz — o2_shared.py zeichnet nur explizite @agent-Erwähnungen auf statt einer vollständig verbundenen Clique.
6. Verschränkungs-Fehlalarme — semantic_detector.py normalisiert Konzeptzahlen vor dem Schwellenwertvergleich.
7. Ziel-Callback-Logik — Redteam-Orchestrator und -Executor parsen jetzt korrekt blocked/ aus Abwehrantworten, statt anzunehmen, dass Erfolg = blockiert bedeutet.

📊 Benchmark-Ergebnisse

Vollständige Benchmark-Ergebnisse über 4 Datensätze und 2000 adversariale Varianten aus der C4-Abwehr-Pipeline.

Siehe c4protocol/BENCHMARK_RESULTS.md für den vollständigen Bericht.

Hinweis: Verteiltes O₂ erfordert einen Redis-Cluster für die Produktion. Einzelknotenmodus für die Entwicklung verfügbar (siehe Bereitstellungsanleitung).

📊 Status

Red-Team-Challenge

C4-METAs Abwehr ist stark — aber kein System ist perfekt. Wenn Sie einen Prompt finden, der den Ensemble-Klassifikator, die AoC-Abwehrmodule oder die O₂-Engine umgeht, möchten wir davon erfahren.

Umgehungen melden:

• GitLab Issues: https://gitlab.com/cognitive-functors/c4-meta-system/-/issues
• E-Mail: [email protected]

Was wir benötigen: Den Prompt, der die Abwehr umgangen hat, die erwartete Antwort und die Angabe, welche Abwehrschicht versagt hat. Wir würdigen alle Melder in unserer Security Hall of Fame.

C4-META v1.0.0-alpha — Forschungsprototyp für mehrschichtige KI-Abwehr. Interne Validierung abgeschlossen. Externes Audit ausstehend.