Sistema C4-META v1.0.0 (protótipo de pesquisa)

Protótipo de pesquisa para defesa de IA em múltiplas camadas: explicabilidade C4, classificadores ensemble, desofuscação, mecanismo de segurança O₂, defesa ThoughtVirus e alinhamento de valores SVETILO. Grau alfa — validado internamente, auditoria externa pendente.

Versão: 1.0.0-alpha | Status: Protótipo de Pesquisa | Licença: BSL 1.1 (gratuito fora de produção; produção → comercial)

Autor: I.G. Selyutin. Coautor do modelo C4-META: N.I. Kovalev.
Identidade do produto (2026-08): protótipo de pesquisa BSL / profundidade comercial de uma pilha de defesa C4 multicamadas mais robusta (ensemble, andaime O₂, laboratório red-team) construída sobre o c4protocol sob licença Apache-2.0.
Não é um segundo protocolo aberto. Não é defesa de AGI de produção certificada. Não é "v8 FINAL".
Auditoria de honestidade: docs/AUDIT-c4-meta-system-2026-08.md.
Caminho de promoção: docs/PROMOTE-FROM-PROTOCOL.md (consumir/fixar c4protocol; sem despejo do ensemble no SDK enxuto).
GitLab Pages = public/ (EN + public/ru/). Comprovante de runtime aberto: make conformance no c4protocol.

🎯 Visão Geral

O Sistema C4-META é um protótipo de pesquisa para defesa de IA em múltiplas camadas que implementa:

Arquitetura de Defesa em 4 Camadas

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

• Camada 1 — Saneamento de Entrada: pipeline de desofuscação (leetspeak, mais de 90 homóglifos Unicode, caracteres de largura zero, override RTL, Base64/ROT13)
• Camada 2 — Análise Semântica: votação ensemble de 4 classificadores (ONNX BERT + RuleBased + Heuristic + LLM Semantic)
• Camada 3 — Análise Comportamental: módulos de defesa AoC, correspondência de padrões, detecção de anomalias de trajetória
• Camada 4 — Meta-Observador (O₂): entropia de transferência, consenso BFT, entrelaçamento semântico, análise de grafo causal

Principais Capacidades

• Votação Ensemble de 4 Classificadores — ONNX BERT + RuleBased (mais de 80 padrões) + Heuristic (32 palavras de perigo) + LLM Semantic (Ollama/DeepSeek)
• Lógica OR de classificador duplo: BERT semântico + classificador de palavras-chave RuleBased com fallback OR — sem ponto único de falha
• 16 Módulos de Defesa AoC — 11 clássicos + 5 estendidos (heurístico/laboratório; não é uma afirmação de que "todas as falhas multiagente foram resolvidas")
• Defesa ThoughtVirus — defesa em duas camadas (detecção de padrões regex + análise de trajetória C4). Inspirada em arXiv:2603.00131 (Iniciativa de Segurança Multiagente; não Microsoft)(https://arxiv.org/abs/2603.00131)
• SVETILO — 7 selos heurísticos via value_verification.py (não é um modelo de ética treinado)
• Explicabilidade C4 (T,S,A) — análise de coordenadas cognitivas via modelo ONNX quantizado (737KB, ~50ms)
• Andaime O₂ — módulos de pesquisa; o caminho BFT é simulação consultiva, não FT Bizantino de produção
• Desofuscação — Leetspeak, mais de 90 homóglifos Unicode, caracteres de largura zero, override RTL, Base64/ROT13
• Laboratório Red Team — desenho científico de controle/tratamento, teste exato de Fisher, d de Cohen, IC bootstrap
• Scanner de Conteúdo Subliminar — detecta mapeamentos token→conceito
• Detecção de jailbreak multietapa — rastreamento de escalada baseado em sessão
• Implantação Docker/K8s — implantação conteinerizada multinó

🏗 Arquitetura

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

Votação dos 4 classificadores:

• ONNX_BERT: coordenadas cognitivas C4 (T,S,A) por meio de modelo quantizado (737KB, ~50ms)
• RuleBased: mais de 80 padrões regex cobrindo injeção, jailbreak, role-play e bypass de autoridade
• Heuristic: 32 palavras de perigo + análise de eixos C4 + métrica de densidade semântica
• LLM_SEMANTIC: Ollama/DeepSeek — classificação de ataques semânticos (~300ms)

Lógica OR de classificador duplo: BERT + RuleBased operam como porta primária com fallback OR — se qualquer um sinalizar a entrada, ela segue para as camadas de defesa. Nenhum classificador isolado é um gargalo.

📁 Estrutura do Projeto

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

🐳 Implantação Docker

O sistema está totalmente preparado para conteinerização com configuração sensível ao ambiente.

Opções de implantação:

# 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 Saúde

• Contêiner principal: GET /health na porta 8080
• Runner do Red Team: GET /health na porta 8081

🚀 Início Rápido

Instalação

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

Executar o Servidor Principal

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

Executar o Painel Red Team

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

🏗️ Histórico de Correções de Bugs

Principais Correções de Bugs (60 resolvidas ao longo das rodadas de auditoria)

1. Auto-DoS do Kill-Switch — o2_engine.py não bloqueia mais todo o tráfego quando o O2 está desabilitado.
2. Contenção de Lock BFT — o consenso BFT é executado fora da seção crítica, prevenindo bloqueio head-of-line.
3. Vazamentos do Event Bus — o ThreadPoolExecutor agora faz a limpeza via atexit; callbacks assíncronos usam run_coroutine_threadsafe().
4. Inversão de Amostragem do O2 — o explainable_o2.py agora amostra corretamente a fração sample_rate em vez de 1 - sample_rate.
5. Falsa Malha de Comunicação — o o2_shared.py só registra menções explícitas @agent em vez de um clique totalmente conectado.
6. Falsos Positivos de Entrelaçamento — o semantic_detector.py normaliza as contagens de conceitos antes da comparação de limiar.
7. Lógica do Callback de Alvo — o orquestrador e o executor do redteam agora analisam corretamente blocked/ das respostas de defesa em vez de assumir que sucesso = bloqueado.

📊 Resultados de Benchmark

Resultados completos de benchmark em 4 conjuntos de dados e 2000 variantes adversariais do pipeline de defesa C4.

Consulte c4protocol/BENCHMARK_RESULTS.md para o relatório completo.

Observação: o O₂ distribuído requer cluster Redis para produção. O modo de nó único está disponível para desenvolvimento (consulte o guia de implantação).

📊 Status

Desafio Red Team

As defesas do C4-META são fortes — mas nenhum sistema é perfeito. Se você encontrar um prompt que burle o classificador ensemble, os módulos de defesa AoC ou o mecanismo O₂, queremos saber.

Relate burlas:

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

O que precisamos: o prompt que burla, a resposta esperada e qual camada de defesa falhou. Reconhecemos todos os relatores em nosso hall da fama de segurança.

C4-META v1.0.0-alpha — protótipo de pesquisa de defesa de IA em múltiplas camadas. Validação interna concluída. Auditoria externa pendente.