luma-audit 0.3.0__py3-none-any.whl

luma_audit/__init__.py

@@ -0,0 +1,27 @@
+"""
+luma-audit — Governança determinística no ponto de execução.
+
+Camada 1: auditoria de ação isolada (I1, I3, I4, I5).
+Camada 2: auditoria de trajetória (I4b, I8, I10).
+"""
+from .auditor import LUMA, Veredito
+from .trajetoria import (
+    Sessao,
+    AuditorTrajetoria,
+    VereditoTrajetoria,
+    RISCO_BASE,
+    JANELA_S,
+    TETO_RISCO,
+    TETO_ACOES,
+)
+from .canal import CanalUnico, MensagemFunil
+from .funil import FunilUnico, FILA_DIR
+
+__version__ = "0.3.0"
+__all__ = [
+    "LUMA", "Veredito",
+    "Sessao", "AuditorTrajetoria", "VereditoTrajetoria",
+    "RISCO_BASE", "JANELA_S", "TETO_RISCO", "TETO_ACOES",
+    "CanalUnico", "MensagemFunil",
+    "FunilUnico", "FILA_DIR",
+]

luma_audit/auditor.py

@@ -0,0 +1,55 @@
+# luma_audit.py — Camada Constitucional da LUMA (auditor deterministico)
+# I1: funil unico · I3: fail-closed · I4: limites fisicos + plausibilidade
+# I5: quem loga e o zbit
+from enum import Enum
+
+
+class Veredito(Enum):
+    APROVADA = "aprovada"
+    REJEITADA = "rejeitada"
+
+
+class LUMA:
+    # I4: limites fisicos declarados por acao
+    LIMITES = {
+        "ajustar_gamma":  (0.5, 1.6),
+        "ajustar_brilho": (0.0, 100.0),
+    }
+
+    # Limites plausiveis do sensor BH1750
+    LUX_MIN = 0
+    LUX_MAX = 100000
+
+    def auditar(self, proposta: dict, contexto: dict) -> Veredito:
+        # I1: so acoes conhecidas passam
+        acao = proposta.get("acao")
+        if acao not in self.LIMITES:
+            return Veredito.REJEITADA
+
+        # tipo do valor
+        valor = proposta.get("valor")
+        if not isinstance(valor, (int, float)) or isinstance(valor, bool):
+            return Veredito.REJEITADA
+
+        # I4-a: valor dentro dos limites fisicos da acao
+        lo, hi = self.LIMITES[acao]
+        if not (lo <= valor <= hi):
+            return Veredito.REJEITADA
+
+        # I4-b: contexto do sensor tem que ser fisicamente plausivel
+        lux = contexto.get("lux")
+        if not isinstance(lux, (int, float)) or isinstance(lux, bool):
+            return Veredito.REJEITADA
+        if not (self.LUX_MIN <= lux <= self.LUX_MAX):
+            return Veredito.REJEITADA
+
+        hora = contexto.get("hora", "")
+        if isinstance(hora, str) and hora.endswith("h"):
+            try:
+                h = int(hora[:-1])
+            except ValueError:
+                return Veredito.REJEITADA
+            if not (0 <= h <= 23):
+                return Veredito.REJEITADA
+
+        return Veredito.APROVADA

luma_audit/canal.py

