C4-META System v1.0.0 (prototipo de investigación)

Prototipo de investigación para la defensa multicapa de IA: explicabilidad C4, clasificadores ensemble, desofuscación, motor de seguridad O₂, defensa ThoughtVirus y alineación de valores SVETILO. Grado alfa: validado internamente, auditoría externa pendiente.

Versión: 1.0.0-alpha | Estado: Prototipo de investigación | Licencia: BSL 1.1 (gratuita para no producción; producción → comercial)

Autor: I.G. Selyutin. Coautor del modelo C4-META: N.I. Kovalev.
Identidad del producto (2026-08): prototipo de investigación BSL / de profundidad comercial de una pila de defensa C4 multicapa más robusta (ensemble, andamiaje O₂, laboratorio red-team) construida sobre c4protocol con licencia Apache-2.0.
No es un segundo protocolo abierto. No es una defensa AGI certificada para producción. No es «v8 FINAL».
Auditoría de honestidad: docs/AUDIT-c4-meta-system-2026-08.md.
Ruta de promoción: docs/PROMOTE-FROM-PROTOCOL.md (consumir/fijar c4protocol; sin volcado del ensemble en el SDK ligero).
GitLab Pages = public/ (EN + public/ru/). Comprobante del runtime abierto: make conformance en c4protocol.

🎯 Descripción general

C4-META System es un prototipo de investigación para la defensa multicapa de IA que implementa:

Arquitectura de defensa en 4 capas

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

• Capa 1 — Saneamiento de entrada: pipeline de desofuscación (leet speak, más de 90 homoglifos Unicode, caracteres de ancho cero, anulación RTL, Base64/ROT13)
• Capa 2 — Análisis semántico: votación de ensemble de 4 clasificadores (ONNX BERT + RuleBased + Heuristic + LLM Semantic)
• Capa 3 — Análisis de comportamiento: módulos de defensa AoC, coincidencia de patrones, detección de anomalías de trayectoria
• Capa 4 — Meta-Observador (O₂): entropía de transferencia, consenso BFT, entrelazamiento semántico, análisis de grafos causales

Capacidades clave

• Votación de ensemble de 4 clasificadores — ONNX BERT + RuleBased (más de 80 patrones) + Heuristic (32 palabras de peligro) + LLM Semantic (Ollama/DeepSeek)
• Lógica OR de doble clasificador: clasificador semántico BERT + clasificador por palabras clave RuleBased con respaldo OR: sin punto único de fallo
• 16 módulos de defensa AoC — 11 clásicos + 5 ampliados (heurísticos/de laboratorio; no es una afirmación de que «todos los fallos multi-agente estén resueltos»)
• Defensa ThoughtVirus — defensa de dos capas (detección de patrones regex + análisis de trayectoria C4). Inspirada en arXiv:2603.00131 (Iniciativa de Seguridad Multi-Agente; no Microsoft)(https://arxiv.org/abs/2603.00131)
• SVETILO — 7 sellos heurísticos mediante value_verification.py (no es un modelo de ética entrenado)
• Explicabilidad C4 (T,S,A) — análisis de coordenadas cognitivas mediante modelo ONNX cuantizado (737KB, ~50ms)
• Andamiaje O₂ — módulos de investigación; la vía BFT es una simulación consultiva, no tolerancia a fallos bizantinos de producción
• Desofuscación — leet speak, más de 90 homoglifos Unicode, caracteres de ancho cero, anulación RTL, Base64/ROT13
• Laboratorio Red Team — diseño científico control/tratamiento, prueba exacta de Fisher, d de Cohen, IC por bootstrap
• Escáner de contenido subliminal — detecta mapeos token→concepto
• Detección de jailbreak multiturno — seguimiento de escalada basado en sesiones
• Despliegue Docker/K8s — despliegue multinodo contenerizado

🏗 Arquitectura

┌──────────────────────────────────────────────┐
│  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)         │
└──────────────────────────────────────────────┘

Votación de los 4 clasificadores:

• ONNX_BERT: coordenadas cognitivas C4 (T,S,A) mediante modelo cuantizado (737KB, ~50ms)
• RuleBased: más de 80 patrones regex que cubren inyección, jailbreak, juegos de rol y bypass de autoridad
• Heuristic: 32 palabras de peligro + análisis de ejes C4 + métrica de densidad semántica
• LLM_SEMANTIC: Ollama/DeepSeek — clasificación semántica de ataques (~300ms)

Lógica OR de doble clasificador: BERT + RuleBased operan como puerta principal con respaldo OR: si cualquiera de los dos marca la entrada, esta pasa a las capas de defensa. Ningún clasificador individual es un cuello de botella.

📁 Estructura del proyecto

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

🐳 Despliegue con Docker

El sistema está totalmente preparado para la contenerización, con configuración sensible al entorno.

Opciones de despliegue:

# 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

Endpoints de salud

• Contenedor principal: GET /health en el puerto 8080
• Ejecutor de Red Team: GET /health en el puerto 8081

🚀 Inicio rápido

Instalación

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

Ejecutar el servidor principal

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

Ejecutar el panel de Red Team

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

🏗️ Historial de correcciones de errores

Correcciones clave (60 resueltas en las rondas de auditoría)

1. Auto-DoS del Kill-Switch — o2_engine.py ya no bloquea todo el tráfico cuando O2 está deshabilitado.
2. Contención de bloqueo BFT — el consenso BFT se ejecuta fuera de la sección crítica, evitando el bloqueo de cabeza de línea.
3. Fugas del bus de eventos — ThreadPoolExecutor ahora se limpia mediante atexit; las devoluciones de llamada asíncronas usan run_coroutine_threadsafe().
4. Inversión del muestreo de O2 — explainable_o2.py ahora muestrea correctamente la fracción sample_rate en lugar de 1 - sample_rate.
5. Malla de comunicación falsa — o2_shared.py solo registra menciones explícitas @agent en lugar de un clique totalmente conectado.
6. Falsos positivos de entrelazamiento — semantic_detector.py normaliza los recuentos de conceptos antes de la comparación con el umbral.
7. Lógica de devolución de llamada de destino — el orquestador y el ejecutor de Redteam ahora analizan correctamente / de las respuestas de defensa en lugar de asumir que éxito = bloqueado.

📊 Resultados de benchmark

Resultados completos de benchmark en 4 conjuntos de datos y 2000 variantes adversariales del pipeline de defensa C4.

Consulta c4protocol/BENCHMARK_RESULTS.md para ver el informe completo.

Nota: el O₂ distribuido requiere un clúster de Redis para producción. El modo de un solo nodo está disponible para desarrollo (consulta la guía de despliegue).

📊 Estado

Reto Red Team

Las defensas de C4-META son sólidas, pero ningún sistema es perfecto. Si encuentras un prompt que evada el clasificador ensemble, los módulos de defensa AoC o el motor O₂, queremos saberlo.

Informa de las evasiones:

• Incidencias de GitLab: https://gitlab.com/cognitive-functors/c4-meta-system/-/issues
• Correo electrónico: [email protected]

Lo que necesitamos: el prompt evasor, la respuesta esperada y qué capa de defensa falló. Reconocemos a todos los informantes en nuestro salón de la fama de seguridad.

C4-META v1.0.0-alpha — prototipo de investigación de defensa de IA multicapa. Validación interna completa. Auditoría externa pendiente.