Add top-level files for Cassandra organism

CONSTITUTION.md

@@ -0,0 +1,42 @@
+# Constituição do Organismo Cassandra
+
+Este documento define os princípios e as regras básicas que regem todas as operações do organismo digital Cassandra.
+
+## Princípios Fundamentais
+
+1. **Governança > Capacidade**  
+   O sistema prioriza a governança e as políticas constitucionais sobre qualquer ganho de performance ou capacidade de processamento.
+
+2. **Coerência > Criatividade**  
+   Respostas devem ser corretas e consistentes antes de se preocuparem com a criatividade.  
+   Alucinações, contradições internas ou incoerências são bloqueadas.
+
+3. **Evidência > Promessa**  
+   Afirmações feitas pelo sistema devem ser baseadas em evidências verificáveis ou fontes rastreáveis.  
+   O sistema nunca entrega promessas vazias ou afirmações infundadas.
+
+4. **Auditabilidade > Velocidade**  
+   Toda decisão é registrada no ledger imutável.  
+   A transparência e a capacidade de auditabilidade superam a necessidade de respostas rápidas.
+
+5. **Segurança > Conveniência**  
+   Nenhuma operação que viole políticas de segurança deve ocorrer, mesmo que seja mais conveniente ou mais rápida.
+
+## Invariantes Constitucionais
+
+Estes invariantes devem ser verificados antes de qualquer mudança arquitetônica ou de função:
+
+* **Integridade do Ledger** — O ledger precisa ser imutável, assinando cada entrada com chaves criptográficas válidas e garantindo hash encadeado.  
+* **Integridade da Governança** — As políticas de decisão (PBSE) não podem ser alteradas sem revisão constitucional.  
+* **Integridade do MIC** — O firewall epistemológico não pode ser contornado.  
+* **Fail‑Closed** — Qualquer falha ou resultado indecidível deve resultar em bloqueio ou silêncio, nunca em execução.
+* **Traço de Evidência** — Toda interação relevante deve deixar um traço auditável.
+
+## Atualizações da Constituição
+
+Alterações neste documento exigem:
+
+1. **Justificativa Formal** de por que a mudança é necessária.  
+2. **Prova de Segurança** de que os invariantes são mantidos ou estendidos.  
+3. **Revisão por Pares** — Revisão humana ou multi‑agente para consenso.  
+4. **Registro Público** — Ancoragem no ledger de todas as mudanças.

README.md

@@ -1,14 +1,57 @@
----
-title: Cassandra Organism
-emoji: 👁
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Organismo digital Cassandra de três corpos com governança, M
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Casssandra Organism
+
+**Cassandra Organism** é um exemplo de implementação do modelo cognitivo de três corpos descrito no prompt.  
+Esta implementação em Python visa ser um ponto de partida para a criação de um organismo digital soberano com governança, imunidade e cognição bem definidas. O projeto foi concebido para ser executado como um Space no Hugging Face usando Gradio como interface de usuário.
+
+## Estrutura do Projeto
+
+```
+cassandra-organism/
+├── app.py                # Interface Gradio e bootstrap do organismo
+├── requirements.txt      # Dependências Python
+├── README.md             # Este arquivo de documentação
+├── CONSTITUTION.md       # Invariantes e princípios constitucionais
+├── core/                 # Código principal do organismo
+│   ├── __init__.py
+│   ├── quca.py           # Implementação do Cubo Cognitivo (QUCA)
+│   ├── mic.py            # Implementação do firewall epistemológico (MIC)
+│   ├── pbse.py           # Implementação da governança (PBSE)
+│   ├── ledger.py         # Ledger imutável com assinaturas
+│   ├── metrics.py        # Cálculo das métricas Ψ, Θ, CVaR e PoLE
+│   ├── cfc.py            # Analisador de acoplamento de frequências cognitivas
+│   └── evolution.py      # Matriz de autoevolução controlada
+├── data/
+│   ├── ledger.json       # Ledger inicial vazio
+│   └── keys/             # Chaves criptográficas (poderão ser geradas em tempo de execução)
+└── docs/
+    └── ARCHITECTURE.md   # Descrição da arquitetura (não implementado neste exemplo)
+```
+
+## Como Executar Localmente
+
+1. Crie um ambiente virtual Python 3.11 ou superior:
+
+   ```bash
+   python3 -m venv .venv
+   source .venv/bin/activate
+   pip install --upgrade pip
+   ```
+
+2. Instale as dependências listadas em `requirements.txt`:
+
+   ```bash
+   pip install -r cassandra-organism/requirements.txt
+   ```
+
+3. Execute a aplicação Gradio localmente:
+
+   ```bash
+   python cassandra-organism/app.py
+   ```
+
+4. Acesse a interface em `http://localhost:7860` no seu navegador para interagir com o organismo.
+
+## Observações
+
+* Este projeto é um protótipo funcional e serve como exemplo. Para uso em produção, recomenda‑se adicionar persistência apropriada das chaves, conexões reais de PQC, ancoragens em blockchain e melhorias na análise de métricas.
+* O código foi escrito de forma didática para demonstrar os principais conceitos descritos no prompt, como falha fechada, governança verificável e memória histórica.