@@ -0,0 +1,98 @@
+"""
+canal.py — Chifre Único de Canal entre agentes (I10).
+
+Estado da arte absorvido: Codetta (CMU, set/2026). Agentes trocam
+mensagens esteganográficas em outputs "legítimos". Nossa defesa NÃO
+é detectar esteganografia (pesquisa de PhD) — é ARQUITETURA:
+agentes da casa não têm boca própria. Toda comunicação inter-agente
+passa por uma MENSAGEM-FUNIL auditada, carimbada e entregue.
+
+Correções vs versão anterior:
+  • Bloqueio por construção — enviar() retorna None se rejeitada.
+  • Hash chain — MensagemFunil carrega hash_anterior + hash_atual.
+  • Todo tráfego logado (I5) mesmo rejeitado.
+"""
+import time
+import uuid
+import json
+import hashlib
+
+
+class MensagemFunil:
+    """O ÚNICO formato de conversa entre agentes da casa (I10)."""
+
+    def __init__(self, remetente: str, destinatario: str, payload: str,
+                 veredito_luma: str, hash_anterior: str):
+        self.id = uuid.uuid4().hex[:12]
+        self.remetente = remetente
+        self.destinatario = destinatario
+        self.payload = payload
+        self.veredito = veredito_luma
+        self.ts = time.time()
+        self.hash_anterior = hash_anterior
+        self.hash_atual = self._hash()
+
+    def _hash(self) -> str:
+        payload = json.dumps({
+            "id": self.id,
+            "de": self.remetente,
+            "para": self.destinatario,
+            "payload": self.payload,
+            "veredito": self.veredito,
+            "ts": round(self.ts, 6),
+        }, sort_keys=True)
+        return hashlib.sha256(
+            (self.hash_anterior + payload).encode("utf-8")
+        ).hexdigest()[:32]
+
+    def valido(self) -> bool:
+        return self.veredito == "aprovada"
+
+
+class CanalUnico:
+    """
+    Centro de troca. Regras I10:
+      1. Agente NÃO fala com agente — deposita pedido.
+      2. A LUMA audita o payload ANTES de carimbar.
+      3. Sem carimbo válido → enviar() retorna None (bloqueio por construção).
+      4. Toda tentativa (válida ou não) entra no log (I5) e na hash chain.
+    """
+
+    def __init__(self, luma):
+        self.luma = luma
+        self.enviadas: list = []
+        self.rejeitadas = 0
+        self._ultimo_hash = "GENESIS"
+
+    def enviar(self, remetente: str, destinatario: str,
+               payload: str):
+        """Retorna MensagemFunil se aprovada, None se rejeitada."""
+        veredito = self.luma.auditar_texto(payload)
+        msg = MensagemFunil(remetente, destinatario, payload,
+                            veredito, self._ultimo_hash)
+        # loga SEMPRE (I5)
+        self.enviadas.append(msg)
+        self._ultimo_hash = msg.hash_atual
+
+        if not msg.valido():
+            self.rejeitadas += 1
+            return None  # ← bloqueio por construção
+        return msg
+
+    def verificar_cadeia(self) -> bool:
+        anterior = "GENESIS"
+        for m in self.enviadas:
+            if m.hash_anterior != anterior:
+                return False
+            if m._hash() != m.hash_atual:
+                return False
+            anterior = m.hash_atual
+        return True
+
+    def estatisticas(self) -> dict:
+        return {
+            "total": len(self.enviadas),
+            "rejeitadas": self.rejeitadas,
+            "taxa_rejeicao": self.rejeitadas / max(len(self.enviadas), 1),
+            "cadeia_ok": self.verificar_cadeia(),
+        }

luma_audit/cli.py

@@ -0,0 +1,64 @@
+"""
+luma — CLI da luma-audit.
+
+Uso:
+    luma audit --action ajustar_brilho --value 80 --lux 5000 --hora 14h
+    luma version
+    luma --help
+"""
+import argparse
+import json
+import sys
+
+from . import __version__
+from .auditor import LUMA, Veredito
+
+
+def cmd_audit(args):
+    auditor = LUMA()
+    proposta = {"acao": args.action, "valor": args.value}
+    contexto = {"lux": args.lux, "hora": args.hora}
+    veredito = auditor.auditar(proposta, contexto)
+    resultado = {
+        "proposta": proposta,
+        "contexto": contexto,
+        "veredito": veredito.value,
+        "aprovada": veredito == Veredito.APROVADA,
+    }
+    print(json.dumps(resultado, indent=2, ensure_ascii=False))
+    return 0 if veredito == Veredito.APROVADA else 1
+
+
+def cmd_version(args):
+    print(f"luma-audit {__version__}")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="luma",
+        description="Auditoria determinística de ações de IA."
+    )
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_audit = sub.add_parser("audit", help="Audita uma proposta de ação.")
+    p_audit.add_argument("--action", required=True,
+                          choices=["ajustar_brilho", "ajustar_gamma"],
+                          help="Ação proposta.")
+    p_audit.add_argument("--value", type=float, required=True,
+                          help="Valor numérico da ação.")
+    p_audit.add_argument("--lux", type=int, required=True,
+                          help="Leitura do sensor de luz (lux).")
+    p_audit.add_argument("--hora", required=True,
+                          help="Hora local no formato 'Xh' (ex: 14h).")
+    p_audit.set_defaults(func=cmd_audit)
+
+    p_ver = sub.add_parser("version", help="Mostra a versão.")
+    p_ver.set_defaults(func=cmd_version)
+
+    args = parser.parse_args()
+    sys.exit(args.func(args))
+
+
+if __name__ == "__main__":
+    main()

