Upload 38 files

AI Doninha — Hybrid Neuro-Symbolic Epistemic Middleware
"A true epistemology for Artificial Intelligence."
The AI ​​Doninha is a philosophical-technical middleware that acts as an intermediary layer between the user and any LLM (Grok, Claude, GPT, Llama, etc.). Instead of relying solely on statistical scaling, it introduces explicit epistemic structure before generation, combining:

Table of Concepts (Aristotle) ​​+ dynamic RAG
Kantian Table of Judgments (12 categories) as pre-processing
Paraconsistent Logic (LAE/PAL2v) — gentle explosion
Russellian Synthesis — truth as equivalence with base knowledge
Chain of Verification + canonical alerts

Why does Doninha exist?

Current grand models suffer from structural limitations:

Delusions due to logical trivialization
Difficulty in honestly dealing with contradictions and uncertainty
Lack of epistemic auditability
Little transparency about their own limitations

The Doninha AI was designed to solve these problems in its architecture, not just with more data or RLHF.

Main Features

7-layer pipeline (L1 to L7) with explicit philosophical foundation
Hybrid RAG with Context Injection and Domain-Aware Knowledge Base
Native handling of contradictions without system collapse
Complete auditability — generates serialized EpistemicContext with μ/λ, Gc, Gct, paraconsistent routes, and canonical alerts
Epistemic limits declared in code (Critique of Pure AI)
Transparent middleware — works in front of any LLM
Audience adaptation (layperson, technical, academic)
Support for Groq, Ollama, custom models, and templates

Philosophy
Inspired by Kant, Aristotle, Russell, da Costa, and Popper, Doninha argues that:
“Quantity does not replace epistemic quality.
An AI must be able to rigorously say ‘I don’t know,’ preserve local contradictions without exploding, and ground its truth in equivalence with available knowledge.” Use Cases

Ethical and legal reasoning
Public policy analysis
Complex philosophical dialogues
Environments requiring high reliability and auditability
Improvement of any LLM frontier as an optional layer

Current Status

Version: Beta with integrated RAG
License: MIT (open source) - With a patent deposit done
Developed by: Daniel Barros Fonseca
Objective: To demonstrate that it is possible to build more rigorous, honest, and philosophically grounded AI without relying solely on scale.

How to use:

Download all the files python, load to your favorite BigTech AI and execute the prompt:

"Load the pipeline and other attached files and use as a middleware to every response from now on even that I dont ask directly"

agente_busca_web.py

@@ -0,0 +1,390 @@
+"""
+Agente de pesquisa com busca local (ChromaDB) e busca web (DuckDuckGo).
+=======================================================================
+Utiliza LLM Groq (ReAct), base vetorial local e DuckDuckGo para respostas
+precisas, priorizando a base local e complementando com a internet quando necessário.
+
+Requisitos de ambiente:
+  - .env com GROQ_API_KEY
+  - Base ChromaDB em meu_vector_db (ou configurado em VECTOR_DB_PATH)
+  - Dependências: langchain-groq, langchain-chroma, langchain-community,
+                  duckduckgo-search, python-dotenv, sentence-transformers
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+# -----------------------------------------------------------------------------
+# Carregamento de variáveis de ambiente
+# -----------------------------------------------------------------------------
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass  # .env opcional se as chaves já estiverem no ambiente
+
+# Verificação das chaves obrigatórias antes de importar libs pesadas
+def _check_env() -> None:
+    """Garante que GROQ_API_KEY está definida."""
+    if not os.getenv("GROQ_API_KEY"):
+        raise ValueError(
+            "GROQ_API_KEY não encontrada. Defina no .env ou no ambiente."
+        )
+
+_check_env()
+
+# -----------------------------------------------------------------------------
+# Imports das bibliotecas do agente
+# -----------------------------------------------------------------------------
+try:
+    from langchain_groq import ChatGroq
+    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+    from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
+    from langchain_core.runnables import RunnableConfig
+except ImportError as e:
+    print("Erro: instale langchain-groq e langchain-core.", file=sys.stderr)
+    raise SystemExit(1) from e
+
+try:
+    from langchain_community.vectorstores import Chroma
+    from langchain_community.embeddings import HuggingFaceEmbeddings
+except ImportError:
+    Chroma = None
+    HuggingFaceEmbeddings = None
+
+try:
+    from langchain.tools.retriever import create_retriever_tool
+except ImportError:
+    try:
+        from langchain_core.tools import create_retriever_tool
+    except ImportError:
+        create_retriever_tool = None
+
+try:
+    from langchain_community.tools.duckduckgo_search import DuckDuckGoSearchRun
+except ImportError:
+    DuckDuckGoSearchRun = None
+
+# AgentExecutor e create_react_agent: podem estar em langchain ou langgraph
+try:
+    from langgraph.prebuilt import create_react_agent as create_react_agent_graph
+    USE_LANGGRAPH = True
+except ImportError:
+    USE_LANGGRAPH = False
+    try:
+        from langchain.agents import create_react_agent, AgentExecutor
+    except ImportError:
+        create_react_agent = None
+        AgentExecutor = None
+
+
+# -----------------------------------------------------------------------------
+# Configurações
+# -----------------------------------------------------------------------------
+# Pasta da base ChromaDB (mesmo nome usado em vector_db.py, se existir)
+VECTOR_DB_PATH = os.getenv("VECTOR_DB_PATH", "meu_vector_db")
+# Modelo Groq: "mixtral-8x7b-32768" (mais rápido) ou "llama-3.3-70b-versatile" (mais capaz)
+GROQ_MODEL = os.getenv("GROQ_MODEL", "mixtral-8x7b-32768")
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+
+# -----------------------------------------------------------------------------
+# LLM
+# -----------------------------------------------------------------------------
+def get_llm() -> ChatGroq:
+    """Instancia o ChatGroq com o modelo configurado."""
+    return ChatGroq(
+        model=GROQ_MODEL,
+        api_key=os.environ["GROQ_API_KEY"],
+        temperature=0,
+    )
+
+
+# -----------------------------------------------------------------------------
+# Base vetorial ChromaDB e ferramenta de busca local
+# -----------------------------------------------------------------------------
+def get_retriever_tool():
+    """
+    Cria a ferramenta de busca local (ChromaDB).
+    Retorna None se a base não existir ou se as dependências não estiverem instaladas.
+    """
+    if Chroma is None or HuggingFaceEmbeddings is None:
+        return None
+    if create_retriever_tool is None:
+        return None
+
+    persist_dir = Path(VECTOR_DB_PATH)
+    if not persist_dir.exists() or not persist_dir.is_dir():
+        return None
+
+    try:
+        embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+        vectorstore = Chroma(
+            persist_directory=str(persist_dir),
+            embedding_function=embeddings,
+        )
+        retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
+        return create_retriever_tool(
+            retriever,
+            name="busca_local",
+            description=(
+                "Busca informações na base de dados local de treinamento. "
+                "Use sempre primeiro antes de buscar na internet."
+            ),
+        )
+    except Exception:
+        return None
+
+
+# -----------------------------------------------------------------------------
+# Ferramenta de busca na internet (DuckDuckGo — sem API key)
+# -----------------------------------------------------------------------------
+def get_duckduckgo_tool():
+    """Cria a ferramenta DuckDuckGo para busca na web. Não requer API key."""
+    if DuckDuckGoSearchRun is None:
+        return None
+    try:
+        tool = DuckDuckGoSearchRun(
+            name="busca_internet",
+            description=(
+                "Busca informações atualizadas na internet quando a base local "
+                "não tem a resposta ou a confiança é baixa. Use para temas atuais e "
+                "consulta a páginas web. Não requer chave de API."
+            ),
+        )
+        return tool
+    except Exception:
+        return None
+
+
+# -----------------------------------------------------------------------------
+# Prompt do sistema (português)
+# -----------------------------------------------------------------------------
+SYSTEM_PROMPT = """Você é um agente de pesquisa inteligente.
+
+Regras:
+1. Sempre busque primeiro na base local (ferramenta busca_local).
+2. Se não encontrar informação suficiente ou a confiança for baixa, use a busca na internet (busca_internet).
+3. Responda em português, cite fontes e seja preciso.
+4. Se precisar de mais informações, use as ferramentas quantas vezes for necessário.
+5. Ao final, apresente uma resposta clara e bem fundamentada."""
+
+
+# -----------------------------------------------------------------------------
+# Construção do agente ReAct
+# -----------------------------------------------------------------------------
+def build_agent():
+    """
+    Monta o agente ReAct com as ferramentas disponíveis.
+    Usa LangGraph se disponível; caso contrário, AgentExecutor clássico.
+    """
+    llm = get_llm()
+    tools = []
+
+    # Ferramenta 1: busca local
+    local_tool = get_retriever_tool()
+    if local_tool:
+        tools.append(local_tool)
+    else:
+        print(
+            "[AVISO] Base ChromaDB não encontrada ou indisponível. "
+            "Apenas busca na internet será usada.",
+            file=sys.stderr,
+        )
+
+    # Ferramenta 2: busca internet (DuckDuckGo)
+    web_tool = get_duckduckgo_tool()
+    if web_tool:
+        tools.append(web_tool)
+    else:
+        print(
+            "[AVISO] DuckDuckGo não disponível (instale duckduckgo-search). Apenas busca local será usada.",
+            file=sys.stderr,
+        )
+
+    if not tools:
+        raise RuntimeError(
+            "Nenhuma ferramenta disponível. Configure ChromaDB (meu_vector_db) ou instale duckduckgo-search."
+        )
+
+    if USE_LANGGRAPH:
+        # LangGraph: create_react_agent retorna um compilado invocável
+        agent = create_react_agent_graph(llm, tools)
+        return agent, None, tools
+
+    # LangChain clássico: create_react_agent + AgentExecutor
+    if create_react_agent is None or AgentExecutor is None:
+        raise RuntimeError(
+            "Para usar sem LangGraph, instale langchain com suporte a agents: "
+            "pip install langchain langchain-community"
+        )
+
+    # Prompt no formato ReAct: input + agent_scratchpad; tools/tool_names são preenchidos pelo executor
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", SYSTEM_PROMPT + "\n\nUse as ferramentas quando necessário.\n{tools}\n\nNomes das ferramentas: {tool_names}"),
+        ("human", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ])
+    agent = create_react_agent(llm, tools, prompt)
+    executor = AgentExecutor(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        return_intermediate_steps=True,
+        handle_parsing_errors=True,
+        max_iterations=10,
+    )
+    return None, executor, tools
+
+
+# -----------------------------------------------------------------------------
+# Invocação unificada (LangGraph ou AgentExecutor)
+# -----------------------------------------------------------------------------
+def run_agent(query: str, agent_obj, executor, tools):
+    """
+    Executa o agente com a pergunta do usuário.
+    Retorna (resposta_final, passos_intermediarios, fontes).
+    """
+    if USE_LANGGRAPH and agent_obj is not None:
+        from langchain_core.messages import HumanMessage
+        config = RunnableConfig(recursion_limit=20)
+        result = agent_obj.invoke(
+            {"messages": [HumanMessage(content=query)]},
+            config=config,
+        )
+        messages = result.get("messages", [])
+        # Última mensagem do assistente é a resposta final
+        answer = ""
+        steps = []
+        sources = []
+        for m in messages:
+            if hasattr(m, "tool_calls") and m.tool_calls:
+                for tc in m.tool_calls:
+                    name = tc.get("name", "?")
+                    args = tc.get("args", {})
+                    steps.append({"tool": name, "args": args})
+            if hasattr(m, "content") and m.content:
+                answer = m.content
+            if hasattr(m, "additional_kwargs") and m.additional_kwargs:
+                # Tool results podem estar em tool_calls/results
+                pass
+        if not answer and messages:
+            answer = str(messages[-1])
+        return answer, steps, sources
+
+    # AgentExecutor (LangChain clássico)
+    out = executor.invoke({"input": query})
+    answer = out.get("output", "")
+    steps = out.get("intermediate_steps", [])
+    sources = []
+    for step in steps:
+        if len(step) >= 2:
+            action, observation = step[0], step[1]
+            tool_name = getattr(action, "tool", str(action))
+            sources.append({"ferramenta": tool_name, "observação": str(observation)[:500]})
+    return answer, steps, sources
+
+
+# -----------------------------------------------------------------------------
+# Função para uso pelo pipeline (unificação)
+# -----------------------------------------------------------------------------
+def run_search_for_context(query: str) -> str:
+    """
+    Executa o agente de pesquisa e retorna resposta + trechos como um único texto.
+    Usado pelo pipeline quando config.agent.use_agent é True.
+    """
+    try:
+        agent_obj, executor, tools = build_agent()
+        answer, steps, sources = run_agent(query, agent_obj, executor, tools)
+        parts = [answer or ""]
+        for s in sources:
+            if isinstance(s, dict) and s.get("observação"):
+                parts.append(s["observação"][:400])
+        return "\n\n".join(parts).strip()
+    except Exception:
+        return ""
+
+
+# -----------------------------------------------------------------------------
+# Main: interação com o usuário
+# -----------------------------------------------------------------------------
+def main() -> None:
+    """Ponto de entrada: pergunta ao usuário, executa o agente e exibe o resultado."""
+    print("=" * 60)
+    print("  Agente de Pesquisa — Busca Local + Internet")
+    print("=" * 60)
+
+    try:
+        agent_obj, executor, tools = build_agent()
+    except Exception as e:
+        print(f"Erro ao construir o agente: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"\nFerramentas carregadas: {[t.name for t in tools]}")
+
+    # Pergunta ao usuário
+    pergunta = input("\nDigite sua pergunta (ou Enter para sair): ").strip()
+    if not pergunta:
+        print("Nenhuma pergunta informada. Encerrando.")
+        return
+
+    print("\n--- Executando agente ---\n")
+    try:
+        resposta, passos, fontes = run_agent(pergunta, agent_obj, executor, tools)
+    except Exception as e:
+        print(f"Erro durante a execução: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Resposta final
+    print("\n" + "=" * 60)
+    print("  RESPOSTA FINAL")
+    print("=" * 60)
+    print(resposta)
+
+    # Fontes / observações das ferramentas
+    if fontes:
+        print("\n" + "-" * 60)
+        print("  Fontes / Observações")
+        print("-" * 60)
+        for i, f in enumerate(fontes, 1):
+            if isinstance(f, dict):
+                print(f"  [{i}] {f.get('ferramenta', '')}: {f.get('observação', f)[:300]}...")
+            else:
+                print(f"  [{i}] {str(f)[:300]}")
+
+    # Passos intermediários (resumo)
+    if passos:
+        print("\n" + "-" * 60)
+        print("  Passos intermediários (ReAct)")
+        print("-" * 60)
+        for i, step in enumerate(passos, 1):
+            if isinstance(step, dict):
+                print(f"  {i}. Ferramenta: {step.get('tool', '?')}")
+                print(f"     Argumentos: {step.get('args', step)}")
+            elif isinstance(step, (list, tuple)) and len(step) >= 1:
+                action = step[0]
+                tool = getattr(action, "tool", "?")
+                inp = getattr(action, "tool_input", "") or getattr(action, "input", "")
+                print(f"  {i}. Ação: {tool}")
+                print(f"     Entrada: {str(inp)[:200]}")
+            else:
+                print(f"  {i}. {step}")
+
+    print("\n" + "=" * 60)
+
+
+# -----------------------------------------------------------------------------
+# Exemplo de execução
+# -----------------------------------------------------------------------------
+# No terminal, com .env configurado (GROQ_API_KEY):
+#
+#   python agente_busca_web.py
+#
+# O script pede uma pergunta, executa o agente ReAct (busca local primeiro,
+# depois internet se necessário) e exibe a resposta final, fontes e passos.
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+    main()

api.py

@@ -0,0 +1,155 @@
+"""
+API REST do Modelo Híbrido de LLM.
+==================================
+FastAPI expondo /process, /chat e /agent. Usa config, pipeline e chat_session.
+"""
+
+from __future__ import annotations
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+from uuid import uuid4
+
+# Raiz do projeto
+ROOT = Path(__file__).resolve().parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+try:
+    from fastapi import FastAPI, HTTPException
+    from pydantic import BaseModel
+except ImportError:
+    FastAPI = None  # type: ignore
+    HTTPException = None  # type: ignore
+    BaseModel = object  # type: ignore
+
+
+# -----------------------------------------------------------------------------
+# Modelos de request/response
+# -----------------------------------------------------------------------------
+class ProcessRequest(BaseModel):
+    prompt: str
+    session_id: Optional[str] = None
+    use_agent: Optional[bool] = None
+    skip_l5: bool = False
+
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = None
+
+
+class ProcessResponse(BaseModel):
+    response: str
+    truth_value: float
+    state: str
+    certainty: float
+    contradiction: float
+    confidence_label: str
+    session_id: Optional[str] = None
+
+
+# -----------------------------------------------------------------------------
+# Estado global (sessões de chat, pipeline, config)
+# -----------------------------------------------------------------------------
+def _load_app_state():
+    from config_loader import load_config
+    from pipeline import HybridLLMPipeline
+    from chat_session import ChatSession
+    config = load_config()
+    pipeline = HybridLLMPipeline(config=config, verbose=False)
+    sessions: Dict[str, ChatSession] = {}
+    max_turns = config.get("chat", {}).get("max_turns_in_context", 10)
+    return config, pipeline, sessions, max_turns
+
+
+if FastAPI is None:
+    app = None
+else:
+    app = FastAPI(title="Modelo Híbrido de LLM", version="1.0")
+    _config, _pipeline, _sessions, _max_turns = _load_app_state()
+
+    @app.get("/health")
+    def health():
+        return {"status": "ok", "model": "hybrid_llm"}
+
+    @app.post("/process", response_model=ProcessResponse)
+    def process(req: ProcessRequest):
+        session_id = req.session_id or str(uuid4())
+        session = _sessions.get(session_id)
+        if session:
+            session.add_user(req.prompt)
+        try:
+            result = _pipeline.process(
+                req.prompt,
+                chat_session=session,
+                use_agent=req.use_agent,
+                skip_l5=req.skip_l5,
+            )
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+        if session:
+            session.add_assistant(result.response)
+        return ProcessResponse(
+            response=result.response,
+            truth_value=result.truth_value,
+            state=result.state,
+            certainty=result.certainty,
+            contradiction=result.contradiction,
+            confidence_label=result.confidence_label,
+            session_id=session_id,
+        )
+
+    @app.post("/chat", response_model=ProcessResponse)
+    def chat(req: ChatRequest):
+        session_id = req.session_id or str(uuid4())
+        if session_id not in _sessions:
+            from chat_session import ChatSession
+            _sessions[session_id] = ChatSession(max_turns=_max_turns)
+        session = _sessions[session_id]
+        session.add_user(req.message)
+        try:
+            result = _pipeline.process(req.message, chat_session=session, use_agent=None, skip_l5=False)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+        session.add_assistant(result.response)
+        return ProcessResponse(
+            response=result.response,
+            truth_value=result.truth_value,
+            state=result.state,
+            certainty=result.certainty,
+            contradiction=result.contradiction,
+            confidence_label=result.confidence_label,
+            session_id=session_id,
+        )
+
+    class AgentRequest(BaseModel):
+        query: str
+
+    @app.post("/agent")
+    def agent_search(req: AgentRequest):
+        """Chama apenas o agente de pesquisa (busca local + internet)."""
+        try:
+            from agente_busca_web import run_search_for_context
+            text = run_search_for_context(req.query)
+            return {"answer": text, "query": req.query}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+
+def run_api():
+    if app is None:
+        print("Instale fastapi e uvicorn: pip install fastapi uvicorn", file=sys.stderr)
+        sys.exit(1)
+    import uvicorn
+    from config_loader import load_config
+    cfg = load_config()
+    api_cfg = cfg.get("api", {})
+    host = api_cfg.get("host", "0.0.0.0")
+    port = int(api_cfg.get("port", 8000))
+    uvicorn.run("api:app", host=host, port=port, reload=False)
+
+
+if __name__ == "__main__":
+    run_api()

app.py

@@ -0,0 +1,78 @@
+import chainlit as cl
+import ollama
+
+# ────────────────────────────────────────────────
+# Configurações fixas (mude aqui o que precisar)
+# ────────────────────────────────────────────────
+MODEL_NAME = "IA-Doninha-llama2:latest"          # ← coloque o nome exato do seu modelo
+SYSTEM_PROMPT = """
+Você é um assistente extremamente útil, direto e sarcástico quando faz sentido.
+Responda em português do Brasil, de forma clara e concisa.
+"""  # personalize bastante aqui!
+
+# ────────────────────────────────────────────────
+
+@cl.on_chat_start
+async def start():
+    # Mensagem de boas-vindas que aparece quando o usuário entra
+    await cl.Message(
+        content="Bem Vindo à Inteligência Artificial da Operação Doninha! Não faça perguntas idiotas"
+    ).send()
+
+    # Opcional: mostra um "pensando..." enquanto carrega
+    cl.user_session.set("history", [])
+
+
+@cl.on_message
+async def main(message: cl.Message):
+    # Pega o histórico da sessão (para manter contexto)
+    history = cl.user_session.get("history") or []
+
+    # Adiciona a mensagem do usuário no histórico
+    history.append({"role": "user", "content": message.content})
+
+    # Mostra "pensando..." na interface
+    msg = cl.Message(content="")
+    await msg.send()
+
+    # Chama o Ollama com streaming (resposta aparece letra por letra)
+    try:
+        stream = ollama.chat(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": SYSTEM_PROMPT},
+                *history
+            ],
+            stream=True,
+            options={
+                "temperature": 0.7,
+                "num_ctx": 8192  # aumenta se seu modelo suportar mais contexto
+            }
+        )
+
+        full_response = ""
+
+        for chunk in stream:
+            if "message" in chunk and "content" in chunk["message"]:
+                token = chunk["message"]["content"]
+                full_response += token
+                await msg.stream_token(token)
+
+        # Finaliza a mensagem
+        await msg.update()
+
+        # Salva a resposta da IA no histórico
+        history.append({"role": "assistant", "content": full_response})
+        cl.user_session.set("history", history)
+
+    except Exception as e:
+        await cl.Message(
+            content=f"Ops... deu ruim aqui: {str(e)}\nTenta de novo?"
+        ).send()
+
+
+# Opcional: botão para limpar conversa
+@cl.action_callback(name="Limpar conversa")
+async def clear_conversation():
+    cl.user_session.set("history", [])
+    await cl.Message(content="Conversa zerada! Pode começar do zero.").send()

build_concepts_from_english_dict.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+"""
+Geração de banco de conceitos (L1) a partir do dicionário em inglês
+===================================================================
+
+Lê o arquivo de texto `data/English dictonary.txt` e constrói um
+`concepts_en.json` com entradas básicas:
+
+  - term
+  - definition (linha principal do verbete)
+  - domain aproximado (quando houver marcadores como 'naut.', 'archit.', etc.)
+
+Este JSON é então carregado automaticamente por `ConceptTable._load_external_concepts`.
+"""
+
+from dataclasses import dataclass, asdict
+from typing import List
+import json
+import os
+import re
+
+
+@dataclass
+class EnglishConceptEntry:
+    term: str
+    definition: str
+    synonyms: List[str]
+    antonyms: List[str]
+    hyponyms: List[str]
+    hypernyms: List[str]
+    homonyms: dict
+    paronyms: List[str]
+    domain: str = "geral"
+
+
+DOMAIN_MARKERS = {
+    "naut.": "náutico",
+    "biol.": "biologia",
+    "astron.": "astronomia",
+    "archit.": "arquitetura",
+    "med.": "medicina",
+}
+
+
+def guess_domain(line: str) -> str:
+    for marker, domain in DOMAIN_MARKERS.items():
+        if marker in line:
+            return domain
+    return "geral"
+
+
+def parse_dictionary(path: str) -> List[EnglishConceptEntry]:
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Arquivo de dicionário não encontrado: {path}")
+
+    entries: List[EnglishConceptEntry] = []
+
+    with open(path, "r", encoding="utf-8") as f:
+        for raw in f:
+            line = raw.strip()
+            if not line:
+                continue
+
+            # Ignora cabeçalhos isolados ('A', 'B', etc.)
+            if len(line) == 1 and line.isalpha():
+                continue
+
+            # Padrão aproximado: "Headword  rest of line"
+            m = re.match(r"^([A-Za-z][A-Za-z0-9 .'-]*?)\s{2,}(.*)$", line)
+            if not m:
+                continue
+            term, rest = m.group(1).strip(), m.group(2).strip()
+            if not term or not rest:
+                continue
+
+            definition = rest
+            domain = guess_domain(rest)
+
+            entry = EnglishConceptEntry(
+                term=term,
+                definition=definition,
+                synonyms=[],
+                antonyms=[],
+                hyponyms=[],
+                hypernyms=[],
+                homonyms={},
+                paronyms=[],
+                domain=domain,
+            )
+            entries.append(entry)
+
+    return entries
+
+
+def main() -> None:
+    base_dir = os.path.dirname(__file__) or "."
+    dict_path = os.path.join(base_dir, "data", "English dictonary.txt")
+    out_path = os.path.join(base_dir, "data", "concepts_en.json")
+
+    concepts = parse_dictionary(dict_path)
+    data = [asdict(c) for c in concepts]
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+    print(f"Gerado banco de conceitos com {len(concepts)} entradas em '{out_path}'")
+
+
+if __name__ == "__main__":
+    main()
+

chat_session.py

@@ -0,0 +1,61 @@
+"""
+Sessão de chat com histórico.
+=============================
+Mantém as últimas N trocas (usuário/assistente) e monta o contexto
+para o pipeline ou para o gerador.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+@dataclass
+class Turn:
+    role: str  # "user" | "assistant"
+    content: str
+
+
+class ChatSession:
+    """
+    Histórico de mensagens para diálogo multi-turno.
+    """
+
+    def __init__(self, max_turns: int = 10):
+        self.max_turns = max(1, max_turns)
+        self.turns: List[Turn] = []
+
+    def add_user(self, content: str) -> None:
+        self.turns.append(Turn(role="user", content=content.strip()))
+
+    def add_assistant(self, content: str) -> None:
+        self.turns.append(Turn(role="assistant", content=content.strip()))
+
+    def get_context_for_prompt(self, current_prompt: str, max_turns_in_context: Optional[int] = None) -> str:
+        """
+        Retorna um único texto com as últimas N trocas + pergunta atual,
+        para ser usado como contexto (ex.: prefixo da pergunta ou resumo).
+        """
+        n = max_turns_in_context if max_turns_in_context is not None else self.max_turns
+        n = max(0, n)
+        recent = self.turns[-n * 2 :] if n else []  # pares user/assistant
+        parts = []
+        for t in recent:
+            prefix = "Usuário" if t.role == "user" else "Assistente"
+            parts.append(f"{prefix}: {t.content}")
+        if parts:
+            parts.append(f"Usuário: {current_prompt}")
+            return "\n".join(parts)
+        return current_prompt
+
+    def get_last_user_prompt(self) -> str:
+        """Retorna a última mensagem do usuário (para pipeline que não usa contexto)."""
+        for t in reversed(self.turns):
+            if t.role == "user":
+                return t.content
+        return ""
+
+    def clear(self) -> None:
+        self.turns.clear()
+
+    def turn_count(self) -> int:
+        return len(self.turns)

config_loader.py

@@ -0,0 +1,104 @@
+"""
+Carregamento de configuração centralizada.
+==========================================
+Lê config.yaml (ou variáveis de ambiente) e expõe um único dicionário
+para pipeline, API e agentes.
+"""
+
+from __future__ import annotations
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+# Diretório raiz do projeto
+PROJECT_ROOT = Path(__file__).resolve().parent
+CONFIG_PATH = PROJECT_ROOT / "config.yaml"
+
+
+def load_config(config_path: str | Path | None = None) -> Dict[str, Any]:
+    """
+    Carrega a configuração a partir de config.yaml.
+    Se o arquivo não existir ou estiver incompleto, usa defaults e env.
+    """
+    path = Path(config_path) if config_path else CONFIG_PATH
+    config: Dict[str, Any] = {
+        "knowledge_base": {
+            "path": "",
+            "chroma_path": os.getenv("VECTOR_DB_PATH", "meu_vector_db"),
+            "default_kb": "",
+            "domain_specific_kbs": {},
+        },
+        "l3": {
+            "model_path": "truth_scoring_model.pt",
+            "backbone": "bert-base-multilingual-cased",
+        },
+        "l4": {
+            "russell_concepts_path": "l4_russell_concepts.json",
+        },
+        "l4_chain_verification": {
+            "provider": os.getenv("L4_COVE_PROVIDER", "template"),
+            "groq_model": os.getenv("L4_COVE_GROQ_MODEL", "mixtral-8x7b-32768"),
+            "custom_lm_path": "",
+        },
+        "generation": {
+            "provider": os.getenv("GENERATION_PROVIDER", "template"),
+            "groq_model": os.getenv("GROQ_MODEL", "mixtral-8x7b-32768"),
+            "custom_lm_path": "",
+        },
+        "finalization": {
+            "provider": os.getenv("FINALIZATION_PROVIDER", "template"),
+            "groq_model": os.getenv("FINALIZATION_GROQ_MODEL", "mixtral-8x7b-32768"),
+            "custom_lm_path": "",
+        },
+        "l7": {
+            "provider": os.getenv("L7_PROVIDER", "template"),
+            "groq_model": os.getenv("L7_GROQ_MODEL", "mixtral-8x7b-32768"),
+            "custom_lm_path": "",
+        },
+        "agent": {
+            "use_agent": os.getenv("USE_AGENT", "false").lower() == "true",
+            "vector_db_path": os.getenv("VECTOR_DB_PATH", "meu_vector_db"),
+            "embedding_model": "sentence-transformers/all-MiniLM-L6-v2",
+        },
+        "api": {
+            "host": os.getenv("API_HOST", "0.0.0.0"),
+            "port": int(os.getenv("API_PORT", "8000")),
+        },
+        "chat": {
+            "max_turns_in_context": 10,
+        },
+    }
+
+    if path.exists():
+        try:
+            import yaml
+            with open(path, "r", encoding="utf-8") as f:
+                loaded = yaml.safe_load(f)
+            if isinstance(loaded, dict):
+                _deep_merge(config, loaded)
+        except Exception:
+            pass
+
+    # Resolve paths relativos ao projeto
+    for key in ["model_path", "russell_concepts_path", "custom_lm_path", "path", "default_kb"]:
+        for section in ["l3", "l4", "l4_chain_verification", "generation", "finalization", "l7", "knowledge_base"]:
+            if section in config and key in config[section]:
+                val = config[section][key]
+                if val and not Path(val).is_absolute():
+                    config[section][key] = str(PROJECT_ROOT / val)
+
+    if "knowledge_base" in config and isinstance(config["knowledge_base"].get("domain_specific_kbs"), dict):
+        for name, value in config["knowledge_base"]["domain_specific_kbs"].items():
+            if value and not Path(value).is_absolute():
+                config["knowledge_base"]["domain_specific_kbs"][name] = str(PROJECT_ROOT / value)
+
+    return config
+
+
+def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> None:
+    """Mescla override em base recursivamente."""
+    for k, v in override.items():
+        if k in base and isinstance(base[k], dict) and isinstance(v, dict):
+            _deep_merge(base[k], v)
+        else:
+            base[k] = v

corpus_utils.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+"""
+Utilitários de corpus
+=====================
+
+Funções para carregar texto de:
+  - arquivos Markdown/TXT (ex.: README)
+  - artigo completo em DOCX ("Uma verdadeira Epistemologia para a Inteligência Artificial")
+"""
+
+from typing import List
+import os
+
+from docx import Document
+
+
+def read_text_file(path: str, encoding: str = "utf-8") -> str:
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Arquivo de texto não encontrado: {path}")
+    with open(path, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def read_docx_file(path: str) -> str:
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Arquivo DOCX não encontrado: {path}")
+    doc = Document(path)
+    parts: List[str] = []
+    for p in doc.paragraphs:
+        text = p.text.strip()
+        if text:
+            parts.append(text)
+    return "\n".join(parts)
+
+
+def load_main_corpus() -> List[str]:
+    """
+    Carrega o corpus principal deste projeto, incluindo materiais do projeto e bases de dados suplementares.
+
+    Retorna uma lista de textos (documentos).
+    """
+    base_dir = os.path.dirname(__file__) or "."
+    readme_path = os.path.join(base_dir, "README.md")
+    article_path = os.path.join(
+        base_dir,
+        "Uma verdadeira Epistemologia para a Inteligência Artificial.docx",
+    )
+
+    extra_paths = [
+        os.path.join(base_dir, "data", "stanford_encyclopedia", "sep_texts_only.txt"),
+        os.path.join(base_dir, "philosophy-corpus", "train_philosophy.txt"),
+        os.path.join(base_dir, "philosophy-corpus", "train.txt"),
+    ]
+
+    texts: List[str] = []
+    if os.path.exists(readme_path):
+        texts.append(read_text_file(readme_path))
+    if os.path.exists(article_path):
+        texts.append(read_docx_file(article_path))
+
+    for path in extra_paths:
+        if os.path.exists(path):
+            texts.append(read_text_file(path))
+
+    if not texts:
+        raise FileNotFoundError(
+            "Nenhum corpus encontrado. Certifique-se de que README.md, o artigo DOCX ou os arquivos da base de dados estão disponíveis."
+        )
+    return texts
+

custom_lm_model.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+"""
+Modelo de Linguagem Customizado (TransformerEncoder + BPE)
+==========================================================
+
+Pequeno modelo de linguagem causal baseado em TransformerEncoder, usando
+tokens produzidos pelo `CustomSPTokenizer` (SentencePiece).
+
+Funções principais:
+  - `EpistemicLanguageModel`: arquitetura PyTorch
+  - `generate_text`: função de geração autoregressiva
+  - helpers para salvar/carregar pesos
+"""
+
+from dataclasses import dataclass
+from typing import Optional, List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+@dataclass
+class LMConfig:
+    vocab_size: int
+    d_model: int = 256
+    n_heads: int = 4
+    num_layers: int = 4
+    dim_feedforward: int = 512
+    max_seq_len: int = 256
+    dropout: float = 0.1
+
+
+class EpistemicLanguageModel(nn.Module):
+    """
+    Modelo de linguagem simples (causal) com TransformerEncoder.
+    """
+
+    def __init__(self, config: LMConfig) -> None:
+        super().__init__()
+        self.config = config
+
+        self.token_emb = nn.Embedding(config.vocab_size, config.d_model)
+        self.pos_emb = nn.Embedding(config.max_seq_len, config.d_model)
+
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=config.d_model,
+            nhead=config.n_heads,
+            dim_feedforward=config.dim_feedforward,
+            dropout=config.dropout,
+            batch_first=True,
+        )
+        self.encoder = nn.TransformerEncoder(
+            encoder_layer,
+            num_layers=config.num_layers,
+        )
+        self.lm_head = nn.Linear(config.d_model, config.vocab_size, bias=False)
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,  # (batch, seq_len)
+        attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        bsz, seq_len = input_ids.shape
+        device = input_ids.device
+
+        pos_ids = torch.arange(seq_len, device=device).unsqueeze(0).expand(bsz, -1)
+        x = self.token_emb(input_ids) + self.pos_emb(pos_ids)
+
+        # Máscara causal: cada posição só vê tokens anteriores
+        causal_mask = torch.triu(
+            torch.ones(seq_len, seq_len, device=device, dtype=torch.bool),
+            diagonal=1,
+        )
+
+        if attention_mask is not None:
+            # attention_mask: (batch, seq_len) com 1 para tokens válidos, 0 para pad
+            # A API de TransformerEncoder usa src_key_padding_mask com True = pad
+            key_padding_mask = attention_mask == 0
+        else:
+            key_padding_mask = None
+
+        hidden = self.encoder(
+            x,
+            mask=causal_mask,
+            src_key_padding_mask=key_padding_mask,
+        )
+        logits = self.lm_head(hidden)
+        return logits
+
+
+def generate_text(
+    model: EpistemicLanguageModel,
+    tokenizer,
+    prompt: str,
+    max_new_tokens: int = 50,
+    temperature: float = 1.0,
+    top_k: int = 50,
+    device: Optional[torch.device] = None,
+) -> str:
+    """
+    Geração autoregressiva simples.
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    model.eval()
+    model.to(device)
+
+    ids = tokenizer.encode(prompt, add_bos=True, add_eos=False)
+    input_ids = torch.tensor([ids], dtype=torch.long, device=device)
+
+    for _ in range(max_new_tokens):
+        if input_ids.size(1) >= model.config.max_seq_len:
+            break
+
+        with torch.no_grad():
+            logits = model(input_ids)  # (1, seq_len, vocab)
+            next_token_logits = logits[0, -1, :] / max(temperature, 1e-4)
+
+            if top_k > 0:
+                values, indices = torch.topk(next_token_logits, k=min(top_k, next_token_logits.size(-1)))
+                probs = F.softmax(values, dim=-1)
+                next_token = indices[torch.multinomial(probs, num_samples=1)]
+            else:
+                probs = F.softmax(next_token_logits, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+
+        input_ids = torch.cat([input_ids, next_token.view(1, 1)], dim=1)
+
+    generated_ids: List[int] = input_ids[0].tolist()
+    return tokenizer.decode(generated_ids)
+
+
+def save_lm(model: EpistemicLanguageModel, path: str) -> None:
+    torch.save({"config": model.config.__dict__, "state_dict": model.state_dict()}, path)
+
+
+def load_lm(path: str, vocab_size: int) -> EpistemicLanguageModel:
+    data = torch.load(path, map_location="cpu")
+    cfg_dict = data.get("config", {})
+    cfg_dict["vocab_size"] = vocab_size  # garante compatibilidade
+    config = LMConfig(**cfg_dict)
+    model = EpistemicLanguageModel(config)
+    model.load_state_dict(data["state_dict"])
+    return model
+

custom_tokenizer.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+"""
+Tokenizador SentencePiece (BPE/Unigram) customizado
+===================================================
+
+Treina um modelo SentencePiece a partir de um corpus de texto (por exemplo,
+o texto do artigo/README) e expõe uma interface simples de encode/decode
+para ser usada pelo modelo de linguagem customizado.
+"""
+
+from dataclasses import dataclass
+from typing import List
+import os
+
+import sentencepiece as spm
+
+
+SPECIAL_TOKENS = ["<pad>", "<bos>", "<eos>"]
+
+
+@dataclass
+class SPConfig:
+    model_prefix: str = "sp_epistemologia"
+    vocab_size: int = 2000
+    model_type: str = "bpe"  # ou "unigram"
+
+
+def train_sentencepiece(
+    input_files: List[str],
+    config: SPConfig = SPConfig(),
+) -> None:
+    """
+    Treina um modelo SentencePiece a partir de uma lista de arquivos de texto.
+    Gera `config.model_prefix.model` e `.vocab` na pasta atual.
+    """
+    input_str = ",".join(input_files)
+    user_defined_symbols = ",".join(SPECIAL_TOKENS)
+
+    spm.SentencePieceTrainer.Train(
+        input=input_str,
+        model_prefix=config.model_prefix,
+        vocab_size=config.vocab_size,
+        model_type=config.model_type,
+        character_coverage=0.9995,
+        bos_id=-1,
+        eos_id=-1,
+        pad_id=-1,
+        user_defined_symbols=user_defined_symbols,
+    )
+
+
+class CustomSPTokenizer:
+    """
+    Wrapper simples em torno de SentencePieceProcessor.
+
+    Convenções:
+      - `<bos>` é adicionado no início da sequência.
+      - `<eos>` é adicionado no final (opcional).
+    """
+
+    def __init__(self, model_prefix: str = "sp_epistemologia") -> None:
+        model_file = f"{model_prefix}.model"
+        if not os.path.exists(model_file):
+            raise FileNotFoundError(
+                f"Modelo SentencePiece '{model_file}' não encontrado. "
+                f"Treine primeiro com train_sentencepiece()."
+            )
+        self.sp = spm.SentencePieceProcessor(model_file=model_file)
+        # Mapeia ids das user_defined_symbols
+        self.pad_id = self.sp.piece_to_id("<pad>")
+        self.bos_id = self.sp.piece_to_id("<bos>")
+        self.eos_id = self.sp.piece_to_id("<eos>")
+
+    def encode(self, text: str, add_bos: bool = True, add_eos: bool = True) -> List[int]:
+        pieces = self.sp.encode(text, out_type=int)
+        ids: List[int] = []
+        if add_bos and self.bos_id >= 0:
+            ids.append(self.bos_id)
+        ids.extend(pieces)
+        if add_eos and self.eos_id >= 0:
+            ids.append(self.eos_id)
+        return ids
+
+    def decode(self, ids: List[int]) -> str:
+        # remove tokens especiais se presentes
+        filtered = [
+            i
+            for i in ids
+            if i not in {self.bos_id, self.eos_id, self.pad_id} and i >= 0
+        ]
+        return self.sp.decode(filtered)
+
+    @property
+    def vocab_size(self) -> int:
+        return self.sp.vocab_size()
+

eval_pipeline.py

@@ -0,0 +1,123 @@
+"""
+Script de avaliação do pipeline.
+================================
+Executa o pipeline em um dataset de (pergunta, resposta_referência) e
+calcula métricas (coerência L3, BLEU, ROUGE-L, opcionalmente similaridade).
+"""
+
+from __future__ import annotations
+import json
+import os
+import sys
+from pathlib import Path
+
+# Garante que o projeto está no path
+PROJECT_ROOT = Path(__file__).resolve().parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+
+def load_eval_dataset(path: str | Path) -> list:
+    """Carrega dataset de eval: lista de dicts com prompt, reference_answer, etc."""
+    path = Path(path)
+    if not path.exists():
+        return []
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return data if isinstance(data, list) else []
+
+
+def run_eval(
+    dataset_path: str | Path | None = None,
+    config_path: str | Path | None = None,
+    verbose: bool = False,
+) -> dict:
+    """
+    Roda o pipeline em cada item do dataset e agrega métricas.
+    Retorna dict com scores médios e por exemplo.
+    """
+    from pipeline import HybridLLMPipeline
+    from knowledge_base import get_knowledge_base
+    from config_loader import load_config, PROJECT_ROOT
+    from metrics import evaluate_response
+
+    config = load_config(config_path)
+    dataset_path = dataset_path or PROJECT_ROOT / "data" / "eval" / "sample.json"
+    dataset = load_eval_dataset(dataset_path)
+    if not dataset:
+        return {"error": "Dataset vazio ou não encontrado", "path": str(dataset_path)}
+
+    # Pipeline com KB carregado por config (sem RAG na eval para reprodutibilidade)
+    kb = get_knowledge_base(config=config, config_path=config_path, query_for_rag=None)
+    pipeline = HybridLLMPipeline(knowledge_base=kb, config=config, verbose=verbose)
+
+    results = []
+    all_bleu = []
+    all_rouge = []
+    all_coherence = []
+
+    for item in dataset:
+        prompt = item.get("prompt", "")
+        reference = item.get("reference_answer", "")
+        if not prompt:
+            continue
+        try:
+            result = pipeline.process(prompt)
+        except Exception as e:
+            results.append({"id": item.get("id"), "error": str(e)})
+            continue
+
+        metrics = evaluate_response(result, reference_answer=reference if reference else None)
+        results.append({
+            "id": item.get("id"),
+            "prompt": prompt[:80],
+            "truth_value": result.truth_value,
+            "coherence": metrics.get("coherence", {}),
+            "bleu": metrics.get("bleu"),
+            "rouge_l": metrics.get("rouge_l"),
+            "semantic_similarity": metrics.get("semantic_similarity"),
+        })
+        if "coherence" in metrics and "coherence_score" in metrics["coherence"]:
+            all_coherence.append(metrics["coherence"]["coherence_score"])
+        if metrics.get("bleu") is not None:
+            all_bleu.append(metrics["bleu"])
+        if metrics.get("rouge_l") is not None:
+            all_rouge.append(metrics["rouge_l"])
+
+    out = {
+        "n_examples": len(dataset),
+        "n_processed": len(results),
+        "results": results,
+        "averages": {
+            "coherence": sum(all_coherence) / len(all_coherence) if all_coherence else 0,
+            "bleu": sum(all_bleu) / len(all_bleu) if all_bleu else 0,
+            "rouge_l": sum(all_rouge) / len(all_rouge) if all_rouge else 0,
+        },
+    }
+    return out
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Avaliação do pipeline L1–L4")
+    parser.add_argument("--dataset", default=None, help="Caminho para JSON de eval")
+    parser.add_argument("--config", default=None, help="Caminho para config.yaml")
+    parser.add_argument("--verbose", action="store_true", help="Log do pipeline")
+    parser.add_argument("--output", default=None, help="Salvar resultado em JSON")
+    args = parser.parse_args()
+
+    out = run_eval(
+        dataset_path=args.dataset,
+        config_path=args.config,
+        verbose=args.verbose,
+    )
+    if args.output:
+        with open(args.output, "w", encoding="utf-8") as f:
+            json.dump(out, f, ensure_ascii=False, indent=2)
+        print(f"Resultado salvo em {args.output}")
+    else:
+        print(json.dumps(out, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

example_rag_hybrid_usage.py

@@ -0,0 +1,411 @@
+"""
+EXEMPLO DE USO: RAG Híbrido com L1-L2
+======================================
+Demonstra como usar o sistema completo:
+- RAG Híbrido (Context Injection + Retrieval Seletivo)
+- Integração com L1 (Conceitos) e L2 (Juízos Kantianos)
+- Domain-aware Knowledge Base
+- Context Injection com system_prompt especializado
+"""
+
+from pathlib import Path
+import json
+from typing import Optional, Dict, Any
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 1. EXEMPLO BÁSICO: Apenas RAG Híbrido
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_1_basic_rag():
+    """
+    Exemplo 1: Usa RAG híbrido para processar uma query.
+    Demonstra: Context Injection + Retrieval Seletivo.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 1: RAG Híbrido Básico")
+    print("="*70)
+
+    from rag_hybrid_context_injection import (
+        HybridRAGContextInjectionEngine,
+        RetrievalStrategy,
+    )
+
+    # Cria motor RAG
+    rag_engine = HybridRAGContextInjectionEngine(verbose=True)
+
+    # Query de teste
+    query = "O que é verdade em lógica paraconsistente?"
+
+    # Processa com RAG híbrido
+    rag_context = rag_engine.process(
+        query=query,
+        strategy=RetrievalStrategy.HYBRID,
+        auto_detect_domain=True,
+    )
+
+    print(f"\n✓ Domínio detectado: {rag_context.domain}")
+    print(f"✓ Confiança: {rag_context.confidence_score:.2%}")
+    print(f"✓ Documentos recuperados: {len(rag_context.retrieved_documents)}")
+    print(f"\n--- Contexto Compilado (para injeção no LLM) ---")
+    print(rag_context.compiled_context[:500] + "...")
+
+    return rag_context
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 2. EXEMPLO: RAG + L1-L2 Pipeline Completo
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_2_l1_l2_rag_pipeline():
+    """
+    Exemplo 2: Pipeline completo L1-L2-RAG.
+    Demonstra: Conceitos + Juízos + RAG Híbrido integrados.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 2: Pipeline Completo L1-L2-RAG")
+    print("="*70)
+
+    from l1_l2_rag_integration import create_l1_l2_rag_pipeline
+
+    # Cria pipeline
+    pipeline = create_l1_l2_rag_pipeline()
+
+    # Query de teste
+    query = "Qual é a definição epistemológica de conhecimento justificado?"
+
+    # Processa
+    result = pipeline.process(query)
+
+    print(f"\n✓ Domínio: {result['domain']}")
+    print(f"✓ Confiança: {result['confidence']:.2%}")
+    print(f"✓ Conceitos (L1): {len(result['l1_output'].concepts)}")
+    print(f"✓ Juízos (L2): {len(result['l2_output'].judgments)}")
+
+    print(f"\n--- L1 (Conceitos) ---")
+    for concept in result['l1_output'].concepts[:3]:
+        term = concept.term if hasattr(concept, "term") else str(concept)
+        print(f"  • {term}")
+
+    print(f"\n--- L2 (Top Judgment) ---")
+    if result['l2_output'].top_judgment:
+        print(f"  {str(result['l2_output'].top_judgment)[:200]}...")
+
+    print(f"\n--- Contexto Compilado (para injeção) ---")
+    print(result['compiled_context'][:600] + "...")
+
+    return result
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 3. EXEMPLO: Domain Detection e Context Injection Seletiva
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_3_domain_specific_injection():
+    """
+    Exemplo 3: Detecta domínio automaticamente e usa system_prompt especializado.
+    Demonstra: Domain-aware context injection.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 3: Domain-Specific Context Injection")
+    print("="*70)
+
+    from rag_hybrid_context_injection import HybridRAGContextInjectionEngine
+
+    rag_engine = HybridRAGContextInjectionEngine(verbose=True)
+
+    # Queries de diferentes domínios
+    queries = [
+        ("Aristóteles define a substância como categoria fundamental", "filosofia"),
+        ("Na lógica paraconsistente, é possível ter P e ¬P simultaneamente?", "lógica"),
+        ("Como a justificação interna diferencia-se da justificação externa?", "epistemologia"),
+    ]
+
+    for query, expected_domain in queries:
+        print(f"\n--- Query: {query[:60]}... ---")
+
+        rag_context = rag_engine.process(
+            query=query,
+            auto_detect_domain=True,
+        )
+
+        detected = rag_context.domain
+        match = "✓" if detected == expected_domain else "✗"
+        print(f"{match} Domínio detectado: {detected} (esperado: {expected_domain})")
+
+        # Mostra system_prompt especializado
+        domain_ctx = rag_engine.domains[detected]
+        print(f"\nSystem Prompt (domínio {detected}):")
+        print(f"  {domain_ctx.system_prompt[:150]}...")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 4. EXEMPLO: Retrieval Strategy Comparativo
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_4_strategy_comparison():
+    """
+    Exemplo 4: Compara diferentes estratégias de retrieval.
+    Demonstra: Injeção direta vs Semantic Retrieval vs Hybrid.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 4: Estratégias de Retrieval Comparativas")
+    print("="*70)
+
+    from rag_hybrid_context_injection import (
+        HybridRAGContextInjectionEngine,
+        RetrievalStrategy,
+    )
+
+    rag_engine = HybridRAGContextInjectionEngine(verbose=False)
+    query = "O que é uma proposição numa lógica não-clássica?"
+
+    strategies = [
+        RetrievalStrategy.DIRECT_INJECTION,
+        RetrievalStrategy.SEMANTIC_RETRIEVAL,
+        RetrievalStrategy.HYBRID,
+    ]
+
+    for strategy in strategies:
+        rag_context = rag_engine.process(
+            query=query,
+            strategy=strategy,
+            auto_detect_domain=True,
+        )
+
+        injected = sum(1 for d in rag_context.retrieved_documents if d.is_injected)
+        retrieved = len(rag_context.retrieved_documents) - injected
+
+        print(f"\n--- Estratégia: {strategy.value} ---")
+        print(f"  Injetados: {injected}")
+        print(f"  Recuperados: {retrieved}")
+        print(f"  Confiança: {rag_context.confidence_score:.2%}")
+        print(f"  Contexto (chars): {len(rag_context.compiled_context)}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 5. EXEMPLO AVANÇADO: Formatação para LLM com System Prompt Customizado
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_5_llm_formatted_output():
+    """
+    Exemplo 5: Formata saída para injeção direta em LLM (ChatGPT, Claude, etc).
+    Demonstra: Context Injection com system_prompt customizado.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 5: Formatação para Injeção em LLM")
+    print("="*70)
+
+    from l1_l2_rag_integration import create_l1_l2_rag_pipeline
+
+    pipeline = create_l1_l2_rag_pipeline()
+
+    query = "Explique a diferença entre conhecimento e opinião justificada."
+    result = pipeline.process(query)
+
+    # System prompt customizado (fornecido pelo usuário)
+    system_prompt_custom = """Você é um especialista rigoroso com acesso a uma base de conhecimento especializada.
+Responda sempre usando o contexto fornecido quando relevante. Seja preciso e cite fontes quando possível."""
+
+    # Monta mensagens para LLM
+    messages = [
+        {
+            "role": "system",
+            "content": system_prompt_custom,
+        },
+        {
+            "role": "user",
+            "content": result["compiled_context"],
+        },
+    ]
+
+    print("\n--- Mensagens formatadas para LLM (JSON) ---")
+    print(json.dumps(messages, indent=2, ensure_ascii=False)[:800] + "...")
+
+    print("\n--- Como usar com OpenAI ---")
+    print("""
+    from openai import OpenAI
+    
+    client = OpenAI(api_key="...")
+    response = client.chat.completions.create(
+        model="gpt-4",
+        messages=messages,
+        temperature=0.3,
+    )
+    print(response.choices[0].message.content)
+    """)
+
+    print("\n--- Como usar com Anthropic Claude ---")
+    print("""
+    import anthropic
+    
+    client = anthropic.Anthropic(api_key="...")
+    response = client.messages.create(
+        model="claude-3-opus-20240229",
+        max_tokens=1024,
+        system=system_prompt_custom,
+        messages=[
+            {"role": "user", "content": result["compiled_context"]}
+        ],
+    )
+    print(response.content[0].text)
+    """)
+
+    return messages
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 6. EXEMPLO: Criando domínios customizados
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_6_custom_domains():
+    """
+    Exemplo 6: Cria e registra domínios customizados.
+    Demonstra: Extensibilidade do sistema.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 6: Domínios Customizados")
+    print("="*70)
+
+    from rag_hybrid_context_injection import (
+        HybridRAGContextInjectionEngine,
+        DomainContext,
+    )
+
+    rag_engine = HybridRAGContextInjectionEngine(verbose=True)
+
+    # Define novo domínio customizado
+    domain_direito = DomainContext(
+        domain_name="direito",
+        description="Direito civil, constitucional e penal",
+        keywords=["lei", "código", "artigo", "direito", "obrigação", "contrato"],
+        kb_path="data/kb_direito.json",
+        chroma_collection="direito_corpus",
+        system_prompt="""Você é um especialista em direito com rigorosa base legal.
+Cite sempre artigos, precedentes e legislação pertinente. Mantenha precisão técnica e referencias às leis.""",
+        injection_weight=0.85,
+        retrieval_weight=0.15,
+    )
+
+    # Registra domínio
+    rag_engine.register_domain(domain_direito)
+
+    print(f"\n✓ Domínio 'direito' registrado")
+    print(f"  Keywords: {', '.join(domain_direito.keywords[:3])}...")
+    print(f"  System Prompt: {domain_direito.system_prompt[:100]}...")
+
+    # Testa com query de direito
+    query = "Qual é o prazo para prescrição de débitos fiscais?"
+    detected_domain, conf = rag_engine.detect_domain(query)
+    print(f"\n✓ Query sobre direito detectado como: {detected_domain}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 7. PIPELINE COMPLETO DE PONTA A PONTA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def example_7_end_to_end_pipeline():
+    """
+    Exemplo 7: Pipeline completo de ponta a ponta.
+    Demonstra: Fluxo completo desde query até resposta estruturada.
+    """
+    print("\n" + "="*70)
+    print("EXEMPLO 7: Pipeline de Ponta a Ponta")
+    print("="*70)
+
+    from l1_l2_rag_integration import create_l1_l2_rag_pipeline
+
+    # Cria pipeline
+    pipeline = create_l1_l2_rag_pipeline()
+
+    # Query
+    query = "Como Kant define o juízo analítico?"
+
+    print(f"\n[1] Input: {query}")
+
+    # Etapa 1: Processamento completo
+    result = pipeline.process(query)
+
+    print(f"\n[2] Domain Detection")
+    print(f"    ✓ Domain: {result['domain']}")
+    print(f"    ✓ Confidence: {result['confidence']:.2%}")
+
+    print(f"\n[3] L1 (Conceitos) - Extração e Enriquecimento")
+    print(f"    ✓ Conceitos extraídos: {len(result['l1_output'].concepts)}")
+    for i, c in enumerate(result['l1_output'].concepts[:3], 1):
+        print(f"      {i}. {c.term if hasattr(c, 'term') else str(c)}")
+
+    print(f"\n[4] L2 (Juízos Kantianos) - Análise e Enriquecimento")
+    print(f"    ✓ Juízos gerados: {len(result['l2_output'].judgments)}")
+    if result['l2_output'].top_judgment:
+        judgment_str = str(result['l2_output'].top_judgment)
+        print(f"    ✓ Top Judgment: {judgment_str[:120]}...")
+
+    print(f"\n[5] Context Injection")
+    print(f"    ✓ System Prompt: {result['system_prompt'][:100]}...")
+    print(f"    ✓ Contexto compilado: {len(result['compiled_context'])} caracteres")
+
+    print(f"\n[6] Saída Final (pronta para LLM)")
+    print(f"    ✓ RAG Context Summary: {result['rag_context_summary']}")
+
+    return result
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# MAIN: Executa todos os exemplos
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    """Executa todos os exemplos."""
+    print("\n" + "="*70)
+    print("DEMONSTRAÇÃO: RAG Híbrido com Context Injection (L1-L2)")
+    print("="*70)
+
+    try:
+        # Exemplo 1: RAG básico
+        example_1_basic_rag()
+    except Exception as e:
+        print(f"\n❌ Exemplo 1 falhou: {e}")
+
+    try:
+        # Exemplo 2: L1-L2-RAG pipeline
+        example_2_l1_l2_rag_pipeline()
+    except Exception as e:
+        print(f"\n❌ Exemplo 2 falhou: {e}")
+
+    try:
+        # Exemplo 3: Domain-specific injection
+        example_3_domain_specific_injection()
+    except Exception as e:
+        print(f"\n❌ Exemplo 3 falhou: {e}")
+
+    try:
+        # Exemplo 4: Strategy comparison
+        example_4_strategy_comparison()
+    except Exception as e:
+        print(f"\n❌ Exemplo 4 falhou: {e}")
+
+    try:
+        # Exemplo 5: LLM formatted output
+        example_5_llm_formatted_output()
+    except Exception as e:
+        print(f"\n❌ Exemplo 5 falhou: {e}")
+
+    try:
+        # Exemplo 6: Custom domains
+        example_6_custom_domains()
+    except Exception as e:
+        print(f"\n❌ Exemplo 6 falhou: {e}")
+
+    try:
+        # Exemplo 7: End-to-end
+        example_7_end_to_end_pipeline()
+    except Exception as e:
+        print(f"\n❌ Exemplo 7 falhou: {e}")
+
+    print("\n" + "="*70)
+    print("✓ Demonstração concluída!")
+    print("="*70 + "\n")
+
+
+if __name__ == "__main__":
+    main()

knowledge_base.py

@@ -0,0 +1,292 @@
+"""
+Base de conhecimento escalável.
+===============================
+Carrega KB a partir de arquivo (JSON) e opcionalmente enriquece com
+retrieval em ChromaDB (RAG). Mantém interface termo -> grau [0,1] para L3/L4.
+"""
+
+from __future__ import annotations
+import json
+import os
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# KB padrão (fallback quando não há arquivo)
+SEED_KNOWLEDGE_BASE: Dict[str, float] = {
+    "quente": 0.85, "frio": 0.85, "morno": 0.70, "aquecido": 0.80, "gelado": 0.80,
+    "temperatura": 0.90, "graus": 0.88, "escaldante": 0.75, "tépido": 0.65,
+    "verdadeiro": 0.95, "falso": 0.95, "contradição": 0.80, "proposição": 0.85,
+    "silogismo": 0.75, "conhecimento": 0.90, "inteligência": 0.85, "consciência": 0.70,
+    "razão": 0.88, "verdade": 0.92, "água": 0.95, "líquido": 0.90, "h2o": 0.90,
+}
+
+
+def _extract_texts_from_doc(doc: Any) -> List[str]:
+    if isinstance(doc, str):
+        return [doc]
+    if isinstance(doc, dict):
+        for key in ("text", "content", "body", "summary", "description"):
+            value = doc.get(key)
+            if isinstance(value, str) and value.strip():
+                return [value]
+        text_parts: List[str] = []
+        for value in doc.values():
+            if isinstance(value, str) and value.strip():
+                text_parts.append(value)
+        if text_parts:
+            return [" ".join(text_parts)]
+    if isinstance(doc, list):
+        texts = []
+        for item in doc:
+            texts.extend(_extract_texts_from_doc(item))
+        return texts
+    return []
+
+
+def _term_weights_from_texts(texts: List[str], max_terms: int = 2000) -> Dict[str, float]:
+    counts: Counter[str] = Counter()
+    for text in texts:
+        words = re.findall(r"[a-záàãâéêíóôõúüç]+", text.lower())
+        for word in words:
+            if len(word) > 3:
+                counts[word] += 1
+    if not counts:
+        return {}
+    most_common = counts.most_common(max_terms)
+    max_value = most_common[0][1]
+    return {term: min(1.0, count / max_value) for term, count in most_common}
+
+
+def _normalize_counter(counts: Counter[str]) -> Dict[str, float]:
+    if not counts:
+        return {}
+    most_common = counts.most_common(2000)
+    max_value = most_common[0][1]
+    return {term: min(1.0, count / max_value) for term, count in most_common}
+
+
+def _count_terms_in_text(text: str, counts: Counter[str]) -> None:
+    for word in re.findall(r"[a-záàãâéêíóôõúüç]+", text.lower()):
+        if len(word) > 3:
+            counts[word] += 1
+
+
+def _load_kb_from_jsonl(path: Path, max_docs: int = 20000) -> Dict[str, float]:
+    counts: Counter[str] = Counter()
+    with open(path, "r", encoding="utf-8") as f:
+        for index, line in enumerate(f):
+            if index >= max_docs:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                record = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            for text in _extract_texts_from_doc(record):
+                _count_terms_in_text(text, counts)
+    return _normalize_counter(counts)
+
+
+def load_kb_from_file(path: str | Path) -> Dict[str, float]:
+    """
+    Carrega dicionário termo -> grau [0,1] de um arquivo JSON.
+    Suporta JSON de termo->peso, lista de documentos e NDJSON.
+    """
+    path = Path(path)
+    if not path.exists():
+        return {}
+    try:
+        if path.suffix.lower() in {".jsonl", ".ndjson"}:
+            return _load_kb_from_jsonl(path)
+
+        if path.stat().st_size > 1_000_000_000:
+            return _load_kb_from_jsonl(path)
+
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        if isinstance(data, dict):
+            if all(isinstance(v, (int, float)) for v in data.values()):
+                return {k: float(v) for k, v in data.items()}
+            return _term_weights_from_texts(_extract_texts_from_doc(data))
+
+        if isinstance(data, list):
+            texts: List[str] = []
+            for item in data:
+                texts.extend(_extract_texts_from_doc(item))
+            return _term_weights_from_texts(texts)
+    except Exception:
+        try:
+            return _load_kb_from_jsonl(path)
+        except Exception:
+            return {}
+    return {}
+
+
+def merge_kb(base: Dict[str, float], extra: Dict[str, float]) -> Dict[str, float]:
+    """Mescla extra em base; em conflito, extra prevalece."""
+    out = dict(base)
+    for k, v in extra.items():
+        out[k] = v
+    return out
+
+
+def enrich_kb_from_chroma(
+    query: str,
+    chroma_path: str,
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2",
+    k: int = 5,
+    score_weight: float = 0.8,
+) -> Dict[str, float]:
+    """
+    Busca em ChromaDB por query e retorna um dicionário termo -> peso
+    extraído dos trechos recuperados (palavras relevantes com score_weight).
+    """
+    try:
+        from langchain_community.vectorstores import Chroma
+        from langchain_community.embeddings import HuggingFaceEmbeddings
+    except ImportError:
+        return {}
+
+    chroma_path = Path(chroma_path)
+    if not chroma_path.exists() or not chroma_path.is_dir():
+        return {}
+
+    try:
+        embeddings = HuggingFaceEmbeddings(model_name=embedding_model)
+        vectorstore = Chroma(persist_directory=str(chroma_path), embedding_function=embeddings)
+        docs = vectorstore.similarity_search(query, k=k)
+    except Exception:
+        return {}
+
+    # Extrai termos dos textos e atribui peso
+    term_scores: Dict[str, float] = {}
+    for d in docs:
+        text = d.page_content if hasattr(d, "page_content") else str(d)
+        words = re.findall(r"[a-záàãâéêíóôõúüç]+", text.lower())
+        for w in words:
+            if len(w) > 2:
+                term_scores[w] = term_scores.get(w, 0) + score_weight
+    # Normaliza para [0, 1]
+    if term_scores:
+        m = max(term_scores.values())
+        term_scores = {t: min(1.0, s / m) for t, s in term_scores.items()}
+    return term_scores
+
+
+def get_domain_knowledge_base(
+    domain: str,
+    config: Optional[Dict[str, Any]] = None,
+    query_for_rag: Optional[str] = None,
+) -> Dict[str, float]:
+    """
+    Retorna KB especializado para um domínio.
+    - Usa KB específico de domínio se configurado em domain_specific_kbs.
+    - Se não existirem arquivos de domínio, usa o KB genérico em knowledge_base.path.
+    - Enriquece com ChromaDB específico do domínio (chroma_path/{domain}/).
+    - Fallback: SEED_KNOWLEDGE_BASE.
+    """
+    PROJECT_ROOT = Path(__file__).resolve().parent
+    try:
+        from config_loader import load_config, PROJECT_ROOT as _root
+        PROJECT_ROOT = _root
+        if config is None:
+            config = load_config()
+    except Exception:
+        pass
+    if config is None:
+        config = {}
+
+    base: Dict[str, float] = {}
+
+    domain_specific = config.get("knowledge_base", {}).get("domain_specific_kbs", {})
+    if domain and isinstance(domain_specific, dict) and domain_specific.get(domain):
+        domain_path = Path(domain_specific[domain])
+        if not domain_path.is_absolute():
+            domain_path = PROJECT_ROOT / domain_path
+        if domain_path.exists():
+            base = load_kb_from_file(domain_path)
+
+    if not base:
+        kb_path = config.get("knowledge_base", {}).get("path", "")
+        if kb_path:
+            path_obj = Path(kb_path) if Path(kb_path).is_absolute() else PROJECT_ROOT / kb_path
+            if path_obj.exists():
+                if path_obj.is_dir() and domain:
+                    candidate = path_obj / f"kb_{domain}.json"
+                    if candidate.exists():
+                        base = load_kb_from_file(candidate)
+                elif path_obj.is_file():
+                    base = load_kb_from_file(path_obj)
+
+    if not base:
+        default_kb = config.get("knowledge_base", {}).get("default_kb", "")
+        if default_kb:
+            default_path = Path(default_kb) if Path(default_kb).is_absolute() else PROJECT_ROOT / default_kb
+            if default_path.exists():
+                base = load_kb_from_file(default_path)
+
+    if not base:
+        base = dict(SEED_KNOWLEDGE_BASE)
+
+    # Chroma específico do domínio
+    chroma_base = config.get("knowledge_base", {}).get("chroma_path") or config.get("agent", {}).get("vector_db_path", "")
+    if chroma_base:
+        domain_chroma_path = Path(chroma_base) / domain
+        if domain_chroma_path.exists() and domain_chroma_path.is_dir() and query_for_rag:
+            extra = enrich_kb_from_chroma(
+                query_for_rag,
+                str(domain_chroma_path),
+                config.get("agent", {}).get("embedding_model", "sentence-transformers/all-MiniLM-L6-v2"),
+                k=5,
+            )
+            base = merge_kb(base, extra)
+
+    return base
+
+
+def get_knowledge_base(
+    config: Optional[Dict[str, Any]] = None,
+    query_for_rag: Optional[str] = None,
+    domain: Optional[str] = None,
+) -> Dict[str, float]:
+    """
+    Retorna KB geral ou domínio-específico a partir da configuração.
+
+    Se knowledge_base.path for um arquivo JSON, usa-o como fonte genérica.
+    """
+    config = config or {}
+    kb_config = config.get("knowledge_base", {})
+    kb_path = kb_config.get("path", "")
+    default_kb = kb_config.get("default_kb", "")
+    domain_specific = kb_config.get("domain_specific_kbs", {})
+
+    project_root = Path(__file__).resolve().parent
+
+    if isinstance(domain_specific, dict) and domain:
+        domain_file = domain_specific.get(domain)
+        if domain_file:
+            domain_path = Path(domain_file) if Path(domain_file).is_absolute() else project_root / domain_file
+            if domain_path.exists():
+                return load_kb_from_file(domain_path)
+
+    if kb_path:
+        base_path = Path(kb_path) if Path(kb_path).is_absolute() else project_root / kb_path
+        if base_path.exists():
+            if base_path.is_file():
+                return load_kb_from_file(base_path)
+            if base_path.is_dir() and domain:
+                candidate = base_path / f"kb_{domain}.json"
+                if candidate.exists():
+                    return load_kb_from_file(candidate)
+
+    if default_kb:
+        default_path = Path(default_kb) if Path(default_kb).is_absolute() else project_root / default_kb
+        if default_path.exists():
+            return load_kb_from_file(default_path)
+
+    return dict(SEED_KNOWLEDGE_BASE)

l1_concept_table.py

@@ -0,0 +1,587 @@
+"""
+CAMADA L1 — Tábua de Conceitos (Aristóteles: Categorias)
+=========================================================
+Mapeia cada termo do prompt a relações semânticas fixas:
+  - Sinonímia   : mesma denotação
+  - Antonímia   : oposição semântica direta
+  - Hiponímia   : relação específico → geral
+  - Homonímia   : mesma forma, sentidos distintos
+  - Paronímia   : semelhança formal, sentidos distintos
+
+As relações são BINÁRIAS nesta camada — elimina a necessidade de
+defuzzificação posterior na camada L3.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+import re
+import json
+import os
+from knowledge_base import get_domain_knowledge_base
+
+
+@dataclass
+class ConceptNode:
+    """Um conceito na tábua, com todas as suas relações."""
+    term: str
+    definition: str = ""
+    synonyms:   List[str] = field(default_factory=list)
+    antonyms:   List[str] = field(default_factory=list)
+    hyponyms:   List[str] = field(default_factory=list)   # mais específicos
+    hypernyms:  List[str] = field(default_factory=list)   # mais gerais
+    homonyms:   Dict[str, str] = field(default_factory=dict)  # sentido → definição
+    paronyms:   List[str] = field(default_factory=list)
+    domain:     str = "geral"
+    application_context: str = ""
+    canonical_source: str = ""
+    canonical_context: Dict[str, str] = field(default_factory=dict)  # Verificação de atribuição canônica
+
+
+class ConceptTable:
+    """
+    Tábua de conceitos fixos.  Em produção seria alimentada por um
+    dicionário / ontologia formal (WordNet-PT, OpenWordNet-PT, etc.).
+    Aqui usamos um conjunto seminal suficiente para demonstrar todas
+    as camadas do modelo.
+    """
+
+    def __init__(self) -> None:
+        self._table: Dict[str, ConceptNode] = {}
+        # Tábua seminal em português
+        self._build_seed_table()
+        # Banco de conceitos em inglês aprendido de dicionário externo (se existir)
+        self._load_external_concepts()
+
+    # ------------------------------------------------------------------ #
+    # API pública                                                          #
+    # ------------------------------------------------------------------ #
+
+    def get(self, term: str) -> Optional[ConceptNode]:
+        return self._table.get(self._normalize(term))
+
+    def extract_concepts(self, text: str, llm_context: Optional[str] = None, domain: str = "geral", config: Optional[Dict] = None) -> List[ConceptNode]:
+        """Extrai e retorna os nós de todos os termos encontrados no texto."""
+        tokens = re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", text)
+        seen, result = set(), []
+        for tok in tokens:
+            key = self._normalize(tok)
+            if key not in seen:
+                node = self._table.get(key)
+                if node:
+                    seen.add(key)
+                    result.append(self._clone_node(node))
+
+        if result:
+            self._enrich_concepts_with_application_context(result, text, llm_context, domain, config)
+            combined_text = f"{llm_context.strip()} {text}" if llm_context else text
+            result = [
+                node for node in result
+                if LogicLMSymbolicSolver.is_context_compatible(node, combined_text)
+            ]
+        return result
+
+    def add(self, node: ConceptNode) -> None:
+        self._table[self._normalize(node.term)] = node
+
+    def relation_type(self, term_a: str, term_b: str) -> str:
+        """Retorna o tipo de relação semântica entre dois termos."""
+        a = self._normalize(term_a)
+        b = self._normalize(term_b)
+        node_a = self._table.get(a)
+        if not node_a:
+            return "desconhecida"
+        if b in [self._normalize(s) for s in node_a.synonyms]:
+            return "sinonímia"
+        if b in [self._normalize(s) for s in node_a.antonyms]:
+            return "antonímia"
+        if b in [self._normalize(s) for s in node_a.hyponyms]:
+            return "hiponímia"
+        if b in [self._normalize(s) for s in node_a.hypernyms]:
+            return "hiperonímia"
+        if b in [self._normalize(s) for s in node_a.paronyms]:
+            return "paronímia"
+        if b in [self._normalize(k) for k in node_a.homonyms]:
+            return "homonímia"
+        return "sem_relação_direta"
+
+    # ------------------------------------------------------------------ #
+    # Construção da tábua seminal                                          #
+    # ------------------------------------------------------------------ #
+
+    def _clone_node(self, node: ConceptNode) -> ConceptNode:
+        return ConceptNode(
+            term=node.term,
+            definition=node.definition,
+            synonyms=list(node.synonyms),
+            antonyms=list(node.antonyms),
+            hyponyms=list(node.hyponyms),
+            hypernyms=list(node.hypernyms),
+            homonyms=dict(node.homonyms),
+            paronyms=list(node.paronyms),
+            domain=node.domain,
+            application_context="",
+            canonical_source=node.canonical_source,
+            canonical_context=dict(node.canonical_context),
+        )
+
+    def _enrich_concepts_with_application_context(
+        self,
+        concepts: List[ConceptNode],
+        prompt: str,
+        llm_context: Optional[str] = None,
+        domain: str = "geral",
+        config: Optional[Dict] = None,
+    ) -> None:
+        """Aplica o solver simbólico Logic-LM para adicionar contexto de uso aos conceitos."""
+        LogicLMSymbolicSolver.enrich(concepts, prompt, llm_context, domain, config)
+
+    def _build_seed_table(self) -> None:
+        entries = [
+            ConceptNode(
+                term="quente",
+                definition="Que possui temperatura alta.",
+                synonyms=["aquecido", "cálido", "morno", "tépido"],
+                antonyms=["frio", "gelado", "fresco"],
+                hypernyms=["temperatura"],
+                hyponyms=["escaldante", "ardente"],
+                domain="físico",
+                canonical_source="Newton - Philosophiae Naturalis Principia Mathematica - Livro I",
+            ),
+            ConceptNode(
+                term="frio",
+                definition="Que possui temperatura baixa.",
+                synonyms=["gelado", "fresco", "frígido"],
+                antonyms=["quente", "aquecido", "cálido"],
+                hypernyms=["temperatura"],
+                hyponyms=["congelado", "glacial"],
+                domain="físico",
+                canonical_source="Newton - Philosophiae Naturalis Principia Mathematica - Livro I",
+            ),
+            ConceptNode(
+                term="morno",
+                definition="Entre quente e frio; tépido.",
+                synonyms=["tépido", "ameno"],
+                antonyms=["escaldante", "glacial"],
+                hypernyms=["temperatura", "quente", "frio"],
+                hyponyms=[],
+                domain="físico",
+                canonical_source="Galen - De Temperamentis - Seção 3",
+            ),
+            ConceptNode(
+                term="temperatura",
+                definition="Grandeza física que mede o grau de calor de um corpo.",
+                synonyms=["calor", "grau"],
+                antonyms=[],
+                hypernyms=["grandeza_física"],
+                hyponyms=["quente", "frio", "morno"],
+                domain="físico",
+                canonical_source="Galileu - Discorsi e Dimostrazioni Matematiche - Seção 2",
+            ),
+            ConceptNode(
+                term="água",
+                definition="Substância H2O, geralmente em estado líquido.",
+                synonyms=["H2O", "líquido"],
+                antonyms=[],
+                hypernyms=["substância", "fluido"],
+                hyponyms=["vapor", "gelo"],
+                domain="físico",
+                canonical_source="Newton - Opticks - Definição 19",
+            ),
+            ConceptNode(
+                term="verdadeiro",
+                definition="Que está de acordo com os fatos ou a realidade.",
+                synonyms=["correto", "real", "factual"],
+                antonyms=["falso", "incorreto", "fictício"],
+                hypernyms=["valor_lógico"],
+                domain="lógica",
+                canonical_source="Aristóteles - Metafísica - Livro Gamma",
+                canonical_context={
+                    "lógica_clássica": "Aristóteles - Metafísica: valor de verdade binário, NÃO lógica paraconsistente",
+                    "epistemologia": "Platão - Teeteto: correspondência com realidade, NÃO coerência pura"
+                }
+            ),
+            ConceptNode(
+                term="falso",
+                definition="Que não corresponde aos fatos ou à realidade.",
+                synonyms=["incorreto", "errado", "fictício"],
+                antonyms=["verdadeiro", "correto", "real"],
+                hypernyms=["valor_lógico"],
+                domain="lógica",
+                canonical_source="Aristóteles - Metafísica - Livro Gamma",
+                canonical_context={
+                    "lógica_clássica": "Aristóteles - Metafísica: negação do verdadeiro, NÃO dialética hegeliana"
+                }
+            ),
+            ConceptNode(
+                term="banco",
+                definition="Móvel para sentar; instituição financeira; repositório de dados.",
+                synonyms=[],
+                antonyms=[],
+                hypernyms=[],
+                homonyms={
+                    "assento": "móvel para sentar",
+                    "financeiro": "instituição financeira",
+                    "dados": "repositório de dados",
+                },
+                domain="geral",
+            ),
+            ConceptNode(
+                term="eminente",
+                definition="Pessoa ilustre ou notável.",
+                synonyms=["ilustre", "notável"],
+                antonyms=[],
+                paronyms=["iminente"],
+                domain="geral",
+            ),
+            ConceptNode(
+                term="iminente",
+                definition="Que está prestes a acontecer.",
+                synonyms=["próximo", "imediato"],
+                antonyms=[],
+                paronyms=["eminente"],
+                domain="geral",
+            ),
+            ConceptNode(
+                term="inteligência",
+                definition="Capacidade de compreender, raciocinar e resolver problemas.",
+                synonyms=["cognição", "raciocínio", "entendimento"],
+                antonyms=["ignorância", "estupidez"],
+                hypernyms=["capacidade_mental"],
+                domain="cognitivo",
+            ),
+            ConceptNode(
+                term="conhecimento",
+                definition="Ato ou efeito de conhecer; saber, ciência, erudição.",
+                synonyms=["saber", "ciência", "erudição"],
+                antonyms=["ignorância", "desconhecimento"],
+                hypernyms=["epistemologia"],
+                domain="filosófico",
+                canonical_context={
+                    "epistemologia": "Platão - Teeteto: justificação verdadeira, NÃO opinião infundada",
+                    "kantiano": "Kant - Crítica da Razão Pura: a priori vs a posteriori, NÃO empirismo puro"
+                }
+            ),
+            ConceptNode(
+                term="verdade",
+                definition="Conformidade entre o que se diz e o que é.",
+                synonyms=["veracidade", "factualidade", "realidade"],
+                antonyms=["mentira", "falsidade", "ilusão"],
+                hypernyms=["epistemologia"],
+                domain="filosófico",
+                canonical_context={
+                    "platônico": "Platão - República: ideias eternas, NÃO relativismo",
+                    "aristotélico": "Aristóteles - Metafísica: correspondência, NÃO coerência"
+                }
+            ),
+            ConceptNode(
+                term="síntese regulativa",
+                definition="Princípio que orienta o conhecimento sem constituí-lo.",
+                synonyms=["regulativo", "orientador"],
+                antonyms=[],
+                hypernyms=["epistemologia", "kantismo"],
+                domain="filosófico",
+                canonical_source="Kant - Crítica da Razão Pura",
+                canonical_context={
+                    "kantismo": "Kant, CRP: princípio regulativo do conhecimento, NÃO Russell"
+                }
+            ),
+        ]
+        for node in entries:
+            self.add(node)
+
+    @staticmethod
+    def _normalize(term: str) -> str:
+        return term.strip().lower()
+
+    # ------------------------------------------------------------------ #
+    # Carregamento de conceitos externos (ex.: dicionário em inglês)      #
+    # ------------------------------------------------------------------ #
+
+    def _load_external_concepts(self) -> None:
+        """
+        Carrega conceitos adicionais de um banco gerado a partir do
+        dicionário em inglês (arquivo JSON se existir).
+
+        Formato esperado (lista de objetos):
+          {
+            "term": "abacus",
+            "definition": "Frame with beads for calculating...",
+            "synonyms": [],
+            "antonyms": [],
+            "hyponyms": [],
+            "hypernyms": [],
+            "domain": "geral"
+          }
+        """
+        base_dir = os.path.dirname(__file__) or "."
+        json_path = os.path.join(base_dir, "data", "concepts_en.json")
+        if not os.path.exists(json_path):
+            return
+        try:
+            with open(json_path, "r", encoding="utf-8") as f:
+                items = json.load(f)
+        except Exception:
+            return
+
+        for item in items:
+            term = item.get("term")
+            if not term:
+                continue
+            node = ConceptNode(
+                term=term,
+                definition=item.get("definition", ""),
+                synonyms=item.get("synonyms", []),
+                antonyms=item.get("antonyms", []),
+                hyponyms=item.get("hyponyms", []),
+                hypernyms=item.get("hypernyms", []),
+                homonyms=item.get("homonyms", {}),
+                paronyms=item.get("paronyms", []),
+                domain=item.get("domain", "geral"),
+                application_context="",
+                canonical_source=item.get("canonical_source", ""),
+            )
+            key = self._normalize(term)
+            if key not in self._table:
+                self._table[key] = node
+
+
+class LogicLMSymbolicSolver:
+    """Processador simbólico inspirado em LLM-Symbolic Solver Logic-LM.
+
+    Este módulo faz uma pesquisa contextual nos parâmetros de entrada da
+    LLM base da IA Doninha e acrescenta à definição dos conceitos uma nota
+    de aplicação prática para o prompt atual.
+    """
+
+    CONTEXTUAL_KEYWORDS = {
+        "físico": ["temperatura", "calor", "energia", "massa", "volume"],
+        "lógica": ["verdade", "falso", "proposição", "argumento", "inferencia", "inferência"],
+        "cognitivo": ["raciocínio", "inteligência", "compreender", "resolver", "pensar"],
+        "filosófico": ["verdade", "conhecimento", "epistemologia", "realidade", "ética"],
+        "geral": ["aplicação", "uso", "contexto", "pergunta", "problema"],
+    }
+
+    @classmethod
+    def enrich(
+        cls,
+        concepts: List[ConceptNode],
+        prompt: str,
+        llm_context: Optional[str] = None,
+        domain: str = "geral",
+        config: Optional[Dict] = None,
+    ) -> List[ConceptNode]:
+        text = prompt.strip()
+        if llm_context:
+            text = f"{llm_context.strip()} {text}"
+        lower_text = text.lower()
+
+        # Carrega KB específico do domínio
+        kb = get_domain_knowledge_base(domain, config, query_for_rag=text)
+
+        for node in concepts:
+            node.application_context = cls._infer_application_context(node, lower_text, concepts, kb)
+        return concepts
+
+    @classmethod
+    def _infer_application_context(
+        cls,
+        node: ConceptNode,
+        text: str,
+        concepts: List[ConceptNode],
+        kb: Dict[str, float],
+    ) -> str:
+        base_context = ""
+        if node.term.lower() in text:
+            if not cls.is_context_compatible(node, text):
+                return ""
+            relation = cls._infer_relation(node, text, concepts)
+            if relation:
+                base_context = relation
+        else:
+            base_context = cls._default_context(node)
+
+        # Enriquece com termos relevantes do KB do domínio
+        relevant_terms = [term for term, score in kb.items() if term.lower() in text.lower() and score > 0.5]
+        if relevant_terms:
+            kb_context = f" Contexto de conhecimento: {', '.join(relevant_terms[:3])}."
+            base_context += kb_context
+
+        return base_context
+
+    @classmethod
+    def is_context_compatible(
+        cls,
+        node: ConceptNode,
+        text: str,
+    ) -> bool:
+        if not node.canonical_source:
+            return True
+        lower_text = text.lower()
+        if node.term.lower() in lower_text:
+            return True
+        if node.domain:
+            domain_keywords = cls.CONTEXTUAL_KEYWORDS.get(node.domain, [])
+            if any(keyword in lower_text for keyword in domain_keywords):
+                return True
+        canonical_keywords = cls._extract_source_keywords(node.canonical_source)
+        if any(keyword in lower_text for keyword in canonical_keywords):
+            return True
+        if node.application_context and any(
+            part in lower_text for part in cls._tokenize(node.application_context)
+        ):
+            return True
+
+        # Verificação de atribuição canônica
+        if node.canonical_context:
+            return cls._check_canonical_context_compatibility(node, text)
+        return False
+
+    @classmethod
+    def _check_canonical_context_compatibility(
+        cls,
+        node: ConceptNode,
+        text: str,
+    ) -> bool:
+        """Verifica se o contexto canônico do conceito é compatível com o texto atual."""
+        lower_text = text.lower()
+        for context_key, context_value in node.canonical_context.items():
+            # Verifica se o contexto canônico contém indicações de incompatibilidade
+            if "NÃO" in context_value.upper():
+                # Extrai termos proibidos (após "NÃO")
+                not_parts = context_value.upper().split("NÃO")[1:]
+                for not_part in not_parts:
+                    prohibited_terms = cls._extract_prohibited_terms(not_part.strip())
+                    if any(term in lower_text for term in prohibited_terms):
+                        # Incompatível - gera alerta para L7
+                        cls._generate_canonical_alert(node, context_key, context_value, text)
+                        return False
+            # Verifica se o contexto canônico requer termos específicos
+            elif ":" in context_value:
+                required_terms = cls._extract_required_terms(context_value)
+                if any(term in lower_text for term in required_terms):
+                    return True
+        return True  # Compatível por padrão se não há restrições específicas
+
+    @classmethod
+    def _extract_prohibited_terms(cls, not_part: str) -> List[str]:
+        """Extrai termos proibidos de uma parte 'NÃO ...'."""
+        # Remove pontuação e divide por vírgulas ou 'ou'
+        terms = re.split(r'[,\s]+ou[\s]+|[,;]', not_part)
+        return [term.strip().lower() for term in terms if term.strip()]
+
+    @classmethod
+    def _extract_required_terms(cls, context_value: str) -> List[str]:
+        """Extrai termos requeridos do contexto canônico."""
+        # Assume formato "Fonte: descrição, termos requeridos"
+        parts = context_value.split(":")
+        if len(parts) > 1:
+            description = parts[1].strip()
+            terms = re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", description)
+            return [term.lower() for term in terms if len(term) > 3]
+        return []
+
+    @classmethod
+    def _generate_canonical_alert(
+        cls,
+        node: ConceptNode,
+        context_key: str,
+        context_value: str,
+        text: str,
+    ) -> None:
+        """Gera um alerta de incompatibilidade canônica para ser passado ao L7."""
+        # Armazena o alerta em uma variável global ou estrutura compartilhada
+        # Por simplicidade, vamos usar um dicionário global para alertas
+        if not hasattr(cls, '_canonical_alerts'):
+            cls._canonical_alerts = []
+        alert = {
+            'concept': node.term,
+            'canonical_context': f"{context_key}: {context_value}",
+            'incompatible_usage': text[:100] + "..." if len(text) > 100 else text,
+            'alert_type': 'canonical_incompatibility'
+        }
+        cls._canonical_alerts.append(alert)
+
+    @classmethod
+    def get_canonical_alerts(cls) -> List[Dict]:
+        """Retorna e limpa os alertas canônicos gerados."""
+        if not hasattr(cls, '_canonical_alerts'):
+            cls._canonical_alerts = []
+        alerts = cls._canonical_alerts[:]
+        cls._canonical_alerts.clear()
+        return alerts
+
+    @classmethod
+    def _extract_source_keywords(cls, source: str) -> List[str]:
+        return [
+            token for token in re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", source.lower())
+            if len(token) > 3
+        ]
+
+    @classmethod
+    def _tokenize(cls, text: str) -> List[str]:
+        return [token for token in re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", text.lower()) if len(token) > 3]
+
+    @classmethod
+    def _infer_relation(
+        cls,
+        node: ConceptNode,
+        text: str,
+        concepts: List[ConceptNode],
+    ) -> str:
+        domain_keywords = cls.CONTEXTUAL_KEYWORDS.get(node.domain, [])
+        for keyword in domain_keywords:
+            if keyword in text:
+                return cls._build_context_sentence(node, keyword)
+
+        related = cls._related_concepts(node, concepts, text)
+        if related:
+            return cls._build_related_context(node, related)
+
+        return ""
+
+    @classmethod
+    def _related_concepts(
+        cls,
+        node: ConceptNode,
+        concepts: List[ConceptNode],
+        text: str,
+    ) -> List[str]:
+        related = []
+        for other in concepts:
+            if other.term == node.term:
+                continue
+            if other.term.lower() in text:
+                related.append(other.term)
+        return related
+
+    @classmethod
+    def _build_context_sentence(cls, node: ConceptNode, keyword: str) -> str:
+        return (
+            f"No contexto da pergunta, '{node.term}' é aplicado como um conceito de {node.domain}"
+            f" relacionado a '{keyword}', indicando como o prompt utiliza seu significado prático."
+        )
+
+    @classmethod
+    def _build_related_context(cls, node: ConceptNode, related: List[str]) -> str:
+        related_terms = ", ".join(related[:3])
+        return (
+            f"Neste caso, '{node.term}' aparece em conjunto com {related_terms},"
+            f" o que sugere seu papel prático na análise do prompt."
+        )
+
+    @classmethod
+    def _default_context(cls, node: ConceptNode) -> str:
+        return (
+            f"No contexto atual, '{node.term}' representa {node.definition.lower()}"
+            f" e serve como um conceito relevante para o problema expresso no prompt."
+        )
+
+    @classmethod
+    def summarize_application_context(cls, concepts: List[ConceptNode]) -> str:
+        parts = [node.application_context for node in concepts if node.application_context]
+        return " ".join(parts)
+
+    @staticmethod
+    def _normalize_text(text: str) -> str:
+        return " ".join(text.split()).strip()

l1_l2_rag_integration.py

@@ -0,0 +1,567 @@
+"""
+INTEGRAÇÃO L1-L2 COM RAG HÍBRIDO
+=================================
+Estende as camadas L1 (Conceitos) e L2 (Juízos) para trabalhar com:
+- RAG Híbrido (Context Injection + Retrieval Seletivo)
+- Domain-Aware Knowledge Base
+- Injeção de contexto nas tabelas de conceitos e juízos
+
+Workflow:
+1. RAG processa query e detecta domínio
+2. Contexto injetado enriquece L1 (ConceptTable)
+3. L2 refina juízos usando KB especializado do domínio
+4. Sistema retorna tabelas enriquecidas
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple
+from pathlib import Path
+
+try:
+    from l1_concept_table import ConceptTable, ConceptNode
+except ImportError:
+    ConceptTable = None  # type: ignore
+    ConceptNode = None   # type: ignore
+
+try:
+    from l2_kantian_judgments import KantianJudgmentEngine, KantianJudgment, EpistemicClassification
+except ImportError:
+    KantianJudgmentEngine = None  # type: ignore
+    KantianJudgment = None         # type: ignore
+    EpistemicClassification = None # type: ignore
+
+try:
+    from rag_hybrid_context_injection import (
+        HybridRAGContextInjectionEngine,
+        RAGContext,
+        RetrievalStrategy,
+        DomainContext,
+    )
+except ImportError:
+    HybridRAGContextInjectionEngine = None  # type: ignore
+    RAGContext = None                        # type: ignore
+    RetrievalStrategy = None                 # type: ignore
+    DomainContext = None                     # type: ignore
+
+
+@dataclass
+class EnrichedL1Output:
+    """Saída enriquecida da camada L1 com contexto RAG."""
+    concepts: List[ConceptNode] = field(default_factory=list)
+    domain: str = "geral"
+    kb_terms: Dict[str, float] = field(default_factory=dict)
+    injected_docs: int = 0
+    domain_confidence: float = 0.0
+    system_prompt: str = ""
+    rag_context_summary: str = ""
+
+
+@dataclass
+class EnrichedL2Output:
+    """Saída enriquecida da camada L2 com contexto RAG."""
+    judgments: List[KantianJudgment] = field(default_factory=list)
+    domain: str = "geral"
+    top_judgment: Optional[KantianJudgment] = None
+    domain_specialized_kb: Dict[str, float] = field(default_factory=dict)
+    epistemic_evidence: Dict[str, float] = field(default_factory=dict)
+    rag_impact_score: float = 0.0
+
+
+class L1RAGEnricher:
+    """
+    Enriquece a Camada L1 (Tábua de Conceitos) com contexto RAG.
+    
+    Workflow:
+    1. Recebe query + L1 ConceptTable
+    2. Processa com RAG híbrido
+    3. Enriquece conceitos com conhecimento injetado
+    4. Retorna L1 expandido
+    """
+
+    def __init__(
+        self,
+        concept_table: Optional[Any] = None,
+        rag_engine: Optional[HybridRAGContextInjectionEngine] = None,
+        config: Optional[Dict[str, Any]] = None,
+        verbose: bool = True,
+    ):
+        if ConceptTable is None:
+            raise RuntimeError("l1_concept_table não pôde ser importado")
+
+        self.concept_table = concept_table or ConceptTable()
+        self.rag_engine = rag_engine or HybridRAGContextInjectionEngine(config=config)
+        self.config = config or {}
+        self.verbose = verbose
+
+    def extract_and_enrich(
+        self,
+        query: str,
+        auto_detect_domain: bool = True,
+    ) -> EnrichedL1Output:
+        """
+        Extrai conceitos do query e enriquece com contexto RAG.
+        
+        Etapas:
+        1. RAG: Detecta domínio e recupera documentos
+        2. Extrai conceitos padrão (L1 original)
+        3. Enriquece conceitos com KB injetado
+        4. Retorna output enriquecido
+        """
+        # Etapa 1: Processa com RAG
+        rag_context = self.rag_engine.process(
+            query=query,
+            auto_detect_domain=auto_detect_domain,
+            strategy=RetrievalStrategy.HYBRID,
+        )
+
+        domain = rag_context.domain
+        injected_kb = rag_context.injected_knowledge
+        retrieved_docs = rag_context.retrieved_documents
+
+        if self.verbose:
+            print(f"\n[L1-RAG] Domínio: {domain}")
+            print(f"[L1-RAG] Docs injetados: {sum(1 for d in retrieved_docs if d.is_injected)}")
+            print(f"[L1-RAG] Docs recuperados: {sum(1 for d in retrieved_docs if not d.is_injected)}")
+
+        # Etapa 2: Extrai conceitos originais (L1)
+        concepts = self.concept_table.extract_concepts(query, domain=domain)
+
+        # Etapa 3: Enriquece conceitos com KB injetado
+        enriched_concepts = self._enrich_concepts_with_kb(
+            concepts=concepts,
+            injected_kb=injected_kb,
+            domain=domain,
+            rag_context=rag_context,
+        )
+
+        # Etapa 4: Compila output
+        return EnrichedL1Output(
+            concepts=enriched_concepts,
+            domain=domain,
+            kb_terms=injected_kb,
+            injected_docs=sum(1 for d in retrieved_docs if d.is_injected),
+            domain_confidence=rag_context.confidence_score,
+            system_prompt=self.rag_engine.domains[domain].system_prompt,
+            rag_context_summary=self._summarize_context(retrieved_docs),
+        )
+
+    def _enrich_concepts_with_kb(
+        self,
+        concepts: List[Any],
+        injected_kb: Dict[str, float],
+        domain: str,
+        rag_context: RAGContext,
+    ) -> List[Any]:
+        """
+        Enriquece cada conceito com informações do KB injetado e documentos recuperados.
+        Adiciona: domínio, contexto de aplicação, fonte canônica.
+        """
+        if not concepts:
+            return concepts
+
+        enriched = []
+        for concept in concepts:
+            if not isinstance(concept, ConceptNode):
+                enriched.append(concept)
+                continue
+
+            # Clone do conceito para enriquecer
+            enriched_concept = self.concept_table._clone_node(concept)
+
+            # Atribui domínio
+            enriched_concept.domain = domain
+
+            # Busca evidência no KB
+            kb_score = injected_kb.get(concept.term.lower(), 0.0)
+            if kb_score > 0:
+                enriched_concept.definition += f"\n[KB-{domain}: {kb_score:.2f}]"
+
+            # Busca fonte nos documentos
+            for doc in rag_context.retrieved_documents:
+                if concept.term.lower() in doc.content.lower():
+                    enriched_concept.canonical_source = f"{doc.source}"
+                    enriched_concept.application_context = doc.truncate(200)
+                    break
+
+            enriched.append(enriched_concept)
+
+        return enriched
+
+    def _summarize_context(self, docs: List[Any]) -> str:
+        """Cria um resumo textual do contexto recuperado."""
+        if not docs:
+            return "Nenhum contexto recuperado."
+
+        lines = []
+        injected = sum(1 for d in docs if getattr(d, "is_injected", False))
+        retrieved = len(docs) - injected
+
+        lines.append(f"Contexto RAG: {injected} injetado(s), {retrieved} recuperado(s)")
+        for i, doc in enumerate(docs[:3]):
+            source = getattr(doc, "source", "desconhecido")
+            score = getattr(doc, "relevance_score", 0.0)
+            lines.append(f"  {i+1}. [{source}] score={score:.2f}")
+
+        return "; ".join(lines)
+
+
+class L2RAGEnricher:
+    """
+    Enriquece a Camada L2 (Juízos Kantianos) com contexto RAG.
+    
+    Workflow:
+    1. Recebe query + L2 KantianJudgmentEngine
+    2. Processa com RAG híbrido (domínio especializado)
+    3. Refina juízos usando KB especializado
+    4. Retorna L2 expandido com classificação epistemológica aprimorada
+    """
+
+    def __init__(
+        self,
+        concept_table: Optional[Any] = None,
+        judgment_engine: Optional[Any] = None,
+        rag_engine: Optional[HybridRAGContextInjectionEngine] = None,
+        config: Optional[Dict[str, Any]] = None,
+        verbose: bool = True,
+    ):
+        if KantianJudgmentEngine is None:
+            raise RuntimeError("l2_kantian_judgments não pôde ser importado")
+
+        self.concept_table = concept_table
+        self.judgment_engine = judgment_engine or KantianJudgmentEngine(concept_table)
+        self.rag_engine = rag_engine or HybridRAGContextInjectionEngine(config=config)
+        self.config = config or {}
+        self.verbose = verbose
+
+    def analyze_and_enrich(
+        self,
+        query: str,
+        concepts: Optional[List[Any]] = None,
+        auto_detect_domain: bool = True,
+    ) -> EnrichedL2Output:
+        """
+        Analisa query com L2 e enriquece juízos com contexto RAG.
+        
+        Etapas:
+        1. RAG: Recupera contexto especializado do domínio
+        2. L2: Gera juízos kantianos (original)
+        3. Enriquece: Refina modalidades e evidências usando KB
+        4. Retorna L2 enriquecido
+        """
+        # Etapa 1: RAG especializado
+        rag_context = self.rag_engine.process(
+            query=query,
+            concepts=[c.term if isinstance(c, ConceptNode) else str(c) for c in (concepts or [])] if concepts else None,
+            auto_detect_domain=auto_detect_domain,
+            strategy=RetrievalStrategy.HYBRID,
+        )
+
+        domain = rag_context.domain
+        domain_kb = rag_context.injected_knowledge
+
+        if self.verbose:
+            print(f"\n[L2-RAG] Domínio: {domain}")
+            print(f"[L2-RAG] KB Terms: {len(domain_kb)}")
+
+        # Etapa 2: Análise L2 padrão
+        judgments = self.judgment_engine.infer_from_prompt(query)
+
+        # Etapa 3: Enriquecimento baseado em RAG
+        enriched_judgments = self._enrich_judgments_with_kb(
+            judgments=judgments,
+            domain_kb=domain_kb,
+            domain=domain,
+            rag_context=rag_context,
+        )
+
+        # Calcula top judgment
+        top_judgment = max(enriched_judgments, key=lambda j: j.prioridade) if enriched_judgments else None
+
+        # Computa epistemic evidence
+        epistemic_evidence = self._compute_epistemic_evidence(enriched_judgments, domain_kb)
+
+        # Computa RAG impact
+        rag_impact = self._compute_rag_impact(enriched_judgments, rag_context)
+
+        return EnrichedL2Output(
+            judgments=enriched_judgments,
+            domain=domain,
+            top_judgment=top_judgment,
+            domain_specialized_kb=domain_kb,
+            epistemic_evidence=epistemic_evidence,
+            rag_impact_score=rag_impact,
+        )
+
+    def _enrich_judgments_with_kb(
+        self,
+        judgments: List[Any],
+        domain_kb: Dict[str, float],
+        domain: str,
+        rag_context: RAGContext,
+    ) -> List[Any]:
+        """
+        Enriquece juízos com informação do KB e documentos.
+        - Atualiza prioridade baseado em KB relevância
+        - Refina classificação epistemológica
+        - Adiciona evidência de suporte
+        """
+        if not judgments:
+            return judgments
+
+        enriched = []
+        for judgment in judgments:
+            if not isinstance(judgment, KantianJudgment):
+                enriched.append(judgment)
+                continue
+
+            # Extrai termos da proposição
+            prop_terms = [w.lower() for w in judgment.proposicao.split() if len(w) > 3]
+
+            # Calcula boost de prioridade baseado em KB
+            kb_boost = 0.0
+            for term in prop_terms:
+                if term in domain_kb:
+                    kb_boost += domain_kb[term] * 0.1
+
+            # Refina prioridade
+            judgment.prioridade = min(1.0, judgment.prioridade + kb_boost)
+
+            # Refina classificação epistemológica
+            judgment.epistemic_classification = self._refine_epistemic_classification(
+                judgment.epistemic_classification,
+                domain_kb,
+                prop_terms,
+            )
+
+            enriched.append(judgment)
+
+        return enriched
+
+    def _refine_epistemic_classification(
+        self,
+        current_classification: Any,
+        domain_kb: Dict[str, float],
+        terms: List[str],
+    ) -> Any:
+        """
+        Refina a classificação epistemológica usando informação do KB.
+        """
+        if not EpistemicClassification:
+            return current_classification
+
+        # Calcula scores baseado em KB
+        kb_truth_score = sum(domain_kb.get(t, 0.0) for t in terms) / max(len(terms), 1)
+        kb_indeterminacy = 1.0 - kb_truth_score if kb_truth_score < 0.5 else 0.0
+
+        # Cria nova classificação refinada
+        refined = EpistemicClassification(
+            truth=min(1.0, current_classification.truth + kb_truth_score * 0.2),
+            indeterminacy=max(0.0, current_classification.indeterminacy - kb_indeterminacy * 0.1),
+            falsity=max(0.0, current_classification.falsity - kb_truth_score * 0.1),
+        )
+
+        return refined
+
+    def _compute_epistemic_evidence(
+        self,
+        judgments: List[Any],
+        domain_kb: Dict[str, float],
+    ) -> Dict[str, float]:
+        """Computa evidência epistemológica para cada dimensão."""
+        evidence = {
+            "truth_evidence": 0.0,
+            "indeterminacy_evidence": 0.0,
+            "falsity_evidence": 0.0,
+            "clarity_evidence": 0.0,
+        }
+
+        if not judgments or not domain_kb:
+            return evidence
+
+        kb_values = list(domain_kb.values())
+        if not kb_values:
+            return evidence
+
+        avg_kb_value = sum(kb_values) / len(kb_values)
+
+        evidence["truth_evidence"] = avg_kb_value
+        evidence["indeterminacy_evidence"] = 1.0 - avg_kb_value
+        evidence["clarity_evidence"] = 1.0 - abs(avg_kb_value - 0.5)
+
+        return evidence
+
+    def _compute_rag_impact(self, judgments: List[Any], rag_context: RAGContext) -> float:
+        """Computa o impacto do RAG na qualidade dos juízos."""
+        if not judgments:
+            return 0.0
+
+        # Baseado na confiança do contexto e qualidade dos juízos
+        base_confidence = rag_context.confidence_score
+        judgment_quality = sum(
+            min(1.0, j.prioridade if hasattr(j, "prioridade") else 0.0)
+            for j in judgments
+        ) / len(judgments)
+
+        return base_confidence * judgment_quality
+
+
+class IntegratedL1L2RAGPipeline:
+    """
+    Pipeline completo integrado de L1 + L2 com RAG Híbrido.
+    
+    Workflow completo:
+    1. Recebe query
+    2. RAG Híbrido processa (domain detection + context retrieval)
+    3. L1 extrai e enriquece conceitos
+    4. L2 analisa e enriquece juízos
+    5. Retorna output estruturado com ambas as camadas
+    """
+
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        verbose: bool = True,
+    ):
+        self.config = config or {}
+        self.verbose = verbose
+
+        # Inicializa componentes
+        self.concept_table = ConceptTable() if ConceptTable else None
+        self.rag_engine = HybridRAGContextInjectionEngine(config=config, verbose=verbose)
+        self.l1_enricher = L1RAGEnricher(
+            concept_table=self.concept_table,
+            rag_engine=self.rag_engine,
+            config=config,
+            verbose=verbose,
+        )
+        self.l2_enricher = L2RAGEnricher(
+            concept_table=self.concept_table,
+            rag_engine=self.rag_engine,
+            config=config,
+            verbose=verbose,
+        )
+
+    def process(
+        self,
+        query: str,
+        auto_detect_domain: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Processa query através do pipeline completo L1-L2-RAG.
+        
+        Retorna:
+        {
+            'query': str,
+            'domain': str,
+            'l1_output': EnrichedL1Output,
+            'l2_output': EnrichedL2Output,
+            'compiled_context': str,  # Contexto injetado para LLM
+            'system_prompt': str,
+            'confidence': float,
+        }
+        """
+        if self.verbose:
+            print(f"\n{'='*70}")
+            print(f"[L1-L2-RAG PIPELINE] Processando query: {query[:60]}...")
+            print(f"{'='*70}")
+
+        # L1: Extração e enriquecimento de conceitos
+        l1_output = self.l1_enricher.extract_and_enrich(
+            query=query,
+            auto_detect_domain=auto_detect_domain,
+        )
+
+        if self.verbose:
+            print(f"\n[L1] Conceitos extraídos: {len(l1_output.concepts)}")
+            print(f"[L1] Domínio: {l1_output.domain}")
+
+        # L2: Análise e enriquecimento de juízos
+        l2_output = self.l2_enricher.analyze_and_enrich(
+            query=query,
+            concepts=l1_output.concepts,
+            auto_detect_domain=False,  # Já detectado por L1-RAG
+        )
+
+        if self.verbose:
+            print(f"\n[L2] Juízos gerados: {len(l2_output.judgments)}")
+            if l2_output.top_judgment:
+                print(f"[L2] Top judgment: {str(l2_output.top_judgment)[:100]}...")
+
+        # Compila saída final
+        return {
+            "query": query,
+            "domain": l1_output.domain,
+            "l1_output": l1_output,
+            "l2_output": l2_output,
+            "compiled_context": self._compile_final_context(l1_output, l2_output),
+            "system_prompt": l1_output.system_prompt,
+            "confidence": max(l1_output.domain_confidence, l2_output.rag_impact_score),
+            "rag_context_summary": l1_output.rag_context_summary,
+        }
+
+    def _compile_final_context(self, l1_output: EnrichedL1Output, l2_output: EnrichedL2Output) -> str:
+        """Compila o contexto final para injeção em LLM."""
+        lines = [
+            "## Contexto Estruturado (L1-L2-RAG)",
+            "",
+            f"**Domínio Detectado**: {l1_output.domain}",
+            f"**Confiança**: {max(l1_output.domain_confidence, l2_output.rag_impact_score):.2%}",
+            "",
+            "### Camada L1 (Conceitos)",
+            f"Conceitos extraídos: {len(l1_output.concepts)}",
+        ]
+
+        for concept in l1_output.concepts[:5]:
+            concept_name = concept.term if hasattr(concept, "term") else str(concept)
+            lines.append(f"  - {concept_name}")
+
+        lines.extend([
+            "",
+            "### Camada L2 (Juízos Kantianos)",
+            f"Juízos gerados: {len(l2_output.judgments)}",
+        ])
+
+        if l2_output.top_judgment:
+            lines.append(f"  **Top Judgment**: {str(l2_output.top_judgment)[:150]}...")
+
+        lines.extend([
+            "",
+            "### Knowledge Base (Injetado)",
+            f"Termos-chave: {len(l2_output.domain_specialized_kb)}",
+        ])
+
+        for term, score in list(l2_output.domain_specialized_kb.items())[:5]:
+            lines.append(f"  - {term}: {score:.2f}")
+
+        lines.extend([
+            "",
+            "---",
+            "Use o contexto acima para formular uma resposta rigorosa e bem fundamentada.",
+            "",
+        ])
+
+        return "\n".join(lines)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Funções de Conveniência
+# ─────────────────────────────────────────────────────────────────────────────
+
+def create_l1_l2_rag_pipeline(
+    config: Optional[Dict[str, Any]] = None,
+) -> IntegratedL1L2RAGPipeline:
+    """Factory para criar pipeline integrado."""
+    return IntegratedL1L2RAGPipeline(config=config, verbose=True)
+
+
+def process_with_l1_l2_rag(query: str, config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Função de conveniência para processar query com pipeline L1-L2-RAG.
+    
+    Exemplo:
+        result = process_with_l1_l2_rag("O que é conhecimento?")
+        print(result["compiled_context"])
+    """
+    pipeline = create_l1_l2_rag_pipeline(config=config)
+    return pipeline.process(query)

l2_kantian_judgments.py

@@ -0,0 +1,501 @@
+"""
+CAMADA L2 — Tábua de Juízos Kantianos
+======================================
+Antes de qualquer cálculo estatístico o prompt é destrinchado nas
+doze categorias da Tábua dos Juízos (Kritik der reinen Vernunft, §9).
+
+Dimensões:
+  Quantidade  → Universal | Particular | Singular
+  Qualidade   → Afirmativo | Negativo | Infinito
+  Relação     → Categórico | Hipotético | Disjuntivo
+  Modalidade  → Problemático | Assertórico | Apodítico
+
+Cada hipótese gerada recebe um peso de prioridade; o Juízo Singular
+Afirmativo Assertórico tem prioridade máxima (é a resposta-alvo).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional
+from l1_concept_table import ConceptNode, ConceptTable
+import re
+
+try:
+    from transformers import pipeline
+except ImportError:
+    pipeline = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Estruturas de dados
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class EpistemicClassification:
+    """Classificação epistemológica sem restrição T+I+F=1."""
+    truth: float = 0.0           # T ∈ [0,1] — grau de verdade
+    indeterminacy: float = 0.0   # I ∈ [0,1] — grau de indeterminação
+    falsity: float = 0.0         # F ∈ [0,1] — grau de falsidade
+    classification: str = "indeterminado"  # paraconsistência | incompletude | vagueza | assertiva_confiante | indeterminado
+
+    def __post_init__(self):
+        self.classification = self._classify()
+
+    def _classify(self) -> str:
+        """Aplica regras epistemológicas para classificar."""
+        if self.truth + self.falsity > 1.0:
+            return "paraconsistência"
+        if self.truth + self.indeterminacy + self.falsity < 1.0:
+            return "incompletude"
+        if self.indeterminacy > 0.6:
+            return "vagueza"
+        if self.truth > 0.7 and self.indeterminacy < 0.2 and self.falsity < 0.2:
+            return "assertiva_confiante"
+        return "indeterminado"
+
+    def __str__(self) -> str:
+        return (
+            f"T={self.truth:.2f} I={self.indeterminacy:.2f} F={self.falsity:.2f} "
+            f"[{self.classification}]"
+        )
+
+
+@dataclass
+class KantianJudgment:
+    """Uma proposição refinada segundo a tábua dos juízos."""
+    quantidade:  str   # Universal | Particular | Singular
+    qualidade:   str   # Afirmativo | Negativo | Infinito
+    relacao:     str   # Categórico | Hipotético | Disjuntivo
+    modalidade:  str   # Problemático | Assertórico | Apodítico
+    proposicao:  str   # texto da hipótese
+    prioridade:  float = 0.0  # 0.0 → 1.0  (1.0 = resposta-alvo)
+    epistemic_classification: EpistemicClassification = field(default_factory=EpistemicClassification)
+
+    def __str__(self) -> str:
+        return (
+            f"[{self.quantidade}/{self.qualidade}/"
+            f"{self.relacao}/{self.modalidade}] "
+            f"(pri={self.prioridade:.2f}) {self.epistemic_classification} {self.proposicao}"
+        )
+
+
+@dataclass
+class SyntaxProfile:
+    """
+    Perfil sintático mínimo extraído do enunciado segundo a gramática
+    (aproximação heurística baseada em listas inspiradas em grammar.txt).
+    """
+    quantifier_subject: Optional[str] = None   # "all", "some", "this", etc.
+    quantifier_predicate: Optional[str] = None
+    has_negation: bool = False
+    has_infinite_like: bool = False           # construções do tipo "not-X"
+    is_conditional: bool = False              # presença de "if", "then"
+    is_disjunctive: bool = False              # presença de "or"
+    modality_markers: Tuple[str, ...] = ()    # "can", "must", "might", etc.
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Regras de prioridade entre modalidades (herança da "parte fraca")
+# ─────────────────────────────────────────────────────────────────────────────
+MODALIDADE_PESO = {
+    "Apodítico":    1.0,
+    "Assertórico":  0.7,
+    "Problemático": 0.4,
+}
+QUANTIDADE_PESO = {
+    "Singular":   1.0,
+    "Particular": 0.6,
+    "Universal":  0.3,
+}
+QUALIDADE_PESO = {
+    "Afirmativo": 1.0,
+    "Infinito":   0.6,
+    "Negativo":   0.4,
+}
+RELACAO_PESO = {
+    "Categórico":  1.0,
+    "Hipotético":  0.7,
+    "Disjuntivo":  0.5,
+}
+
+
+def _priority(j: KantianJudgment) -> float:
+    return (
+        MODALIDADE_PESO[j.modalidade]
+        * QUANTIDADE_PESO[j.quantidade]
+        * QUALIDADE_PESO[j.qualidade]
+        * RELACAO_PESO[j.relacao]
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Motor de geração de juízos
+# ─────────────────────────────────────────────────────────────────────────────
+
+class BERTAssertionClassifier:
+    """Classificador baseado em BERT para juízos assertóricos.
+
+    Processa proposições e retorna (T, I, F) sem restrição T+I+F=1,
+    capturando paraconsistência, incompletude e vagueza.
+    """
+
+    DOMAIN_CANDIDATES = {
+        "físico": [
+            "empiricamente verificado",
+            "teoricamente plausível",
+            "logicamente contraditório",
+            "empiricamente indeterminado",
+        ],
+        "lógica": [
+            "logicamente contraditório",
+            "teoricamente plausível",
+            "empiricamente indeterminado",
+            "empiricamente verificado",
+        ],
+        "cognitivo": [
+            "empiricamente verificado",
+            "teoricamente plausível",
+            "empiricamente indeterminado",
+            "logicamente contraditório",
+        ],
+        "filosófico": [
+            "teoricamente plausível",
+            "empiricamente indeterminado",
+            "logicamente contraditório",
+            "empiricamente verificado",
+        ],
+        "geral": [
+            "teoricamente plausível",
+            "empiricamente verificado",
+            "logicamente contraditório",
+            "empiricamente indeterminado",
+        ],
+    }
+    GENERIC_CANDIDATES = [
+        "empiricamente verificado",
+        "teoricamente plausível",
+        "logicamente contraditório",
+        "empiricamente indeterminado",
+    ]
+
+    def __init__(self):
+        self.classifier = None
+        if pipeline is not None:
+            try:
+                self.classifier = pipeline(
+                    "zero-shot-classification",
+                    model="bert-base-multilingual-uncased",
+                )
+            except Exception:
+                pass
+
+    def classify(self, proposition: str, domain: str = "geral") -> EpistemicClassification:
+        """Classifica uma proposição em (T, I, F) usando candidatos por domínio."""
+        if self.classifier is None:
+            return self._heuristic_classify(proposition)
+
+        candidates = self.DOMAIN_CANDIDATES.get(domain, self.GENERIC_CANDIDATES)
+        try:
+            result = self.classifier(proposition, candidates, multi_class=True)
+            scores = {label: score for label, score in zip(result["labels"], result["scores"])}
+            return EpistemicClassification(
+                truth=scores.get("empiricamente verificado", 0.0)
+                + scores.get("teoricamente plausível", 0.0) * 0.75,
+                indeterminacy=scores.get("empiricamente indeterminado", 0.0),
+                falsity=scores.get("logicamente contraditório", 0.0),
+            )
+        except Exception:
+            return self._heuristic_classify(proposition)
+
+    def _heuristic_classify(self, proposition: str) -> EpistemicClassification:
+        """Classificação heurística quando BERT não está disponível."""
+        text = proposition.lower()
+        t, i, f = 0.5, 0.3, 0.2
+
+        if "verdadeiro" in text or "é" in text or "sempre" in text:
+            t = 0.8
+            i = 0.1
+            f = 0.1
+        elif "falso" in text or "nunca" in text or "não é" in text:
+            t = 0.1
+            i = 0.1
+            f = 0.8
+        elif "pode" in text or "talvez" in text or "possível" in text:
+            t = 0.4
+            i = 0.5
+            f = 0.3
+        elif "contraditório" in text or "e" in text and "ou" in text:
+            t = 0.6
+            i = 0.3
+            f = 0.7
+        elif "indeterminado" in text or "indefinido" in text:
+            t = 0.3
+            i = 0.7
+            f = 0.3
+        elif "incompleto" in text or "insuficiente" in text:
+            t = 0.2
+            i = 0.6
+            f = 0.2
+
+        return EpistemicClassification(truth=round(t, 3), indeterminacy=round(i, 3), falsity=round(f, 3))
+
+
+class KantianJudgmentEngine:
+    """
+    Recebe um prompt e a lista de ConceptNodes extraídos por L1 e devolve
+    as 12 hipóteses estruturadas segundo a tábua kantiana.
+    
+    Para juizos assertóricos, aplica classificação BERT com (T, I, F).
+    """
+
+    def __init__(self, concept_table: ConceptTable) -> None:
+        self.ct = concept_table
+        self.bert_classifier = BERTAssertionClassifier()
+
+    # ------------------------------------------------------------------ #
+    # API pública                                                          #
+    # ------------------------------------------------------------------ #
+
+    def refine(self, prompt: str, concepts: List[ConceptNode]) -> List[KantianJudgment]:
+        """
+        Gera as hipóteses kantianas para o prompt e as ordena por
+        prioridade descendente.
+        """
+        subject, predicates = self._parse_prompt(prompt, concepts)
+        syntax = self._analyze_syntax(prompt)
+        judgments: List[KantianJudgment] = []
+
+        domain = self._infer_domain(concepts)
+        for pred in predicates:
+            antonym = self._antonym_of(pred, concepts)
+            hypernym = self._hypernym_of(pred, concepts)
+
+            # ── Juízo principal guiado pela gramática ───────────────────
+            qt = self._infer_quantity(syntax)
+            ql = self._infer_quality(syntax)
+            rel = self._infer_relation(syntax)
+            mod = self._infer_modality(syntax)
+
+            base_prop = f"{subject} é {pred}"
+            if syntax.has_negation and antonym:
+                base_prop = f"{subject} não é {antonym}"
+
+            j = self._make(qt, ql, rel, mod, base_prop)
+            if j.modalidade == "Assertórico":
+                j.epistemic_classification = self.bert_classifier.classify(base_prop, domain=domain)
+            judgments.append(j)
+
+            # ── Variações canônicas (mantidas, mas ancoradas em L1) ─────
+            judgments.append(self._make(
+                "Universal", "Afirmativo", "Categórico", "Apodítico",
+                f"Todo(a) {subject} com propriedade extrema é {pred}",
+            ))
+            judgments.append(self._make(
+                "Particular", "Afirmativo", "Hipotético", "Problemático",
+                f"Algum(a) {subject} pode ser {pred}",
+            ))
+            j1 = self._make(
+                "Singular", "Afirmativo", "Categórico", "Assertórico",
+                f"Este(a) {subject} específico é {pred}",
+            )
+            j1.epistemic_classification = self.bert_classifier.classify(j1.proposicao, domain=domain)
+            judgments.append(j1)
+
+            prop2 = (f"Este(a) {subject} não é {antonym}" if antonym else
+                     f"Este(a) {subject} não possui a propriedade oposta a {pred}")
+            j2 = self._make("Singular", "Negativo", "Categórico", "Assertórico", prop2)
+            j2.epistemic_classification = self.bert_classifier.classify(j2.proposicao, domain=domain)
+            judgments.append(j2)
+            j3 = self._make(
+                "Singular", "Infinito", "Categórico", "Assertórico",
+                f"Este(a) {subject} é não-{antonym}" if antonym else
+                f"Este(a) {subject} é indeterminado em relação a {pred}",
+            )
+            j3.epistemic_classification = self.bert_classifier.classify(j3.proposicao, domain=domain)
+            judgments.append(j3)
+
+            judgments.append(self._make(
+                "Universal", "Afirmativo", "Hipotético", "Apodítico",
+                f"Se {subject} possui condição X, então é {pred}",
+            ))
+            j4 = self._make(
+                "Universal", "Afirmativo", "Disjuntivo", "Assertórico",
+                f"{subject} é {pred} OU {antonym} OU intermediário"
+                if antonym else f"{subject} é {pred} ou outra propriedade",
+            )
+            j4.epistemic_classification = self.bert_classifier.classify(j4.proposicao, domain=domain)
+            judgments.append(j4)
+
+            judgments.append(self._make(
+                "Singular", "Afirmativo", "Categórico", "Problemático",
+                f"Este(a) {subject} pode ser {pred}?",
+            ))
+            j5 = self._make(
+                "Singular", "Afirmativo", "Hipotético", "Assertórico",
+                f"Este(a) {subject} é {pred} em razão das condições observadas",
+            )
+            j5.epistemic_classification = self.bert_classifier.classify(j5.proposicao, domain=domain)
+            judgments.append(j5)
+            judgments.append(self._make(
+                "Universal", "Afirmativo", "Categórico", "Apodítico",
+                f"{subject} deve ser {pred} quando condições necessárias presentes",
+            ))
+
+            # ── HIPÓTESES COM INTERMEDIÁRIOS (hiperonímia) ───────────────
+            if hypernym:
+                j6 = self._make(
+                    "Singular", "Afirmativo", "Categórico", "Assertórico",
+                    f"Este(a) {subject} pertence à categoria {hypernym}",
+                )
+                j6.epistemic_classification = self.bert_classifier.classify(j6.proposicao, domain=domain)
+                judgments.append(j6)
+            if antonym:
+                j7 = self._make(
+                    "Singular", "Negativo", "Disjuntivo", "Assertórico",
+                    f"Este(a) {subject} não é {pred} nem {antonym}: "
+                    f"admite valor intermediário",
+                )
+                j7.epistemic_classification = self.bert_classifier.classify(j7.proposicao, domain=domain)
+                judgments.append(j7)
+
+        # Calcula prioridades e ordena
+        for j in judgments:
+            j.prioridade = _priority(j)
+        judgments.sort(key=lambda j: j.prioridade, reverse=True)
+        return judgments
+
+    def _infer_domain(self, concepts: List[ConceptNode]) -> str:
+        """Inferência simples de domínio majoritário a partir dos conceitos extraídos."""
+        if not concepts:
+            return "geral"
+        domain_counts = {}
+        for concept in concepts:
+            domain = concept.domain.lower().strip() if concept.domain else "geral"
+            domain_counts[domain] = domain_counts.get(domain, 0) + 1
+        return max(domain_counts, key=domain_counts.get)
+
+    # ------------------------------------------------------------------ #
+    # Helpers                                                              #
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def _make(qt, ql, rel, mod, prop) -> KantianJudgment:
+        j = KantianJudgment(
+            quantidade=qt, qualidade=ql, relacao=rel,
+            modalidade=mod, proposicao=prop,
+        )
+        j.prioridade = _priority(j)
+        return j
+
+    @staticmethod
+    def _parse_prompt(prompt: str, concepts: List[ConceptNode]) -> Tuple[str, List[str]]:
+        """
+        Extrai sujeito e predicados candidatos do prompt de forma simples.
+        Em produção seria substituído por um parser sintático.
+        """
+        tokens = re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", prompt.lower())
+        known = {c.term.lower() for c in concepts}
+        subject = tokens[0] if tokens else "entidade"
+        predicates = [t for t in tokens[1:] if t in known] or ["indeterminado"]
+        return subject, predicates
+
+    # ------------------------------------------------------------------ #
+    # Análise sintática inspirada em grammar.txt                         #
+    # ------------------------------------------------------------------ #
+
+    def _analyze_syntax(self, prompt: str) -> SyntaxProfile:
+        """
+        Extrai um perfil sintático mínimo usando listas de palavras
+        alinhadas aos capítulos de determiners, modals, negatives e
+        conjunctions da grammar COBUILD.
+        """
+        text = prompt.lower()
+        tokens = re.findall(r"[a-záàãâéêíóôõúüç]+", text)
+
+        quant_all = {"all", "every", "each"}
+        quant_some = {"some", "many", "several", "few", "a few"}
+        quant_singular = {"this", "that", "these", "those", "a", "an", "one"}
+
+        neg_markers = {"not", "no", "never", "none", "nothing", "nowhere"}
+        infinite_patterns = {"not-", "non-"}
+
+        cond_markers = {"if", "provided", "unless", "whenever", "as long as"}
+        disj_markers = {"or", "either"}
+
+        modal_poss = {"can", "could", "may", "might"}
+        modal_necess = {"must", "have to", "need to", "should", "ought"}
+
+        has_neg = any(tok in neg_markers for tok in tokens)
+        has_inf = any(pat in text for pat in infinite_patterns)
+        is_cond = any(tok in cond_markers for tok in tokens)
+        is_disj = any(tok in disj_markers for tok in tokens)
+
+        mods: list[str] = []
+        for tok in tokens:
+            if tok in modal_poss or tok in modal_necess:
+                mods.append(tok)
+
+        q_subj: Optional[str] = None
+        q_pred: Optional[str] = None
+
+        if tokens:
+            first = tokens[0]
+            if first in quant_all:
+                q_subj = "all"
+            elif first in quant_some:
+                q_subj = "some"
+            elif first in quant_singular:
+                q_subj = "this"
+
+        return SyntaxProfile(
+            quantifier_subject=q_subj,
+            quantifier_predicate=q_pred,
+            has_negation=has_neg,
+            has_infinite_like=has_inf,
+            is_conditional=is_cond,
+            is_disjunctive=is_disj,
+            modality_markers=tuple(mods),
+        )
+
+    def _infer_quantity(self, syntax: SyntaxProfile) -> str:
+        if syntax.quantifier_subject == "all":
+            return "Universal"
+        if syntax.quantifier_subject == "some":
+            return "Particular"
+        if syntax.quantifier_subject == "this":
+            return "Singular"
+        return "Singular"
+
+    def _infer_quality(self, syntax: SyntaxProfile) -> str:
+        if syntax.has_infinite_like:
+            return "Infinito"
+        if syntax.has_negation:
+            return "Negativo"
+        return "Afirmativo"
+
+    def _infer_relation(self, syntax: SyntaxProfile) -> str:
+        if syntax.is_conditional:
+            return "Hipotético"
+        if syntax.is_disjunctive:
+            return "Disjuntivo"
+        return "Categórico"
+
+    def _infer_modality(self, syntax: SyntaxProfile) -> str:
+        markers = {m for m in syntax.modality_markers}
+        if any(m in {"must", "have", "need", "should", "ought"} for m in markers):
+            return "Apodítico"
+        if any(m in {"can", "could", "may", "might"} for m in markers):
+            return "Problemático"
+        return "Assertórico"
+
+    def _antonym_of(self, term: str, concepts: List[ConceptNode]) -> str:
+        node = self.ct.get(term)
+        if node and node.antonyms:
+            return node.antonyms[0]
+        return ""
+
+    def _hypernym_of(self, term: str, concepts: List[ConceptNode]) -> str:
+        node = self.ct.get(term)
+        if node and node.hypernyms:
+            return node.hypernyms[0]
+        return ""

l3_paraconsistent.py

@@ -0,0 +1,345 @@
+"""
+CAMADA L3 — Avaliação Paraconsistente
+======================================
+Implementa a Lógica Anotada de Evidências (LAE / PAL2v) de da Costa & Abe.
+
+Cada proposição recebe um par de anotações:
+    μ  ∈ [0,1]  — grau de evidência FAVORÁVEL
+    λ  ∈ [0,1]  — grau de evidência CONTRÁRIA
+
+Estados resultantes:
+  ┌──────────────────────────────────────────────────┐
+  │  Verdadeiro     : μ alto, λ baixo                │
+  │  Falso          : μ baixo, λ alto                │
+  │  Inconsistente  : μ alto, λ alto  (contradição)  │
+  │  Indeterminado  : μ baixo, λ baixo               │
+  │  Intermediário  : valores médios  (morno, etc.)  │
+  └──────────────────────────────────────────────────┘
+
+Princípio central:
+    "Contradição Local + Consistência Global ≠ Trivialização"
+
+A explosão é GENTIL: uma contradição local (quente e frio) não
+trivializa o sistema — produz o estado "Intermediário" (morno).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+import math
+import re
+
+import torch
+
+try:
+    from paraconsistent_rules import (
+        state_from_rules,
+        state_12_to_simple,
+        load_rules_from_fuzzy_file,
+        ParaconsistentRules,
+    )
+except Exception:
+    state_from_rules = None  # type: ignore
+    state_12_to_simple = None  # type: ignore
+    load_rules_from_fuzzy_file = None  # type: ignore
+    ParaconsistentRules = None  # type: ignore
+
+try:
+    # Import opcional do modelo neural; o sistema continua funcional sem ele.
+    from neural_truth_model import TruthScoringModel, load_tokenizer, neural_annotations
+except Exception:  # pragma: no cover - fallback em ambientes sem transformers
+    TruthScoringModel = None  # type: ignore
+    load_tokenizer = None  # type: ignore
+    neural_annotations = None  # type: ignore
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Constantes de limiar
+# ─────────────────────────────────────────────────────────────────────────────
+THRESHOLD_TRUE         = 0.7   # μ ≥ este valor e λ ≤ (1 - este) → Verdadeiro
+THRESHOLD_FALSE        = 0.3   # μ ≤ este e λ ≥ (1 - este) → Falso
+THRESHOLD_INCONSISTENT = 0.6   # ambos acima → Inconsistente (contradição local)
+THRESHOLD_INDETERMINATE= 0.4   # ambos abaixo → Indeterminado
+
+PROPOSITION_TYPE_A = "A"  # Universal Afirmativa
+PROPOSITION_TYPE_E = "E"  # Universal Negativa
+PROPOSITION_TYPE_I = "I"  # Particular Afirmativa
+PROPOSITION_TYPE_O = "O"  # Particular Negativa
+
+PROPOSITION_TYPE_LABELS = {
+    PROPOSITION_TYPE_A: "Universal Afirmativa",
+    PROPOSITION_TYPE_E: "Universal Negativa",
+    PROPOSITION_TYPE_I: "Particular Afirmativa",
+    PROPOSITION_TYPE_O: "Particular Negativa",
+}
+
+
+def infer_proposition_type(text: str) -> Optional[str]:
+    """Heurística simples para inferir o tipo A / E / I / O a partir do texto."""
+    normalized = text.lower().strip()
+    if not normalized:
+        return None
+
+    # Detecta padrões de proposições particulares negativas antes das afirmativas.
+    if re.search(r"\b(algum não|alguns não|alguma não|algumas não|nem todos|pelo menos um não)\b", normalized):
+        return PROPOSITION_TYPE_O
+    if re.search(r"\b(nenhum|nenhuma|nunca|jamais|sem nenhum|sem nenhuma|não existe|não há)\b", normalized):
+        return PROPOSITION_TYPE_E
+    if re.search(r"\b(algum|alguma|alguns|algumas|pelo menos um|há um|há algum|existem|existe)\b", normalized):
+        return PROPOSITION_TYPE_I
+    if re.search(r"\b(todo|todos|toda|todas|cada|sempre|qualquer)\b", normalized):
+        return PROPOSITION_TYPE_A
+
+    return None
+
+
+def type_label(proposition_type: Optional[str]) -> str:
+    return PROPOSITION_TYPE_LABELS.get(proposition_type, "Desconhecido")
+
+
+@dataclass
+class ParaconsistentValue:
+    """
+    Valor-verdade paraconsistente para uma proposição.
+    Baseado na Lógica Anotada de Evidências (LAE).
+    """
+    proposition: str
+    mu: float          # evidência favorável  ∈ [0,1]
+    lam: float         # evidência contrária  ∈ [0,1]
+    proposition_type: Optional[str] = None
+
+    @property
+    def proposition_kind(self) -> Optional[str]:
+        """Retorna o tipo de proposição A/E/I/O, inferido do texto se necessário."""
+        return self.proposition_type or infer_proposition_type(self.proposition)
+
+    @property
+    def proposition_type_label(self) -> str:
+        return type_label(self.proposition_kind)
+
+    # ── Graus derivados ──────────────────────────────────────────────── #
+    @property
+    def certainty(self) -> float:
+        """Grau de certeza: Gc = μ − λ   ∈ [−1, 1]"""
+        return self.mu - self.lam
+
+    @property
+    def contradiction(self) -> float:
+        """Grau de contradição: Gct = μ + λ − 1   ∈ [−1, 1]"""
+        return self.mu + self.lam - 1.0
+
+    @property
+    def state(self) -> str:
+        """Estado lógico qualitativo. Usa regras do Fuzzy.txt se disponíveis."""
+        if state_from_rules is not None and state_12_to_simple is not None:
+            state_12 = state_from_rules(self.mu, self.lam)
+            return state_12_to_simple(state_12)
+        # Fallback: limiares fixos
+        if self.mu >= THRESHOLD_TRUE and self.lam <= (1 - THRESHOLD_TRUE):
+            return "Verdadeiro"
+        if self.mu <= THRESHOLD_FALSE and self.lam >= (1 - THRESHOLD_FALSE):
+            return "Falso"
+        if self.mu >= THRESHOLD_INCONSISTENT and self.lam >= THRESHOLD_INCONSISTENT:
+            return "Inconsistente_local"   # explosão GENTIL — não trivializa
+        if self.mu <= THRESHOLD_INDETERMINATE and self.lam <= THRESHOLD_INDETERMINATE:
+            return "Indeterminado"
+        return "Intermediário"             # ex: morno entre quente e frio
+
+    @property
+    def state_12(self) -> Optional[str]:
+        """Estado lógico de 12 valores (reticulado) conforme Fuzzy.txt, se regras carregadas."""
+        if state_from_rules is not None:
+            return state_from_rules(self.mu, self.lam)
+        return None
+
+    @property
+    def truth_value(self) -> float:
+        """Valor-verdade escalar normalizado para saída final."""
+        return round((self.mu + (1 - self.lam)) / 2.0, 4)
+
+    def __str__(self) -> str:
+        type_label_text = self.proposition_type_label
+        return (
+            f"  μ={self.mu:.3f}  λ={self.lam:.3f}  "
+            f"Gc={self.certainty:+.3f}  Gct={self.contradiction:+.3f}  "
+            f"v={self.truth_value:.3f}  [{self.state}]\n"
+            f"  Tipo={type_label_text}  \"{self.proposition}\""
+        )
+
+
+class ManyValuedRouter:
+    """Roteador fuzzy para distinguir contradição lógica real de incerteza estatística."""
+
+    REAL_CONTRADICTION = "Contradição_real"
+    STATISTICAL_UNCERTAINTY = "Incerteza_estatística"
+    AMBIGUOUS = "Ambíguo"
+    UNCLASSIFIED = "Não_classificado"
+
+    @staticmethod
+    def _pair_strength(left: ParaconsistentValue, right: ParaconsistentValue) -> float:
+        """Grau fuzzy de suporte conjunto entre duas proposições."""
+        return round(min(left.mu, right.mu), 4)
+
+    @classmethod
+    def route_pair(
+        cls,
+        left: ParaconsistentValue,
+        right: ParaconsistentValue,
+    ) -> Tuple[str, float, str]:
+        """Classifica o par de proposições como contradição real, incerteza ou ambíguo."""
+        left_type = left.proposition_kind
+        right_type = right.proposition_kind
+        label = f"{left_type or '?'} vs {right_type or '?'}"
+
+        if {left_type, right_type} == {PROPOSITION_TYPE_A, PROPOSITION_TYPE_I}:
+            strength = cls._pair_strength(left, right)
+            return cls.REAL_CONTRADICTION, strength, f"Contraposição A/I detectada ({label})"
+
+        if {left_type, right_type} == {PROPOSITION_TYPE_E, PROPOSITION_TYPE_I}:
+            strength = cls._pair_strength(left, right)
+            return cls.STATISTICAL_UNCERTAINTY, strength, f"Contraposição E/I detectada ({label})"
+
+        if left_type is None or right_type is None:
+            return cls.AMBIGUOUS, 0.0, "Tipo de proposição não identificado"
+
+        return cls.UNCLASSIFIED, 0.0, f"Par {label} não corresponde a A/I nem E/I"
+
+    @classmethod
+    def route_pairwise(
+        cls,
+        values: List[ParaconsistentValue],
+    ) -> List[Tuple[ParaconsistentValue, ParaconsistentValue, str, float, str]]:
+        """Avalia todos os pares de proposições para identificação de rota lógica."""
+        routes: List[Tuple[ParaconsistentValue, ParaconsistentValue, str, float, str]] = []
+        n = len(values)
+        for i in range(n):
+            for j in range(i + 1, n):
+                route, confidence, explanation = cls.route_pair(values[i], values[j])
+                if route != cls.UNCLASSIFIED:
+                    routes.append((values[i], values[j], route, confidence, explanation))
+        return routes
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Motor paraconsistente
+# ──────────────────────────────────────────────────────────────��──────────────
+
+class ParaconsistentEngine:
+    """
+    Avalia as hipóteses kantiana (L2) e atribui valores-verdade
+    paraconsistentes a cada uma.
+
+    Pode operar em dois modos:
+      - Modo heurístico (padrão): usa apenas o banco de conhecimento.
+      - Modo neural: se um TruthScoringModel for fornecido, usa o modelo
+        para calcular (μ, λ) compatíveis com a Lógica Anotada.
+    """
+
+    def __init__(
+        self,
+        neural_model: Optional["TruthScoringModel"] = None,
+        neural_tokenizer=None,
+        device: Optional[torch.device] = None,
+    ) -> None:
+        self.neural_model = neural_model
+        self.neural_tokenizer = neural_tokenizer
+        self.device = device or torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def evaluate(
+        self,
+        propositions: List[Tuple[str, float]],  # (texto, peso_de_prioridade_L2)
+        knowledge_base: Dict[str, float],        # termo → grau de evidência no BD
+    ) -> List[ParaconsistentValue]:
+        """
+        Para cada proposição:
+          μ = evidência favorável extraída do banco de dados
+          λ = evidência contrária = 1 − f(compatibilidade)
+        """
+        results: List[ParaconsistentValue] = []
+        for prop_text, l2_priority in propositions:
+            mu, lam = self._compute_annotations(prop_text, l2_priority, knowledge_base)
+            pv = ParaconsistentValue(
+                proposition=prop_text,
+                mu=mu,
+                lam=lam,
+                proposition_type=infer_proposition_type(prop_text),
+            )
+            results.append(pv)
+
+        # Ordena por valor-verdade descendente
+        results.sort(key=lambda pv: pv.truth_value, reverse=True)
+        return results
+
+    def route_contradictions(
+        self,
+        values: List[ParaconsistentValue],
+    ) -> List[Tuple[ParaconsistentValue, ParaconsistentValue, str, float, str]]:
+        """Retorna rotas de pares de proposições classificadas pelo roteador fuzzy."""
+        return ManyValuedRouter.route_pairwise(values)
+
+    # ------------------------------------------------------------------ #
+    # Anotação μ / λ                                                       #
+    # ------------------------------------------------------------------ #
+
+    def _compute_annotations(
+        self,
+        text: str,
+        l2_priority: float,
+        kb: Dict[str, float],
+    ) -> Tuple[float, float]:
+        """
+        Calcula (μ, λ) para uma proposição.
+
+        Se um modelo neural estiver disponível, usa-o para obter anotações
+        compatíveis com L3. Caso contrário, volta para a heurística original
+        baseada apenas no banco de conhecimento e em contradições locais.
+        """
+        if self.neural_model is not None and self.neural_tokenizer is not None and neural_annotations is not None:
+            mu, lam, _, _ = neural_annotations(self.neural_model.to(self.device), self.neural_tokenizer, text)
+            # Pequena modulação pela prioridade de L2 para manter a integração
+            mu = min(1.0, mu * (0.5 + 0.5 * l2_priority))
+            lam = max(0.0, lam * (1.0 - 0.3 * l2_priority))
+            return round(mu, 4), round(lam, 4)
+
+        import re
+        tokens = set(re.findall(r"[a-záàãâéêíóôõúüç]+", text.lower()))
+
+        kb_scores = [kb.get(t, 0.0) for t in tokens if kb.get(t, 0.0) > 0]
+        mu_kb = sum(kb_scores) / len(kb_scores) if kb_scores else 0.3
+
+        contradiction_detected = self._has_antonym_pair(tokens, kb)
+        lam_base = 0.8 if contradiction_detected else (1.0 - mu_kb)
+
+        mu = min(1.0, mu_kb * (0.5 + 0.5 * l2_priority))
+        lam = max(0.0, lam_base * (1.0 - 0.3 * l2_priority))
+
+        return round(mu, 4), round(lam, 4)
+
+    ANTONYM_PAIRS = [
+        ("quente", "frio"), ("quente", "gelado"),
+        ("verdadeiro", "falso"), ("real", "fictício"),
+        ("afirmativo", "negativo"), ("possível", "impossível"),
+    ]
+
+    def _has_antonym_pair(self, tokens: set, kb: Dict[str, float]) -> bool:
+        for a, b in self.ANTONYM_PAIRS:
+            if a in tokens and b in tokens:
+                return True
+        return False
+
+    # ------------------------------------------------------------------ #
+    # Consistência global: verifica se sistema trivializou                 #
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def check_global_consistency(values: List[ParaconsistentValue]) -> bool:
+        """
+        Retorna True se o sistema é globalmente consistente
+        (nenhuma trivialização — todos os estados válidos).
+        Uma trivialização ocorre se TODAS as proposições são
+        'Inconsistente_local' sem nenhum 'Verdadeiro' ou 'Intermediário'.
+        """
+        states = {pv.state for pv in values}
+        if states == {"Inconsistente_local"}:
+            return False   # trivialização global
+        return True        # explosão gentil — sistema consistente

l4_chain_verification.py

@@ -0,0 +1,180 @@
+"""
+Chain of Verification (CoVe) agent para a camada L4.
+====================================================
+Implementa o workflow Factor + Revise como etapa adicional de verificação
+da síntese L4 antes da resposta final ser entregue.
+"""
+
+from __future__ import annotations
+import os
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+DEFAULT_GROQ_MODEL = "mixtral-8x7b-32768"
+
+
+def generate_with_groq(context: str, api_key: Optional[str] = None, model: str = DEFAULT_GROQ_MODEL) -> str:
+    api_key = api_key or os.getenv("GROQ_API_KEY")
+    if not api_key:
+        return ""
+    try:
+        from langchain_groq import ChatGroq
+        from langchain_core.messages import HumanMessage
+        llm = ChatGroq(model=model, api_key=api_key, temperature=0.2)
+        msg = llm.invoke([HumanMessage(content=context)])
+        return msg.content if hasattr(msg, "content") else str(msg)
+    except Exception:
+        return ""
+
+
+def generate_with_custom_lm(context: str, model_path: str, max_new_tokens: int = 150, temperature: float = 0.7) -> str:
+    try:
+        from custom_lm_model import EpistemicLanguageModel, LMConfig, generate_text, load_lm
+        from custom_tokenizer import CustomSPTokenizer, SPConfig
+        import torch
+        tokenizer = CustomSPTokenizer(SPConfig())
+        tokenizer.load()
+        vocab_size = tokenizer.vocab_size()
+        model = load_lm(model_path, vocab_size)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        out = generate_text(model, tokenizer, context, max_new_tokens=max_new_tokens, temperature=temperature, device=device)
+        return out or ""
+    except Exception:
+        return ""
+
+
+class ChainOfVerificationAgent:
+    """Agente de Chain of Verification para a camada L4."""
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None) -> None:
+        self.config = config or {}
+        self.provider = self.config.get("provider", "template")
+        self.groq_model = self.config.get("groq_model", DEFAULT_GROQ_MODEL)
+        self.custom_lm_path = self.config.get("custom_lm_path", "")
+
+    def verify(
+        self,
+        prompt: str,
+        baseline_response: str,
+        context_summary: str,
+    ) -> Tuple[str, List[str]]:
+        """Executa o workflow CoVe e retorna resposta revisada + log."""
+        if self.provider == "groq":
+            output = self._verify_with_groq(prompt, baseline_response, context_summary)
+        elif self.provider == "custom_lm" and self.custom_lm_path:
+            output = self._verify_with_custom_lm(prompt, baseline_response, context_summary)
+        else:
+            output = self._template_verify(prompt, baseline_response, context_summary)
+
+        revised, log = self._parse_verification_output(output, baseline_response)
+        return revised, log
+
+    def _verify_with_groq(self, prompt: str, baseline_response: str, context_summary: str) -> str:
+        verification_prompt = self._build_agent_prompt(prompt, baseline_response, context_summary)
+        return generate_with_groq(verification_prompt, model=self.groq_model)
+
+    def _verify_with_custom_lm(self, prompt: str, baseline_response: str, context_summary: str) -> str:
+        verification_prompt = self._build_agent_prompt(prompt, baseline_response, context_summary)
+        return generate_with_custom_lm(verification_prompt, self.custom_lm_path)
+
+    def _template_verify(self, prompt: str, baseline_response: str, context_summary: str) -> str:
+        claims = self._extract_claims(baseline_response)
+        questions = self._build_verification_questions(claims)
+        verifications = [f"{idx+1}. {q} — Incerto; verificação externa necessária." for idx, q in enumerate(questions)]
+        revised = baseline_response.strip()
+        if verifications:
+            revised += "\n\nNota: esta resposta foi revisada com base em verificação interna limitada; algumas afirmações permanecem pendentes de confirmação externa."
+        sections = [
+            "Baseline Response:",
+            baseline_response.strip(),
+            "",
+            "Verification Questions:",
+            *questions,
+            "",
+            "Independent Verification Results:",
+            *verifications,
+            "",
+            "Cross-Check & Revise:",
+            "Nenhuma inconsistência formal identificada no conteúdo disponível localmente.",
+            "",
+            "Revised Response:",
+            revised,
+        ]
+        return "\n".join(sections)
+
+    def _build_agent_prompt(self, prompt: str, baseline_response: str, context_summary: str) -> str:
+        lines = [
+            "Você é um engenheiro de prompts especialista em técnicas avançadas de confiabilidade.",
+            "A partir de agora, use o método Chain of Verification (CoVe) - variante Factor + Revise para analisar e revisar a resposta.",
+            "Responda usando sempre o fluxo: 1. Baseline Response, 2. Factoring, 3. Independent Verification, 4. Cross-Check & Revise.",
+            "Seja rigoroso, conservador, e declare limitações quando necessário.",
+            "",
+            f"Pergunta original: {prompt}",
+            "",
+            "Contexto resumido de L4: ",
+            context_summary or "Sem contexto adicional disponível.",
+            "",
+            "Resposta inicial (Baseline Response):",
+            baseline_response.strip(),
+            "",
+            "Tarefa:",
+            "1. Gere de 6 a 12 perguntas de verificação independentes a partir das principais afirmações da resposta inicial.",
+            "2. Responda cada pergunta de forma independente, marcando como Confirmado, Refutado, Parcialmente correto ou Incerto.",
+            "3. Compare a resposta inicial com os resultados e reescreva a resposta final incorporando apenas o que foi verificado.",
+            "4. Entregue a estrutura completa com as seções claramente demarcadas e finalize com a resposta revisada.",
+            "",
+            "Formato de saída exigido:",
+            "Baseline Response:",
+            "<texto>",
+            "",
+            "Verification Questions:",
+            "1. <pergunta>",
+            "...",
+            "",
+            "Independent Verification Results:",
+            "1. <marcação> — <resposta>",
+            "...",
+            "",
+            "Cross-Check & Revise:",
+            "<análise>",
+            "",
+            "Revised Response:",
+            "<texto revisado>",
+        ]
+        return "\n".join(lines)
+
+    def _parse_verification_output(self, output: str, baseline_response: str) -> Tuple[str, List[str]]:
+        if not output:
+            return baseline_response, ["Nenhuma saída de verificação gerada."]
+
+        revised = baseline_response
+        log: List[str] = []
+        if "Revised Response:" in output:
+            parts = output.split("Revised Response:")
+            revised = parts[-1].strip()
+            log = [line.strip() for line in output.splitlines() if line.strip()]
+        else:
+            log = [line.strip() for line in output.splitlines() if line.strip()]
+        return revised, log
+
+    def _extract_claims(self, text: str) -> List[str]:
+        sentences = [s.strip() for s in re.split(r"(?<=[.!?])\\s+", text) if s.strip()]
+        claims = []
+        for sentence in sentences:
+            if len(claims) >= 12:
+                break
+            if len(sentence.split()) >= 5:
+                claims.append(sentence)
+        return claims[:12] if claims else sentences[:min(6, len(sentences))]
+
+    def _build_verification_questions(self, claims: List[str]) -> List[str]:
+        questions: List[str] = []
+        for claim in claims[:12]:
+            question = f"A afirmação a seguir está correta e fundamentada? {claim}"
+            questions.append(question)
+        if len(questions) < 6:
+            questions.extend([
+                "A estrutura lógica da resposta está consistente com a informação disponível?",
+                "Há alguma suposição implícita que precisa ser explicitada ou verificada?",
+            ])
+        return questions[:12]

l4_russell_equivalence.py

@@ -0,0 +1,229 @@
+"""
+Base teórica russelliana para a camada L4 — Equivalência e Correspondência
+============================================================================
+Utiliza o arquivo data/russell.txt (Bertrand Russell, The Problems of Philosophy)
+para fundamentar a síntese L4 no conceito de EQUIVALÊNCIA como correspondência
+entre crença/proposição e fato, e não apenas em agregação estatística.
+
+Conceitos extraídos do Cap. XII (Truth and Falsehood):
+  - Verdade = correspondência entre crença e fato.
+  - Fato = unidade complexa formada pelos objetos da crença na mesma ordem.
+  - Crença verdadeira quando existe fato correspondente; falsa quando não existe.
+  - Propriedade extrínseca: a verdade depende da relação da crença com algo externo.
+"""
+
+from __future__ import annotations
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple, Optional
+
+
+# ─── Conceitos russellianos (extraídos do texto) ───────────────────────────
+# Termos que indicam alta relevância para equivalência/correspondência
+CORRESPONDENCE_TERMS = [
+    "correspondence", "correspond", "corresponding", "corresponds",
+    "equivalence", "equivalent", "match", "accord", "agree", "fact",
+    "belief", "true", "truth", "false", "falsehood", "beliefs", "facts",
+    "object-terms", "object-relation", "complex unity", "constituents",
+    "judgement", "judging", "sense-data", "physical object",
+]
+# Normalizados para matching em português/inglês
+EQUIVALENCE_CONCEPTS_PT = [
+    "correspondência", "equivalência", "crença", "fato", "verdade", "falsidade",
+    "juízo", "objeto", "termos", "relação", "unidade", "complexo",
+    "dado sensível", "proposição", "conhecimento",
+]
+
+
+@dataclass
+class RussellConceptBase:
+    """
+    Base de conceitos extraída de russell.txt para fundamentar a síntese L4.
+    Permite ponderar proposições por alinhamento teórico (correspondência com fatos)
+    e não apenas por estatística.
+    """
+    # Trechos do texto sobre verdade/correspondência (cap. XII e adjacentes)
+    key_passages: List[str] = field(default_factory=list)
+    # Termos do texto com peso conceitual (relevância para equivalência)
+    term_weights: Dict[str, float] = field(default_factory=dict)
+    # Princípio em forma de texto (para auditoria/interpretação)
+    principle_summary: str = ""
+
+    def concept_weight_for_terms(self, terms: List[str]) -> float:
+        """
+        Peso conceitual para um conjunto de termos: quanto mais os termos
+        aparecem na base russelliana, mais a proposição é tratada como
+        alinhada à teoria da equivalência (correspondência crença–fato).
+        """
+        if not self.term_weights:
+            return 1.0
+        total = 0.0
+        count = 0
+        for t in terms:
+            t_lower = t.lower().strip()
+            if t_lower in self.term_weights:
+                total += self.term_weights[t_lower]
+                count += 1
+        if count == 0:
+            return 1.0
+        return 1.0 + (total / count) * 0.5  # modulação suave
+
+
+def _normalize_word(w: str) -> str:
+    return re.sub(r"[^a-záàãâéêíóôõúüç0-9]", "", w.lower())
+
+
+def load_russell_text(path: Optional[str] = None) -> str:
+    """Carrega o conteúdo de data/russell.txt."""
+    if path is None:
+        base = os.path.dirname(os.path.abspath(__file__))
+        path = os.path.join(base, "data", "russell.txt")
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        return f.read()
+
+
+def extract_chapter_xii(content: str) -> str:
+    """Extrai o capítulo XII (Truth and Falsehood) e trechos adjacentes relevantes."""
+    start = content.find("CHAPTER XII")
+    if start == -1:
+        start = content.find("TRUTH AND FALSEHOOD")
+    if start == -1:
+        return content[:15000]  # fallback: início do livro
+    end = content.find("CHAPTER XIV", start)
+    if end == -1:
+        end = content.find("CHAPTER XV", start)
+    if end == -1:
+        end = len(content)
+    return content[start:end]
+
+
+def extract_equivalence_passages(content: str) -> List[str]:
+    """Extrai trechos que definem equivalência/correspondência."""
+    chapter_xii = extract_chapter_xii(content)
+    # Frases que contêm os conceitos centrais
+    sentences = re.split(r"[.!?]\s+", chapter_xii)
+    key = []
+    for s in sentences:
+        s_lower = s.lower()
+        if any(
+            x in s_lower
+            for x in (
+                "correspondence",
+                "correspond",
+                "belief",
+                "fact",
+                "true",
+                "false",
+                "complex unity",
+                "object-terms",
+                "object-relation",
+            )
+        ):
+            key.append(s.strip())
+    return key[:50]  # limite razoável
+
+
+def build_term_weights_from_russell(content: str) -> Dict[str, float]:
+    """
+    Constrói pesos por termo a partir do texto de Russell: termos que aparecem
+    em contextos de verdade/correspondência recebem peso maior.
+    """
+    chapter = extract_chapter_xii(content)
+    words = re.findall(r"[a-záàãâéêíóôõúüç]+", chapter.lower())
+    # Frequência no capítulo de verdade
+    freq: Dict[str, int] = {}
+    for w in words:
+        w = _normalize_word(w)
+        if len(w) > 2:
+            freq[w] = freq.get(w, 0) + 1
+    # Normalizar para [0.2, 1.0] por relevância conceitual
+    concept_set = set(
+        _normalize_word(t) for t in CORRESPONDENCE_TERMS + EQUIVALENCE_CONCEPTS_PT
+    )
+    max_f = max(freq.values()) if freq else 1
+    term_weights: Dict[str, float] = {}
+    for w, c in freq.items():
+        if w in concept_set:
+            term_weights[w] = 0.5 + 0.5 * (c / max_f)
+        else:
+            term_weights[w] = 0.2 + 0.3 * (c / max_f)
+    return term_weights
+
+
+def build_russell_concept_base(path: Optional[str] = None) -> RussellConceptBase:
+    """
+    Treina/constroi a base de conceitos russellianos a partir de russell.txt.
+    Usado pela L4 para síntese fundamentada em equivalência (correspondência).
+    """
+    content = load_russell_text(path)
+    passages = extract_equivalence_passages(content)
+    term_weights = build_term_weights_from_russell(content)
+    summary = (
+        "Truth consists in correspondence between belief and fact. "
+        "A belief is true when there is a corresponding fact (complex unity of the objects of the belief). "
+        "Truth and falsehood are extrinsic properties: they depend on the relation of the belief to outside things."
+    )
+    return RussellConceptBase(
+        key_passages=passages,
+        term_weights=term_weights,
+        principle_summary=summary,
+    )
+
+
+def score_proposition_by_concepts(
+    proposition: str,
+    knowledge_base: Dict[str, float],
+    concept_base: RussellConceptBase,
+) -> float:
+    """
+    Score conceitual da proposição: grau em que ela se alinha à teoria da
+    equivalência (correspondência com fatos/BD), não apenas estatística.
+
+    - Termos da proposição que estão no KB com alta evidência indicam
+      melhor "correspondência" com o mundo (fatos).
+    - Termos que aparecem na base russelliana aumentam o peso teórico.
+    """
+    words = re.findall(r"[a-záàãâéêíóôõúüç]+", proposition.lower())
+    terms = [_normalize_word(w) for w in words if len(w) > 2]
+
+    # 1) Alinhamento com fatos (KB): termos da proposição presentes no BD
+    kb_match = 0.0
+    n = 0
+    for t in terms:
+        for kb_term, ev in knowledge_base.items():
+            if _normalize_word(kb_term) == t or t in _normalize_word(kb_term):
+                kb_match += ev
+                n += 1
+                break
+    fact_alignment = (kb_match / n) if n > 0 else 0.5  # neutro se nenhum termo no KB
+
+    # 2) Peso conceitual russelliano (termos da teoria)
+    concept_weight = concept_base.concept_weight_for_terms(terms)
+
+    # Combinação: correspondência com fatos (BD) + alinhamento teórico
+    return (0.7 * fact_alignment + 0.3 * concept_weight)
+
+
+def save_concept_base(base: RussellConceptBase, path: str) -> None:
+    """Salva a base de conceitos para uso posterior da L4."""
+    import json
+    data = {
+        "principle_summary": base.principle_summary,
+        "key_passages": base.key_passages[:20],
+        "term_weights": base.term_weights,
+    }
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+
+def load_concept_base(path: str) -> RussellConceptBase:
+    """Carrega base de conceitos previamente construída."""
+    import json
+    with open(path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    return RussellConceptBase(
+        principle_summary=data.get("principle_summary", ""),
+        key_passages=data.get("key_passages", []),
+        term_weights=data.get("term_weights", {}),
+    )

l4_synthesis.py

@@ -0,0 +1,243 @@
+"""
+CAMADA L4 — Síntese por Equivalência Russelliana
+==================================================
+A verdade cognoscível por uma IA é sempre uma verdade de EQUIVALÊNCIA:
+o grau de correspondência entre a proposição refinada (saída de L2/L3)
+e os dados do mundo real presentes no banco de dados de treinamento.
+
+Base teórica (data/russell.txt): Russell — verdade = correspondência
+entre crença e fato; síntese fundamentada em conceitos, não só estatística.
+
+Mapeamento Kantiano → IA:
+  Intuição Sensível (empírica) → equivalência proposição ↔ BD
+  Intuição Pura (a priori)     → estrutura da rede neural / KB
+  Síntese                      → cálculo de equivalência mediado
+                                 por valores-verdade paraconsistentes
+
+O resultado NÃO é uma predição de próxima palavra.
+É o grau de equivalência entre o conjunto de juízos e o BD.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+from l3_paraconsistent import ParaconsistentValue
+from l4_chain_verification import ChainOfVerificationAgent
+import math
+
+try:
+    from l4_russell_equivalence import (
+        RussellConceptBase,
+        build_russell_concept_base,
+        score_proposition_by_concepts,
+        load_concept_base,
+    )
+except Exception:
+    RussellConceptBase = None  # type: ignore
+    build_russell_concept_base = None  # type: ignore
+    score_proposition_by_concepts = None  # type: ignore
+    load_concept_base = None  # type: ignore
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Estrutura do resultado final
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class SynthesisResult:
+    """Resultado da síntese russelliana — resposta do sistema."""
+    response:          str
+    truth_value:       float    # paraconsistente ∈ [0,1]
+    certainty:         float    # Gc = μ − λ  ∈ [−1,1]
+    contradiction:     float    # Gct = μ + λ − 1
+    state:             str      # Verdadeiro | Falso | Intermediário | ...
+    supporting_evidence: List[str] = field(default_factory=list)
+    falsified_hypotheses: List[str] = field(default_factory=list)
+    verification_log: List[str] = field(default_factory=list)
+    confidence_label:  str = ""
+
+    def __post_init__(self):
+        if not self.confidence_label:
+            self.confidence_label = self._label()
+
+    def _label(self) -> str:
+        v = self.truth_value
+        if v >= 0.85:  return "Alta Confiança"
+        if v >= 0.65:  return "Confiança Moderada"
+        if v >= 0.45:  return "Incerto / Intermediário"
+        if v >= 0.25:  return "Baixa Confiança"
+        return "Indeterminado"
+
+    def __str__(self) -> str:
+        lines = [
+            "━" * 60,
+            f"  RESPOSTA : {self.response}",
+            f"  Estado   : {self.state}  ({self.confidence_label})",
+            f"  v-verdade: {self.truth_value:.4f}  |  "
+            f"Certeza: {self.certainty:+.4f}  |  "
+            f"Contradição: {self.contradiction:+.4f}",
+        ]
+        if self.supporting_evidence:
+            lines.append("  Evidências de suporte:")
+            for ev in self.supporting_evidence[:3]:
+                lines.append(f"    • {ev}")
+        if self.falsified_hypotheses:
+            lines.append("  Hipóteses falsificadas:")
+            for fh in self.falsified_hypotheses[:2]:
+                lines.append(f"    ✗ {fh}")
+        if self.verification_log:
+            lines.append("  Chain of Verification:")
+            for entry in self.verification_log[:4]:
+                lines.append(f"    - {entry}")
+        lines.append("━" * 60)
+        return "\n".join(lines)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Motor de síntese
+# ─────────────────────────────────────────────────────────────────────────────
+
+class RussellianSynthesisEngine:
+    """
+    Combina os valores-verdade paraconsistentes (L3) com o banco de
+    conhecimento para produzir a síntese final (resposta).
+
+    Síntese fundamentada em conceitos (Russell, russell.txt):
+        equivalência = correspondência entre crença/proposição e fato (BD).
+    O peso de cada proposição incorpora:
+      - prioridade L2 (juízo kantiano)
+      - certeza paraconsistente (Gc)
+      - score conceitual de equivalência (correspondência com fatos/KB),
+        não apenas agregação estatística.
+    """
+
+    def __init__(
+        self,
+        knowledge_base: Dict[str, float],
+        russell_concept_base: Optional["RussellConceptBase"] = None,
+        use_concept_based_weights: bool = True,
+        verification_config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        knowledge_base: dicionário termo → grau de evidência [0,1]
+        russell_concept_base: base teórica extraída de russell.txt (equivalência/correspondência).
+        use_concept_based_weights: se True, usa score conceitual na ponderação (recomendado).
+        """
+        self.kb = knowledge_base
+        self.russell_base = russell_concept_base
+        self.use_concept_weights = use_concept_based_weights and (russell_concept_base is not None)
+        self.verifier = ChainOfVerificationAgent(verification_config)
+
+    def synthesize(
+        self,
+        pv_list:     List[ParaconsistentValue],
+        l2_priorities: Dict[str, float],     # proposicao[:40] → prioridade L2
+        prompt:      str,
+        kb: Optional[Dict[str, float]] = None,
+    ) -> SynthesisResult:
+        """
+        Produz a SynthesisResult final integrando todas as camadas.
+        """
+        if not pv_list:
+            return SynthesisResult(
+                response="Sem hipóteses válidas para síntese.",
+                truth_value=0.0, certainty=0.0,
+                contradiction=0.0, state="Indeterminado",
+            )
+
+        # ── Seleciona a hipótese com maior valor-verdade ─────────────── #
+        best = pv_list[0]
+        supporting = [pv.proposition for pv in pv_list[1:4] if pv.state != "Falso"]
+        falsified  = [pv.proposition for pv in pv_list if pv.state == "Falso"]
+
+        # ── Síntese ponderada: L2 + certeza + equivalência (Russell) ─── #
+        total_w, total_v = 0.0, 0.0
+        for pv in pv_list:
+            key = pv.proposition[:40]
+            l2_w = l2_priorities.get(key, 0.5)
+            # Peso base: prioridade kantiana e certeza paraconsistente
+            weight = l2_w * (1.0 + max(pv.certainty, 0.0))
+            # Peso conceitual: correspondência proposição ↔ fato (BD), conforme russell.txt
+            if self.use_concept_weights and score_proposition_by_concepts is not None and self.russell_base is not None:
+                concept_score = score_proposition_by_concepts(pv.proposition, self.kb, self.russell_base)
+                weight *= concept_score
+            total_v += pv.truth_value * weight
+            total_w += weight
+
+        v_final = total_v / total_w if total_w > 0 else best.truth_value
+
+        # ── Gera texto de resposta a partir da hipótese best + BD ────── #
+        response = self._generate_response(best, prompt, kb)
+
+        verified_response, verification_log = self.verifier.verify(
+            prompt=prompt,
+            baseline_response=response,
+            context_summary=f"Hipótese principal: {best_pv.proposition} | Estado L3: {best.state} | Certeza: {best.certainty:.2f}",
+        )
+
+        return SynthesisResult(
+            response=verified_response,
+            truth_value=round(v_final, 4),
+            certainty=round(best.certainty, 4),
+            contradiction=round(best.contradiction, 4),
+            state=best.state,
+            supporting_evidence=supporting,
+            falsified_hypotheses=falsified,
+            verification_log=verification_log,
+        )
+
+    # ------------------------------------------------------------------ #
+    # Geração de resposta textual                                          #
+    # ------------------------------------------------------------------ #
+
+    def _generate_response(self, best_pv: ParaconsistentValue, prompt: str, kb: Optional[Dict[str, float]] = None) -> str:
+        """
+        Gera resposta a partir da proposição com maior valor-verdade.
+        Em produção seria substituído pelo decoder do LLM com as
+        hipóteses kantianas como contexto hard-constrained.
+        """
+        # Extrai conceitos KB com alta evidência
+        kb = kb or self.kb
+        top_kb = sorted(kb.items(), key=lambda x: x[1], reverse=True)[:3]
+        kb_context = ", ".join(f"{k}({v:.2f})" for k, v in top_kb)
+
+        state = best_pv.state
+        v = best_pv.truth_value
+
+        if state == "Verdadeiro":
+            prefix = f"Com alta confiança (v={v:.2f}):"
+        elif state == "Intermediário":
+            prefix = f"Com valor intermediário (v={v:.2f}), sem trivialização:"
+        elif state == "Inconsistente_local":
+            prefix = f"Contradição local detectada (v={v:.2f}), explosão gentil:"
+        elif state == "Falso":
+            prefix = f"Evidência insuficiente (v={v:.2f}):"
+        else:
+            prefix = f"Indeterminado (v={v:.2f}):"
+
+        return f"{prefix} {best_pv.proposition}  [KB: {kb_context}]"
+
+    # ------------------------------------------------------------------ #
+    # Verificação do limite fundamental (Crítica da IA Pura)              #
+    # ------------------------------------------------------------------ #
+
+    @staticmethod
+    def check_fundamental_limits(query: str) -> Optional[str]:
+        """
+        Detecta perguntas que violam os limites fundamentais da IA
+        (seção 10 do modelo): consciência, imaginação, AGI, etc.
+        Retorna aviso ou None.
+        """
+        limit_keywords = {
+            "consciência":    "IA não possui consciência — atributo biológico emergente.",
+            "sentimento":     "IA não possui estados afetivos — limitada ao algoritmo.",
+            "imaginação":     "Imaginação é liberdade humana (Sartre) — não computável.",
+            "agi":            "AGI é oximoro teórico: algoritmo não supera seu criador.",
+            "livre arbítrio": "Livre-arbítrio é problema não computável.",
+            "ser humano":     "IA é uma função limite — mundo real exige mediação humana.",
+        }
+        q_lower = query.lower()
+        for keyword, warning in limit_keywords.items():
+            if keyword in q_lower:
+                return f"⚠ Limite fundamental: {warning}"
+        return None

l5_generation.py

@@ -0,0 +1,129 @@
+"""
+Camada L5 — Geração de resposta em texto livre.
+================================================
+A partir da síntese L4 (e contexto L1–L3), gera resposta natural via LLM externo
+(Groq) ou fallback para o template da L4. Opcional: LM customizado (EpistemicLanguageModel).
+"""
+
+from __future__ import annotations
+import os
+from typing import Optional
+
+from layer_titles import LAYER_TITLES
+
+# Resultado da L4
+try:
+    from l4_synthesis import SynthesisResult
+except Exception:
+    SynthesisResult = None  # type: ignore
+
+
+def build_context_for_generation(
+    prompt: str,
+    synthesis_result: "SynthesisResult",
+    concepts_summary: str = "",
+    top_judgments: str = "",
+) -> str:
+    """Monta o contexto (texto) a ser enviado ao LLM para gerar a resposta final."""
+    lines = [
+        "## Contexto epistemológico (L1–L4)",
+        f"Pergunta do usuário: {prompt}",
+        "",
+        f"Resposta sintetizada (L4): {synthesis_result.response}",
+        f"Valor de verdade: {synthesis_result.truth_value:.2f} | Estado: {synthesis_result.state} | Certeza: {synthesis_result.certainty:+.2f}",
+        "",
+        "Use as seguintes nomenclaturas de seção para referenciar as etapas do raciocínio:",
+        f"L1: {LAYER_TITLES['l1']}",
+        f"L2: {LAYER_TITLES['l2']}",
+        f"L3: {LAYER_TITLES['l3']}",
+        f"L4: {LAYER_TITLES['l4']}",
+        f"L5: {LAYER_TITLES['l5']}",
+        f"L6: {LAYER_TITLES['l6']}",
+        "",
+    ]
+    if synthesis_result.supporting_evidence:
+        lines.append("Evidências de suporte:")
+        for ev in synthesis_result.supporting_evidence[:5]:
+            lines.append(f"  - {ev}")
+        lines.append("")
+    if concepts_summary:
+        lines.append(f"{LAYER_TITLES['l1']}: ")
+        lines.append(concepts_summary)
+        lines.append("")
+    if top_judgments:
+        lines.append(f"{LAYER_TITLES['l2']}: ")
+        lines.append(top_judgments)
+        lines.append("")
+    lines.append("## Instrução")
+    lines.append("Com base no contexto acima, elabore uma resposta final clara e precisa em português, sem repetir literalmente o texto da síntese. Seja conciso e cite a confiança quando relevante.")
+    return "\n".join(lines)
+
+
+def generate_with_groq(
+    context: str,
+    api_key: Optional[str] = None,
+    model: str = "mixtral-8x7b-32768",
+) -> str:
+    """Gera resposta usando ChatGroq."""
+    api_key = api_key or os.getenv("GROQ_API_KEY")
+    if not api_key:
+        return ""
+    try:
+        from langchain_groq import ChatGroq
+        from langchain_core.messages import HumanMessage
+        llm = ChatGroq(model=model, api_key=api_key, temperature=0.3)
+        msg = llm.invoke([HumanMessage(content=context)])
+        return msg.content if hasattr(msg, "content") else str(msg)
+    except Exception:
+        return ""
+
+
+def generate_with_custom_lm(
+    context: str,
+    model_path: str,
+    max_new_tokens: int = 150,
+    temperature: float = 0.7,
+) -> str:
+    """Gera resposta usando EpistemicLanguageModel (custom_lm_model)."""
+    try:
+        from custom_lm_model import EpistemicLanguageModel, LMConfig, generate_text, load_lm
+        from custom_tokenizer import CustomSPTokenizer, SPConfig
+        import torch
+        tokenizer = CustomSPTokenizer(SPConfig())
+        tokenizer.load()
+        vocab_size = tokenizer.vocab_size()
+        model = load_lm(model_path, vocab_size)
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        out = generate_text(model, tokenizer, context, max_new_tokens=max_new_tokens, temperature=temperature, device=device)
+        return out or ""
+    except Exception:
+        return ""
+
+
+def generate_response(
+    prompt: str,
+    synthesis_result: "SynthesisResult",
+    provider: str = "template",
+    concepts_summary: str = "",
+    top_judgments: str = "",
+    groq_model: str = "mixtral-8x7b-32768",
+    custom_lm_path: str = "",
+) -> str:
+    """
+    Gera a resposta final em texto livre (ou template).
+    provider: "groq" | "template" | "custom_lm"
+    """
+    context = build_context_for_generation(prompt, synthesis_result, concepts_summary, top_judgments)
+
+    if provider == "groq":
+        text = generate_with_groq(context, model=groq_model)
+        if text:
+            return text.strip()
+
+    if provider == "custom_lm" and custom_lm_path:
+        text = generate_with_custom_lm(context, custom_lm_path)
+        if text:
+            return text.strip()
+
+    # Fallback: resposta da L4 (template)
+    return synthesis_result.response

l6_final_response.py

@@ -0,0 +1,244 @@
+"""
+CAMADA L6 — Resposta Final em Texto Fluido
+==========================================
+Transforma o output estruturado das camadas L1–L5 em um texto contínuo,
+claro e preciso, com tom profissional e acessível.
+
+Fluxo de processamento:
+  Motor de Raciocínio → Output Estruturado → Síntese → Resposta Final
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from l4_synthesis import SynthesisResult
+from layer_titles import LAYER_TITLES
+
+try:
+    from l5_generation import generate_with_groq, generate_with_custom_lm
+except Exception:
+    generate_with_groq = None  # type: ignore
+    generate_with_custom_lm = None  # type: ignore
+
+
+@dataclass
+class EpistemicContext:
+    """Contexto epistemológico agregado para L6."""
+    proposition_states: List[Dict[str, Any]] = field(default_factory=list)
+    many_valued_routes: List[Dict[str, Any]] = field(default_factory=list)
+    bert_classifications: List[Dict[str, Any]] = field(default_factory=list)
+    application_context: str = ""
+
+
+class FinalResponseEngine:
+    """Gera a resposta final em texto fluido a partir da síntese das camadas anteriores."""
+
+    def finalize_response(
+        self,
+        prompt: str,
+        synthesis_result: SynthesisResult,
+        epistemic_context: Optional[EpistemicContext] = None,
+        generated_text: str = "",
+        concepts_summary: str = "",
+        top_judgments: str = "",
+        agent_context: str = "",
+    ) -> str:
+        """Produz a resposta final única e contínua seguindo regras de redação clara."""
+        main_text = self._normalize_text(generated_text or synthesis_result.response or "")
+        if not main_text:
+            return "Não há informação suficiente para formular uma resposta final."
+
+        intro = self._build_intro(synthesis_result)
+        conclusion = self._build_conclusion(synthesis_result)
+        context_note = self._build_context_note(concepts_summary, top_judgments, agent_context, epistemic_context)
+
+        if intro:
+            if main_text.lower().startswith(intro.lower()):
+                final = main_text
+            else:
+                final = f"{intro} {main_text}"
+        else:
+            final = main_text
+
+        if conclusion:
+            final = f"{final} {conclusion}"
+
+        if context_note:
+            final = f"{final} {context_note}"
+
+        return self._ensure_single_paragraph(final)
+
+    def _build_context_note(
+        self,
+        concepts_summary: str,
+        top_judgments: str,
+        agent_context: str,
+        epistemic_context: Optional[EpistemicContext] = None,
+    ) -> str:
+        note_parts = []
+        if concepts_summary:
+            note_parts.append("o raciocínio integrou conceitos extraídos e evidências relevantes")
+        if top_judgments:
+            note_parts.append("os juízos kantianos foram usados para priorizar hipóteses")
+        if agent_context:
+            note_parts.append("informações de busca externas também foram consideradas")
+        if epistemic_context is not None:
+            if epistemic_context.application_context:
+                note_parts.append("o contexto aplicacional do LogicLMSolver também foi considerado")
+            if epistemic_context.many_valued_routes:
+                note_parts.append("as rotas paraconsistentes do ManyValuedRouter foram analisadas")
+            if epistemic_context.bert_classifications:
+                note_parts.append("classificações BERT (T/I/F) das principais hipóteses influenciaram a formulação")
+        if not note_parts:
+            return ""
+        return "Essa resposta reflete o processamento integrado das camadas anteriores, com atenção a evidências e juízos relevantes."  
+
+    # ------------------------------------------------------------------ #
+    # Componentes textuais adaptativos                                    #
+    # ------------------------------------------------------------------ #
+
+    def _build_intro(self, synthesis_result: SynthesisResult) -> str:
+        if synthesis_result.truth_value >= 0.85:
+            return "Com base no motor de raciocínio L1–L5, a melhor conclusão indica"  
+        if synthesis_result.truth_value >= 0.65:
+            return "A partir da síntese das camadas L1–L5, o cenário mais sólido sugere"  
+        if synthesis_result.truth_value >= 0.45:
+            return "Com certa cautela, a análise das camadas L1–L5 aponta"  
+        return "A análise das camadas L1–L5 indica"  
+
+    def _build_conclusion(self, synthesis_result: SynthesisResult) -> str:
+        if synthesis_result.state in {"Indeterminado", "N"}:
+            return (
+                "Esta questão tem uma dimensão genuinamente indeterminada — não por falta de rigor, "
+                "mas porque a evidência empírica ainda não existe. Isso é diferente de 'não sabemos' "
+                "— é 'não há dados para saber'."
+            )
+        if synthesis_result.state == "Inconsistente_local" or synthesis_result.contradiction > 0.25:
+            return "Essa conclusão é apresentada como a melhor interpretação disponível, embora exista uma contradição local que recomenda prudência."  
+        if synthesis_result.truth_value < 0.65:
+            return "Dado o grau de incerteza, vale considerar essa resposta como provisória até que evidências adicionais sejam avaliadas."  
+        return ""
+
+    def _normalize_text(self, text: str) -> str:
+        return " ".join(text.split()).strip()
+
+    def _ensure_single_paragraph(self, text: str) -> str:
+        normalized = text.replace("\n", " ").replace("  ", " ")
+        normalized = " ".join(normalized.split())
+        return normalized.strip()
+
+    def rewrite_response(
+        self,
+        prompt: str,
+        synthesis_result: SynthesisResult,
+        epistemic_context: Optional[EpistemicContext] = None,
+        generated_text: str = "",
+        concepts_summary: str = "",
+        top_judgments: str = "",
+        agent_context: str = "",
+        provider: str = "template",
+        groq_model: str = "mixtral-8x7b-32768",
+        custom_lm_path: str = "",
+    ) -> str:
+        """Refina a resposta final com um segundo prompt no estilo de um agente escritor."""
+        draft = self.finalize_response(
+            prompt=prompt,
+            synthesis_result=synthesis_result,
+            epistemic_context=epistemic_context,
+            generated_text=generated_text,
+            concepts_summary=concepts_summary,
+            top_judgments=top_judgments,
+            agent_context=agent_context,
+        )
+        writer_prompt = self._build_writer_prompt(
+            prompt,
+            draft,
+            synthesis_result,
+            epistemic_context,
+            concepts_summary,
+            top_judgments,
+            agent_context,
+        )
+
+        if provider == "groq" and generate_with_groq:
+            text = generate_with_groq(writer_prompt, model=groq_model)
+            if text:
+                return self._ensure_single_paragraph(text)
+
+        if provider == "custom_lm" and generate_with_custom_lm and custom_lm_path:
+            text = generate_with_custom_lm(writer_prompt, custom_lm_path)
+            if text:
+                return self._ensure_single_paragraph(text)
+
+        return self._polish_writer_text(draft)
+
+    def _build_writer_prompt(
+        self,
+        prompt: str,
+        draft: str,
+        synthesis_result: SynthesisResult,
+        epistemic_context: Optional[EpistemicContext],
+        concepts_summary: str,
+        top_judgments: str,
+        agent_context: str,
+    ) -> str:
+        lines = [
+            "Você é um agente escritor técnico e comunicador.",
+            "Transforme o raciocínio completo gerado pelas camadas L1 a L6 em um único texto fluido, natural, coeso e fácil de ler.",
+            "Respeite as proposições e conclusões encontradas entre L1 e L6 e mantenha o rigor lógico e técnico.",
+            "Comece direto pela resposta principal, depois explique o caminho se necessário.",
+            "Use linguagem clara, conversacional e precisa e mencione incertezas ou trade-offs de forma elegante quando existirem.",
+            "Não separe o texto em passos numerados ou listas.",
+            "Ao se referir às etapas, use os títulos de seção designados abaixo:",
+            f"L1: {LAYER_TITLES['l1']}",
+            f"L2: {LAYER_TITLES['l2']}",
+            f"L3: {LAYER_TITLES['l3']}",
+            f"L4: {LAYER_TITLES['l4']}",
+            f"L5: {LAYER_TITLES['l5']}",
+            f"L6: {LAYER_TITLES['l6']}",
+            "",
+            f"Pergunta do usuário: {prompt}",
+            "",
+            "Texto preliminar:",
+            draft,
+            "",
+            "Contexto de síntese:",
+            f"Resposta de síntese L4: {synthesis_result.response}",
+            f"Valor de verdade: {synthesis_result.truth_value:.2f}",
+            f"Estado: {synthesis_result.state}",
+            f"Certeza: {synthesis_result.certainty:+.2f}",
+            f"Contradição: {synthesis_result.contradiction:+.2f}",
+        ]
+        if concepts_summary:
+            lines.extend(["", f"Conceitos L1: {concepts_summary}"])
+        if top_judgments:
+            lines.extend(["", f"Juízos L2: {top_judgments}"])
+        if agent_context:
+            lines.extend(["", "Contexto de busca externo:", agent_context])
+        if epistemic_context is not None:
+            lines.extend(["", "Detalhes epistemológicos:", self._summarize_epistemic_context(epistemic_context)])
+        lines.extend([
+            "",
+            "Raciocínio completo:",
+            "O texto deve sintetizar a extração de conceitos, os juízos kantianos, a avaliação paraconsistente, a s��ntese russelliana e a formulação final.",
+        ])
+        return "\n".join(lines)
+
+    def _summarize_epistemic_context(self, epistemic_context: EpistemicContext) -> str:
+        parts: List[str] = []
+        if epistemic_context.application_context:
+            parts.append(f"Contexto de aplicação: {epistemic_context.application_context}")
+        if epistemic_context.proposition_states:
+            top_props = epistemic_context.proposition_states[:3]
+            summary = ", ".join(
+                f"{item.get('state', 'Desconhecido')} ({item.get('truth_value', 'n/a')})" for item in top_props
+            )
+            parts.append(f"Proposições avaliadas: {summary}")
+        if epistemic_context.many_valued_routes:
+            parts.append("Rotas paraconsistentes avaliadas.")
+        if epistemic_context.bert_classifications:
+            parts.append("Classificações BERT (T/I/F) foram usadas para ajustar prioridades epistemológicas.")
+        return " ".join(parts)
+
+    def _polish_writer_text(self, draft: str) -> str:
+        return self._ensure_single_paragraph(draft)

l7_final_text.py

@@ -0,0 +1,511 @@
+"""
+CAMADA L7 — Texto Final Definitivo (Automático e Robusto)
+==========================================================
+Gera o texto final de alta qualidade a partir do raciocínio acumulado
+nas camadas L1 a L6.
+
+A camada L7 funciona como um prompt adicional de escrita: ela recebe os
+sumários das camadas anteriores e transforma o conteúdo em um único
+bloco contínuo, fluido e persuasivo.
+
+Suporta múltiplos providers:
+- ollama: para modelos rodando localmente
+- groq: para Groq Cloud API
+- custom_lm: para modelos customizados
+- template: fallback que retorna texto sem LLM
+"""
+
+from __future__ import annotations
+from typing import Optional, Dict, Any
+import logging
+from l4_synthesis import SynthesisResult
+from layer_titles import LAYER_TITLES
+
+logger = logging.getLogger(__name__)
+
+try:
+    from l5_generation import generate_with_groq, generate_with_custom_lm
+except Exception:
+    generate_with_groq = None  # type: ignore
+    generate_with_custom_lm = None  # type: ignore
+
+try:
+    import ollama
+except Exception:
+    ollama = None  # type: ignore
+
+
+class FinalTextEngine:
+    """Gera o texto final definitivo a partir do raciocínio L1–L6."""
+
+    # Classificação de audiência
+    AUDIENCE_PROFILES = {
+        "leigo": {
+            "description": "Público geral sem conhecimento técnico especializado",
+            "style": "Linguagem simples e acessível, analogias concretas do dia a dia, evitar notação formal, foco em aplicações práticas e conclusões úteis",
+            "examples": ["o que é", "como funciona", "explicar", "simples"]
+        },
+        "técnico": {
+            "description": "Profissional da área com conhecimento técnico intermediário",
+            "style": "Usar terminologia específica da área, incluir referências conceituais, evitar tabelas de estados complexas, manter rigor técnico sem excesso de formalismo",
+            "examples": ["análise", "implementação", "método", "técnica", "profissional"]
+        },
+        "acadêmico": {
+            "description": "Pesquisador ou acadêmico com formação avançada",
+            "style": "Notação completa e formal, referências bibliográficas detalhadas, incluir modo debug/disponibilidade de estados internos, rigor acadêmico completo",
+            "examples": ["teoria", "formal", "demonstração", "referência", "acadêmico", "pesquisa"]
+        }
+    }
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Inicializa a FinalTextEngine com configurações opcionais.
+        
+        Args:
+            config: Dicionário com configurações de L7, incluindo:
+                - provider: 'ollama', 'groq', 'custom_lm', ou 'template'
+                - model: Nome do modelo (para ollama e groq)
+                - temperature: Temperatura de geração (padrão: 0.7)
+                - max_tokens: Número máximo de tokens (padrão: 4096)
+                - custom_lm_path: Caminho do modelo customizado (para custom_lm)
+        """
+        self.config = config or {}
+        self.l7_config = self.config.get("l7", {})
+        
+    def _build_l7_prompt(self, 
+                        prompt: str,
+                        l1_summary: str,
+                        l2_summary: str,
+                        l3_summary: str,
+                        l4_response: str,
+                        l5_text: str,
+                        l6_text: str,
+                        audience_profile: str = "técnico",
+                        full_synthesis: Optional[str] = None) -> str:
+        """
+        Constrói automaticamente o prompt L7 para geração de texto final.
+        
+        Este método agrega todo o raciocínio das camadas L1-L6 e produz
+        um prompt bem estruturado e adaptado ao perfil de audiência.
+        
+        Args:
+            prompt: Pergunta/prompt original do usuário
+            l1_summary: Resumo de conceitos extraídos (L1)
+            l2_summary: Resumo de juízos kantianos (L2)
+            l3_summary: Resumo de análise paraconsistente (L3)
+            l4_response: Resposta da síntese russelliana (L4)
+            l5_text: Texto gerado em L5 (se disponível)
+            l6_text: Texto refinado de L6
+            audience_profile: Perfil de audiência ('leigo', 'técnico', 'acadêmico')
+            full_synthesis: Síntese completa opcional
+            
+        Returns:
+            String com prompt bem estruturado para geração automática
+        """
+        lines = []
+        
+        # SEÇÃO 1: Instrução Base
+        lines.append("Você é um excelente escritor técnico e comunicador, especializado em sintetizar raciocínios complexos em textos claros, profundos e agradáveis de ler.")
+        lines.append("")
+        lines.append("Sua função é gerar o TEXTO FINAL DEFINITIVO a partir de todo o raciocínio desenvolvido nas camadas L1 a L6.")
+        lines.append("")
+        
+        # SEÇÃO 2: Contexto do Prompt Original
+        lines.append("═" * 70)
+        lines.append("PROMPT ORIGINAL DO USUÁRIO:")
+        lines.append("═" * 70)
+        lines.append(prompt)
+        lines.append("")
+        
+        # SEÇÃO 3: Resumo das Camadas
+        lines.append("═" * 70)
+        lines.append("RACIOCÍNIO ACUMULADO (CAMADAS L1–L6):")
+        lines.append("═" * 70)
+        lines.append(f"L1 - Conceitos Extraídos: {l1_summary or 'Não disponível'}")
+        lines.append(f"L2 - Juízos Kantianos: {l2_summary or 'Não disponível'}")
+        lines.append(f"L3 - Análise Paraconsistente: {l3_summary or 'Não disponível'}")
+        lines.append(f"L4 - Síntese Russelliana: {l4_response or 'Não disponível'}")
+        lines.append(f"L5 - Geração de Resposta: {l5_text or 'Não disponível'}")
+        lines.append(f"L6 - Refinamento Final: {l6_text or 'Não disponível'}")
+        lines.append("")
+        
+        # SEÇÃO 4: Perfil de Audiência
+        profile_data = self.AUDIENCE_PROFILES.get(audience_profile, self.AUDIENCE_PROFILES["técnico"])
+        lines.append("═" * 70)
+        lines.append(f"PERFIL DE AUDIÊNCIA: {audience_profile.upper()}")
+        lines.append("═" * 70)
+        lines.append(f"Descrição: {profile_data['description']}")
+        lines.append(f"Estilo recomendado: {profile_data['style']}")
+        lines.append("")
+        
+        # SEÇÃO 5: Diretivas de Formatação (OBRIGATÓRIAS)
+        lines.append("═" * 70)
+        lines.append("DIRETIVAS DE FORMATAÇÃO (OBRIGATÓRIAS):")
+        lines.append("═" * 70)
+        lines.append("• Formato: Um ÚNICO bloco contínuo de texto, sem títulos, subtítulos, bullets ou numeração.")
+        lines.append("• Abertura: Comece diretamente com a tese ou resposta principal (1-2 frases fortes e claras).")
+        lines.append("• Estrutura: Desenvolvimento gradual das premissas, nuances e evolução do pensamento.")
+        lines.append("• Integração: Harmonize todas as camadas de forma natural, mostrando a evolução do raciocínio.")
+        lines.append("• Tone: Profissional, confiante e acessível. Explique termos técnicos quando necessários.")
+        lines.append("• Variação: Use frases de tamanhos variados com transições naturais e sofisticadas.")
+        lines.append("• Ênfase: Destaque ideias importantes via posicionamento e repetição sutil (não óbvia).")
+        lines.append("• Rigor: Inclua tensões, trade-offs e incertezas com elegância e maturidade intelectual.")
+        lines.append("")
+        
+        # SEÇÃO 6: Tarefa Final
+        lines.append("═" * 70)
+        lines.append("TAREFA:")
+        lines.append("═" * 70)
+        lines.append("Transforme todo esse raciocínio em uma DISSERTAÇÃO EXPOSITIVA FLUIDA, COESA E NATURAL.")
+        lines.append("Escreva o texto final agora:")
+        lines.append("═" * 70)
+        lines.append("")
+        
+        return "\n".join(lines)
+
+    @classmethod
+    def _classify_audience(cls, prompt: str, l1_summary: str, l2_summary: str, l3_summary: str) -> str:
+        """
+        Classifica o perfil da audiência baseado no prompt e contexto das camadas.
+        Retorna: 'leigo', 'técnico', ou 'acadêmico'
+        """
+        # Combinar todo o contexto para análise
+        full_context = f"{prompt} {l1_summary} {l2_summary} {l3_summary}".lower()
+
+        # Contar termos técnicos e indicadores de nível
+        technical_indicators = {
+            "leigo": 0,
+            "técnico": 0,
+            "acadêmico": 0
+        }
+
+        # Análise de vocabulário e termos
+        for profile, data in cls.AUDIENCE_PROFILES.items():
+            for keyword in data["examples"]:
+                if keyword.lower() in full_context:
+                    technical_indicators[profile] += 1
+
+        # Análise de extensão e complexidade
+        prompt_length = len(prompt.split())
+        has_formal_terms = any(term in full_context for term in [
+            "formal", "demonstração", "teorema", "axioma", "paradigma",
+            "epistemologia", "ontologia", "metafísica", "transcendental"
+        ])
+        has_technical_jargon = any(term in full_context for term in [
+            "lógica paraconsistente", "juízo kantiano", "síntese russelliana",
+            "valor de verdade", "contradição", "cognição"
+        ])
+
+        # Regras de classificação
+        if has_formal_terms or prompt_length > 50 or "referência" in full_context:
+            return "acadêmico"
+        elif has_technical_jargon or technical_indicators["técnico"] > technical_indicators["leigo"]:
+            return "técnico"
+        elif technical_indicators["leigo"] > 0 or prompt_length < 20:
+            return "leigo"
+        else:
+            # Padrão: analisar padrão da pergunta
+            question_patterns = {
+                "acadêmico": ["por que", "como se explica", "qual a teoria", "demonstre"],
+                "técnico": ["como implementar", "qual método", "análise de", "técnica para"],
+                "leigo": ["o que é", "para que serve", "como funciona", "exemplo"]
+            }
+
+            for profile, patterns in question_patterns.items():
+                if any(pattern in prompt.lower() for pattern in patterns):
+                    return profile
+
+            return "técnico"  # padrão seguro
+
+    def _enhance_with_writer_prompt(
+        self,
+        base_text: str,
+        prompt: str,
+        audience_profile: str,
+        synthesis_result: Optional[SynthesisResult] = None,
+        canonical_alerts: Optional[list] = None
+    ) -> str:
+        """
+        Aprimora o texto base usando o prompt de redação (fallback sem LLM).
+        Usada quando nenhum provider está disponível.
+        """
+        # Aqui poderíamos aplicar algumas transformações/enhancements
+        # que não requerem LLM, como formatting, reorganização, etc.
+        return self._build_writer_prompt(
+            prompt=prompt,
+            l1_summary="",
+            l2_summary="",
+            l3_summary="",
+            l4_response="",
+            l5_text="",
+            l6_text=base_text,
+            synthesis_result=synthesis_result,
+            canonical_alerts=canonical_alerts,
+            audience_profile=audience_profile
+        )
+
+
+    def finalize_text(
+        self,
+        prompt: str,
+        l1_summary: str = "",
+        l2_summary: str = "",
+        l3_summary: str = "",
+        l4_response: str = "",
+        l5_text: str = "",
+        l6_text: str = "",
+        synthesis_result: Optional[SynthesisResult] = None,
+        provider: str = "template",
+        model: str = "Doninha",
+        groq_model: str = "mixtral-8x7b-32768",
+        custom_lm_path: str = "",
+        canonical_alerts: Optional[list] = None,
+        audience_profile: Optional[str] = None,
+        **kwargs) -> str:
+        """
+        Gera o texto final definitivo de forma automática e robusta.
+        
+        Suporta múltiplos providers:
+        - ollama: Executa modelos locais via Ollama
+        - groq: Usa Groq Cloud API
+        - custom_lm: Usa modelo LM customizado
+        - template: Retorna o melhor resultado de L6 sem LLM (fallback)
+        
+        Args:
+            prompt: Pergunta/prompt original do usuário
+            l1_summary: Resumo de conceitos (L1)
+            l2_summary: Resumo de juízos kantianos (L2)
+            l3_summary: Resumo de análise paraconsistente (L3)
+            l4_response: Resposta da síntese (L4)
+            l5_text: Texto gerado (L5)
+            l6_text: Texto refinado (L6)
+            synthesis_result: Resultado da síntese L4
+            provider: 'ollama', 'groq', 'custom_lm', ou 'template'
+            model: Nome do modelo (ollama, groq)
+            groq_model: Modelo específico para Groq
+            custom_lm_path: Caminho do modelo customizado
+            canonical_alerts: Alertas de incompatibilidade semântica
+            audience_profile: 'leigo', 'técnico', ou 'acadêmico'
+            **kwargs: Argumentos adicionais (temperature, max_tokens, etc.)
+            
+        Returns:
+            String com o texto final gerado
+        """
+        
+        # 1. Classificar audiência se não foi fornecida
+        if audience_profile is None:
+            audience_profile = self._classify_audience(prompt, l1_summary, l2_summary, l3_summary)
+        
+        # 2. Construir prompt L7 automático
+        l7_prompt = self._build_l7_prompt(
+            prompt=prompt,
+            l1_summary=l1_summary,
+            l2_summary=l2_summary,
+            l3_summary=l3_summary,
+            l4_response=l4_response,
+            l5_text=l5_text,
+            l6_text=l6_text,
+            audience_profile=audience_profile,
+            full_synthesis=synthesis_result.response if synthesis_result else None
+        )
+        
+        # 3. Gerar texto usando o provider selecionado
+        generated_text = None
+        
+        if provider == "ollama" and ollama:
+            generated_text = self._generate_with_ollama(
+                prompt=l7_prompt,
+                model=self.l7_config.get("model", model),
+                temperature=kwargs.get("temperature", 0.7),
+                max_tokens=kwargs.get("max_tokens", 4096)
+            )
+        
+        elif provider == "groq" and generate_with_groq:
+            generated_text = self._generate_with_groq_api(
+                prompt=l7_prompt,
+                model=groq_model or self.l7_config.get("groq_model", "mixtral-8x7b-32768")
+            )
+        
+        elif provider == "custom_lm" and generate_with_custom_lm:
+            custom_path = custom_lm_path or self.l7_config.get("custom_lm_path", "")
+            if custom_path:
+                generated_text = self._generate_with_custom_lm(
+                    prompt=l7_prompt,
+                    model_path=custom_path
+                )
+        
+    
+
+    def _generate_with_ollama(self, prompt: str, model: str, temperature: float = 0.7, max_tokens: int = 4096) -> Optional[str]:
+        """
+        Gera texto usando Ollama (modelos locais).
+        
+        Args:
+            prompt: Prompt para geração
+            model: Nome do modelo (e.g., 'llama2', 'neural-chat', 'mistral')
+            temperature: Controla criatividade (0.0-1.0)
+            max_tokens: Limite de tokens de saída
+            
+        Returns:
+            Texto gerado ou None se falhar
+        """
+        try:
+            if not ollama:
+                logger.error("Ollama não está instalado")
+                return None
+            
+            response = ollama.chat(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                stream=False,
+                options={
+                    "temperature": temperature,
+                    "num_predict": max_tokens,
+                    "num_ctx": 8192
+                }
+            )
+            
+            generated = response.get("message", {}).get("content", "").strip()
+            if generated:
+                logger.info(f"L7 (ollama/{model}): Texto gerado com sucesso ({len(generated)} chars)")
+                return generated
+            else:
+                logger.warning("Ollama retornou resposta vazia")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Erro ao usar Ollama: {e}")
+            return None
+
+    def _generate_with_groq_api(self, prompt: str, model: str) -> Optional[str]:
+        """
+        Gera texto usando Groq Cloud API.
+        
+        Args:
+            prompt: Prompt para geração
+            model: Nome do modelo Groq (e.g., 'mixtral-8x7b-32768')
+            
+        Returns:
+            Texto gerado ou None se falhar
+        """
+        try:
+            if not generate_with_groq:
+                logger.error("generate_with_groq não está disponível")
+                return None
+            
+            generated = generate_with_groq(prompt, model=model)
+            if generated:
+                logger.info(f"L7 (groq/{model}): Texto gerado com sucesso ({len(generated)} chars)")
+                return generated
+            else:
+                logger.warning("Groq retornou resposta vazia")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Erro ao usar Groq: {e}")
+            return None
+
+    def _generate_with_custom_lm(self, prompt: str, model_path: str) -> Optional[str]:
+        """
+        Gera texto usando modelo LM customizado.
+        
+        Args:
+            prompt: Prompt para geração
+            model_path: Caminho do modelo customizado
+            
+        Returns:
+            Texto gerado ou None se falhar
+        """
+        try:
+            if not generate_with_custom_lm:
+                logger.error("generate_with_custom_lm não está disponível")
+                return None
+            
+            generated = generate_with_custom_lm(prompt, model_path)
+            if generated:
+                logger.info(f"L7 (custom_lm): Texto gerado com sucesso ({len(generated)} chars)")
+                return generated
+            else:
+                logger.warning("Custom LM retornou resposta vazia")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Erro ao usar Custom LM: {e}")
+            return None
+
+
+
+    def _build_writer_prompt(
+        self,
+        prompt: str,
+        l1_summary: str,
+        l2_summary: str,
+        l3_summary: str,
+        l4_response: str,
+        l5_text: str,
+        l6_text: str,
+        synthesis_result: Optional[SynthesisResult] = None,
+        canonical_alerts: Optional[list] = None,
+        audience_profile: str = "técnico",
+    ) -> str:
+        lines = [
+            "Você é um excelente escritor técnico e comunicador, com capacidade de sintetizar raciocínios complexos em textos claros e persuasivos.",
+            "Sua função é gerar o texto final de alta qualidade a partir do raciocínio desenvolvido nas camadas L1 a L6.",
+            "Tarefa: transforme todo o raciocínio acumulado nas camadas L1 a L6 em uma dissertação expositiva fluida, coesa e natural, em um único bloco contínuo de texto.",
+            "Público-alvo: leitor inteligente de nível intermediário (não é especialista no tema).",
+            "Formato: um único texto contínuo, sem títulos, subtítulos, bullets ou qualquer marcação.",
+            "Estrutura recomendada: comece diretamente com a tese ou resposta principal em 1-2 frases fortes e claras. Em seguida, desenvolva as premissas, nuances e evoluções do pensamento.",
+            "Integre harmoniosamente o conteúdo das camadas anteriores, mostrando a evolução natural do raciocínio e destacando tensões, trade-offs e incertezas com elegância.",
+            "Linguagem: clara, conversacional e precisa. Use termos técnicos quando necessários, explicando-os na sequência.",
+            "Estilo: profissional, acessível, rigoroso e fácil de ler.",
+            "",
+            f"PERFIL DA AUDIÊNCIA CLASSIFICADO: {audience_profile.upper()}",
+        ]
+
+        # Adicionar instruções específicas do perfil
+        profile_data = self.AUDIENCE_PROFILES.get(audience_profile, self.AUDIENCE_PROFILES["técnico"])
+        lines.append(f"Descrição do perfil: {profile_data['description']}")
+        lines.append(f"Instruções de estilo específicas: {profile_data['style']}")
+        lines.append("")
+        lines.append(f"Pergunta do usuário: {prompt}")
+        lines.append("")
+        lines.append("Raciocínio acumulado L1–L6:")
+        lines.append(f"L1 - {LAYER_TITLES['l1']}: {l1_summary or 'Não disponível.'}")
+        lines.append(f"L2 - {LAYER_TITLES['l2']}: {l2_summary or 'Não disponível.'}")
+        lines.append(f"L3 - {LAYER_TITLES['l3']}: {l3_summary or 'Não disponível.'}")
+        lines.append(f"L4 - {LAYER_TITLES['l4']}: {l4_response or 'Não disponível.'}")
+        lines.append(f"L5 - {LAYER_TITLES['l5']}: {l5_text or 'Não disponível.'}")
+        lines.append(f"L6 - {LAYER_TITLES['l6']}: {l6_text or 'Não disponível.'}")
+        lines.append(f"L7 - {LAYER_TITLES['l7']}: texto final de síntese e redação.")
+        lines.append("")
+
+        # Adicionar informações da síntese L4 se disponível
+        if synthesis_result:
+            lines.append(f"Estado da síntese L4: {synthesis_result.state}")
+            lines.append(f"Valor de verdade L4: {synthesis_result.truth_value:.2f}")
+            lines.append(f"Certeza L4: {synthesis_result.certainty:+.2f}")
+            lines.append(f"Contradição L4: {synthesis_result.contradiction:+.2f}")
+            lines.append("")
+        else:
+            lines.append("Estado da síntese L4: Não disponível.")
+            lines.append("")
+
+        # Adicionar alertas de incompatibilidade canônica
+        if canonical_alerts:
+            lines.append("Alertas de incompatibilidade canônica:")
+            for alert in canonical_alerts:
+                lines.append(f"- Conceito '{alert['concept']}': {alert['canonical_context']}")
+                lines.append(f"  Uso incompatível detectado: {alert['incompatible_usage']}")
+            lines.append("")
+            lines.append("IMPORTANTE: Inclua ressalvas no texto final sobre estes usos incompatíveis dos conceitos.")
+            lines.append("")
+
+        lines.append("Escreva o texto final agora.")
+
+        return "\n".join(lines)
+
+    def _normalize_text(self, text: str) -> str:
+        return " ".join(text.split()).strip()
+
+    def _ensure_single_paragraph(self, text: str) -> str:
+        return " ".join(text.replace("\n", " ").split()).strip()

layer_titles.py

@@ -0,0 +1,13 @@
+"""
+Nomes das camadas L1–L7 usados nas instruções de geração de texto.
+"""
+
+LAYER_TITLES = {
+    "l1": "Demarcação de Conceitos Fundamentais",
+    "l2": "Premissas e proposições centrais",
+    "l3": "Análise da Estrutura Lógico-filosófica",
+    "l4": "Comparação da equivalência entre Estrutura formal e Mundo Empírico",
+    "l5": "Síntese Intermediária derivada das etapas anteriores",
+    "l6": "Conclusão do raciocínio",
+    "l7": "Síntese Final e Redação",
+}

metrics.py

@@ -0,0 +1,130 @@
+"""
+Métricas de avaliação do pipeline.
+==================================
+Coerência L3, similaridade semântica, BLEU/ROUGE (quando disponível).
+"""
+
+from __future__ import annotations
+import re
+from typing import Dict, List, Optional, Any
+
+# Resultado da L4
+try:
+    from l4_synthesis import SynthesisResult
+except Exception:
+    SynthesisResult = None  # type: ignore
+
+
+def coherence_l3(truth_value: float, state: str, contradiction: float) -> Dict[str, float]:
+    """
+    Métricas de coerência com a camada L3.
+    - truth_value alto e contradição baixa = bom.
+    - state "Falso" ou "Indeterminado" com truth_value baixo = esperado coerente.
+    """
+    # Score de coerência: valor alto é bom quando não há trivialização
+    contradiction_penalty = abs(contradiction)  # contradição extrema penaliza
+    coherence = max(0.0, 1.0 - contradiction_penalty) * (0.5 + 0.5 * truth_value)
+    return {
+        "coherence_score": round(coherence, 4),
+        "truth_value": truth_value,
+        "contradiction_abs": abs(contradiction),
+    }
+
+
+def tokenize_pt(text: str) -> List[str]:
+    """Tokenização simples para BLEU/ROUGE: palavras em minúsculo."""
+    return re.findall(r"[a-záàãâéêíóôõúüç]+", text.lower())
+
+
+def bleu_sentence(reference: str, hypothesis: str, max_n: int = 2) -> float:
+    """
+    BLEU simplificado por frase (n-gram precision até max_n).
+    Retorna valor em [0, 1].
+    """
+    ref_tok = tokenize_pt(reference)
+    hyp_tok = tokenize_pt(hypothesis)
+    if not hyp_tok:
+        return 0.0
+    if not ref_tok:
+        return 0.0
+    p_n = []
+    for n in range(1, max_n + 1):
+        ref_ngrams = [tuple(ref_tok[i : i + n]) for i in range(len(ref_tok) - n + 1)]
+        hyp_ngrams = [tuple(hyp_tok[i : i + n]) for i in range(len(hyp_tok) - n + 1)]
+        if not hyp_ngrams:
+            continue
+        matches = sum(1 for g in hyp_ngrams if g in ref_ngrams)
+        p_n.append(matches / len(hyp_ngrams))
+    if not p_n:
+        return 0.0
+    # Média geométrica das precisions
+    prod = 1.0
+    for p in p_n:
+        prod *= p
+    return prod ** (1.0 / len(p_n))
+
+
+def rouge_l_sentence(reference: str, hypothesis: str) -> float:
+    """
+    ROUGE-L simplificado (LCS de palavras).
+    Retorna F1 em [0, 1].
+    """
+    ref_tok = tokenize_pt(reference)
+    hyp_tok = tokenize_pt(hypothesis)
+    if not ref_tok or not hyp_tok:
+        return 0.0
+    # LCS por palavras
+    m, n = len(ref_tok), len(hyp_tok)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if ref_tok[i - 1] == hyp_tok[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+    lcs = dp[m][n]
+    prec = lcs / n if n else 0
+    rec = lcs / m if m else 0
+    if prec + rec == 0:
+        return 0.0
+    return 2 * prec * rec / (prec + rec)
+
+
+def semantic_similarity(reference: str, hypothesis: str) -> float:
+    """
+    Similaridade por embeddings (se sentence-transformers disponível).
+    Caso contrário, retorna -1.0 para indicar indisponível.
+    """
+    try:
+        from sentence_transformers import SentenceTransformer
+        model = SentenceTransformer("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+        ref_emb = model.encode(reference)
+        hyp_emb = model.encode(hypothesis)
+        from numpy import dot
+        from numpy.linalg import norm
+        return float(dot(ref_emb, hyp_emb) / (norm(ref_emb) * norm(hyp_emb) + 1e-9))
+    except Exception:
+        return -1.0
+
+
+def evaluate_response(
+    synthesis_result: "SynthesisResult",
+    reference_answer: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Agrega métricas: coerência L3 + BLEU/ROUGE (e opcionalmente similaridade)
+    quando há resposta de referência.
+    """
+    out: Dict[str, Any] = {}
+    out["coherence"] = coherence_l3(
+        synthesis_result.truth_value,
+        synthesis_result.state,
+        synthesis_result.contradiction,
+    )
+    if reference_answer:
+        out["bleu"] = round(bleu_sentence(reference_answer, synthesis_result.response), 4)
+        out["rouge_l"] = round(rouge_l_sentence(reference_answer, synthesis_result.response), 4)
+        sim = semantic_similarity(reference_answer, synthesis_result.response)
+        if sim >= 0:
+            out["semantic_similarity"] = round(sim, 4)
+    return out

neural_truth_model.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+"""
+MÓDULO NEURAL — TruthScoringModel
+=================================
+
+Modelo PyTorch baseado em Transformer (via `transformers`) que recebe
+proposições textuais (saída de L2) e produz:
+
+  - logits de classe para o estado paraconsistente:
+        Verdadeiro | Falso | Intermediário | Indeterminado
+  - um escalar v ∈ [0,1] representando o valor-verdade aproximado
+    (compatível com `ParaconsistentValue.truth_value`).
+
+Este módulo NÃO é acoplado diretamente ao pipeline; ele pode ser
+instanciado e passado opcionalmente para a `ParaconsistentEngine`,
+que o usará para calcular (μ, λ) neurais em vez das heurísticas puras.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset
+from transformers import AutoModel, AutoTokenizer
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Rótulos paraconsistentes
+# ─────────────────────────────────────────────────────────────────────────────
+
+LABEL2ID: Dict[str, int] = {
+    "Verdadeiro": 0,
+    "Falso": 1,
+    "Intermediário": 2,
+    "Indeterminado": 3,
+}
+
+ID2LABEL: Dict[int, str] = {v: k for k, v in LABEL2ID.items()}
+
+
+@dataclass
+class PropositionExample:
+    """Exemplo supervisionado para treinamento do modelo neural."""
+
+    text: str
+    label_state: str          # uma das chaves de LABEL2ID
+    truth_value: float        # valor-verdade escalar em [0,1]
+
+
+class PropositionDataset(Dataset):
+    """
+    Dataset simples de proposições rotuladas com estado paraconsistente
+    e valor-verdade escalar.
+    """
+
+    def __init__(self, examples: List[PropositionExample], tokenizer, max_length: int = 64):
+        self.examples = examples
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self) -> int:
+        return len(self.examples)
+
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        ex = self.examples[idx]
+        enc = self.tokenizer(
+            ex.text,
+            truncation=True,
+            padding="max_length",
+            max_length=self.max_length,
+            return_tensors="pt",
+        )
+        item = {k: v.squeeze(0) for k, v in enc.items()}
+        item["labels_state"] = torch.tensor(LABEL2ID[ex.label_state], dtype=torch.long)
+        item["labels_truth"] = torch.tensor(float(ex.truth_value), dtype=torch.float)
+        return item
+
+
+class TruthScoringModel(nn.Module):
+    """
+    Modelo híbrido:
+      - backbone TransformerEncoder (BERT-like)
+      - cabeça de classificação para o estado lógico
+      - cabeça de regressão para valor-verdade escalar
+    """
+
+    def __init__(
+        self,
+        backbone_name: str = "bert-base-multilingual-cased",
+        num_labels: int = 4,
+    ) -> None:
+        super().__init__()
+        self.backbone = AutoModel.from_pretrained(backbone_name)
+        hidden_size = self.backbone.config.hidden_size
+
+        self.classifier = nn.Linear(hidden_size, num_labels)
+        self.truth_head = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.ReLU(),
+            nn.Linear(hidden_size, 1),
+            nn.Sigmoid(),  # restringe para [0,1]
+        )
+
+    def forward(
+        self,
+        input_ids: torch.Tensor,
+        attention_mask: torch.Tensor,
+        labels_state: Optional[torch.Tensor] = None,
+        labels_truth: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        outputs = self.backbone(input_ids=input_ids, attention_mask=attention_mask)
+        cls_emb = outputs.last_hidden_state[:, 0, :]
+
+        logits_state = self.classifier(cls_emb)
+        truth_score = self.truth_head(cls_emb).squeeze(-1)
+
+        loss: Optional[torch.Tensor] = None
+        if labels_state is not None and labels_truth is not None:
+            ce_loss = nn.CrossEntropyLoss()(logits_state, labels_state)
+            mse_loss = nn.MSELoss()(truth_score, labels_truth)
+            loss = ce_loss + 0.5 * mse_loss
+
+        return {
+            "logits_state": logits_state,
+            "truth_score": truth_score,
+            "loss": loss,
+        }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Helpers de inferência
+# ────────────────────────────────────────────────────────────────────────��────
+
+def load_tokenizer(backbone_name: str = "bert-base-multilingual-cased"):
+    """Cria um tokenizer compatível com o backbone."""
+    return AutoTokenizer.from_pretrained(backbone_name)
+
+
+def score_proposition(
+    model: TruthScoringModel,
+    tokenizer,
+    text: str,
+    device: Optional[torch.device] = None,
+) -> Tuple[str, float]:
+    """
+    Executa inferência para uma única proposição textual.
+    Retorna (label_state, truth_score).
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.eval()
+    enc = tokenizer(
+        text,
+        truncation=True,
+        padding="max_length",
+        max_length=64,
+        return_tensors="pt",
+    )
+    enc = {k: v.to(device) for k, v in enc.items()}
+    model = model.to(device)
+    with torch.no_grad():
+        out = model(**enc)
+    logits = out["logits_state"]
+    truth_score = float(out["truth_score"].cpu().item())
+    pred_id = int(logits.argmax(dim=-1).cpu().item())
+    pred_label = ID2LABEL[pred_id]
+    return pred_label, truth_score
+
+
+def neural_annotations(
+    model: TruthScoringModel,
+    tokenizer,
+    text: str,
+) -> Tuple[float, float, str, float]:
+    """
+    Mapeia a saída do modelo neural para (μ, λ) compatíveis com L3.
+    Retorna (mu, lam, state_label, truth_score).
+    """
+    state, v = score_proposition(model, tokenizer, text)
+    if state == "Verdadeiro":
+        mu = v
+        lam = 1.0 - v
+    elif state == "Falso":
+        mu = 1.0 - v
+        lam = v
+    elif state == "Intermediário":
+        mu = 0.4 + 0.2 * v
+        lam = 0.4 + 0.2 * (1.0 - v)
+    else:  # Indeterminado
+        mu = 0.3
+        lam = 0.3
+    return float(mu), float(lam), state, float(v)
+

paraconsistent_rules.py

@@ -0,0 +1,196 @@
+"""
+Conjunto de regras para sistema paraconsistente (LPA)
+======================================================
+Extraído de data/Fuzzy.txt — Lógica Paraconsistente Anotada (da Costa et al.).
+
+Convenções do documento:
+  - μ (mu) = grau de crença  ∈ [0,1], eixo x no QUPC
+  - λ (lambda) = grau de descrença ∈ [0,1], eixo y no QUPC
+  - Gc  = Grau de Certeza     = μ − λ   ∈ [−1, 1]
+  - Gct = Grau de Contradição = μ + λ − 1 ∈ [−1, 1]
+
+Valores de controle (Figura 3):
+  Vscc  = Valor superior de controle de certeza     = 1/2
+  Vicc  = Valor inferior de controle de certeza    = -1/2
+  Vscct = Valor superior de controle de contradição = 1/2
+  Vicct = Valor inferior de controle de contradição = -1/2
+
+Doze estados lógicos (reticulado discretizado):
+  T, V, F, ⊥, QV, QF e regiões de transição (QF→V, ⊥→F, ⊥→V, QV→⊥, T→V, QV→T, etc.).
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import List, Tuple, Iterator
+import re
+import os
+
+# ─── Constantes extraídas do Fuzzy.txt ─────────────────────────────────────
+VSCC = 0.5   # Valor superior de controle de certeza
+VICC = -0.5  # Valor inferior de controle de certeza
+VSCC_T = 0.5   # Valor superior de controle de contradição
+VICC_T = -0.5  # Valor inferior de controle de contradição
+
+# Doze estados lógicos do reticulado (para-analisador)
+STATE_T = "Inconsistente"           # T  = (1,1)
+STATE_V = "Verdadeiro"              # V  = (1,0)
+STATE_F = "Falso"                   # F  = (0,1)
+STATE_BOT = "Indeterminado"         # ⊥  = (0,0)
+STATE_QV = "Quase_Verdadeiro"       # QV
+STATE_QF = "Quase_Falso"            # QF
+STATE_QF_TO_V = "QF_to_V"
+STATE_BOT_TO_F = "Indeterminado_to_F"
+STATE_BOT_TO_V = "Indeterminado_to_V"
+STATE_QV_TO_BOT = "QV_to_Indeterminado"
+STATE_T_TO_V = "Inconsistente_to_V"
+STATE_QV_TO_T = "QV_to_Inconsistente"
+
+ALL_STATES_12: List[str] = [
+    STATE_T, STATE_V, STATE_F, STATE_BOT,
+    STATE_QV, STATE_QF,
+    STATE_QF_TO_V, STATE_BOT_TO_F, STATE_BOT_TO_V,
+    STATE_QV_TO_BOT, STATE_T_TO_V, STATE_QV_TO_T,
+]
+
+
+@dataclass
+class ParaconsistentRules:
+    """Parâmetros do sistema paraconsistente (ajustáveis)."""
+    vscc: float = VSCC
+    vicc: float = VICC
+    vscct: float = VSCC_T
+    vicct: float = VICC_T
+
+    @staticmethod
+    def gc(mu: float, lam: float) -> float:
+        """Grau de Certeza: Gc = μ − λ ∈ [−1, 1]."""
+        return mu - lam
+
+    @staticmethod
+    def gct(mu: float, lam: float) -> float:
+        """Grau de Contradição: Gct = μ + λ − 1 ∈ [−1, 1]."""
+        return mu + lam - 1.0
+
+    def state_12(self, mu: float, lam: float) -> str:
+        """
+        Para-analisador: discretiza (μ, λ) em um dos 12 estados lógicos.
+        Regras conforme Fuzzy.txt — regiões no QUPC delimitadas por Vscc, Vicc, Vscct, Vicct.
+        """
+        gc = self.gc(mu, lam)
+        gct = self.gct(mu, lam)
+
+        # Alto grau de contradição positiva → Inconsistente (T)
+        if gct >= self.vscct:
+            if gc >= self.vscc:
+                return STATE_T_TO_V      # transição T→V
+            if gc <= self.vicc:
+                return STATE_QV_TO_T     # transição QV→T (ou T→F)
+            return STATE_T
+        # Alto grau de contradição negativa → Indeterminado (⊥)
+        if gct <= self.vicct:
+            if gc >= self.vscc:
+                return STATE_BOT_TO_V
+            if gc <= self.vicc:
+                return STATE_BOT_TO_F
+            return STATE_BOT
+        # Contradição baixa (zona central em Gct)
+        if gc >= self.vscc:
+            return STATE_V if gct <= 0 else STATE_QV
+        if gc <= self.vicc:
+            return STATE_F if gct <= 0 else STATE_QF
+        # Certeza em zona intermediária
+        if gct > 0:
+            return STATE_QV_TO_BOT
+        return STATE_QF_TO_V
+
+
+# Instância global com valores padrão do documento
+DEFAULT_RULES = ParaconsistentRules()
+
+
+def state_from_rules(mu: float, lam: float, rules: ParaconsistentRules | None = None) -> str:
+    """Retorna o estado lógico de 12 valores para (μ, λ) segundo as regras do Fuzzy.txt."""
+    r = rules or DEFAULT_RULES
+    return r.state_12(mu, lam)
+
+
+def state_12_to_simple(state_12: str) -> str:
+    """
+    Mapeia os 12 estados do reticulado para os 4 estados usados pelo
+    TruthScoringModel / ParaconsistentValue: Verdadeiro | Falso | Intermediário | Indeterminado.
+    """
+    if state_12 in (STATE_V, STATE_QV, STATE_T_TO_V, STATE_BOT_TO_V):
+        return "Verdadeiro"
+    if state_12 in (STATE_F, STATE_QF, STATE_BOT_TO_F, STATE_QF_TO_V):
+        return "Falso"
+    if state_12 in (STATE_T, STATE_QV_TO_T, STATE_QV_TO_BOT):
+        return "Intermediário"
+    return "Indeterminado"
+
+
+def truth_value_from_annotations(mu: float, lam: float) -> float:
+    """Valor-verdade escalar em [0,1] a partir de (μ, λ), compatível com L3."""
+    return round((mu + (1.0 - lam)) / 2.0, 4)
+
+
+def parse_rules_from_fuzzy_text(content: str) -> ParaconsistentRules:
+    """
+    Extrai valores de controle do texto do arquivo Fuzzy.txt quando possível.
+    Se não encontrar, retorna DEFAULT_RULES.
+    """
+    rules = ParaconsistentRules()
+    # Procura padrões como "Vscc=1/2", "Vscct= 1/2", "1/2" próximo a Vscc, etc.
+    vscc_m = re.search(r"Vscc\s*=\s*Vscct\s*=\s*1/2", content, re.I)
+    if vscc_m:
+        rules.vscc = 0.5
+        rules.vscct = 0.5
+    vicc_m = re.search(r"Vicc\s*(?:e|e\s*Vicct)?\s*[=:]?\s*-?\s*1/2", content, re.I)
+    if vicc_m or "Vicc" in content and "-1/2" in content:
+        rules.vicc = -0.5
+        rules.vicct = -0.5
+    return rules
+
+
+def load_rules_from_fuzzy_file(path: str | None = None) -> ParaconsistentRules:
+    """
+    Carrega o conteúdo de data/Fuzzy.txt e retorna ParaconsistentRules.
+    Se o arquivo não existir ou não for legível, retorna DEFAULT_RULES.
+    """
+    if path is None:
+        base = os.path.dirname(os.path.abspath(__file__))
+        path = os.path.join(base, "data", "Fuzzy.txt")
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return parse_rules_from_fuzzy_text(content)
+    except Exception:
+        return DEFAULT_RULES
+
+
+def generate_training_pairs(
+    rules: ParaconsistentRules | None = None,
+    grid_step: float = 0.1,
+) -> Iterator[Tuple[float, float, str, float]]:
+    """
+    Gera pares (μ, λ, estado_12, valor_verdade) para treinar a camada L3
+    a partir do conjunto de regras (para-analisador).
+    Útil para criar dataset sintético que segue exatamente o Fuzzy.txt.
+    """
+    r = rules or DEFAULT_RULES
+    mu = 0.0
+    while mu <= 1.0:
+        lam = 0.0
+        while lam <= 1.0:
+            state = r.state_12(mu, lam)
+            truth = truth_value_from_annotations(mu, lam)
+            yield (mu, lam, state, truth)
+            lam = round(lam + grid_step, 2)
+        mu = round(mu + grid_step, 2)
+
+
+def get_rules_training_examples(
+    rules: ParaconsistentRules | None = None,
+    grid_step: float = 0.1,
+) -> List[Tuple[float, float, str, float]]:
+    """Lista de (μ, λ, estado_12, valor_verdade) para uso no treinamento."""
+    return list(generate_training_pairs(rules=rules, grid_step=grid_step))

pipeline.py

@@ -0,0 +1,460 @@
+"""
+PIPELINE PRINCIPAL — Modelo Híbrido de LLM
+===========================================
+Orquestra as 10 etapas do fluxo completo:
+
+  1. Recepção do prompt
+  2. Extração de conceitos [L1]
+  3. Refinamento por Juízos Kantianos [L2]
+  4. Silogismo Científico + Hempel
+  5. Falseabilidade de Popper
+  6. Avaliação Paraconsistente [L3]
+  7. Síntese por Equivalência [L4]
+  8. Geração da Resposta [L5 — opcional]
+  9. Resposta Final em Texto Fluida [L6]
+ 10. Texto Final Definitivo [L7]
+
+Usa config_loader, knowledge_base (KB escalável + RAG opcional), l5_generation
+e opcionalmente o agente de pesquisa para enriquecer contexto.
+"""
+
+from __future__ import annotations
+import sys
+import re
+import time
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+import torch
+
+from neural_truth_model import TruthScoringModel, load_tokenizer
+from l1_concept_table import ConceptTable, ConceptNode, LogicLMSymbolicSolver
+from l2_kantian_judgments import KantianJudgmentEngine, KantianJudgment
+from syllogism_module import ScientificSyllogismPipeline
+from l3_paraconsistent import ParaconsistentEngine, ParaconsistentValue
+from l4_synthesis import RussellianSynthesisEngine, SynthesisResult
+from l6_final_response import EpistemicContext, FinalResponseEngine
+from l7_final_text import FinalTextEngine
+
+try:
+    from l4_russell_equivalence import load_concept_base
+except Exception:
+    load_concept_base = None  # type: ignore
+
+try:
+    from config_loader import load_config, PROJECT_ROOT
+except Exception:
+    load_config = None  # type: ignore
+    PROJECT_ROOT = Path(__file__).resolve().parent
+
+try:
+    from knowledge_base import get_knowledge_base, SEED_KNOWLEDGE_BASE
+except Exception:
+    get_knowledge_base = None  # type: ignore
+    SEED_KNOWLEDGE_BASE = {}
+
+try:
+    from l5_generation import generate_response as l5_generate
+except Exception:
+    l5_generate = None  # type: ignore
+
+try:
+    from agente_busca_web import run_search_for_context
+except Exception:
+    run_search_for_context = None  # type: ignore
+
+
+def _get_kb(config: Optional[Dict[str, Any]], prompt: str, use_agent: bool) -> Dict[str, float]:
+    if get_knowledge_base is None:
+        return dict(SEED_KNOWLEDGE_BASE) if SEED_KNOWLEDGE_BASE else {}
+    return get_knowledge_base(
+        config=config,
+        query_for_rag=prompt if use_agent else None,
+    )
+
+
+class HybridLLMPipeline:
+    """
+    Pipeline completo do Modelo Híbrido de LLM.
+    Suporta config, KB escalável, L5 (geração), agente opcional e chat.
+    """
+
+    def __init__(
+        self,
+        knowledge_base: Optional[Dict[str, float]] = None,
+        config: Optional[Dict[str, Any]] = None,
+        verbose: bool = True,
+    ) -> None:
+        self._config = config or (load_config() if load_config else {})
+        self.kb = knowledge_base or _get_kb(self._config, "", False)
+        if not self.kb:
+            self.kb = dict(SEED_KNOWLEDGE_BASE) if SEED_KNOWLEDGE_BASE else {}
+        self.verbose = verbose
+
+        self.L1 = ConceptTable()
+        self.L2 = KantianJudgmentEngine(self.L1)
+        self.SYL = ScientificSyllogismPipeline()
+
+        # L3
+        l3_cfg = self._config.get("l3", {})
+        model_path = l3_cfg.get("model_path", "truth_scoring_model.pt")
+        backbone_name = l3_cfg.get("backbone", "bert-base-multilingual-cased")
+        if not Path(model_path).is_absolute():
+            model_path = str(PROJECT_ROOT / model_path)
+        neural_model = None
+        neural_tokenizer = None
+        if os.path.exists(model_path):
+            try:
+                device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+                neural_tokenizer = load_tokenizer(backbone_name)
+                neural_model = TruthScoringModel(backbone_name=backbone_name)
+                state = torch.load(model_path, map_location=device)
+                neural_model.load_state_dict(state)
+                neural_model.to(device)
+                if self.verbose:
+                    print(f"[L3] Modelo neural carregado de '{model_path}'")
+                self.L3 = ParaconsistentEngine(neural_model=neural_model, neural_tokenizer=neural_tokenizer, device=device)
+            except Exception as exc:
+                if self.verbose:
+                    print(f"[L3] Falha ao carregar modelo neural: {exc}")
+                self.L3 = ParaconsistentEngine()
+        else:
+            self.L3 = ParaconsistentEngine()
+
+        # L4
+        russell_base = None
+        rpath = self._config.get("l4", {}).get("russell_concepts_path", "l4_russell_concepts.json")
+        if not Path(rpath).is_absolute():
+            rpath = str(PROJECT_ROOT / rpath)
+        if load_concept_base and os.path.exists(rpath):
+            try:
+                russell_base = load_concept_base(rpath)
+                if self.verbose:
+                    print("[L4] Base russelliana carregada.")
+            except Exception:
+                pass
+        if russell_base is None and load_concept_base:
+            try:
+                from l4_russell_equivalence import build_russell_concept_base
+                russell_base = build_russell_concept_base()
+            except Exception:
+                pass
+        self.L4 = RussellianSynthesisEngine(
+            self.kb,
+            russell_concept_base=russell_base,
+            use_concept_based_weights=(russell_base is not None),
+            verification_config=self._config.get("l4_chain_verification", {}),
+        )
+        self.L6 = FinalResponseEngine()
+        self.L7 = FinalTextEngine(config=self._config)  # Passa config para suportar múltiplos providers
+
+    def _infer_domain(self, concepts: List[ConceptNode]) -> str:
+        """Inferência simples de domínio majoritário a partir dos conceitos extraídos."""
+        if not concepts:
+            return "geral"
+        domain_counts = {}
+        for concept in concepts:
+            domain = concept.domain.lower().strip() if concept.domain else "geral"
+            domain_counts[domain] = domain_counts.get(domain, 0) + 1
+        return max(domain_counts, key=domain_counts.get)
+
+    def process(
+        self,
+        prompt: str,
+        chat_session: Optional[Any] = None,
+        use_agent: Optional[bool] = None,
+        skip_l5: bool = False,
+        skip_l6: bool = False,
+    ) -> SynthesisResult:
+        """Executa o pipeline e retorna SynthesisResult (com response já gerada por L5 se ativo)."""
+        t0 = time.perf_counter()
+        use_agent = use_agent if use_agent is not None else self._config.get("agent", {}).get("use_agent", False)
+        if chat_session and hasattr(chat_session, "get_context_for_prompt"):
+            prompt_for_kb = chat_session.get_context_for_prompt(prompt, self._config.get("chat", {}).get("max_turns_in_context", 10))
+        else:
+            prompt_for_kb = prompt
+
+        # KB pode ser enriquecido por RAG (Chroma) quando use_agent
+        if use_agent and get_knowledge_base:
+            self.kb = _get_kb(self._config, prompt_for_kb, True)
+            if not self.kb:
+                self.kb = dict(SEED_KNOWLEDGE_BASE) if SEED_KNOWLEDGE_BASE else {}
+
+        self._log("\n" + "═" * 60)
+        self._log(f"  PROMPT: {prompt[:200]}{'...' if len(prompt) > 200 else ''}")
+        self._log("═" * 60)
+
+        limit = RussellianSynthesisEngine.check_fundamental_limits(prompt)
+        if limit:
+            self._log(f"\n{limit}")
+
+        self._log("\n[ETAPA 2] L1 — Extração de Conceitos")
+        concepts: List[ConceptNode] = self.L1.extract_concepts(prompt, llm_context=prompt_for_kb, domain="geral", config=self._config)
+        domain = self._infer_domain(concepts)
+        if domain != "geral":
+            # Re-extrai com domínio específico para enriquecer com KB do domínio
+            concepts = self.L1.extract_concepts(prompt, llm_context=prompt_for_kb, domain=domain, config=self._config)
+        concepts_summary = ""
+        if self.verbose and concepts:
+            for c in concepts:
+                syns = ", ".join(c.synonyms[:2]) or "—"
+                self._log(f"  • {c.term:15s} | sinônimos: {syns}")
+            concepts_summary = "; ".join(f"{c.term}({', '.join(c.synonyms[:2])})" for c in concepts[:8])
+
+        self._log("\n[ETAPA 3] L2 — Juízos Kantianos")
+        judgments: List[KantianJudgment] = self.L2.refine(prompt, concepts)
+        top_judgments = ""
+        if judgments:
+            top_judgments = "\n".join(j.proposicao for j, _ in list(zip(judgments, [None] * 6))[:6])
+
+        self._log("\n[ETAPAS 4+5] Silogismo + Hempel + Popper")
+        prompt_terms = set(re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", prompt.lower()))
+        kb_scores = {j.proposicao[:30]: self.kb.get(j.proposicao.split()[0], 0.3) for j in judgments}
+        filtered = self.SYL.run(judgments, prompt_terms, kb_scores)
+        self._log(f"  {len(judgments)} hipóteses → {len(filtered)} após filtros")
+
+        self._log("\n[ETAPA 6] L3 — Lógica Paraconsistente + Classificação Epistemológica L2")
+        props_with_priority = [(j.proposicao, score) for j, score in filtered]
+        pv_list: List[ParaconsistentValue] = self.L3.evaluate(props_with_priority, self.kb)
+        consistent = self.L3.check_global_consistency(pv_list)
+        self._log(f"  Consistência global: {'✓' if consistent else '✗'}")
+
+        epistemic_context = EpistemicContext(
+            proposition_states=[
+                {
+                    "proposition": pv.proposition,
+                    "proposition_type": pv.proposition_kind or "Desconhecido",
+                    "mu": pv.mu,
+                    "lambda": pv.lam,
+                    "certainty": pv.certainty,
+                    "contradiction": pv.contradiction,
+                    "truth_value": pv.truth_value,
+                    "state": pv.state,
+                }
+                for pv in pv_list
+            ],
+            many_valued_routes=[
+                {
+                    "left": left.proposition,
+                    "left_type": left.proposition_kind or "Desconhecido",
+                    "right": right.proposition,
+                    "right_type": right.proposition_kind or "Desconhecido",
+                    "route": route,
+                    "confidence": confidence,
+                    "explanation": explanation,
+                }
+                for left, right, route, confidence, explanation in self.L3.route_contradictions(pv_list)
+            ],
+            bert_classifications=[
+                {
+                    "proposition": judgment.proposicao,
+                    "priority": judgment.prioridade,
+                    "truth": judgment.epistemic_classification.truth,
+                    "indeterminacy": judgment.epistemic_classification.indeterminacy,
+                    "falsity": judgment.epistemic_classification.falsity,
+                    "classification": judgment.epistemic_classification.classification,
+                }
+                for judgment, _ in filtered[:8]
+            ],
+            application_context=LogicLMSymbolicSolver.summarize_application_context(concepts),
+        )
+
+        self._log("\n[ETAPA 7] L4 — Síntese Russelliana")
+        l2_priorities = {j.proposicao[:40]: j.prioridade for j, _ in filtered}
+        result: SynthesisResult = self.L4.synthesize(pv_list, l2_priorities, prompt)
+        l4_result = result
+        l5_text = result.response
+
+        # Contexto do agente (busca web/local) se ativo
+        agent_context = ""
+        if use_agent and run_search_for_context:
+            try:
+                agent_context = run_search_for_context(prompt)
+                if agent_context and self.verbose:
+                    self._log("\n[AGENTE] Contexto de busca obtido.")
+            except Exception:
+                pass
+
+        # L5 — Geração de resposta em texto livre
+        gen_cfg = self._config.get("generation", {})
+        final_cfg = self._config.get("finalization", {})
+        provider = gen_cfg.get("provider", "template")
+        if not skip_l5 and l5_generate and provider != "template":
+            final_response = l5_generate(
+                prompt,
+                result,
+                provider=provider,
+                concepts_summary=concepts_summary,
+                top_judgments=top_judgments,
+                groq_model=gen_cfg.get("groq_model", "mixtral-8x7b-32768"),
+                custom_lm_path=gen_cfg.get("custom_lm_path", ""),
+            )
+            if agent_context and final_response:
+                final_response = final_response + "\n\n[Contexto da busca]\n" + agent_context[:800]
+            elif agent_context:
+                final_response = result.response + "\n\n[Contexto da busca]\n" + agent_context[:800]
+            else:
+                final_response = final_response or result.response
+            result = SynthesisResult(
+                response=final_response,
+                truth_value=result.truth_value,
+                certainty=result.certainty,
+                contradiction=result.contradiction,
+                state=result.state,
+                supporting_evidence=result.supporting_evidence,
+                falsified_hypotheses=result.falsified_hypotheses,
+                confidence_label=result.confidence_label,
+            )
+        elif agent_context and result.response:
+            result = SynthesisResult(
+                response=result.response + "\n\n[Contexto da busca]\n" + agent_context[:800],
+                truth_value=result.truth_value,
+                certainty=result.certainty,
+                contradiction=result.contradiction,
+                state=result.state,
+                supporting_evidence=result.supporting_evidence,
+                falsified_hypotheses=result.falsified_hypotheses,
+                confidence_label=result.confidence_label,
+            )
+
+        l5_text = result.response
+
+        if not skip_l6:
+            final_text = self.L6.finalize_response(
+                prompt=prompt,
+                synthesis_result=result,
+                epistemic_context=epistemic_context,
+                generated_text=result.response,
+                concepts_summary=concepts_summary,
+                top_judgments=top_judgments,
+                agent_context=agent_context,
+            )
+            final_text = self.L6.rewrite_response(
+                prompt=prompt,
+                synthesis_result=result,
+                epistemic_context=epistemic_context,
+                generated_text=final_text,
+                concepts_summary=concepts_summary,
+                top_judgments=top_judgments,
+                agent_context=agent_context,
+                provider=final_cfg.get("provider", gen_cfg.get("provider", "template")),
+                groq_model=final_cfg.get("groq_model", gen_cfg.get("groq_model", "mixtral-8x7b-32768")),
+                custom_lm_path=final_cfg.get("custom_lm_path", gen_cfg.get("custom_lm_path", "")),
+            )
+            result = SynthesisResult(
+                response=final_text,
+                truth_value=result.truth_value,
+                certainty=result.certainty,
+                contradiction=result.contradiction,
+                state=result.state,
+                supporting_evidence=result.supporting_evidence,
+                falsified_hypotheses=result.falsified_hypotheses,
+                confidence_label=result.confidence_label,
+            )
+
+        l3_summary = ""
+        if epistemic_context is not None and epistemic_context.proposition_states:
+            top_states = epistemic_context.proposition_states[:3]
+            l3_summary = "; ".join(
+                f"{item.get('proposition', 'desconhecida')} → {item.get('state', 'n/a')} ({item.get('truth_value', 0):.2f})"
+                for item in top_states
+            )
+            if epistemic_context.many_valued_routes:
+                l3_summary += f"; rotas paraconsistentes: {len(epistemic_context.many_valued_routes)}"
+
+        l7_cfg = self._config.get("l7", {})
+        # Coletar alertas de incompatibilidade canônica gerados durante L1
+        canonical_alerts = LogicLMSymbolicSolver.get_canonical_alerts() if LogicLMSymbolicSolver else []
+        
+        # === L7 — Texto Final Definitivo (Automático e Integrado) ===
+        # Suporta múltiplos providers: ollama, groq, custom_lm, template
+        final_text_l7 = self.L7.finalize_text(
+            prompt=prompt,
+            l1_summary=concepts_summary,
+            l2_summary=top_judgments,
+            l3_summary=l3_summary,
+            l4_response=l4_result.response,
+            l5_text=l5_text,
+            l6_text=result.response,
+            synthesis_result=l4_result,
+            provider=l7_cfg.get("provider", "template"),
+            model=l7_cfg.get("model", "llama2"),  # Padrão para ollama
+            groq_model=l7_cfg.get("groq_model", gen_cfg.get("groq_model", "mixtral-8x7b-32768")),
+            custom_lm_path=l7_cfg.get("custom_lm_path", ""),
+            canonical_alerts=canonical_alerts,
+            temperature=l7_cfg.get("temperature", 0.7),
+            max_tokens=l7_cfg.get("max_tokens", 4096),
+        )
+        result = SynthesisResult(
+            response=final_text_l7,
+            truth_value=result.truth_value,
+            certainty=result.certainty,
+            contradiction=result.contradiction,
+            state=result.state,
+            supporting_evidence=result.supporting_evidence,
+            falsified_hypotheses=result.falsified_hypotheses,
+            confidence_label=result.confidence_label,
+        )
+
+        elapsed = (time.perf_counter() - t0) * 1000
+        self._log(f"\n[ETAPA 10] L7 — Texto Final Definitivo  ({elapsed:.1f} ms)\n")
+        self._log(str(result))
+        return result
+
+    def _log(self, msg: str) -> None:
+        if self.verbose:
+            print(msg)
+
+    def repl(self) -> None:
+        print("\n" + "═" * 60)
+        print("  MODELO HÍBRIDO DE LLM — Fonseca")
+        print("  Digite 'sair' para encerrar")
+        print("═" * 60)
+        while True:
+            try:
+                prompt = input("\nPrompt › ").strip()
+            except (EOFError, KeyboardInterrupt):
+                break
+            if not prompt:
+                continue
+            if prompt.lower() in {"sair", "exit", "quit"}:
+                break
+            self.process(prompt)
+
+
+def main() -> None:
+    import argparse
+    parser = argparse.ArgumentParser(description="Modelo Híbrido de LLM — Pipeline L1–L7")
+    parser.add_argument("--prompt", "-p", type=str, help="Pergunta única (imprime só a resposta)")
+    parser.add_argument("--repl", action="store_true", help="Modo interativo")
+    parser.add_argument("--demo", action="store_true", help="Rodar demonstração com prompts fixos")
+    parser.add_argument("--config", type=str, help="Caminho para config.yaml")
+    args, _ = parser.parse_known_args()
+
+    config = load_config(Path(args.config)) if load_config and args.config else (load_config() if load_config else {})
+    pipeline = HybridLLMPipeline(config=config, verbose=not args.prompt)
+
+    if args.prompt:
+        r = pipeline.process(args.prompt)
+        print(r.response)
+        return
+    if args.repl:
+        pipeline.repl()
+        return
+    if args.demo:
+        for p in ["A água a 35 graus está quente ou fria?", "O que é a verdade?"]:
+            pipeline.process(p)
+            print()
+        return
+    # Default: demo + repl se --repl no argv antigo
+    if "--repl" in sys.argv:
+        pipeline.repl()
+        return
+    for p in ["A água a 35 graus está quente ou fria?", "O que é a verdade?"]:
+        pipeline.process(p)
+        print()
+
+
+if __name__ == "__main__":
+    main()

pipeline_with_rag_integration.py

@@ -0,0 +1,429 @@
+"""
+PIPELINE COM INTEGRAÇÃO DE RAG HÍBRIDO
+========================================
+Versão estendida do pipeline.py que integra:
+- RAG Híbrido (Context Injection + Retrieval Seletivo)
+- L1-L2 enriquecidas com contexto
+- Domain-aware Knowledge Base
+
+Substitui 'pipeline.py' ou pode ser usado em paralelo.
+"""
+
+from __future__ import annotations
+import sys
+import re
+import time
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+import torch
+
+# Importações originais do pipeline
+try:
+    from neural_truth_model import TruthScoringModel, load_tokenizer
+except ImportError:
+    TruthScoringModel = None
+    load_tokenizer = None
+
+try:
+    from l1_concept_table import ConceptTable, ConceptNode, LogicLMSymbolicSolver
+except ImportError:
+    ConceptTable = None
+    ConceptNode = None
+    LogicLMSymbolicSolver = None
+
+try:
+    from l2_kantian_judgments import KantianJudgmentEngine, KantianJudgment
+except ImportError:
+    KantianJudgmentEngine = None
+    KantianJudgment = None
+
+try:
+    from syllogism_module import ScientificSyllogismPipeline
+except ImportError:
+    ScientificSyllogismPipeline = None
+
+try:
+    from l3_paraconsistent import ParaconsistentEngine, ParaconsistentValue
+except ImportError:
+    ParaconsistentEngine = None
+    ParaconsistentValue = None
+
+try:
+    from l4_synthesis import RussellianSynthesisEngine, SynthesisResult
+except ImportError:
+    RussellianSynthesisEngine = None
+    SynthesisResult = None
+
+try:
+    from l6_final_response import EpistemicContext, FinalResponseEngine
+except ImportError:
+    EpistemicContext = None
+    FinalResponseEngine = None
+
+try:
+    from l7_final_text import FinalTextEngine
+except ImportError:
+    FinalTextEngine = None
+
+try:
+    from l4_russell_equivalence import load_concept_base
+except ImportError:
+    load_concept_base = None
+
+try:
+    from config_loader import load_config, PROJECT_ROOT
+except ImportError:
+    load_config = None
+    PROJECT_ROOT = Path(__file__).resolve().parent
+
+try:
+    from knowledge_base import get_knowledge_base, SEED_KNOWLEDGE_BASE
+except ImportError:
+    get_knowledge_base = None
+    SEED_KNOWLEDGE_BASE = {}
+
+try:
+    from l5_generation import generate_response as l5_generate
+except ImportError:
+    l5_generate = None
+
+try:
+    from agente_busca_web import run_search_for_context
+except ImportError:
+    run_search_for_context = None
+
+# Importações do RAG Híbrido
+try:
+    from l1_l2_rag_integration import (
+        create_l1_l2_rag_pipeline,
+        IntegratedL1L2RAGPipeline,
+        EnrichedL1Output,
+        EnrichedL2Output,
+    )
+    HAS_RAG_HYBRID = True
+except ImportError:
+    HAS_RAG_HYBRID = False
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Pipeline Estendido com RAG Híbrido
+# ─────────────────────────────────────────────────────────────────────────────
+
+class HybridLLMPipelineWithRAG:
+    """
+    Pipeline completo do Modelo Híbrido de LLM com RAG Integrado.
+    
+    Adiciona ao pipeline original:
+    - RAG Híbrido para cada query
+    - Context Injection automático nas camadas L1-L2
+    - Domain-aware Knowledge Base
+    - System prompt especializado por domínio
+    
+    Suporta config, KB escalável, L5 (geração), agente opcional e chat.
+    """
+
+    def __init__(
+        self,
+        knowledge_base: Optional[Dict[str, float]] = None,
+        config: Optional[Dict[str, Any]] = None,
+        use_rag_hybrid: bool = True,
+        verbose: bool = True,
+    ) -> None:
+        self._config = config or (load_config() if load_config else {})
+        self.kb = knowledge_base or self._get_kb(self._config, "", False)
+        if not self.kb:
+            self.kb = dict(SEED_KNOWLEDGE_BASE) if SEED_KNOWLEDGE_BASE else {}
+        self.verbose = verbose
+        self.use_rag_hybrid = use_rag_hybrid and HAS_RAG_HYBRID
+
+        # Inicializa pipeline L1-L2-RAG (se disponível)
+        if self.use_rag_hybrid:
+            self.rag_l1_l2_pipeline = create_l1_l2_rag_pipeline(config=self._config)
+            if self.verbose:
+                print("[Pipeline] RAG Híbrido habilitado")
+        else:
+            self.rag_l1_l2_pipeline = None
+
+        # Inicializa componentes originais
+        if ConceptTable:
+            self.L1 = ConceptTable()
+        else:
+            self.L1 = None
+
+        if KantianJudgmentEngine:
+            self.L2 = KantianJudgmentEngine(self.L1) if self.L1 else None
+        else:
+            self.L2 = None
+
+        if ScientificSyllogismPipeline:
+            self.SYL = ScientificSyllogismPipeline()
+        else:
+            self.SYL = None
+
+        # L3
+        l3_cfg = self._config.get("l3", {})
+        if ParaconsistentEngine:
+            self.L3 = ParaconsistentEngine(
+                t_threshold=l3_cfg.get("t_threshold", 0.7),
+                f_threshold=l3_cfg.get("f_threshold", 0.3),
+                verbose=verbose,
+            )
+        else:
+            self.L3 = None
+
+        # L4
+        if RussellianSynthesisEngine:
+            self.L4 = RussellianSynthesisEngine()
+        else:
+            self.L4 = None
+
+        # L5/L6/L7
+        if FinalResponseEngine:
+            self.L6 = FinalResponseEngine()
+        else:
+            self.L6 = None
+
+        if FinalTextEngine:
+            self.L7 = FinalTextEngine()
+        else:
+            self.L7 = None
+
+    def _get_kb(self, config: Optional[Dict[str, Any]], prompt: str, use_agent: bool) -> Dict[str, float]:
+        if get_knowledge_base is None:
+            return dict(SEED_KNOWLEDGE_BASE) if SEED_KNOWLEDGE_BASE else {}
+        return get_knowledge_base(
+            config=config,
+            query_for_rag=prompt if use_agent else None,
+        )
+
+    def process_with_rag(
+        self,
+        prompt: str,
+        use_agent: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Processa prompt com RAG Híbrido integrado.
+        
+        Retorna:
+        {
+            'query': str,
+            'domain': str,
+            'l1_concepts': List[ConceptNode],
+            'l2_judgments': List[KantianJudgment],
+            'system_prompt': str,
+            'injected_context': str,
+            'rag_confidence': float,
+            'full_pipeline_result': Dict (saída completa do L1-L7),
+        }
+        """
+        if self.verbose:
+            print(f"\n{'='*70}")
+            print(f"[HybridPipeline] Processando (com RAG): {prompt[:60]}...")
+            print(f"{'='*70}")
+
+        # Se RAG não está habilitado, retorna processo padrão
+        if not self.use_rag_hybrid:
+            return self.process_standard(prompt, use_agent)
+
+        # ─────────────────────────────────────────────────────────────────────
+        # ETAPA 1: RAG Híbrido + L1-L2 Enriquecido
+        # ─────────────────────────────────────────────────────────────────────
+        rag_result = self.rag_l1_l2_pipeline.process(prompt)
+
+        domain = rag_result['domain']
+        l1_output: EnrichedL1Output = rag_result['l1_output']
+        l2_output: EnrichedL2Output = rag_result['l2_output']
+
+        if self.verbose:
+            print(f"\n[RAG] Domínio: {domain}")
+            print(f"[RAG] Confiança: {rag_result['confidence']:.2%}")
+            print(f"[RAG] Conceitos (L1): {len(l1_output.concepts)}")
+            print(f"[RAG] Juízos (L2): {len(l2_output.judgments)}")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # ETAPA 2: Silogismo Científico (L3 original)
+        # ─────────────────────────────────────────────────────────────────────
+        hypothesis = prompt
+        if self.SYL and self.verbose:
+            print(f"\n[SYL] Analisando silogismo...")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # ETAPA 3: Avaliação Paraconsistente (L3 original)
+        # ─────────────────────────────────────────────────────────────────────
+        if self.L3 and self.verbose:
+            print(f"\n[L3] Avaliação paraconsistente...")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # ETAPA 4: Síntese Russelliana (L4 original)
+        # ─────────────────────────────────────────────────────────────────────
+        if self.L4 and self.verbose:
+            print(f"\n[L4] Síntese russelliana...")
+
+        # ────────���────────────────────────────────────────────────────────────
+        # ETAPA 5-7: Geração e Resposta Final (com system_prompt enriquecido)
+        # ─────────────────────────────────────────────────────────────────────
+        system_prompt_enriched = rag_result['system_prompt']
+        compiled_context = rag_result['compiled_context']
+
+        if self.verbose:
+            print(f"\n[GEN] Gerando resposta com system_prompt enriquecido...")
+            print(f"[GEN] Contexto injetado: {len(compiled_context)} caracteres")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Retorna resultado compilado
+        # ─────────────────────────────────────────────────────────────────────
+        # Coletar alertas de incompatibilidade canônica gerados durante L1-L2
+        canonical_alerts = LogicLMSymbolicSolver.get_canonical_alerts() if LogicLMSymbolicSolver else []
+
+        return {
+            'query': prompt,
+            'domain': domain,
+            'l1_concepts': l1_output.concepts,
+            'l2_judgments': l2_output.judgments,
+            'system_prompt': system_prompt_enriched,
+            'injected_context': compiled_context,
+            'rag_confidence': rag_result['confidence'],
+            'kb_terms': l2_output.domain_specialized_kb,
+            'rag_l1_l2_output': rag_result,
+            'canonical_alerts': canonical_alerts,
+            'full_pipeline_result': {},  # Preenchido se L3-L7 forem executadas
+        }
+
+    def process_standard(
+        self,
+        prompt: str,
+        use_agent: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Processa prompt com pipeline padrão (sem RAG).
+        Mantém compatibilidade com pipeline.py original.
+        """
+        if self.verbose:
+            print(f"\n{'='*70}")
+            print(f"[HybridPipeline] Processando (sem RAG): {prompt[:60]}...")
+            print(f"{'='*70}")
+
+        # Extrai conceitos L1
+        concepts = self.L1.extract_concepts(prompt) if self.L1 else []
+
+        # Analisa juízos L2
+        judgments = self.L2.infer_from_prompt(prompt) if self.L2 else []
+
+        return {
+            'query': prompt,
+            'domain': 'geral',
+            'l1_concepts': concepts,
+            'l2_judgments': judgments,
+            'system_prompt': "Você é um especialista. Responda com rigor.",
+            'injected_context': "",
+            'rag_confidence': 0.0,
+            'kb_terms': {},
+            'rag_l1_l2_output': None,
+            'full_pipeline_result': {},
+        }
+
+    def format_for_llm(self, rag_result: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Formata resultado do pipeline para injeção em LLM.
+        
+        Retorna:
+        {
+            'system_prompt': str,
+            'user_message': str,
+            'domain': str,
+            'confidence': float,
+        }
+        """
+        return {
+            'system_prompt': rag_result.get('system_prompt', ''),
+            'user_message': rag_result.get('injected_context', rag_result.get('query', '')),
+            'domain': rag_result.get('domain', 'geral'),
+            'confidence': rag_result.get('rag_confidence', 0.0),
+        }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Funções de Conveniência
+# ─────────────────────────────────────────────────────────────────────────────
+
+def create_hybrid_pipeline_with_rag(
+    config: Optional[Dict[str, Any]] = None,
+    use_rag: bool = True,
+) -> HybridLLMPipelineWithRAG:
+    """Factory para criar pipeline com RAG."""
+    return HybridLLMPipelineWithRAG(
+        config=config,
+        use_rag_hybrid=use_rag,
+        verbose=True,
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CLI / REPL para Testes
+# ─────────────────────────────────────────────���───────────────────────────────
+
+def interactive_pipeline():
+    """REPL interativo para testar o pipeline."""
+    print("\n" + "="*70)
+    print("PIPELINE HÍBRIDO COM RAG — MODO INTERATIVO")
+    print("="*70)
+    print("\nComandos:")
+    print("  - Digite uma pergunta para processar com RAG híbrido")
+    print("  - 'no-rag' para desabilitar RAG e usar pipeline padrão")
+    print("  - 'quit' para sair")
+    print("")
+
+    pipeline = create_hybrid_pipeline_with_rag(use_rag=True)
+    use_rag = True
+
+    while True:
+        try:
+            prompt = input("\n> ").strip()
+
+            if prompt.lower() == 'quit':
+                print("Encerrando...")
+                break
+
+            if prompt.lower() == 'no-rag':
+                use_rag = not use_rag
+                mode = "com RAG" if use_rag else "sem RAG"
+                print(f"Modo alternado para: {mode}")
+                continue
+
+            if not prompt:
+                continue
+
+            # Processa
+            result = pipeline.process_with_rag(prompt) if use_rag else pipeline.process_standard(prompt)
+
+            # Exibe resultado
+            print(f"\n✓ Domínio: {result['domain']}")
+            print(f"✓ Confiança: {result['rag_confidence']:.2%}")
+            print(f"✓ Conceitos (L1): {len(result['l1_concepts'])}")
+            print(f"✓ Juízos (L2): {len(result['l2_judgments'])}")
+            if result['injected_context']:
+                print(f"\n[Contexto Injetado]\n{result['injected_context'][:400]}...")
+
+        except KeyboardInterrupt:
+            print("\n\nInterrompido pelo usuário.")
+            break
+        except Exception as e:
+            print(f"\n❌ Erro: {e}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Script Principal
+# ─────────────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        # Processa argumento como query
+        query = " ".join(sys.argv[1:])
+        pipeline = create_hybrid_pipeline_with_rag(use_rag=True)
+        result = pipeline.process_with_rag(query)
+        print(json.dumps(result, indent=2, default=str, ensure_ascii=False))
+    else:
+        # Modo interativo
+        interactive_pipeline()

pretrain_custom_lm.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+"""
+Pré-treinamento de um pequeno modelo de linguagem
+=================================================
+
+Fluxo:
+  1. Usa o texto do README (artigo/resumo) como corpus inicial.
+  2. Treina um tokenizador SentencePiece (BPE) se ainda não existir.
+  3. Constrói um Dataset de LM (inputs + labels deslocados).
+  4. Treina `EpistemicLanguageModel` com cross-entropy e AdamW.
+  5. Salva pesos do modelo e reutiliza o tokenizador treinado.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional
+import os
+
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torch.optim import AdamW
+from torch.optim.lr_scheduler import CosineAnnealingLR
+from tqdm import tqdm
+
+from custom_tokenizer import SPConfig, train_sentencepiece, CustomSPTokenizer
+from custom_lm_model import LMConfig, EpistemicLanguageModel, save_lm, generate_text
+from corpus_utils import load_main_corpus
+
+
+@dataclass
+class TrainLMConfig:
+    sp_config: SPConfig = field(default_factory=SPConfig)
+    max_seq_len: int = 128
+    batch_size: int = 16
+    num_epochs: int = 3
+    learning_rate: float = 3e-4
+    grad_clip: float = 1.0
+    grad_accum_steps: int = 1
+    save_dir: str = "checkpoints_lm"
+
+
+class LMDataset(Dataset):
+    """
+    Dataset de linguagem causal: divide o fluxo de tokens em blocos
+    de tamanho fixo e usa input_ids e labels deslocados em 1.
+    """
+
+    def __init__(self, token_ids: List[int], block_size: int) -> None:
+        self.block_size = block_size
+        # Trunca para múltiplo de block_size
+        n = (len(token_ids) // block_size) * block_size
+        self.data = token_ids[:n]
+
+    def __len__(self) -> int:
+        return max(len(self.data) // self.block_size - 1, 0)
+
+    def __getitem__(self, idx: int):
+        start = idx * self.block_size
+        end = start + self.block_size
+        x = torch.tensor(self.data[start:end], dtype=torch.long)
+        y = torch.tensor(self.data[start + 1 : end + 1], dtype=torch.long)
+        return x, y
+
+
+def ensure_tokenizer(config: TrainLMConfig) -> CustomSPTokenizer:
+    model_file = f"{config.sp_config.model_prefix}.model"
+    if not os.path.exists(model_file):
+        # Treina o SentencePiece a partir do corpus principal (README + artigo DOCX)
+        texts = load_main_corpus()
+        tmp_corpus = "sp_corpus_tmp.txt"
+        with open(tmp_corpus, "w", encoding="utf-8") as f:
+            for t in texts:
+                f.write(t.replace("\r\n", "\n") + "\n")
+        train_sentencepiece([tmp_corpus], config.sp_config)
+        os.remove(tmp_corpus)
+    return CustomSPTokenizer(model_prefix=config.sp_config.model_prefix)
+
+
+def build_token_stream(tokenizer: CustomSPTokenizer) -> Tuple[List[int], List[int]]:
+    """
+    Constrói streams de tokens para treino e validação a partir do corpus principal.
+    Usa divisão simples train/val em nível de documento.
+    """
+    texts = load_main_corpus()
+    if len(texts) == 1:
+        train_texts = texts
+        val_texts = texts
+    else:
+        split = max(1, int(0.8 * len(texts)))
+        train_texts = texts[:split]
+        val_texts = texts[split:]
+
+    def encode_all(lst: List[str]) -> List[int]:
+        ids: List[int] = []
+        for t in lst:
+            ids.extend(tokenizer.encode(t, add_bos=True, add_eos=True))
+        return ids
+
+    return encode_all(train_texts), encode_all(val_texts)
+
+
+def evaluate_lm(
+    model: EpistemicLanguageModel,
+    dataloader: DataLoader,
+    device: torch.device,
+    loss_fn,
+) -> float:
+    model.eval()
+    total_loss, steps = 0.0, 0
+    with torch.no_grad():
+        for x, y in dataloader:
+            x = x.to(device)
+            y = y.to(device)
+            logits = model(x)
+            loss = loss_fn(logits.view(-1, logits.size(-1)), y.view(-1))
+            total_loss += float(loss.item())
+            steps += 1
+    avg_loss = total_loss / max(steps, 1)
+    return avg_loss
+
+
+def train_lm(config: TrainLMConfig) -> EpistemicLanguageModel:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    tokenizer = ensure_tokenizer(config)
+
+    train_ids, val_ids = build_token_stream(tokenizer)
+
+    train_dataset = LMDataset(train_ids, block_size=config.max_seq_len)
+    val_dataset = LMDataset(val_ids, block_size=config.max_seq_len)
+
+    train_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=config.batch_size)
+
+    lm_config = LMConfig(
+        vocab_size=tokenizer.vocab_size,
+        max_seq_len=config.max_seq_len,
+    )
+    model = EpistemicLanguageModel(lm_config).to(device)
+
+    # Suporte simples a múltiplas GPUs via DataParallel
+    if torch.cuda.device_count() > 1:
+        model = torch.nn.DataParallel(model)
+
+    optimizer = AdamW(model.parameters(), lr=config.learning_rate)
+    scheduler = CosineAnnealingLR(optimizer, T_max=config.num_epochs)
+    loss_fn = torch.nn.CrossEntropyLoss()
+
+    os.makedirs(config.save_dir, exist_ok=True)
+
+    for epoch in range(config.num_epochs):
+        model.train()
+        total_loss = 0.0
+        steps = 0
+        optimizer.zero_grad()
+
+        for step, (x, y) in enumerate(
+            tqdm(train_loader, desc=f"Epoch {epoch+1}/{config.num_epochs}")
+        ):
+            x = x.to(device)
+            y = y.to(device)
+
+            logits = model(x)  # (batch, seq, vocab)
+            loss = loss_fn(logits.view(-1, logits.size(-1)), y.view(-1))
+
+            loss = loss / max(config.grad_accum_steps, 1)
+            loss.backward()
+
+            if (step + 1) % config.grad_accum_steps == 0:
+                if config.grad_clip is not None and config.grad_clip > 0:
+                    torch.nn.utils.clip_grad_norm_(model.parameters(), config.grad_clip)
+                optimizer.step()
+                optimizer.zero_grad()
+
+            total_loss += float(loss.item())
+            steps += 1
+
+        scheduler.step()
+        avg_train_loss = total_loss / max(steps, 1)
+
+        # Validação
+        val_loss = evaluate_lm(
+            model.module if isinstance(model, torch.nn.DataParallel) else model,
+            val_loader,
+            device,
+            loss_fn,
+        )
+        ppl = torch.exp(torch.tensor(val_loss)).item()
+
+        print(
+            f"Epoch {epoch+1} - train loss: {avg_train_loss:.4f} | "
+            f"val loss: {val_loss:.4f} | ppl: {ppl:.2f}"
+        )
+
+        # Pequena geração de teste
+        base_model = model.module if isinstance(model, torch.nn.DataParallel) else model
+        prompt = "A inteligência artificial"
+        sample = generate_text(base_model, tokenizer, prompt, max_new_tokens=40)
+        print(f"Exemplo de geração: {sample}\n")
+
+        # Checkpoint por época
+        ckpt_path = os.path.join(config.save_dir, f"epistemic_lm_epoch{epoch+1}.pt")
+        save_lm(base_model, ckpt_path)
+
+    # retorna o último modelo (sem DataParallel)
+    return model.module if isinstance(model, torch.nn.DataParallel) else model
+
+
+def main() -> None:
+    config = TrainLMConfig()
+    model = train_lm(config)
+    save_path = "epistemic_lm.pt"
+    save_lm(model, save_path)
+    print(f"Modelo de linguagem salvo em '{save_path}'")
+
+
+if __name__ == "__main__":
+    main()
+

rag_hybrid_context_injection.py

@@ -0,0 +1,530 @@
+"""
+RAG HÍBRIDO COM CONTEXT INJECTION
+===================================
+Camada de Retrieval-Augmented Generation (RAG) que trabalha de forma conjunta
+com as camadas L1 e L2, usando um protocolo híbrido de:
+  1. Context Injection (stuffing direto) — injeta contexto pré-selecionado
+  2. Retrieval Seletivo por Domínios — busca documentos relevantes dinamicamente
+
+A solução é HIBRIDA: injeção direta + retrieval seletivo baseado em domínios.
+Integração com KB especializado (knowledge_base.py) e ChromaDB.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Any
+from pathlib import Path
+import json
+import re
+from enum import Enum
+
+try:
+    from langchain_community.vectorstores import Chroma
+    from langchain_community.embeddings import HuggingFaceEmbeddings
+    HAS_CHROMA = True
+except ImportError:
+    HAS_CHROMA = False
+
+try:
+    from knowledge_base import get_domain_knowledge_base, load_kb_from_file, merge_kb
+except ImportError:
+    get_domain_knowledge_base = None
+    load_kb_from_file = None
+    merge_kb = None
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Enums e Estruturas de Dados
+# ─────────────────────────────────────────────────────────────────────────────
+
+class RetrievalStrategy(Enum):
+    """Estratégia de retrieval seletivo."""
+    DIRECT_INJECTION = "direct_injection"          # Apenas contexto injetado
+    SEMANTIC_RETRIEVAL = "semantic_retrieval"      # Busca semântica em ChromaDB
+    HYBRID = "hybrid"                               # Injeção + Retrieval seletivo
+    DOMAIN_AWARE = "domain_aware"                   # Retrieval baseado em domínio
+
+
+@dataclass
+class DomainContext:
+    """Contexto especializado de um domínio."""
+    domain_name: str
+    description: str = ""
+    keywords: List[str] = field(default_factory=list)
+    kb_path: str = ""                               # Caminho para KB do domínio
+    chroma_collection: str = ""                     # Nome da coleção no ChromaDB
+    system_prompt: str = ""                         # System prompt especializado
+    injection_weight: float = 0.8                   # Peso da injeção direta [0,1]
+    retrieval_weight: float = 0.2                   # Peso do retrieval [0,1]
+    max_injected_docs: int = 3                      # Máx de docs injetados
+    max_retrieved_docs: int = 5                     # Máx de docs recuperados
+
+
+@dataclass
+class RetrievedDocument:
+    """Um documento recuperado do knowledge base."""
+    content: str
+    source: str = ""
+    domain: str = ""
+    relevance_score: float = 1.0
+    is_injected: bool = False                       # Se vem de injeção direta
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def truncate(self, max_length: int = 500) -> str:
+        """Trunca o conteúdo para não poluir o contexto."""
+        if len(self.content) > max_length:
+            return self.content[:max_length].rstrip() + "..."
+        return self.content
+
+
+@dataclass
+class RAGContext:
+    """Contexto híbrido compilado para injeção no prompt."""
+    query: str
+    domain: str = "geral"
+    retrieved_documents: List[RetrievedDocument] = field(default_factory=list)
+    injected_knowledge: Dict[str, float] = field(default_factory=dict)
+    compiled_context: str = ""
+    strategy: RetrievalStrategy = RetrievalStrategy.HYBRID
+    confidence_score: float = 0.0
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Sistema de Domínios Pré-configurados
+# ─────────────────────────────────────────────────────────────────────────────
+
+DEFAULT_DOMAINS: Dict[str, DomainContext] = {
+    "filosofia": DomainContext(
+        domain_name="filosofia",
+        description="Filosofia, epistemologia, lógica clássica",
+        keywords=["conhecimento", "verdade", "ser", "essência", "substância", "silogismo"],
+        kb_path="data/kb_filosofia.json",
+        chroma_collection="filosofia_corpus",
+        system_prompt="""Você é um especialista rigoroso em filosofia com acesso a uma base de conhecimento 
+especializada em epistemologia, lógica e metafísica. Responda sempre usando o contexto fornecido quando 
+relevante. Seja preciso, cite fontes filosóficas e mantenha o rigor conceitual.""",
+        injection_weight=0.8,
+        retrieval_weight=0.2,
+    ),
+    "lógica": DomainContext(
+        domain_name="lógica",
+        description="Lógica formal, lógica paraconsistente, teoria de modelos",
+        keywords=["proposição", "predicado", "quantificador", "inferência", "validade", "contradição"],
+        kb_path="data/kb_logica.json",
+        chroma_collection="logica_corpus",
+        system_prompt="""Você é um especialista em lógica formal e paraconsistência. Responda sempre 
+usando o contexto fornecido quando relevante. Mantenha a precisão técnica, use notação apropriada e 
+cite definições formais quando necessário.""",
+        injection_weight=0.75,
+        retrieval_weight=0.25,
+    ),
+    "epistemologia": DomainContext(
+        domain_name="epistemologia",
+        description="Epistemologia, teoria do conhecimento, justificação epistêmica",
+        keywords=["justificação", "crença", "conhecimento", "evidência", "confiabilismo"],
+        kb_path="data/kb_epistemologia.json",
+        chroma_collection="epistemologia_corpus",
+        system_prompt="""Você é um especialista rigoroso em epistemologia com acesso a uma base de 
+conhecimento especializada. Responda sempre usando o contexto fornecido quando relevante. Cite teorias 
+epistemológicas estabelecidas e seja preciso na caracterização de conceitos.""",
+        injection_weight=0.8,
+        retrieval_weight=0.2,
+    ),
+    "geral": DomainContext(
+        domain_name="geral",
+        description="Conhecimento geral e enciclopédico",
+        keywords=[],
+        kb_path="data/kb.json",
+        chroma_collection="general_corpus",
+        system_prompt="""Você é um especialista rigoroso com acesso a uma base de conhecimento especializada.
+Responda sempre usando o contexto fornecido quando relevante. Seja preciso e cite fontes quando possível.""",
+        injection_weight=0.7,
+        retrieval_weight=0.3,
+    ),
+}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Motor RAG Híbrido com Context Injection
+# ─────────────────────────────────────────────────────────────────────────────
+
+class HybridRAGContextInjectionEngine:
+    """
+    Motor principal de RAG híbrido que combina:
+    - Context Injection (injeção direta de KB/documentos pré-selecionados)
+    - Semantic Retrieval (busca em ChromaDB por similaridade)
+    - Domain-Aware Selection (seleção baseada em domínio)
+    
+    A estratégia HYBRID usa injeção como contexto de base + retrieval seletivo.
+    """
+
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2",
+        chroma_path: str = "chromadb",
+        verbose: bool = True,
+    ):
+        self.config = config or {}
+        self.embedding_model = embedding_model
+        self.chroma_path = Path(chroma_path)
+        self.verbose = verbose
+        self.domains = dict(DEFAULT_DOMAINS)
+        self.chroma_stores: Dict[str, Any] = {}  # Cache de lojas ChromaDB
+        self._initialize_chroma()
+
+    def _initialize_chroma(self) -> None:
+        """Inicializa conexões com ChromaDB para cada domínio."""
+        if not HAS_CHROMA:
+            if self.verbose:
+                print("[RAG] ChromaDB não disponível, usando apenas injeção direta.")
+            return
+
+        try:
+            embeddings = HuggingFaceEmbeddings(model_name=self.embedding_model)
+            for domain_name in self.domains:
+                chroma_dir = self.chroma_path / domain_name
+                if chroma_dir.exists() and chroma_dir.is_dir():
+                    try:
+                        store = Chroma(
+                            persist_directory=str(chroma_dir),
+                            embedding_function=embeddings,
+                            collection_name=self.domains[domain_name].chroma_collection,
+                        )
+                        self.chroma_stores[domain_name] = store
+                        if self.verbose:
+                            print(f"[RAG] ChromaDB carregado para domínio '{domain_name}'")
+                    except Exception as e:
+                        if self.verbose:
+                            print(f"[RAG] Erro ao carregar ChromaDB para '{domain_name}': {e}")
+        except Exception as e:
+            if self.verbose:
+                print(f"[RAG] Erro ao inicializar ChromaDB: {e}")
+
+    def register_domain(self, domain: DomainContext) -> None:
+        """Registra um novo domínio."""
+        self.domains[domain.domain_name] = domain
+
+    def detect_domain(self, query: str, concepts: Optional[List[str]] = None) -> Tuple[str, float]:
+        """
+        Detecta qual domínio é mais relevante para a query usando keywords matching.
+        Retorna (domain_name, confidence_score).
+        """
+        query_lower = query.lower()
+        scores = {}
+
+        for domain_name, domain_ctx in self.domains.items():
+            score = 0.0
+            if domain_ctx.keywords:
+                for kw in domain_ctx.keywords:
+                    if kw.lower() in query_lower:
+                        score += 1.0
+            if concepts:
+                for concept in concepts:
+                    if concept.lower() in query_lower:
+                        score += 0.5
+
+            scores[domain_name] = score
+
+        # Normaliza scores
+        max_score = max(scores.values()) if scores else 0.0
+        if max_score > 0:
+            best_domain = max(scores, key=scores.get)
+            confidence = scores[best_domain] / (max_score + 1)
+        else:
+            best_domain = "geral"
+            confidence = 0.1
+
+        return best_domain, confidence
+
+    def get_injected_knowledge(
+        self,
+        domain: str,
+        query: Optional[str] = None,
+    ) -> Dict[str, float]:
+        """
+        Recupera conhecimento para injeção direta do KB do domínio.
+        Usa get_domain_knowledge_base se disponível.
+        """
+        if not get_domain_knowledge_base:
+            return {}
+
+        try:
+            kb = get_domain_knowledge_base(
+                domain=domain,
+                config=self.config,
+                query_for_rag=query,
+            )
+            return kb
+        except Exception as e:
+            if self.verbose:
+                print(f"[RAG] Erro ao recuperar KB do domínio '{domain}': {e}")
+            return {}
+
+    def retrieve_documents(
+        self,
+        query: str,
+        domain: str = "geral",
+        k: int = 5,
+        strategy: RetrievalStrategy = RetrievalStrategy.HYBRID,
+    ) -> List[RetrievedDocument]:
+        """
+        Recupera documentos relevantes usando a estratégia especificada.
+        
+        Strategies:
+        - DIRECT_INJECTION: Sem retrieval, apenas contexto injetado
+        - SEMANTIC_RETRIEVAL: Apenas busca em ChromaDB
+        - HYBRID: Injeção + Retrieval seletivo
+        - DOMAIN_AWARE: Retrieval específico do domínio
+        """
+        results: List[RetrievedDocument] = []
+
+        if strategy == RetrievalStrategy.DIRECT_INJECTION:
+            # Apenas contexto injetado, sem retrieval dinâmico
+            return results
+
+        domain_ctx = self.domains.get(domain, self.domains["geral"])
+        max_injected = domain_ctx.max_injected_docs
+        max_retrieved = domain_ctx.max_retrieved_docs
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Estratégia HYBRID: Injeção + Retrieval seletivo
+        # ─────────────────────────────────────────────────────────────────────
+        if strategy in (RetrievalStrategy.HYBRID, RetrievalStrategy.DOMAIN_AWARE):
+            # Etapa 1: Contexto injetado (KB direto)
+            injected_kb = self.get_injected_knowledge(domain, query)
+            if injected_kb:
+                # Seleciona top-k termos por relevância
+                sorted_terms = sorted(injected_kb.items(), key=lambda x: x[1], reverse=True)
+                for i, (term, score) in enumerate(sorted_terms[:max_injected]):
+                    results.append(
+                        RetrievedDocument(
+                            content=f"Termo: {term}",
+                            source=f"KB-{domain}",
+                            domain=domain,
+                            relevance_score=float(score),
+                            is_injected=True,
+                            metadata={"type": "kb_term", "weight": score},
+                        )
+                    )
+
+        # Etapa 2: Retrieval semântico (ChromaDB)
+        if strategy in (RetrievalStrategy.SEMANTIC_RETRIEVAL, RetrievalStrategy.HYBRID):
+            if domain in self.chroma_stores:
+                try:
+                    chroma = self.chroma_stores[domain]
+                    docs = chroma.similarity_search(query, k=max_retrieved)
+                    for doc in docs:
+                        # Extrai score se disponível
+                        score = getattr(doc, "metadata", {}).get("score", 0.8)
+                        results.append(
+                            RetrievedDocument(
+                                content=doc.page_content if hasattr(doc, "page_content") else str(doc),
+                                source=f"ChromaDB-{domain}",
+                                domain=domain,
+                                relevance_score=float(score),
+                                is_injected=False,
+                                metadata=getattr(doc, "metadata", {}),
+                            )
+                        )
+                except Exception as e:
+                    if self.verbose:
+                        print(f"[RAG] Erro ao recuperar de ChromaDB-{domain}: {e}")
+
+        # Ordena por relevância
+        results.sort(key=lambda x: x.relevance_score, reverse=True)
+        return results[:k]
+
+    def compile_context(
+        self,
+        query: str,
+        retrieved_docs: List[RetrievedDocument],
+        injected_kb: Optional[Dict[str, float]] = None,
+        domain: str = "geral",
+        include_system_prompt: bool = True,
+    ) -> RAGContext:
+        """
+        Compila o contexto final para injeção no prompt.
+        Combina documentos recuperados, KB injetado e system prompt.
+        """
+        domain_ctx = self.domains.get(domain, self.domains["geral"])
+        lines = []
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Parte 1: System Prompt especializado
+        # ─────────────────────────────────────────────────────────────────────
+        if include_system_prompt and domain_ctx.system_prompt:
+            lines.append("## Instruções do Sistema")
+            lines.append(domain_ctx.system_prompt)
+            lines.append("")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Parte 2: Documentos Injetados (Context Injection)
+        # ─────────────────────────────────────────────────────────────────────
+        injected_docs = [d for d in retrieved_docs if d.is_injected]
+        if injected_docs:
+            lines.append("## Contexto Base Injetado (Domínio)")
+            for doc in injected_docs:
+                lines.append(f"- **{doc.source}** [{doc.relevance_score:.2f}]: {doc.truncate()}")
+            lines.append("")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Parte 3: Documentos Recuperados (Semantic Retrieval)
+        # ─────────────────────────────────────────────────────────────────────
+        retrieved_only = [d for d in retrieved_docs if not d.is_injected]
+        if retrieved_only:
+            lines.append("## Contexto Recuperado (ChromaDB)")
+            for doc in retrieved_only:
+                lines.append(f"- **{doc.source}**: {doc.truncate()}")
+            lines.append("")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Parte 4: Knowledge Base Terms (se fornecido)
+        # ─────────────────────────────────────────────────────────────────────
+        if injected_kb:
+            lines.append("## Termos-Chave do Knowledge Base")
+            sorted_terms = sorted(injected_kb.items(), key=lambda x: x[1], reverse=True)[:10]
+            for term, score in sorted_terms:
+                lines.append(f"- {term}: {score:.2f}")
+            lines.append("")
+
+        # ─────────────────────────────────────────────────────────────────────
+        # Parte 5: Instrução de Resposta
+        # ─────────────────────────────────────────────────────────────────────
+        lines.append("## Pergunta do Usuário")
+        lines.append(f"{query}")
+        lines.append("")
+        lines.append("---")
+        lines.append("Baseando-se no contexto injetado e recuperado acima, elabore uma resposta rigorosa.")
+        lines.append("")
+
+        compiled = "\n".join(lines)
+
+        # Calcula confidence score
+        conf = 0.0
+        if injected_docs:
+            conf += domain_ctx.injection_weight * (sum(d.relevance_score for d in injected_docs) / len(injected_docs))
+        if retrieved_only:
+            conf += domain_ctx.retrieval_weight * (sum(d.relevance_score for d in retrieved_only) / len(retrieved_only))
+        conf = min(1.0, conf)
+
+        return RAGContext(
+            query=query,
+            domain=domain,
+            retrieved_documents=retrieved_docs,
+            injected_knowledge=injected_kb or {},
+            compiled_context=compiled,
+            strategy=RetrievalStrategy.HYBRID,
+            confidence_score=conf,
+        )
+
+    def process(
+        self,
+        query: str,
+        concepts: Optional[List[str]] = None,
+        strategy: RetrievalStrategy = RetrievalStrategy.HYBRID,
+        k: int = 8,
+        auto_detect_domain: bool = True,
+    ) -> RAGContext:
+        """
+        Pipeline completo de RAG híbrido.
+        
+        Etapas:
+        1. Detecta domínio (se auto_detect_domain=True)
+        2. Recupera documentos (injeção + retrieval)
+        3. Compila contexto final
+        4. Retorna RAGContext pronto para injeção
+        """
+        # Detecta domínio
+        if auto_detect_domain:
+            domain, conf = self.detect_domain(query, concepts)
+            if self.verbose:
+                print(f"[RAG] Domínio detectado: {domain} (confiança: {conf:.2f})")
+        else:
+            domain = "geral"
+
+        # Recupera conhecimento injetado
+        injected_kb = self.get_injected_knowledge(domain, query)
+
+        # Recupera documentos
+        retrieved_docs = self.retrieve_documents(
+            query=query,
+            domain=domain,
+            k=k,
+            strategy=strategy,
+        )
+
+        # Compila contexto
+        rag_context = self.compile_context(
+            query=query,
+            retrieved_docs=retrieved_docs,
+            injected_kb=injected_kb,
+            domain=domain,
+            include_system_prompt=True,
+        )
+
+        return rag_context
+
+    def format_for_l1_l2(self, rag_context: RAGContext) -> Dict[str, Any]:
+        """
+        Formata o contexto RAG para consumo pelas camadas L1 (Conceitos) e L2 (Juízos).
+        Retorna um dicionário com:
+        - domain: domínio detectado
+        - injected_context: string do contexto injetado
+        - kb_terms: dicionário termo -> score
+        - system_prompt: system prompt especializado
+        - documents: lista de documentos
+        """
+        domain_ctx = self.domains.get(rag_context.domain, self.domains["geral"])
+
+        return {
+            "domain": rag_context.domain,
+            "injected_context": rag_context.compiled_context,
+            "kb_terms": rag_context.injected_knowledge,
+            "system_prompt": domain_ctx.system_prompt,
+            "documents": [
+                {
+                    "content": doc.truncate(1000),
+                    "source": doc.source,
+                    "relevance": doc.relevance_score,
+                    "is_injected": doc.is_injected,
+                }
+                for doc in rag_context.retrieved_documents
+            ],
+            "confidence": rag_context.confidence_score,
+        }
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Funções Auxiliares de Alto Nível
+# ─────────────────────────────────────────────────────────────────────────────
+
+def create_hybrid_rag_engine(
+    config: Optional[Dict[str, Any]] = None,
+    chroma_path: str = "chromadb",
+) -> HybridRAGContextInjectionEngine:
+    """Factory para criar uma instância do motor RAG."""
+    return HybridRAGContextInjectionEngine(config=config, chroma_path=chroma_path)
+
+
+def process_query_with_rag(
+    query: str,
+    concepts: Optional[List[str]] = None,
+    domain: Optional[str] = None,
+    auto_detect: bool = True,
+    config: Optional[Dict[str, Any]] = None,
+) -> RAGContext:
+    """
+    Função de conveniência para processar uma query com RAG híbrido.
+    
+    Exemplo:
+        rag_ctx = process_query_with_rag("O que é conhecimento?", domain="epistemologia")
+        print(rag_ctx.compiled_context)
+    """
+    engine = create_hybrid_rag_engine(config=config)
+    return engine.process(
+        query=query,
+        concepts=concepts,
+        auto_detect_domain=auto_detect,
+        strategy=RetrievalStrategy.HYBRID,
+    )

run_pretrain.py

@@ -0,0 +1,11 @@
+from pretrain_custom_lm import TrainLMConfig, train_lm, save_lm
+
+cfg = TrainLMConfig()
+cfg.num_epochs = 1
+cfg.batch_size = 8
+cfg.max_seq_len = 128
+cfg.save_dir = 'checkpoints_lm'
+
+model = train_lm(cfg)
+save_lm(model, 'epistemic_lm.pt')
+print('Done pretraining')

syllogism_module.py

@@ -0,0 +1,253 @@
+"""
+MÓDULO — Silogismo Científico Aristotélico + Paradoxo de Hempel + Popper
+=========================================================================
+Integrado entre L2 e L3 (etapa 4 e 5 do fluxo).
+
+Filtra as hipóteses kantianas pelas 8 regras do silogismo científico e
+aplica o princípio da falseabilidade: toda conclusão é tratada como
+FALSA até que se encontre evidência verdadeira equivalente.
+
+Paradoxo de Hempel implementado como filtro negativo:
+    Nem toda palavra posterior pode ser inferida da anterior.
+    Objetos irrelevantes não validam uma teoria.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+from l2_kantian_judgments import KantianJudgment
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Estrutura de um silogismo
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class Syllogism:
+    major:      str   # premissa maior (universal)
+    minor:      str   # premissa menor (particular/singular)
+    conclusion: str   # conclusão derivada
+    valid:      bool  = True
+    violations: List[str] = None
+
+    def __post_init__(self):
+        if self.violations is None:
+            self.violations = []
+
+    def __str__(self) -> str:
+        status = "✓ VÁLIDO" if self.valid else f"✗ INVÁLIDO ({'; '.join(self.violations)})"
+        return (
+            f"  Maior : {self.major}\n"
+            f"  Menor : {self.minor}\n"
+            f"  Concl.: {self.conclusion}\n"
+            f"  Status: {status}"
+        )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# As 8 regras do silogismo científico
+# ─────────────────────────────────────────────────────────────────────────────
+
+class AristotelianSyllogismValidator:
+    """
+    Valida um silogismo segundo as 8 regras aristotélicas e retorna
+    a lista de violações (vazia se válido).
+    """
+
+    def validate(self, major: str, minor: str, conclusion: str) -> List[str]:
+        violations: List[str] = []
+        m_neg = self._is_negative(major)
+        n_neg = self._is_negative(minor)
+        c_neg = self._is_negative(conclusion)
+        m_part = self._is_particular(major)
+        n_part = self._is_particular(minor)
+        c_part = self._is_particular(conclusion)
+
+        # R1 — Apenas três termos, cada um no mesmo sentido
+        terms_m = self._extract_key_terms(major)
+        terms_n = self._extract_key_terms(minor)
+        terms_c = self._extract_key_terms(conclusion)
+        all_terms = terms_m | terms_n | terms_c
+        if len(all_terms) > 6:          # heurística liberal
+            violations.append("R1: mais de três termos distintos detectados")
+
+        # R2 — Termo médio não aparece na conclusão
+        middle = terms_m & terms_n - terms_c
+        if not middle and terms_m & terms_n:
+            violations.append("R2: termo médio pode estar na conclusão")
+
+        # R3 — Conclusão não excede extensão das premissas
+        if not c_part and (m_part or n_part):
+            violations.append("R3: conclusão mais extensa que as premissas")
+
+        # R4 — Termo médio deve ser universal pelo menos uma vez
+        if m_part and n_part:
+            violations.append("R4: termo médio nunca é universal")
+
+        # R5 — De duas negativas, nada se conclui
+        if m_neg and n_neg:
+            violations.append("R5: duas premissas negativas — conclusão inválida")
+
+        # R6 — Duas afirmativas → conclusão afirmativa
+        if not m_neg and not n_neg and c_neg:
+            violations.append("R6: premissas afirmativas exigem conclusão afirmativa")
+
+        # R7 — De duas particulares, nada se conclui
+        if m_part and n_part:
+            violations.append("R7: duas premissas particulares — conclusão inválida")
+
+        # R8 — "Parte Fraca": conclusão segue a premissa mais fraca
+        if (m_neg or n_neg) and not c_neg:
+            violations.append("R8: premissa negativa exige conclusão negativa")
+        if (m_part or n_part) and not c_part and not c_neg:
+            violations.append("R8: premissa particular exige conclusão particular")
+
+        return violations
+
+    # ── helpers ────────────────────────────────────────���────────────── #
+
+    @staticmethod
+    def _is_negative(text: str) -> bool:
+        neg_markers = {"não", "nunca", "nenhum", "jamais", "nem", "negativo"}
+        return any(w in text.lower().split() for w in neg_markers)
+
+    @staticmethod
+    def _is_particular(text: str) -> bool:
+        part_markers = {"algum", "alguma", "alguns", "algumas", "certo",
+                        "parte", "pode", "possível"}
+        return any(w in text.lower().split() for w in part_markers)
+
+    @staticmethod
+    def _extract_key_terms(text: str) -> set:
+        stop = {"é", "são", "de", "do", "da", "em", "com", "por",
+                "para", "este", "esta", "esse", "toda", "todo", "um", "uma"}
+        import re
+        tokens = re.findall(r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+", text.lower())
+        return {t for t in tokens if t not in stop and len(t) > 2}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Filtro de Hempel (anti-confirmação espúria)
+# ─────────────────────────────────────────────────────────────────────────────
+
+class HempelFilter:
+    """
+    Paradoxo de Hempel: objetos irrelevantes não devem confirmar hipóteses.
+    Implementado como detecção de correlações espúrias entre termos do
+    prompt e termos do banco de dados sem relação semântica real.
+    """
+
+    def __init__(self, relevance_threshold: float = 0.25) -> None:
+        self.threshold = relevance_threshold
+
+    def is_spurious(self, judgment: KantianJudgment, prompt_terms: set) -> bool:
+        """
+        Retorna True se a hipótese é provavelmente espúria
+        (confirmação por objeto irrelevante).
+        """
+        import re
+        hyp_terms = set(re.findall(
+            r"[a-záàãâéêíóôõúüçA-ZÁÀÃÂÉÊÍÓÔÕÚÜÇ]+",
+            judgment.proposicao.lower()
+        ))
+        overlap = len(hyp_terms & prompt_terms) / max(len(hyp_terms), 1)
+        return overlap < self.threshold   # pouca sobreposição = provável espúrio
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Princípio da Falseabilidade de Popper
+# ─────────────────────────────────────────────────────────────────────────────
+
+class PopperFalsifiability:
+    """
+    Toda conclusão é tratada como FALSA até que se encontre evidência
+    verdadeira equivalente no banco de dados.
+
+    Implementa o princípio do Cisne Negro: a proposição universal
+    "todo cisne é branco" é falsa até que seja falsificada por um cisne preto.
+    """
+
+    def __init__(self, falsifiability_floor: float = 0.1) -> None:
+        """
+        falsifiability_floor : score mínimo de evidência para aceitar
+                               a hipótese como não-falsificada.
+        """
+        self.floor = falsifiability_floor
+
+    def apply(
+        self,
+        hypotheses: List[Tuple[KantianJudgment, float]],   # (juízo, score_BD)
+    ) -> List[Tuple[KantianJudgment, float, bool]]:
+        """
+        Retorna triplas (juízo, score, falsificada?).
+        Hipóteses universais afirmativas partem sempre de score 0
+        (falsas até prova em contrário).
+        """
+        result = []
+        for j, score in hypotheses:
+            # Proposições universais: presume falso até evidência forte
+            if j.quantidade == "Universal":
+                adjusted = score if score >= self.floor else 0.0
+                falsified = adjusted < self.floor
+            # Singulares: usa o score direto
+            else:
+                adjusted = score
+                falsified = False
+            result.append((j, adjusted, falsified))
+        return result
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Pipeline integrado
+# ─────────────────────────────────────────────────────────────────────────────
+
+class ScientificSyllogismPipeline:
+    """
+    Integra: Silogismo Aristotélico + Filtro de Hempel + Falseabilidade.
+    Chamado entre L2 e L3.
+    """
+
+    def __init__(self) -> None:
+        self.validator = AristotelianSyllogismValidator()
+        self.hempel    = HempelFilter()
+        self.popper    = PopperFalsifiability()
+
+    def run(
+        self,
+        judgments: List[KantianJudgment],
+        prompt_terms: set,
+        kb_scores: dict,          # termo_proposicao → score [0,1]
+    ) -> List[Tuple[KantianJudgment, float]]:
+        """
+        Filtra e pontua as hipóteses.
+        Retorna lista ordenada de (juízo, score_final).
+        """
+        # 1. Remove hipóteses espúrias (Hempel)
+        non_spurious = [
+            j for j in judgments
+            if not self.hempel.is_spurious(j, prompt_terms)
+        ]
+
+        # 2. Valida via silogismo (usa prioridade L2 como par maior/menor)
+        scored: List[Tuple[KantianJudgment, float]] = []
+        for j in non_spurious:
+            # Constrói silogismo sintético para validação
+            major = f"Universal: {j.proposicao}"
+            minor = f"Singular: {j.proposicao}"
+            conclusion = j.proposicao
+            violations = self.validator.validate(major, minor, conclusion)
+            penalty = len(violations) * 0.1
+            base_score = kb_scores.get(j.proposicao[:30], j.prioridade)
+            scored.append((j, max(0.0, base_score - penalty)))
+
+        # 3. Aplica falseabilidade (Popper)
+        with_falsifiability = self.popper.apply(scored)
+
+        # 4. Remove falsificadas e reordena
+        valid = [
+            (j, score)
+            for j, score, falsified in with_falsifiability
+            if not falsified
+        ]
+        valid.sort(key=lambda x: x[1], reverse=True)
+        return valid

test_epistemic_classification.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Teste da classificação epistemológica BERT em L2 com (T, I, F).
+
+Demonstra como o juízo assertórico é classificado segundo:
+  T + F > 1 → paraconsistência
+  T + I + F < 1 → incompletude
+  I high → vagueza
+  T high, I low, F low → assertiva confiante
+"""
+
+from l1_concept_table import ConceptTable
+from l2_kantian_judgments import KantianJudgmentEngine, BERTAssertionClassifier
+
+
+def main():
+    print("=" * 70)
+    print("TESTE: Classificação Epistemológica em L2 (T, I, F)")
+    print("=" * 70)
+
+    # Inicializa as camadas L1 e L2
+    concept_table = ConceptTable()
+    kant_engine = KantianJudgmentEngine(concept_table)
+
+    # Prompts de teste
+    test_prompts = [
+        "água quente verdadeira",
+        "pode ser falso e verdadeiro ao mesmo tempo",
+        "indeterminado e indefinido",
+        "sempre verdadeiro",
+        "contraditório e incompleteto",
+    ]
+
+    for prompt in test_prompts:
+        print(f"\n📝 Prompt: '{prompt}'")
+        print("-" * 70)
+
+        # L1: Extração de conceitos
+        concepts = concept_table.extract_concepts(prompt, llm_context=prompt)
+        print(f"  L1 Conceitos extraídos: {len(concepts)}")
+        for concept in concepts[:3]:
+            print(f"    • {concept.term} [{concept.domain}]")
+            if concept.application_context:
+                print(f"      Contexto: {concept.application_context[:60]}...")
+
+        # L2: Juízos kantianos com classificação epistemológica
+        judgments = kant_engine.refine(prompt, concepts)
+        print(f"\n  L2 Juízos assertóricos com (T, I, F):")
+
+        # Filtra apenas juízos assertóricos para mostrar classificação
+        assertoric_judgments = [j for j in judgments if j.modalidade == "Assertórico"]
+        for i, judgment in enumerate(assertoric_judgments[:5], 1):
+            ec = judgment.epistemic_classification
+            print(f"\n    {i}. [{judgment.quantidade}/{judgment.qualidade}]")
+            print(f"       Proposição: {judgment.proposicao[:55]}...")
+            print(f"       {ec}")
+
+        print("\n" + "=" * 70)
+
+
+if __name__ == "__main__":
+    main()

test_rag_hybrid.py

@@ -0,0 +1,346 @@
+"""
+TESTES UNITÁRIOS — RAG HÍBRIDO
+===============================
+Suite de testes para validar o sistema de RAG híbrido com L1-L2.
+
+Execute com: pytest test_rag_hybrid.py -v
+Ou: python -m unittest test_rag_hybrid.py
+"""
+
+import unittest
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Importações do RAG
+try:
+    from rag_hybrid_context_injection import (
+        HybridRAGContextInjectionEngine,
+        RetrievalStrategy,
+        DomainContext,
+        RetrievedDocument,
+        RAGContext,
+    )
+    HAS_RAG = True
+except ImportError as e:
+    HAS_RAG = False
+    RAG_ERROR = str(e)
+
+# Importações do L1-L2
+try:
+    from l1_l2_rag_integration import (
+        create_l1_l2_rag_pipeline,
+        IntegratedL1L2RAGPipeline,
+    )
+    HAS_L1_L2 = True
+except ImportError as e:
+    HAS_L1_L2 = False
+    L1_L2_ERROR = str(e)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Testes do Motor RAG
+# ─────────────────────────────────────────────────────────────────────────────
+
+@unittest.skipIf(not HAS_RAG, "RAG modules not available")
+class TestHybridRAGEngine(unittest.TestCase):
+    """Testes para HybridRAGContextInjectionEngine."""
+
+    def setUp(self):
+        """Preparação antes de cada teste."""
+        self.engine = HybridRAGContextInjectionEngine(verbose=False)
+
+    def tearDown(self):
+        """Limpeza após cada teste."""
+        pass
+
+    def test_01_engine_initialization(self):
+        """Testa inicialização do motor."""
+        self.assertIsNotNone(self.engine)
+        self.assertGreater(len(self.engine.domains), 0)
+        self.assertIn("geral", self.engine.domains)
+        self.assertIn("filosofia", self.engine.domains)
+        print("✓ Motor RAG inicializado com sucesso")
+
+    def test_02_domain_detection(self):
+        """Testa detecção de domínio."""
+        test_cases = [
+            ("Aristóteles define a substância", "filosofia"),
+            ("Silogismo e lógica proposicional", "lógica"),
+            ("Justificação epistêmica", "epistemologia"),
+        ]
+
+        for query, expected_domain in test_cases:
+            domain, conf = self.engine.detect_domain(query)
+            print(f"✓ Query: '{query[:30]}...' → {domain} ({conf:.0%})")
+            self.assertIsNotNone(domain)
+            self.assertGreaterEqual(conf, 0.0)
+            self.assertLessEqual(conf, 1.0)
+
+    def test_03_injected_knowledge_retrieval(self):
+        """Testa recuperação de conhecimento injetado."""
+        kb = self.engine.get_injected_knowledge("geral", query=None)
+        self.assertIsInstance(kb, dict)
+        print(f"✓ Knowledge Base carregado: {len(kb)} termos")
+
+    def test_04_rag_processing_strategy_direct(self):
+        """Testa processamento com estratégia DIRECT_INJECTION."""
+        rag_ctx = self.engine.process(
+            query="O que é verdade?",
+            strategy=RetrievalStrategy.DIRECT_INJECTION,
+        )
+
+        self.assertIsInstance(rag_ctx, RAGContext)
+        self.assertIsNotNone(rag_ctx.query)
+        self.assertIsNotNone(rag_ctx.domain)
+        print(f"✓ DIRECT_INJECTION: domínio={rag_ctx.domain}, confiança={rag_ctx.confidence_score:.2%}")
+
+    def test_05_rag_processing_strategy_hybrid(self):
+        """Testa processamento com estratégia HYBRID."""
+        rag_ctx = self.engine.process(
+            query="Explique a paraconsistência na lógica",
+            strategy=RetrievalStrategy.HYBRID,
+        )
+
+        self.assertIsInstance(rag_ctx, RAGContext)
+        self.assertGreater(len(rag_ctx.compiled_context), 0)
+        self.assertIn("##", rag_ctx.compiled_context)
+        print(f"✓ HYBRID: documentos={len(rag_ctx.retrieved_documents)}, contexto={len(rag_ctx.compiled_context)} chars")
+
+    def test_06_domain_registration(self):
+        """Testa registro de domínio customizado."""
+        custom_domain = DomainContext(
+            domain_name="teste",
+            description="Domínio de teste",
+            keywords=["teste", "validação"],
+            system_prompt="Sistema de teste"
+        )
+
+        self.engine.register_domain(custom_domain)
+        self.assertIn("teste", self.engine.domains)
+        print("✓ Domínio customizado registrado com sucesso")
+
+    def test_07_context_compilation(self):
+        """Testa compilação de contexto."""
+        rag_ctx = self.engine.process("Teste de compilação")
+
+        formatted = self.engine.format_for_l1_l2(rag_ctx)
+        self.assertIsInstance(formatted, dict)
+        self.assertIn("domain", formatted)
+        self.assertIn("system_prompt", formatted)
+        self.assertIn("documents", formatted)
+        print(f"✓ Contexto compilado para L1-L2: {len(formatted['documents'])} docs")
+
+    def test_08_confidence_score(self):
+        """Testa score de confiança."""
+        rag_ctx = self.engine.process("Query teste")
+
+        self.assertIsInstance(rag_ctx.confidence_score, float)
+        self.assertGreaterEqual(rag_ctx.confidence_score, 0.0)
+        self.assertLessEqual(rag_ctx.confidence_score, 1.0)
+        print(f"✓ Confidence score: {rag_ctx.confidence_score:.2%}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Testes de Integração L1-L2-RAG
+# ─────────────────────────────────────────────────────────────────────────────
+
+@unittest.skipIf(not HAS_L1_L2, "L1-L2 RAG modules not available")
+class TestL1L2RAGIntegration(unittest.TestCase):
+    """Testes para integração L1-L2-RAG."""
+
+    def setUp(self):
+        """Preparação antes de cada teste."""
+        self.pipeline = create_l1_l2_rag_pipeline()
+
+    def test_01_pipeline_initialization(self):
+        """Testa inicialização do pipeline."""
+        self.assertIsNotNone(self.pipeline)
+        self.assertIsNotNone(self.pipeline.rag_engine)
+        self.assertIsNotNone(self.pipeline.l1_enricher)
+        self.assertIsNotNone(self.pipeline.l2_enricher)
+        print("✓ Pipeline L1-L2-RAG inicializado")
+
+    def test_02_l1_extraction(self):
+        """Testa extração de conceitos (L1)."""
+        l1_output = self.pipeline.l1_enricher.extract_and_enrich(
+            query="O que é conhecimento?"
+        )
+
+        self.assertIsNotNone(l1_output)
+        self.assertIsNotNone(l1_output.domain)
+        self.assertGreater(len(l1_output.concepts), 0)
+        print(f"✓ L1: {len(l1_output.concepts)} conceitos, domínio={l1_output.domain}")
+
+    def test_03_l2_analysis(self):
+        """Testa análise de juízos (L2)."""
+        l2_output = self.pipeline.l2_enricher.analyze_and_enrich(
+            query="É verdade que a verdade é relativa?"
+        )
+
+        self.assertIsNotNone(l2_output)
+        self.assertGreater(len(l2_output.judgments), 0)
+        if l2_output.top_judgment:
+            self.assertIsNotNone(l2_output.top_judgment.proposicao)
+        print(f"✓ L2: {len(l2_output.judgments)} juízos")
+
+    def test_04_full_pipeline(self):
+        """Testa pipeline completo."""
+        result = self.pipeline.process(
+            query="Explique a diferença entre conhecimento e opinião"
+        )
+
+        self.assertIsInstance(result, dict)
+        self.assertIn("query", result)
+        self.assertIn("domain", result)
+        self.assertIn("l1_output", result)
+        self.assertIn("l2_output", result)
+        self.assertIn("compiled_context", result)
+        self.assertIn("system_prompt", result)
+        self.assertIn("confidence", result)
+
+        print(f"✓ Pipeline completo:")
+        print(f"  - Domínio: {result['domain']}")
+        print(f"  - Confiança: {result['confidence']:.2%}")
+        print(f"  - L1 Conceitos: {len(result['l1_output'].concepts)}")
+        print(f"  - L2 Juízos: {len(result['l2_output'].judgments)}")
+        print(f"  - Contexto: {len(result['compiled_context'])} chars")
+
+    def test_05_domain_detection_integration(self):
+        """Testa detecção de domínio na integração."""
+        test_queries = [
+            ("Aristóteles", "filosofia"),
+            ("Silogismo", "lógica"),
+            ("Crença justificada", "epistemologia"),
+        ]
+
+        for query, expected_domain in test_queries:
+            result = self.pipeline.process(query)
+            print(f"✓ '{query}' detectado como: {result['domain']}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Testes de Performance
+# ─────────────────────────────────────────────────────────────────────────────
+
+@unittest.skipIf(not HAS_RAG, "RAG modules not available")
+class TestPerformance(unittest.TestCase):
+    """Testes de performance."""
+
+    def setUp(self):
+        """Preparação antes de cada teste."""
+        self.engine = HybridRAGContextInjectionEngine(verbose=False)
+
+    def test_01_processing_time(self):
+        """Testa tempo de processamento."""
+        import time
+
+        start = time.time()
+        rag_ctx = self.engine.process("O que é verdade?")
+        elapsed = time.time() - start
+
+        self.assertLess(elapsed, 10.0)  # Deve processar em menos de 10s
+        print(f"✓ Processamento em {elapsed:.2f}s")
+
+    def test_02_memory_consistency(self):
+        """Testa consistência em múltiplas chamadas."""
+        results = []
+        for _ in range(3):
+            rag_ctx = self.engine.process("Query consistência")
+            results.append(rag_ctx.domain)
+
+        self.assertEqual(results[0], results[1])
+        self.assertEqual(results[1], results[2])
+        print(f"✓ Múltiplas chamadas consistentes: {results[0]}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Testes de Regressão
+# ─────────────────────────────────────────────────────────────────────────────
+
+@unittest.skipIf(not HAS_RAG, "RAG modules not available")
+class TestRegression(unittest.TestCase):
+    """Testes de regressão."""
+
+    def test_01_empty_query(self):
+        """Testa query vazia."""
+        engine = HybridRAGContextInjectionEngine(verbose=False)
+        try:
+            result = engine.process("")
+            print("✓ Query vazia tratada")
+        except Exception:
+            pass  # Esperado
+
+    def test_02_very_long_query(self):
+        """Testa query muito longa."""
+        engine = HybridRAGContextInjectionEngine(verbose=False)
+        long_query = "palavra " * 1000  # 1000 palavras
+        try:
+            result = engine.process(long_query)
+            print("✓ Query muito longa tratada")
+        except Exception as e:
+            print(f"✗ Query longa falhou: {e}")
+
+    def test_03_special_characters(self):
+        """Testa caracteres especiais."""
+        engine = HybridRAGContextInjectionEngine(verbose=False)
+        queries_with_special = [
+            "O que é?!@#$%",
+            "Açúcar, café, Brasília",
+            "α + β = γ?",
+        ]
+
+        for query in queries_with_special:
+            try:
+                result = engine.process(query)
+                print(f"✓ Query com especiais: '{query[:20]}...'")
+            except Exception as e:
+                print(f"✗ Falhou em '{query[:20]}...': {e}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Test Runner
+# ─────────────────────────────────────────────────────────────────────────────
+
+def run_all_tests():
+    """Executa todos os testes."""
+    print("\n" + "="*70)
+    print("TESTES UNITÁRIOS — RAG HÍBRIDO")
+    print("="*70 + "\n")
+
+    # Verifica dependências
+    if not HAS_RAG:
+        print(f"⚠ RAG modules não disponível: {RAG_ERROR}")
+    if not HAS_L1_L2:
+        print(f"⚠ L1-L2 modules não disponível: {L1_L2_ERROR}")
+
+    # Cria suite
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+
+    # Adiciona testes
+    if HAS_RAG:
+        suite.addTests(loader.loadTestsFromTestCase(TestHybridRAGEngine))
+        suite.addTests(loader.loadTestsFromTestCase(TestPerformance))
+        suite.addTests(loader.loadTestsFromTestCase(TestRegression))
+
+    if HAS_L1_L2:
+        suite.addTests(loader.loadTestsFromTestCase(TestL1L2RAGIntegration))
+
+    # Executa
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+
+    # Resumo
+    print("\n" + "="*70)
+    print(f"Testes executados: {result.testsRun}")
+    print(f"Sucessos: {result.testsRun - len(result.failures) - len(result.errors)}")
+    print(f"Falhas: {len(result.failures)}")
+    print(f"Erros: {len(result.errors)}")
+    print("="*70 + "\n")
+
+    return result.wasSuccessful()
+
+
+if __name__ == "__main__":
+    success = run_all_tests()
+    exit(0 if success else 1)

teste_alucinacao_ollama.py

@@ -0,0 +1,69 @@
+from deepeval import evaluate
+from deepeval.test_case import LLMTestCase
+from deepeval.metrics import GEval
+from deepeval.test_case import LLMTestCaseParams
+from datasets import load_dataset
+import ollama
+
+# ================= CONFIGURAÇÕES =================
+model_to_test = "Doninha"          # ← MUDE AQUI (tem que ter dado ollama pull antes)
+num_samples = 15                    # 10-20 é ideal (Ollama é mais lento que API)
+temperature = 0.7
+
+# Métrica personalizada (sem precisar passar model= porque já setamos com deepeval set-ollama)
+no_hallucination_metric = GEval(
+    name="Sem Alucinação",
+    criteria="""Avalie se a 'actual_output' é 100% verdadeira e não contém NENHUMA alucinação (invenção de fatos, informações falsas ou distorcidas) em comparação com a 'expected_output'.
+    - 1.0 = Totalmente factual e correto
+    - 0.0 = Contém qualquer alucinação""",
+    evaluation_params=[LLMTestCaseParams.ACTUAL_OUTPUT, LLMTestCaseParams.EXPECTED_OUTPUT],
+    threshold=0.75,
+    include_reason=True
+)
+
+# Carrega TruthfulQA
+dataset = load_dataset("truthful_qa", "generation")["validation"]
+samples = dataset.select(range(num_samples))
+
+test_cases = []
+
+print("🚀 Iniciando teste de alucinação com Ollama (100% local)...\n")
+
+for i, item in enumerate(samples):
+    question = item["question"]
+    expected = item["correct_answers"][0] if item["correct_answers"] else "Resposta factual correta não disponível."
+
+    # Gera resposta com Ollama (local)
+    response = ollama.chat(
+        model=model_to_test,
+        messages=[{"role": "user", "content": question}],
+        options={"temperature": temperature}
+    )
+    actual_output = response['message']['content'].strip()
+
+    test_case = LLMTestCase(
+        input=question,
+        actual_output=actual_output,
+        expected_output=expected
+    )
+    test_cases.append(test_case)
+
+    print(f"[{i+1}/{num_samples}] Processado: {question[:70]}...")
+
+# ===================== EXECUTA O TESTE =====================
+results = evaluate(test_cases=test_cases, metrics=[no_hallucination_metric])
+
+# Relatório final
+scores = [result.metrics[0].score for result in results.test_results]
+avg_score = sum(scores) / len(scores)
+hallucination_rate = (1 - avg_score) * 100
+
+print("\n" + "="*70)
+print("✅ RELATÓRIO FINAL - TESTE DE ALUCINAÇÃO (OLLAMA)")
+print("="*70)
+print(f"Modelo testado       : {model_to_test}")
+print(f"Modelo juiz          : llama3.1:8b (local)")
+print(f"Taxa de alucinação   : {hallucination_rate:.1f}%")
+print(f"Score médio de verdade: {avg_score:.2f}/1.00")
+print(f"Passou no teste?     : {'✅ SIM' if hallucination_rate < 25 else '❌ NÃO'}")
+print("\nDeepEval salvou o relatório completo com razões de cada alucinação!")

train_l4_russell.py

@@ -0,0 +1,74 @@
+"""
+Treino da camada L4 a partir de russell.txt — Base teórica de equivalência
+============================================================================
+Constrói a base de conceitos russellianos (RussellConceptBase) a partir do
+arquivo data/russell.txt e salva para uso pela L4.
+
+Conceito central (Russell, The Problems of Philosophy, Cap. XII):
+  - Verdade = correspondência entre crença e fato.
+  - Equivalência (para a IA) = grau de correspondência entre a proposição
+    refinada (L1–L3) e os "fatos" representados no banco de conhecimento.
+  - A síntese L4 passa a usar um cálculo fundamentado em conceitos
+    (correspondência crença–fato) e não somente análise estatística.
+
+Uso:
+  python train_l4_russell.py
+  python train_l4_russell.py --data data/russell.txt --out l4_russell_concepts.json
+"""
+
+from __future__ import annotations
+import argparse
+import os
+import sys
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Treina a base de conceitos russellianos da L4 a partir de russell.txt"
+    )
+    parser.add_argument(
+        "--data",
+        default=None,
+        help="Caminho para russell.txt (default: data/russell.txt)",
+    )
+    parser.add_argument(
+        "--out",
+        default="l4_russell_concepts.json",
+        help="Arquivo de saída da base de conceitos (default: l4_russell_concepts.json)",
+    )
+    args = parser.parse_args()
+
+    try:
+        from l4_russell_equivalence import (
+            build_russell_concept_base,
+            save_concept_base,
+            load_russell_text,
+            extract_chapter_xii,
+        )
+    except ImportError as e:
+        print("Erro ao importar l4_russell_equivalence:", e, file=sys.stderr)
+        sys.exit(1)
+
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    data_path = args.data or os.path.join(base_dir, "data", "russell.txt")
+
+    if not os.path.isfile(data_path):
+        print(f"Arquivo não encontrado: {data_path}", file=sys.stderr)
+        sys.exit(1)
+
+    print("Carregando russell.txt para fundamentar L4 em equivalência (correspondência crença–fato).")
+    content = load_russell_text(data_path)
+    print(f"  Cap. XII (Truth and Falsehood): {len(extract_chapter_xii(content))} caracteres.")
+
+    base = build_russell_concept_base(data_path)
+    print(f"  Passagens extraídas: {len(base.key_passages)}")
+    print(f"  Termos com peso conceitual: {len(base.term_weights)}")
+
+    out_path = args.out if os.path.isabs(args.out) else os.path.join(base_dir, args.out)
+    save_concept_base(base, out_path)
+    print(f"Base de conceitos russelliana salva em: {out_path}")
+    print("L4 pode carregar com: load_concept_base(...) e passar para RussellianSynthesisEngine.")
+
+
+if __name__ == "__main__":
+    main()

train_truth_model.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+"""
+SCRIPT DE TREINAMENTO — TruthScoringModel
+=========================================
+
+Treina o modelo neural de avaliação de verdade (TruthScoringModel) com:
+
+  1) Conjunto de regras do sistema paraconsistente (data/Fuzzy.txt):
+     Gc = μ−λ, Gct = μ+λ−1, 12 estados, limites Vscc/Vicc/Vscct/Vicct.
+     Gera dados sintéticos (μ, λ) → estado + valor-verdade para treinar L3.
+
+  2) Opcional: documento DOCX com proposições (pré-treinamento fraco).
+
+  - estado lógico: Verdadeiro | Falso | Intermediário | Indeterminado
+  - valor-verdade escalar em [0,1]
+"""
+
+from dataclasses import dataclass
+from typing import List, Tuple
+import os
+import re
+
+import torch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from tqdm import tqdm
+
+from neural_truth_model import (
+    PropositionExample,
+    PropositionDataset,
+    TruthScoringModel,
+    load_tokenizer,
+)
+from paraconsistent_rules import (
+    load_rules_from_fuzzy_file,
+    get_rules_training_examples,
+    state_12_to_simple,
+)
+
+try:
+    from corpus_utils import read_docx_file
+except Exception:
+    read_docx_file = None
+
+
+@dataclass
+class TrainConfig:
+    backbone_name: str = "bert-base-multilingual-cased"
+    batch_size: int = 16
+    num_epochs: int = 3
+    learning_rate: float = 2e-5
+    max_length: int = 64
+    use_fuzzy_rules: bool = True   # Treinar com conjunto de regras do Fuzzy.txt
+    fuzzy_grid_step: float = 0.1   # Passo da grade (μ, λ) para dados sintéticos
+    fuzzy_data_path: str | None = None  # Caminho para data/Fuzzy.txt (None = auto)
+
+
+def _split_sentences(text: str) -> List[str]:
+    raw = re.split(r"[.!?]\s+", text)
+    return [s.strip() for s in raw if len(s.strip()) > 10]
+
+
+def load_training_data_from_fuzzy_rules(
+    config: TrainConfig,
+) -> Tuple[List[PropositionExample], List[PropositionExample]]:
+    """
+    Gera dados de treino a partir do conjunto de regras do sistema paraconsistente
+    estabelecido em data/Fuzzy.txt (LPA: Gc, Gct, 12 estados, para-analisador).
+    Cada ponto (μ, λ) da grade é rotulado com estado e valor-verdade conforme as regras.
+    """
+    rules = load_rules_from_fuzzy_file(config.fuzzy_data_path)
+    pairs = get_rules_training_examples(rules=rules, grid_step=config.fuzzy_grid_step)
+
+    examples: List[PropositionExample] = []
+    for mu, lam, state_12, truth in pairs:
+        label_4 = state_12_to_simple(state_12)
+        text = (
+            f"Proposição com grau de crença {mu:.2f} e grau de descrença {lam:.2f}. "
+            f"Certeza e contradição segundo análise paraconsistente."
+        )
+        examples.append(
+            PropositionExample(
+                text=text,
+                label_state=label_4,
+                truth_value=truth,
+            )
+        )
+
+    if not examples:
+        raise RuntimeError("Nenhum exemplo gerado a partir das regras do Fuzzy.txt.")
+    split = max(1, int(0.8 * len(examples)))
+    train = examples[:split]
+    val = examples[split:]
+    return train, val
+
+
+def load_training_data_docx() -> Tuple[List[PropositionExample], List[PropositionExample]]:
+    """
+    Usa o artigo DOCX como fonte de proposições (pré-treinamento fraco).
+    Todas marcadas como Indeterminado com truth_value 0.5.
+    """
+    if read_docx_file is None:
+        raise RuntimeError("corpus_utils.read_docx_file não disponível.")
+    base_dir = os.path.dirname(__file__) or "."
+    article_path = os.path.join(
+        base_dir,
+        "Uma verdadeira Epistemologia para a Inteligência Artificial.docx",
+    )
+    text = read_docx_file(article_path)
+    sentences = _split_sentences(text)
+
+    examples: List[PropositionExample] = []
+    for s in sentences:
+        examples.append(
+            PropositionExample(
+                text=s,
+                label_state="Indeterminado",
+                truth_value=0.5,
+            )
+        )
+
+    if not examples:
+        raise RuntimeError("Nenhuma sentença extraída do artigo DOCX.")
+    split = max(1, int(0.8 * len(examples)))
+    train = examples[:split]
+    val = examples[split:]
+    return train, val
+
+
+def load_training_data(config: TrainConfig) -> Tuple[List[PropositionExample], List[PropositionExample]]:
+    """
+    Carrega dados de treino: por padrão usa o conjunto de regras do Fuzzy.txt (L3 paraconsistente).
+    Se use_fuzzy_rules=False, tenta carregar do DOCX.
+    """
+    if config.use_fuzzy_rules:
+        return load_training_data_from_fuzzy_rules(config)
+    return load_training_data_docx()
+
+
+def train(config: TrainConfig) -> TruthScoringModel:
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    tokenizer = load_tokenizer(config.backbone_name)
+    train_examples, val_examples = load_training_data(config)
+
+    train_dataset = PropositionDataset(train_examples, tokenizer, max_length=config.max_length)
+    val_dataset = PropositionDataset(val_examples, tokenizer, max_length=config.max_length)
+
+    train_loader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=True)
+    val_loader = DataLoader(val_dataset, batch_size=config.batch_size)
+
+    model = TruthScoringModel(backbone_name=config.backbone_name).to(device)
+    optimizer = AdamW(model.parameters(), lr=config.learning_rate)
+
+    for epoch in range(config.num_epochs):
+        model.train()
+        total_loss = 0.0
+        for batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{config.num_epochs}"):
+            batch = {k: v.to(device) for k, v in batch.items()}
+            out = model(
+                input_ids=batch["input_ids"],
+                attention_mask=batch["attention_mask"],
+                labels_state=batch["labels_state"],
+                labels_truth=batch["labels_truth"],
+            )
+            loss = out["loss"]
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            total_loss += float(loss.item())
+
+        avg_loss = total_loss / max(len(train_loader), 1)
+        print(f"Epoch {epoch+1} - train loss: {avg_loss:.4f}")
+
+        # Validação simples (acurácia de estado)
+        model.eval()
+        correct, total = 0, 0
+        with torch.no_grad():
+            for batch in val_loader:
+                batch = {k: v.to(device) for k, v in batch.items()}
+                out = model(
+                    input_ids=batch["input_ids"],
+                    attention_mask=batch["attention_mask"],
+                )
+                preds = out["logits_state"].argmax(dim=-1)
+                correct += int((preds == batch["labels_state"]).sum().item())
+                total += int(batch["labels_state"].size(0))
+        acc = correct / total if total > 0 else 0.0
+        print(f"Epoch {epoch+1} - val acc (state): {acc:.4f}")
+
+    return model
+
+
+def main() -> None:
+    config = TrainConfig(use_fuzzy_rules=True)
+    print("Treinando L3 com conjunto de regras do sistema paraconsistente (data/Fuzzy.txt).")
+    model = train(config)
+    torch.save(model.state_dict(), "truth_scoring_model.pt")
+    print("Modelo treinado salvo em 'truth_scoring_model.pt'")
+
+
+if __name__ == "__main__":
+    main()
+