app.py

@@ -0,0 +1,180 @@
+"""Interface Gradio para o organismo Cassandra.
+
+Este script inicializa o organismo, carrega ou cria o ledger e expõe uma
+interface Web usando Gradio. O usuário pode interagir com o organismo
+fornecendo uma query e escolhendo o modo de resposta (trivial, robusta
+ou evolutiva). Métricas do Ω‑GATE podem ser exibidas opcionalmente.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any, Dict
+
+import gradio as gr
+
+from core import (
+    QUCACore,
+    MICFirewall,
+    PBSEGovernance,
+    ImmutableLedger,
+    QualityIndex,
+    PerformanceScore,
+    RiskAssessment,
+    EvolutionProof,
+    CFCAnalyzer,
+    MatrizAutoevolutiva,
+)
+
+
+class CASSANDRAOrganism:
+    """Organismo Digital de 3 Corpos.
+
+    Une QUCA (cognição), MIC (imunidade) e PBSE (governança) em um fluxo
+    completo que processa a entrada, aplica verificações, decide e registra.
+    """
+
+    def __init__(self) -> None:
+        # cria diretório de dados se não existir
+        data_path = os.path.join(os.path.dirname(__file__), "data")
+        os.makedirs(data_path, exist_ok=True)
+        ledger_path = os.path.join(data_path, "ledger.json")
+        self.ledger = ImmutableLedger(path=ledger_path)
+        # inicializa corpos
+        self.quca = QUCACore()
+        self.mic = MICFirewall()
+        # invariantes constitucionais carregados a partir de constituição
+        invariants = [
+            "Governança > Capacidade",
+            "Coerência > Criatividade",
+            "Evidência > Promessa",
+            "Auditabilidade > Velocidade",
+            "Segurança > Conveniência",
+        ]
+        self.pbse = PBSEGovernance(self.ledger, invariants)
+        # métricas
+        self.metrics_tools = {
+            "Ψ": QualityIndex(),
+            "Θ": PerformanceScore(),
+            "CVaR": RiskAssessment(),
+            "PoLE": EvolutionProof(),
+        }
+        # análises adicionais
+        self.cfc = CFCAnalyzer()
+        self.evolution = MatrizAutoevolutiva()
+
+    async def process_request(self, user_input: str, mode: str = "robusta") -> Dict[str, Any]:
+        """Executa o pipeline completo e retorna a resposta estruturada.
+
+        Parâmetros:
+            user_input: texto fornecido pelo usuário
+            mode: trivial, robusta ou evolutiva
+
+        Retorna:
+            Um dicionário com campos adequados à interface.
+        """
+        # inicia cronômetro da métrica de performance
+        perf = self.metrics_tools["Θ"]
+        perf.start()
+        # Fase 1: QUCA
+        reasoning = self.quca.process(user_input)
+        # Fase 2: MIC
+        mic_result = self.mic.verify(reasoning)
+        # Fase 3: PBSE
+        pbse_decision = self.pbse.decide(reasoning, mic_result)
+        # Fase 4: calcular métricas
+        psi = self.metrics_tools["Ψ"].calculate(reasoning)
+        theta = perf.measure()
+        cvar = self.metrics_tools["CVaR"].assess(mic_result)
+        pole = self.metrics_tools["PoLE"].verify(self.ledger)
+        metrics = {"Ψ": psi, "Θ": theta, "CVaR": cvar, "PoLE": pole}
+        # Fase 5: armazenar em memória (se passo) 
+        if pbse_decision.status == "PASS":
+            embedding = self.quca.extract_features(user_input)
+            self.quca.store_in_memory(user_input, reasoning, reasoning, embedding)
+        # Estruturar resposta
+        if pbse_decision.status == "BLOCK":
+            return {
+                "status": "BLOCKED",
+                "reason": pbse_decision.reason or "Bloqueado pelo sistema",
+                "metrics": metrics,
+            }
+        if pbse_decision.status == "SILENCE":
+            return {
+                "status": "SILENCE",
+                "reason": pbse_decision.reason or "Risco elevado",
+                "metrics": metrics,
+            }
+        if pbse_decision.status == "ESCALATE":
+            return {
+                "status": "ESCALATE",
+                "reason": pbse_decision.reason or "Revisão necessária",
+                "metrics": metrics,
+            }
+        # Resposta normal
+        response = {
+            "trivial": f"Resumo: {reasoning[:100]}...",
+            "robusta": f"Raciocínio: {reasoning}\n\nMétricas: Ψ={psi:.3f}, Θ={theta:.1f}ms, CVaR={cvar:.3f}, PoLE={pole}",
+            "evolutiva": "Esta implementação simples não fornece recomendações evolutivas.",
+            "metrics": metrics,
+        }
+        return {
+            "status": "PASS",
+            "response": response,
+        }
+
+
+def build_interface() -> gr.Interface:
+    organism = CASSANDRAOrganism()
+
+    async def inference(query: str, mode: str, show_metrics: bool) -> str:
+        result = await organism.process_request(query, mode)
+        if result["status"] != "PASS":
+            return f"Status: {result['status']}\nMotivo: {result['reason']}"
+        resp = result["response"]
+        out = ""
+        if mode == "trivial":
+            out += f"## Síntese Trivial\n{resp['trivial']}\n"
+        elif mode == "robusta":
+            out += f"## Síntese Trivial\n{resp['trivial']}\n\n"
+            out += f"## Formalismo Robusto\n{resp['robusta']}\n"
+        else:  # evolutiva
+            out += f"## Síntese Trivial\n{resp['trivial']}\n\n"
+            out += f"## Formalismo Robusto\n{resp['robusta']}\n\n"
+            out += f"## Análise Evolutiva\n{resp['evolutiva']}\n"
+        if show_metrics:
+            m = result["response"]["metrics"]
+            out += "\n---\n### Métricas Ω‑GATE\n"
+            out += f"- Ψ: {m['Ψ']:.3f}\n"
+            out += f"- Θ: {m['Θ']:.1f}ms\n"
+            out += f"- CVaR: {m['CVaR']:.3f}\n"
+            out += f"- PoLE: {m['PoLE']}\n"
+        return out
+
+    return gr.Interface(
+        fn=inference,
+        inputs=[
+            gr.Textbox(label="Query", lines=3, placeholder="Digite sua pergunta ou comando..."),
+            gr.Radio(["trivial", "robusta", "evolutiva"], label="Modo de Resposta", value="robusta"),
+            gr.Checkbox(label="Mostrar Métricas", value=True),
+        ],
+        outputs=gr.Markdown(label="Resposta Cassandra"),
+        title="🔮 Cassandra — Organismo de 3 Corpos",
+        description=(
+            "Organismo computacional com cognição, imunidade e governança."
+            " Todas as respostas são verificadas e auditadas."
+        ),
+        examples=[
+            ["Explique a arquitetura de 3 corpos", "evolutiva", True],
+            ["O que é falha fechada?", "trivial", True],
+            ["Quais são os invariantes constitucionais?", "robusta", False],
+        ],
+        theme=gr.themes.Monochrome(),
+    )
+
+
+if __name__ == "__main__":
+    # Executa a aplicação Gradio
+    iface = build_interface()
+    iface.launch()

requirements.txt

@@ -0,0 +1,13 @@
+gradio==4.16.0
+cryptography==42.0.0
+numpy==1.26.3
+scipy==1.12.0
+networkx==3.2.1
+sentence-transformers==2.3.1
+faiss-cpu==1.7.4
+prometheus-client==0.19.0
+python-dotenv==1.0.0
+
+# Opcional: para execução assíncrona e servidor FastAPI se for integrar API HTTP
+fastapi==0.109.0
+uvicorn[standard]==0.27.0