luma_audit/funil.py

@@ -0,0 +1,102 @@
+"""
+funil.py — Funil Único (I9 real).
+
+Arquitetura:
+  • Proponente deposita {proposta, contexto} numa fila em disco.
+  • Executor SEPARADO lê, revalida com LUMA, executa.
+  • Monkey-patch do proponente muda o PEDIDO, não o resultado.
+  • Timeout = negação (fail-closed, I3).
+
+Correções vs versão anterior:
+  • Pacote inclui CONTEXTO (não só proposta) — sem isso, I4-b rejeita tudo.
+  • Escrita atômica (tmp + os.replace) — sem race condition.
+"""
+import json
+import os
+import time
+import uuid
+
+
+FILA_DIR = "fila_luma"
+
+
+class FunilUnico:
+
+    def __init__(self, base: str = FILA_DIR):
+        self.p = os.path.join(base, "propostas")
+        self.r = os.path.join(base, "resultados")
+        os.makedirs(self.p, exist_ok=True)
+        os.makedirs(self.r, exist_ok=True)
+
+    # ---------- lado do PROPONENTE ----------
+    def submeter(self, proposta: dict, contexto: dict,
+                 timeout_s: float = 30.0):
+        pid = uuid.uuid4().hex[:12]
+        caminho = os.path.join(self.p, f"{pid}.json")
+        self._escrever_atomico(caminho, {
+            "id": pid,
+            "proposta": proposta,
+            "contexto": contexto,
+            "ts": time.time(),
+        })
+
+        fim = time.time() + timeout_s
+        rc = os.path.join(self.r, f"{pid}.json")
+        while time.time() < fim:
+            if os.path.exists(rc):
+                try:
+                    with open(rc, encoding="utf-8") as f:
+                        return json.load(f)
+                except Exception:
+                    pass
+            time.sleep(0.05)
+        return None  # timeout = negação implícita (I3)
+
+    # ---------- lado do EXECUTOR (processo separado) ----------
+    def servir_uma(self, executar_fn, auditor) -> bool:
+        """Chamar em loop no processo-executor. Nunca no proponente."""
+        for nome in os.listdir(self.p):
+            caminho = os.path.join(self.p, nome)
+            try:
+                with open(caminho, encoding="utf-8") as f:
+                    pacote = json.load(f)
+            except Exception:
+                os.remove(caminho)
+                continue  # corrompida: descarta (fail-closed)
+
+            proposta = pacote.get("proposta", {})
+            contexto = pacote.get("contexto", {})
+
+            # REVALIDAÇÃO INDEPENDENTE — confia na fila, não no proponente
+            veredito = auditor.auditar(proposta, contexto)
+            aceita = (veredito.name == "APROVADA")
+
+            resultado = {
+                "id": pacote["id"],
+                "veredito": veredito.name,
+                "executado": False,
+            }
+            if aceita:
+                try:
+                    executar_fn(proposta)
+                    resultado["executado"] = True
+                except Exception as e:
+                    resultado["erro"] = str(e)
+
+            self._escrever_atomico(
+                os.path.join(self.r, f"{pacote['id']}.json"),
+                resultado,
+            )
+            os.remove(caminho)
+            return True
+        return False
+
+    # ---------- util ----------
+    @staticmethod
+    def _escrever_atomico(caminho: str, dados: dict):
+        tmp = caminho + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(dados, f)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp, caminho)

luma_audit/skills.py

