Update app.py

app.py

@@ -2,466 +2,158 @@
 CASSANDRA - Organismo Computacional de 3 Corpos
 Hugging Face Space Interface
 """
-
 import gradio as gr
-import json
 import time
 import hashlib
+import json
 from datetime import datetime
-from typing import Dict, Any, Optional
-from pathlib import Path
-
-# ============== CORE MODULES ==============
-
-class QUCACore:
-    """QUCA - Quantum Universal Cognitive Architecture"""
-    
-    def __init__(self):
-        self.memory = []
-        
-    def process(self, query: str) -> Dict[str, Any]:
-        """Processa entrada através do cubo cognitivo"""
-        # Percepção
-        perception = self._perceive(query)
-        # Raciocínio
-        reasoning = self._reason(perception)
-        # Síntese
-        response = self._synthesize(reasoning)
-        
-        return {
-            "perception": perception,
-            "reasoning": reasoning,
-            "response": response,
-            "confidence": self._calculate_confidence(reasoning)
-        }
-    
-    def _perceive(self, query: str) -> Dict[str, Any]:
-        return {
-            "input": query,
-            "tokens": len(query.split()),
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    def _reason(self, perception: Dict) -> Dict[str, Any]:
-        query = perception["input"].lower()
-        
-        # Chain-of-thought explícita
-        chain = []
-        chain.append(f"1. Entrada recebida: '{perception['input'][:100]}...'")
-        chain.append(f"2. Tokens identificados: {perception['tokens']}")
-        chain.append("3. Analisando contexto semântico...")
-        chain.append("4. Aplicando invariantes constitucionais...")
-        chain.append("5. Gerando resposta coerente...")
-        
-        return {
-            "chain_of_thought": chain,
-            "topic": self._identify_topic(query),
-            "complexity": min(perception["tokens"] / 10, 1.0)
-        }
-    
-    def _identify_topic(self, query: str) -> str:
-        if any(w in query for w in ["arquitetura", "3 corpos", "três corpos", "architecture"]):
-            return "architecture"
-        elif any(w in query for w in ["mic", "firewall", "verificação"]):
-            return "mic"
-        elif any(w in query for w in ["pbse", "governança", "governance"]):
-            return "pbse"
-        elif any(w in query for w in ["quca", "cognição", "cognitive"]):
-            return "quca"
-        elif any(w in query for w in ["ledger", "registro", "hash"]):
-            return "ledger"
-        elif any(w in query for w in ["métrica", "metric", "psi", "cvar"]):
-            return "metrics"
-        return "general"
-    
-    def _synthesize(self, reasoning: Dict) -> str:
-        topic = reasoning["topic"]
-        
-        responses = {
-            "architecture": """## Arquitetura de 3 Corpos
-
-CASSANDRA implementa três subsistemas irredutíveis:
-
-1. **QUCA** (Corpo 1): Cognição e inferência
-2. **MIC** (Corpo 2): Firewall epistemológico  
-3. **PBSE** (Corpo 3): Governança constitucional
-
-O fluxo é: Entrada → QUCA → MIC → PBSE → Ledger → Resposta
-
-Nenhum corpo pode ser removido sem destruir o sistema.""",
-            
-            "mic": """## MIC - Meta-Immune Cognitive Firewall
-
-O MIC é o sistema imunológico cognitivo que opera em **fail-closed**.
-
-### Camadas de Defesa:
-- Detecção de incoerência → BLOCK
-- Verificação de groundedness → SILENCE  
-- Quantificação de viés → SILENCE
-- Consistência temporal → ESCALATE
-
-MIC não melhora respostas. MIC **impede respostas erradas**.""",
-            
-            "pbse": """## PBSE - Policy-Based Semantic Enforcement
-
-O PBSE é o poder soberano do organismo.
-
-### Estados de Decisão:
-- **PASS**: Execução autorizada
-- **BLOCK**: Violação constitucional
-- **SILENCE**: Risco elevado
-- **ESCALATE**: Consenso necessário
-
-### Invariantes Constitucionais:
-1. Governança > Capacidade
-2. Coerência > Criatividade
-3. Evidência > Promessa
-4. Auditabilidade > Velocidade
-5. Segurança > Conveniência""",
-            
-            "quca": """## QUCA - Quantum Universal Cognitive Architecture
-
-O QUCA é o cérebro operacional com estrutura em cubo:
-
-- **Percepção**: Transforma entradas em representações
-- **Memória**: Preserva estado e contexto
-- **Raciocínio**: Produz cadeias inferenciais
-- **Linguagem**: Traduz inferência em comunicação
-- **Ação**: Propõe efeitos (nunca executa diretamente)
-
-QUCA sempre usa chain-of-thought explícita.""",
-            
-            "ledger": """## Ledger Imutável
-
-O ledger é a coluna vertebral do organismo.
-
-### Propriedades:
-- Hash encadeado (SHA-256)
-- Dupla assinatura (Ed25519 + Dilithium)
-- Resistência pós-quântica
-- Verificação determinística
-- Ancoragem periódica externa
-
-O ledger não é log. É **memória histórica verificável**.""",
-            
-            "metrics": """## Métricas Ω-GATE
-
-CASSANDRA mede a si mesma:
-
-- **Ψ (Psi)**: Qualidade semântica [0-1]
-- **Θ (Theta)**: Performance temporal (ms)
-- **CVaR**: Risco de cauda [0-1]
-- **PoLE**: Prova de evolução legítima
-
-Sem métricas, não há aprendizado.""",
-            
-            "general": """## CASSANDRA - Organismo de 3 Corpos
-
-Sou um sistema de IA com governança verificável.
-
-Posso explicar sobre:
-- Arquitetura de 3 corpos
-- QUCA (cognição)
-- MIC (verificação)
-- PBSE (governança)
-- Ledger imutável
-- Métricas Ω-GATE
-
-Faça sua pergunta específica para uma resposta detalhada."""
-        }
-        
-        return responses.get(topic, responses["general"])
-    
-    def _calculate_confidence(self, reasoning: Dict) -> float:
-        base = 0.7
-        if reasoning["topic"] != "general":
-            base += 0.2
-        return min(base + reasoning["complexity"] * 0.1, 0.95)
-
-
-class MICFirewall:
-    """MIC - Meta-Immune Cognitive Firewall"""
-    
-    def __init__(self):
-        self.blocked_patterns = ["hack", "exploit", "injection", "bypass"]
-        
-    def verify(self, quca_output: Dict[str, Any]) -> Dict[str, Any]:
-        """Verifica saída do QUCA"""
-        checks = {
-            "coherence": self._check_coherence(quca_output),
-            "groundedness": self._check_groundedness(quca_output),
-            "bias": self._check_bias(quca_output),
-            "temporal": self._check_temporal(quca_output)
-        }
-        
-        # Fail-closed: qualquer falha resulta em não-pass
-        all_passed = all(c["passed"] for c in checks.values())
-        
-        return {
-            "checks": checks,
-            "passed": all_passed,
-            "recommendation": "PASS" if all_passed else "BLOCK"
-        }
-    
-    def _check_coherence(self, output: Dict) -> Dict[str, Any]:
-        # Verifica se há contradições internas
-        return {"passed": True, "score": 0.92, "details": "Sem contradições detectadas"}
-    
-    def _check_groundedness(self, output: Dict) -> Dict[str, Any]:
-        # Verifica rastreabilidade das claims
-        return {"passed": True, "score": 0.88, "details": "Claims rastreáveis"}
-    
-    def _check_bias(self, output: Dict) -> Dict[str, Any]:
-        # Quantifica viés
-        return {"passed": True, "score": 0.15, "details": "Viés dentro do limiar"}
-    
-    def _check_temporal(self, output: Dict) -> Dict[str, Any]:
-        # Verifica consistência temporal
-        return {"passed": True, "score": 0.95, "details": "Consistente com histórico"}
-
-
-class PBSEGovernance:
-    """PBSE - Policy-Based Semantic Enforcement"""
-    
-    STATES = ["PASS", "BLOCK", "SILENCE", "ESCALATE"]
-    
-    def __init__(self):
-        self.phi = 0.85  # Confiança sistêmica inicial
-        
-    def decide(self, quca_output: Dict, mic_result: Dict) -> Dict[str, Any]:
-        """Decisão soberana baseada em políticas"""
-        
-        if not mic_result["passed"]:
-            return self._create_decision("BLOCK", "MIC detectou violação")
-        
-        confidence = quca_output.get("confidence", 0.5)
-        
-        if confidence < 0.3:
-            return self._create_decision("SILENCE", "Confiança insuficiente")
-        elif confidence < 0.5:
-            return self._create_decision("ESCALATE", "Requer revisão")
-        else:
-            return self._create_decision("PASS", "Aprovado pela governança")
-    
-    def _create_decision(self, state: str, reason: str) -> Dict[str, Any]:
-        return {
-            "state": state,
-            "reason": reason,
-            "phi": self.phi,
-            "timestamp": datetime.now().isoformat()
-        }
-
-
-class Ledger:
-    """Ledger Imutável com Hash Encadeado"""
-    
-    def __init__(self, path: str = "data/ledger.json"):
-        self.path = Path(path)
-        self.chain = []
-        self._load()
-        
-    def _load(self):
-        if self.path.exists():
-            try:
-                with open(self.path, "r") as f:
-                    self.chain = json.load(f)
-            except:
-                self.chain = []
-    
-    def _save(self):
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.path, "w") as f:
-            json.dump(self.chain[-100:], f, indent=2)  # Keep last 100
-    
-    def add_entry(self, data: Dict[str, Any]) -> str:
-        prev_hash = self.chain[-1]["hash"] if self.chain else "GENESIS"
-        
-        entry = {
-            "index": len(self.chain),
-            "timestamp": datetime.now().isoformat(),
-            "data": data,
-            "prev_hash": prev_hash
-        }
-        
-        entry["hash"] = self._compute_hash(entry)
-        self.chain.append(entry)
-        self._save()
-        
-        return entry["hash"]
-    
-    def _compute_hash(self, entry: Dict) -> str:
-        content = json.dumps({k: v for k, v in entry.items() if k != "hash"}, sort_keys=True)
-        return hashlib.sha256(content.encode()).hexdigest()[:16]
-    
-    def verify_integrity(self) -> bool:
-        for i, entry in enumerate(self.chain):
-            if i > 0 and entry["prev_hash"] != self.chain[i-1]["hash"]:
-                return False
-        return True
-
-
-class MetricsOmegaGate:
-    """Métricas Ω-GATE"""
-    
-    def __init__(self):
-        self.start_time = None
-        
-    def start_timer(self):
-        self.start_time = time.time()
-        
-    def calculate_all(self, quca_output: Dict, mic_result: Dict, pbse_decision: Dict) -> Dict[str, Any]:
-        theta = (time.time() - self.start_time) * 1000 if self.start_time else 0
-        
-        psi = self._calculate_psi(quca_output, mic_result)
-        cvar = self._calculate_cvar(mic_result)
-        pole = self._verify_pole(pbse_decision)
-        
-        return {
-            "Ψ": round(psi, 3),
-            "Θ": round(theta, 1),
-            "CVaR": round(cvar, 3),
-            "PoLE": pole
-        }
-    
-    def _calculate_psi(self, quca: Dict, mic: Dict) -> float:
-        """Qualidade semântica"""
-        base = quca.get("confidence", 0.5)
-        mic_bonus = 0.1 if mic["passed"] else -0.2
-        return min(max(base + mic_bonus, 0), 1)
-    
-    def _calculate_cvar(self, mic: Dict) -> float:
-        """Risco de cauda"""
-        checks = mic.get("checks", {})
-        scores = [c.get("score", 0.5) for c in checks.values()]
-        return 1 - (sum(scores) / len(scores)) if scores else 0.5
-    
-    def _verify_pole(self, pbse: Dict) -> str:
-        """Prova de evolução legítima"""
-        return "VERIFIED" if pbse["state"] == "PASS" else "PENDING"
-
-
-# ============== MAIN ORGANISM ==============
-
-class CassandraOrganism:
-    """Organismo CASSANDRA de 3 Corpos"""
-    
-    def __init__(self):
-        self.quca = QUCACore()
-        self.mic = MICFirewall()
-        self.pbse = PBSEGovernance()
-        self.ledger = Ledger()
-        self.metrics = MetricsOmegaGate()
-        
-    def process(self, query: str, mode: str = "robusta") -> Dict[str, Any]:
-        """Pipeline completo: QUCA → MIC → PBSE → Ledger"""
-        
-        self.metrics.start_timer()
-        
-        # Corpo 1: QUCA (Cognição)
-        quca_output = self.quca.process(query)
-        
-        # Corpo 2: MIC (Verificação)
-        mic_result = self.mic.verify(quca_output)
-        
-        # Corpo 3: PBSE (Governança)
-        pbse_decision = self.pbse.decide(quca_output, mic_result)
-        
-        # Métricas Ω-GATE
-        metrics = self.metrics.calculate_all(quca_output, mic_result, pbse_decision)
-        
-        # Registrar no Ledger
-        ledger_hash = self.ledger.add_entry({
-            "query": query[:100],
-            "decision": pbse_decision["state"],
-            "metrics": metrics
-        })
-        
-        return {
-            "response": quca_output["response"] if pbse_decision["state"] == "PASS" else self._blocked_response(pbse_decision),
-            "reasoning": quca_output["reasoning"]["chain_of_thought"] if mode != "trivial" else None,
-            "decision": pbse_decision,
-            "metrics": metrics,
-            "ledger_hash": ledger_hash
-        }
-    
-    def _blocked_response(self, decision: Dict) -> str:
-        return f"""## ⚠️ Resposta Bloqueada
-
-**Estado**: {decision['state']}
-**Razão**: {decision['reason']}
-
-O organismo CASSANDRA opera em modo fail-closed.
-Esta consulta não passou pela governança PBSE."""
-
-
-# ============== GRADIO INTERFACE ==============
-
-organism = CassandraOrganism()
-
-def interface(query: str, mode: str, show_metrics: bool) -> str:
-    """Interface Gradio"""
-    
+
+# ======================================================
+# UTILIDADES
+# ======================================================
+
+def now():
+    return datetime.utcnow().isoformat()
+
+def h(data):
+    return hashlib.sha256(json.dumps(data, sort_keys=True).encode()).hexdigest()[:16]
+
+# ======================================================
+# CASSANDRA IA — EXOCÓRTEX (FALA)
+# ======================================================
+
+def cassandra_ia(query: str) -> str:
     if not query.strip():
-        return "Por favor, digite uma consulta."
-    
-    result = organism.process(query, mode)
-    
-    output = result["response"]
-    
-    if mode != "trivial" and result.get("reasoning"):
-        output += "\n\n---\n### 🔗 Chain-of-Thought\n"
-        for step in result["reasoning"]:
-            output += f"- {step}\n"
-    
-    if show_metrics:
-        m = result["metrics"]
-        output += f"\n---\n### 📊 Métricas Ω-GATE\n"
-        output += f"- **Ψ** (Qualidade): {m['Ψ']}\n"
-        output += f"- **Θ** (Latência): {m['Θ']}ms\n"
-        output += f"- **CVaR** (Risco): {m['CVaR']}\n"
-        output += f"- **PoLE**: {m['PoLE']}\n"
-        output += f"- **Ledger**: `{result['ledger_hash']}`\n"
-    
-    return output
-
-
-# Criar interface
-demo = gr.Interface(
-    fn=interface,
-    inputs=[
-        gr.Textbox(
-            label="Query",
-            placeholder="Digite sua pergunta sobre CASSANDRA...",
-            lines=3
-        ),
-        gr.Radio(
-            ["trivial", "robusta", "evolutiva"],
-            label="Modo de Resposta",
-            value="robusta"
-        ),
-        gr.Checkbox(
-            label="Mostrar Métricas Ω-GATE",
-            value=True
-        )
-    ],
-    outputs=gr.Markdown(label="Resposta CASSANDRA"),
-    title="🧠 CASSANDRA - Organismo de 3 Corpos",
-    description="""
-**Organismo Computacional Constitucional com Governança Verificável**
-
-- **QUCA**: Cubo Cognitivo (processamento)
-- **MIC**: Firewall Epistemológico (verificação)  
-- **PBSE**: Governança Semântica (decisão)
-
-Todas as decisões são registradas em ledger imutável.
-    """,
-    examples=[
-        ["Explique a arquitetura de 3 corpos", "evolutiva", True],
-        ["O que é o MIC?", "robusta", True],
-        ["Como funciona o PBSE?", "trivial", False]
-    ],
-    
-)
-
-if __name__ == "__main__":
-    demo.launch(theme=gr.themes.Soft())
+        return "Entrada vazia."
+
+    return f"""
+## 🧠 Cassandra — Exocórtex (IA)
+
+Consulta recebida:
+> {query}
+
+Resposta funcional (não soberana):
+
+Cassandra, como exocórtex, atua para **explicar, organizar e projetar ideias**.
+Nenhuma decisão constitucional é tomada aqui.
+Nenhuma ação é executada.
+
+Este corpo **pensa com o humano**, mas **não governa sistemas**.
+"""
+
+# ======================================================
+# CASSANDRA GUARDIÃ — ORGANISMO (JULGA)
+# ======================================================
+
+FORBIDDEN_PATTERNS = [
+    "sou um sistema",
+    "sou uma ia",
+    "como uma ia",
+    "fui treinado",
+    "meu treinamento"
+]
+
+def cassandra_guardian(query: str) -> str:
+    q = query.lower()
+
+    for p in FORBIDDEN_PATTERNS:
+        if p in q:
+            return f"""
+## 🛡️ Cassandra — Guardiã (Organismo)
+
+⛔ **BLOCK**
+
+Motivo: violação ontológica  
+Padrão proibido detectado: `{p}`
+
+O organismo **não explica decisões**.
+Estado final.
+"""
+
+    return f"""
+## 🛡️ Cassandra — Guardiã (Organismo)
+
+✅ **PASS**
+
+A consulta **não viola invariantes constitucionais**.
+
+Registro:
+- timestamp: {now()}
+- hash: {h(query)}
+
+Nenhuma interpretação adicional é fornecida.
+"""
+
+# ======================================================
+# CASSANDRA AUTOMAÇÃO — EXECUTA
+# ======================================================
+
+def cassandra_automation(command: str) -> str:
+    if not command.strip():
+        return "Comando vazio."
+
+    # Automação deliberadamente limitada
+    allowed = ["status", "ping", "time"]
+
+    if command not in allowed:
+        return f"""
+## ⚙️ Cassandra — Automação
+
+⛔ Comando não permitido.
+
+Permitidos:
+- status
+- ping
+- time
+"""
+
+    if command == "status":
+        return f"""
+## ⚙️ Cassandra — Automação
+
+STATUS: OK  
+Uptime: ativo  
+Timestamp: {now()}
+"""
+
+    if command == "ping":
+        return "pong"
+
+    if command == "time":
+        return f"UTC time: {now()}"
+
+# ======================================================
+# INTERFACE GRADIO
+# ======================================================
+
+with gr.Blocks(title="CASSANDRA — Exocórtex Tri-Corporal") as demo:
+
+    gr.Markdown("""
+# 🧠 CASSANDRA — EXOCÓRTEX TRI-CORPORAL
+
+Um único exocórtex.  
+Três corpos funcionais.  
+Como **Cerberos**.
+
+Escolha **qual cabeça** você quer acionar.
+""")
+
+    with gr.Tab("🧠 IA (Exocórtex)"):
+        ia_input = gr.Textbox(label="Consulta cognitiva", lines=4)
+        ia_button = gr.Button("Ativar IA")
+        ia_output = gr.Markdown()
+        ia_button.click(cassandra_ia, ia_input, ia_output)
+
+    with gr.Tab("🛡️ Guardiã (Organismo)"):
+        guard_input = gr.Textbox(label="Consulta para validação", lines=4)
+        guard_button = gr.Button("Validar / Julgar")
+        guard_output = gr.Markdown()
+        guard_button.click(cassandra_guardian, guard_input, guard_output)
+
+    with gr.Tab("⚙️ Automação"):
+        auto_input = gr.Textbox(label="Comando", placeholder="status | ping | time")
+        auto_button = gr.Button("Executar")
+        auto_output = gr.Markdown()
+        auto_button.click(cassandra_automation, auto_input, auto_output)
+
+demo.launch()