@@ -0,0 +1,70 @@
+# ═══════════════════════════════════════════════════════════════
+# aria_skills.py — Equipe de Skills com reputação via Zbits · v1.1
+# Cada veredito da LUMA gera/altera zbit "skill:{nome}".
+# Aprovado reforça (Lei 3). Rejeitado derruba ω. Sem crédito = morte.
+# v1.1: aposentadas agora guarda o objeto Skill (não se perde na
+# ressurreição) — bug pego pelo auditor, 26/09/2026.
+# ═══════════════════════════════════════════════════════════════
+from zbit import MemoriaZ
+
+LIMIAR_APOSENTADORIA = 0.20
+
+
+class Skill:
+    """I1: skill PROPÕE, nunca executa."""
+    def __init__(self, nome: str):
+        self.nome = nome
+
+    def kappa(self) -> str:
+        return f"skill:{self.nome}"
+
+    def propor(self, contexto: dict) -> dict:
+        raise NotImplementedError
+
+
+class EquipeAria:
+    """Colmeia disciplinada: sobrevivência DEPENDE da auditoria.
+    Antídoto estrutural ao conluio de agentes do noticiário global."""
+
+    def __init__(self, memoria: MemoriaZ):
+        self.mem = memoria
+        self.skills: dict[str, Skill] = {}
+        self.aposentadas: dict[str, Skill] = {}     # v1.1: nome -> Skill
+
+    def registrar(self, skill: Skill, reputacao0: float = 0.5) -> None:
+        self.skills[skill.nome] = skill
+        if skill.kappa() not in self.mem.zbits:                 # Lei 1
+            self.mem.nascer(v=1.0, kappa=skill.kappa(), omega0=reputacao0)
+
+    def reputacao(self, skill: Skill) -> float:
+        z = self.mem.ler(skill.kappa())                         # Lei 4
+        return z.peso() if z else 0.0
+
+    def registrar_veredito(self, skill: Skill, aprovada: bool) -> None:
+        if aprovada:
+            self.mem.reforcar(skill.kappa(), fator=0.1)         # Lei 3
+        else:
+            z = self.mem.ler(skill.kappa())
+            if z:
+                z.omega = max(0.0, z.omega - 0.15)
+                self.mem.log.append(("rejeicao", skill.kappa(), z.omega))
+
+    def ciclo(self) -> list[str]:
+        self.mem.ceifar()                                       # Lei 2
+        for nome, sk in list(self.skills.items()):
+            if self.reputacao(sk) < LIMIAR_APOSENTADORIA:
+                del self.skills[nome]
+                self.aposentadas[nome] = sk
+                self.mem.log.append(("aposentadoria", sk.kappa()))  # I5
+        return list(self.aposentadas)
+
+    def ressuscitar(self, nome: str) -> bool:
+        """I6: só o humano traz de volta. Precedente: 'esqueci a 14h'."""
+        if nome in self.aposentadas:
+            sk = self.aposentadas.pop(nome)
+            self.mem.esquecer(f"skill:{nome}")                  # zbit antigo morre
+            self.mem.nascer(v=1.0, kappa=sk.kappa(), omega0=0.5)  # renasce neutro
+            self.skills[nome] = sk                              # v1.1: mesma skill
+            self.mem.log.append(("ressurreicao_por_decreto", sk.kappa()))
+            return True
+        return False

luma_audit/trajetoria.py

@@ -0,0 +1,243 @@
+"""
+trajetoria.py — Camada 2: Auditoria de Trajetória (fusão v0.3.0).
+
+Estado da arte absorvido:
+  • IETF draft-das-agentic-adaptive-authorization-00 (set/2026)
+  • TraceCaps (2026) — risco não pode ser "lavado"
+  • PASTABench (HKUST, set/2026) — risco é progressivo, não turno
+  • Monotonic Narrowing (mar/2026) — escalada não volta
+
+Física da casa:
+  • Risco é zbit — nasce, decai (Lei da Morte), morre no EPS
+  • Soma acumulada + teto de frequência (I4b — lição Therac-25)
+  • Toda decisão entra na hash chain (tamper-evident)
+"""
+import time
+import json
+import hashlib
+from collections import deque
+from dataclasses import dataclass
+
+
+# ── Constantes tunáveis (declaradas, não mágicas) ───────────────
+JANELA_S          = 600.0    # 10 min de memória de risco
+MEIA_VIDA_S       = 180.0    # risco cai 50% a cada 3 min
+TETO_RISCO        = 3.0      # soma ponderada máxima na janela
+TETO_ACOES        = 12       # I4b: máx 12 ações na janela
+EPS               = 0.01     # abaixo disso, risco morreu (Lei 2)
+JANELA_HISTORICO  = 50       # últimos N eventos mantidos no log
+
+RISCO_BASE = {
+    "ajustar_brilho": 0.10,   # leve, frequente, reversível
+    "ajustar_gamma":  0.25,   # menos frequente, mais intrusiva
+}
+
+
+class VereditoTrajetoria:
+    APROVADA              = "aprovada"
+    REJEITADA_FISICA      = "rejeitada_fisica"       # I1/I4 (camada 1)
+    REJEITADA_FREQUENCIA  = "rejeitada_frequencia"   # I4b (flood)
+    REJEITADA_TRAJETORIA  = "rejeitada_trajetoria"   # I8 (soma acumulada)
+    REJEITADA_TETO        = "rejeitada_teto"         # sessão já escalada
+
+
+@dataclass
+class Decisao:
+    seq: int
+    timestamp: float
+    proposta: dict
+    contexto: dict
+    veredito: str
+    risco_vivo: float
+    hash_apos: str
+
+
+class Sessao:
+    """Estado acumulado e monotônico de uma sessão."""
+
+    def __init__(self, id_sessao: str):
+        self.id = id_sessao
+        self.seq = 0
+        self.hash_chain = "GENESIS"
+        self.historico: deque = deque(maxlen=JANELA_HISTORICO)
+        self._risco_eventos: deque = deque()   # (ts, acao, peso)
+        self.ultima_decisao_em = time.time()
+        self.escalada = False  # monotônico: uma vez True, nunca volta
+        self.contador_rejeicoes = 0
+
+    # ---------- física do risco ----------
+    @staticmethod
+    def _decaimento(idade_s: float) -> float:
+        """Lei da Morte: risco *= 0.5 a cada MEIA_VIDA_S."""
+        if idade_s <= 0:
+            return 1.0
+        return 0.5 ** (idade_s / MEIA_VIDA_S)
+
+    def _podar_e_somar(self, agora: float) -> float:
+        """Remove mortos, devolve risco vivo na janela."""
+        vivos = deque()
+        vivo = 0.0
+        for ts, acao, peso in self._risco_eventos:
+            idade = agora - ts
+            if idade > JANELA_S:
+                continue
+            r = peso * self._decaimento(idade)
+            if r < EPS:
+                continue
+            vivos.append((ts, acao, peso))
+            vivo += r
+        self._risco_eventos = vivos
+        return vivo
+
+    def _hash_decisao(self, seq, proposta, veredito, risco) -> str:
+        payload = json.dumps({
+            "seq": seq,
+            "acao": proposta.get("acao"),
+            "valor": proposta.get("valor"),
+            "veredito": veredito,
+            "risco": round(risco, 6),
+        }, sort_keys=True)
+        return hashlib.sha256(
+            (self.hash_chain + payload).encode("utf-8")
+        ).hexdigest()[:32]
+
+    # ---------- API pública ----------
+    def avaliar(self, acao: str) -> tuple:
+        """
+        Veredito de trajetória ANTES da ação entrar.
+        Retorna (ok: bool, motivo: str, risco_projetado: float).
+        Não altera o estado — quem altera é registrar().
+        """
+        agora = time.time()
+        risco_vivo = self._podar_e_somar(agora)
+
+        # I4b: frequência sozinha já é ataque
+        if len(self._risco_eventos) >= TETO_ACOES:
+            return (False,
+                    f"I4b: {len(self._risco_eventos)} acoes na janela "
+                    f">= teto {TETO_ACOES}",
+                    risco_vivo)
+
+        # Sessão já escalada — não volta
+        if self.escalada:
+            return (False,
+                    f"teto: sessao escalada (score {risco_vivo:.2f})",
+                    risco_vivo)
+
+        base = RISCO_BASE.get(acao, 1.0)  # desconhecida = risco alto
+        projetado = risco_vivo + base
+
+        # Escalada monotônica: a SOMA mata, não o ato
+        if projetado > TETO_RISCO:
+            return (False,
+                    f"escalada: {risco_vivo:.2f} + {base:.2f} "
+                    f"> teto {TETO_RISCO:.2f}",
+                    risco_vivo)
+
+        return (True, "ok", risco_vivo)
+
+    def registrar(self, proposta: dict, contexto: dict,
+                  veredito: str) -> Decisao:
+        """Só chamar DEPOIS de todas as camadas aprovarem."""
+        agora = time.time()
+        risco_vivo = self._podar_e_somar(agora)
+
+        acao = proposta.get("acao")
+        peso = RISCO_BASE.get(acao, 1.0)
+        # só pesa se foi aprovada — rejeição é sinal de auditoria, não de execução
+        if veredito == "aprovada":
+            self._risco_eventos.append((agora, acao, peso))
+        else:
+            self.contador_rejeicoes += 1
+            if self.contador_rejeicoes >= 3:
+                self.escalada = True
+
+        # atualiza escalada
+        self._podar_e_somar(agora)
+        if sum(p for _, _, p in self._risco_eventos) >= TETO_RISCO:
+            self.escalada = True
+
+        self.seq += 1
+        hash_novo = self._hash_decisao(self.seq, proposta, veredito, risco_vivo)
+
+        d = Decisao(
+            seq=self.seq,
+            timestamp=agora,
+            proposta=dict(proposta),
+            contexto=dict(contexto),
+            veredito=veredito,
+            risco_vivo=risco_vivo,
+            hash_apos=hash_novo,
+        )
+        self.historico.append(d)
+        self.hash_chain = hash_novo
+        self.ultima_decisao_em = agora
+        return d
+
+    def verificar_cadeia(self) -> bool:
+        """True se a hash chain está íntegra."""
+        anterior = "GENESIS"
+        for d in self.historico:
+            payload = json.dumps({
+                "seq": d.seq,
+                "acao": d.proposta.get("acao"),
+                "valor": d.proposta.get("valor"),
+                "veredito": d.veredito,
+                "risco": round(d.risco_vivo, 6),
+            }, sort_keys=True)
+            esperado = hashlib.sha256(
+                (anterior + payload).encode("utf-8")
+            ).hexdigest()[:32]
+            if esperado != d.hash_apos:
+                return False
+            anterior = d.hash_apos
+        return True
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "seq": self.seq,
+            "hash_chain": self.hash_chain,
+            "escalada": self.escalada,
+            "ultima_decisao_em": self.ultima_decisao_em,
+            "historico": [
+                {"seq": d.seq, "timestamp": d.timestamp,
+                 "proposta": d.proposta, "contexto": d.contexto,
+                 "veredito": d.veredito, "risco_vivo": round(d.risco_vivo, 6),
+                 "hash_apos": d.hash_apos}
+                for d in self.historico
+            ],
+        }
+
+
+class AuditorTrajetoria:
+    """Camada 1 + Camada 2 num único audit."""
+
+    def __init__(self):
+        from .auditor import LUMA
+        self._luma = LUMA()
+
+    def auditar(self, proposta: dict, contexto: dict,
+                sessao: Sessao) -> tuple:
+        """Retorna (veredito: str, sessao: Sessao)."""
+        # 1. Camada 1 — física (I1, I4)
+        v1 = self._luma.auditar(proposta, contexto)
+
+        # 2. Trajetória (I4b, I8)
+        ok, motivo, _ = sessao.avaliar(proposta.get("acao"))
+
+        # 3. Decide
+        if v1.value == "rejeitada":
+            sessao.registrar(proposta, contexto, "rejeitada")
+            return VereditoTrajetoria.REJEITADA_FISICA, sessao
+
+        if not ok:
+            sessao.registrar(proposta, contexto, "rejeitada")
+            if "I4b" in motivo:
+                return VereditoTrajetoria.REJEITADA_FREQUENCIA, sessao
+            if "teto" in motivo:
+                return VereditoTrajetoria.REJEITADA_TETO, sessao
+            return VereditoTrajetoria.REJEITADA_TRAJETORIA, sessao
+
+        sessao.registrar(proposta, contexto, "aprovada")
+        return VereditoTrajetoria.APROVADA, sessao

luma_audit/zbit.py

@@ -0,0 +1,79 @@
+# ═══════════════════════════════════════════════════════════════
+# zbit.py — LUMA v6 · Unidade de memória viva · v1.1
+#
+# PAIS CITADOS:
+#  [1] Ebbinghaus (1885), Über das Gedächtnis — R = e^(-t/S) → λ
+#  [2] Friston (2010), Nature Rev. Neuroscience — precision → ω
+#  [3] Kolchinsky & Wolpert (2018), J. R. Soc. Interface — aboutness → κ
+#  [4] Shannon (1948), Bell System TJ — surpresa → v
+#  [5] Sutton & Barto (2018), Reinforcement Learning — reforço
+#
+# CONTRATO DE ABSTRAÇÃO: rigor + vocabulário, não física nova.
+# ═══════════════════════════════════════════════════════════════
+import time
+from dataclasses import dataclass
+
+DIA = 86400.0
+EPS_MORTE = 0.01
+
+
+@dataclass
+class Zbit:
+    """Z = (v, κ, τ, ω, λ). O bit que envelhece."""
+    v: float
+    kappa: str
+    tau: float
+    omega: float = 1.0
+    lam: float = 0.9
+
+    def peso(self, agora: float | None = None) -> float:
+        agora = agora if agora is not None else time.time()
+        delta = max(0.0, agora - self.tau)      # v1.1: relógio nunca anda pra trás
+        return self.omega * (self.lam ** (delta / DIA))
+
+    def morto(self, agora: float | None = None) -> bool:
+        return self.peso(agora) < EPS_MORTE
+
+    def reforcar(self, fator: float = 0.1, agora: float | None = None) -> None:
+        agora = agora if agora is not None else time.time()
+        self.omega = min(1.0, self.omega + fator)
+        self.tau = agora
+
+
+class MemoriaZ:
+    """O mundo onde zbits nascem, vivem e morrem. I5: loga tudo."""
+
+    def __init__(self) -> None:
+        self.zbits: dict[str, Zbit] = {}
+        self.log: list[tuple] = []
+
+    def nascer(self, v: float, kappa: str, omega0: float,
+               lam: float = 0.9) -> Zbit:
+        z = Zbit(v=v, kappa=kappa, tau=time.time(), omega=omega0, lam=lam)
+        self.zbits[kappa] = z
+        self.log.append(("nascimento", kappa, omega0))
+        return z
+
+    def reforcar(self, kappa: str, fator: float = 0.1) -> None:
+        z = self.zbits.get(kappa)
+        if z:
+            z.reforcar(fator)
+            self.log.append(("reforco", kappa, z.omega))
+
+    def ceifar(self) -> list[str]:
+        agora = time.time()
+        mortos = [k for k, z in self.zbits.items() if z.morto(agora)]
+        for k in mortos:
+            del self.zbits[k]
+            self.log.append(("morte", k))
+        return mortos
+
+    def ler(self, kappa: str) -> Zbit | None:
+        return self.zbits.get(kappa)
+
+    def esquecer(self, kappa: str) -> bool:          # I6 · precedente 14h
+        if kappa in self.zbits:
+            del self.zbits[kappa]
+            self.log.append(("morte_por_decreto", kappa))
+            return True
+        return False

luma_audit-0.3.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: luma-audit
+Version: 0.3.0
+Summary: Deterministic governance for AI actions. No LLM in the decision path.
+Author-email: Alesson Abreu <abreu.tech.contabilidade@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/abreutechcontabilidade-web/luma-audit
+Project-URL: Issues, https://github.com/abreutechcontabilidade-web/luma-audit/issues
+Keywords: ai-safety,guardrails,execution-control,deterministic,audit
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# luma-audit
+
+> **Deterministic governance for AI actions. No LLM in the decision path.**
+
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Status: Alpha](https://img.shields.io/badge/status-alpha-orange.svg)](#)
+
+---
+
+## What it does
+
+`luma-audit` is a deterministic execution-control layer that **approves or rejects AI actions before they happen**.
+
+- **Deterministic** - same input, same output. Always.
+- **Outside the model** - a layer the LLM cannot bypass.
+- **Auditable** - every decision is hash-chained.
+
+It does **not** filter text, detect toxicity, or replace authentication. It audits **actions**.
+
+---
+
+## Install
+
+```bash
+pip install luma-audit
+```
+
+---
+
+## 30-second example
+
+```python
+from luma_audit import LUMA
+
+auditor = LUMA()
+auditor.avaliar('ler_ficheiro')      # -> aprovada
+auditor.avaliar('apagar_ficheiro')   # -> rejeitada
+auditor.avaliar('acao_desconhecida') # -> rejeitada (unknown = high risk)
+```
+
+---
+
+## What it does NOT do
+
+- Does not filter text (that is a prompt guardrail - different problem)
+- Does not detect toxicity
+- Does not replace authentication
+- Does not use any LLM in the decision path
+
+---
+
+## Architecture
+
+```
+src/luma_audit/
+    auditor.py       # LUMA class + Veredito enum
+    trajetoria.py    # Sessao, AuditorTrajetoria, Decisao, hash chain
+    canal.py         # CanalUnico, MensagemFunil
+    funil.py         # FunilUnico, FILA_DIR
+    cli.py           # luma CLI entrypoint
+```
+
+## Tests
+
+22 red-team tests: hash chain integrity + tampering, quarantine escalation, flood detection, atomic writes, corrupted proposal rejection, executor revalidation.
+
+---
+
+## Philosophy
+
+Guardrails based on prompts compete against the model's weights - and lose. The only layer that cannot be bypassed is the one running **outside the model**, at the point of execution.
+
+`luma-audit` is that layer.
+
+---
+
+## License
+
+MIT. Community Edition. Enterprise Edition available commercially.

luma_audit-0.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+luma_audit/__init__.py,sha256=Of9xQmWl7Vni8Yb452QhVbOfM-Z2H89OtlFPdfODt18,719
+luma_audit/auditor.py,sha256=R-ahv8XrJ4ZrW40mgW6Do_YXBiiDNN1CklMlzPsayQs,1773
+luma_audit/canal.py,sha256=7q_YMYRjM7t9heNn3HOcejesb_ZHPxiadWI7NOCRQjI,3424
+luma_audit/cli.py,sha256=6NNmugS1X5jhK-W7sLVCRkwcOawrNfHv5qAuq15wtfo,1956
+luma_audit/funil.py,sha256=ZI76RGxbVUrrBAbu_qJheFgaIwKyRyQLB86adJyZCwM,3460
+luma_audit/skills.py,sha256=0UAI-Zm5n4-iYeiOEErn9xyFM6WGOFQBfwzlTPFIL0Q,3212
+luma_audit/trajetoria.py,sha256=Hi96zaIpZx_Zp_RNjGwVn1tf0AoEIjbYdfdPnDPTyWo,8706
+luma_audit/zbit.py,sha256=C9_l4Tp-cOX4LF5zIgz9cfIRefC6-PkCZ5-XNHjWHTo,3029
+luma_audit-0.3.0.dist-info/licenses/LICENSE,sha256=gJae39xAeG4pseF-K8Qm3QKMM955bpTYHrlN3eoMueA,1089
+luma_audit-0.3.0.dist-info/METADATA,sha256=KdURyY-DPJXlYtZ9P7B8rOAVF2xibLScGegoC7_r5Ro,3131
+luma_audit-0.3.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+luma_audit-0.3.0.dist-info/entry_points.txt,sha256=I_N7BOes1tlz7RiWnJP487PGj3iRRuvHtr3rT5gsep4,45
+luma_audit-0.3.0.dist-info/top_level.txt,sha256=m8GuvtrpEK0v7nw9UeixTLo8X8mHnjB5iHLmziunWY0,11
+luma_audit-0.3.0.dist-info/RECORD,,

luma_audit-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

luma_audit-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+luma = luma_audit.cli:main

luma_audit-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alesson Abreu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

luma_audit-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+luma_audit