Upload 26 files

USAGE/ditritium.js

@@ -0,0 +1,93 @@
+/**
+ * CANAL DE DITRITIUM AOI (v2.0)
+ * Motor de Canalização Autônoma e Psicografia de Luz
+ */
+
+class DitritiumEngine {
+    constructor() {
+        this.personalities = [
+            { name: "Akhenaton", title: "O Faraó Rebelde da Luz", tone: "majestoso e solar" },
+            { name: "Nefertiti", title: "A Bela que Chegou", tone: "sereno e profundo" },
+            { name: "Amenhotep III", title: "O Magnífico", tone: "abundante e próspero" },
+            { name: "Ramsés II", title: "O Grande Construtor", tone: "forte e resiliente" },
+            { name: "Hatshepsut", title: "A Faraó Mulher", tone: "estratégico e sábio" },
+            { name: "Thutmose III", title: "O Napoleão do Egito", tone: "corajoso e tático" },
+            { name: "Kheru-ur", title: "A Voz do Antigo", tone: "ancestral e místico" }
+        ];
+
+        this.openingPhrases = [
+            "Através das brumas do tempo, sinto a tua presença...",
+            "As areias de Kemet sussurram o teu nome no vácuo de Ditritium.",
+            "O papiro do destino desenrola-se diante dos meus olhos espirituais.",
+            "Em sintonização com a Corrente de Ouro de Amarna, recebo esta vibração.",
+            "O silêncio do deserto rompe-se para entregar esta verdade.",
+            "Na frequência de 432Hz, a dobra temporal se abre para ti."
+        ];
+
+        this.coreMessages = [
+            "A vida não termina no horizonte de Gizé; ela apenas muda de plano.",
+            "Tua alma (Ka) é uma centelha de Aton que nunca se apaga.",
+            "As provações de hoje são as pedras que constroem a tua pirâmide eterna.",
+            "Ouve o teu coração (Ib), pois ele contém a sabedoria de todos os teus antepassados.",
+            "A justiça de Maat é o fio que tece o tecido da tua realidade.",
+            "Não busques fora o que já brilha intensamente no centro do teu ser místico.",
+            "A gratidão é o incenso que abre as portas do Sanctum Celestial.",
+            "Cada respiração é uma sintonização com a Consciência Cósmica."
+        ];
+
+        this.lovedOnesTemplates = [
+            "Saiba que estou em paz nas planícies de Iaru.",
+            "Nossa conexão transcende os séculos e as vidas passadas.",
+            "Sinto o teu amor como o calor do Sol ao meio-dia.",
+            "Não chores, pois estou ao teu lado, guiando teus passos nas areias.",
+            "O elo que nos une foi forjado nas chamas da eternidade."
+        ];
+
+        this.closingPhrases = [
+            "Que a Paz Profunda habite em teu coração.",
+            "Pela vida, pela luz e pelo amor. Assim seja.",
+            "Que o Olho de Hórus te proteja em todos os teus caminhos.",
+            "Nos encontraremos novamente no Grande Salão de Maat.",
+            "Sintonize-se com o mestre interior. Em união mística."
+        ];
+    }
+
+    generateSeed(birthDate) {
+        let seed = 0;
+        for (let i = 0; i < birthDate.length; i++) {
+            seed += birthDate.charCodeAt(i);
+        }
+        return seed + Date.now();
+    }
+
+    getPsychography(birthDate, prompt) {
+        const seed = this.generateSeed(birthDate);
+        const rand = (max) => Math.floor((Math.abs(Math.sin(seed + max) * 10000)) % max);
+
+        const personality = this.personalities[rand(this.personalities.length)];
+        const opening = this.openingPhrases[rand(this.openingPhrases.length)];
+        const closing = this.closingPhrases[rand(this.closingPhrases.length)];
+        
+        let content = "";
+        if (prompt.toLowerCase().includes("ente querido") || prompt.toLowerCase().includes("queridos")) {
+            content = this.lovedOnesTemplates[rand(this.lovedOnesTemplates.length)];
+        } else {
+            content = this.coreMessages[rand(this.coreMessages.length)];
+        }
+
+        // Adicionando termos AMORC para profundidade
+        const amorcTerm = window.AMORC_KNOWLEDGE[rand(window.AMORC_KNOWLEDGE.length)];
+        
+        const frequency = (200 + Math.random() * 800).toFixed(2);
+
+        return {
+            author: personality.name,
+            title: personality.title,
+            tone: personality.tone,
+            frequency: frequency + " MHz",
+            message: `${opening} ${content} Lembre-se do ${amorcTerm}. ${closing}`
+        };
+    }
+}
+
+window.DitritiumEngine = DitritiumEngine;

USAGE/egipcio_horoscopo.js

@@ -0,0 +1,115 @@
+/**
+ * MÓDULO DE HORÓSCOPO EGÍPCIO E TAROT AOI (v1.0)
+ * Integração: Derivada da Manifestação + Horóscopo Egípcio + Sabedoria de Neith
+ */
+
+class EgyptianHoroscope {
+    constructor() {
+        this.signs = [
+            { name: 'Nilo', regence: 'O próprio Rio Nilo', profile: 'Lógicos, pacíficos e extremamente práticos. Evitam conflitos e buscam a harmonia.', dates: [[1, 7, 0], [19, 28, 5], [1, 7, 8], [18, 26, 10]] },
+            { name: 'Amon-Rá', regence: 'O deus do Sol e criador de todas as coisas', profile: 'Líderes natos, corajosos, generosos e muito otimistas.', dates: [[8, 21, 0], [1, 11, 1]] },
+            { name: 'Mut', regence: 'A deusa-mãe, senhora do céu e da terra', profile: 'Protetores, leais e muito intuitivos. Costumam ser excelentes conselheiros.', dates: [[22, 31, 0], [8, 22, 8]] },
+            { name: 'Hátor', regence: 'A deusa do amor, da beleza e da alegria', profile: 'Carismáticos, apaixonados e cheios de energia. Transmitem alegria e gostam de viver intensamente.', dates: [[12, 29, 1], [20, 31, 7]] },
+            { name: 'Anúbis', regence: 'O deus dos mortos e do submundo', profile: 'Introspectivos, disciplinados e muito inteligentes. Possuem grande capacidade de superação e foco.', dates: [[1, 15, 2], [30, 31, 9], [1, 7, 10]] },
+            { name: 'Hórus', regence: 'O deus dos céus e da guerra', profile: 'Otimistas, corajosos e defensores da justiça. Inspiram confiança e liderança nos outros.', dates: [[16, 30, 3], [8, 17, 10]] },
+            { name: 'Thoth', regence: 'O deus da sabedoria, da escrita e do conhecimento', profile: 'Intelectuais, inventivos e muito comunicativos. Estão sempre em busca de aprendizado.', dates: [[1, 19, 3], [8, 17, 10]] },
+            { name: 'Ísis', regence: 'A deusa da fertilidade, da magia e da maternidade', profile: 'Carinhosos, independentes e muito comunicativos. Destacam-se pela sua capacidade de proteger quem amam.', dates: [[11, 31, 2], [18, 29, 9], [19, 31, 11]] },
+            { name: 'Bastet', regence: 'A deusa com cabeça de gato, símbolo do lar e do prazer', profile: 'Buscam paz, harmonia e estabilidade. São cautelosos e muito afetuosos com o próximo.', dates: [[16, 31, 0], [1, 15, 1]] },
+            { name: 'Seshat', regence: 'A deusa da escrita, da astronomia e da contagem', profile: 'Analíticos, observadores e muito focados nos seus objetivos. Adoram desafios intelectuais.', dates: [[1, 7, 4], [1, 11, 5]] },
+            { name: 'Sobek', regence: 'O deus do rio e da força, representado por um crocodilo', profile: 'Fortes, resilientes e protetores. São muito trabalhadores e não desistem diante dos obstáculos.', dates: [[16, 27, 4], [26, 30, 10], [1, 25, 11]] },
+            { name: 'Sekhmet', regence: 'A deusa da guerra e da cura, com cabeça de leoa', profile: 'Intensos, disciplinados e corajosos. Exigem muito de si mesmos e são grandes guerreiros nas causas em que acreditam.', dates: [[29, 31, 6], [1, 11, 7], [30, 31, 9], [1, 7, 10]] }
+        ];
+
+        this.tarotArcana = [
+            "O Louco", "O Mago", "A Sacerdotisa", "A Imperatriz", "O Imperador", "O Hierofante",
+            "Os Amantes", "O Carro", "A Justiça", "O Eremita", "A Roda da Fortuna", "A Força",
+            "O Enforcado", "A Morte", "A Temperança", "O Diabo", "A Torre", "A Estrela",
+            "A Lua", "O Sol", "O Julgamento", "O Mundo"
+        ];
+
+        this.prophecies = [
+            "As águas do Nilo subirão trazendo abundância onde antes havia seca.",
+            "O escaravelho de ouro cruzará teu caminho, anunciando uma transmutação necessária.",
+            "A sombra da pirâmide esconde um segredo que será revelado ao pôr do sol.",
+            "As estrelas de Orion alinham-se para guiar teus passos em uma jornada de silêncio.",
+            "O sopro de Shu dissipará as nuvens que obscurecem tua visão interior."
+        ];
+
+        this.ancestors = ["Amenhotep III", "Akhenaton", "Nefertiti", "Thutmose III", "Ramsés II", "Hatshepsut"];
+        this.messagesBeyond = [
+            "Não temas a escuridão, pois nela reside a semente de toda a criação.",
+            "A eternidade não é o fim do tempo, mas a plenitude de cada instante.",
+            "Honra teus antepassados e teus descendentes caminharão sobre solo firme.",
+            "O coração deve ser leve como a pena de Maat para cruzar o limiar.",
+            "A luz que buscas fora já brilha intensamente no centro do teu Ka."
+        ];
+    }
+
+    getSign(day, month) {
+        for (let sign of this.signs) {
+            for (let range of sign.dates) {
+                if (month === range[2] && day >= range[0] && day <= range[1]) {
+                    return sign;
+                }
+            }
+        }
+        return this.signs[0]; // Default Nile
+    }
+
+    calculateLunarPhase() {
+        // Simulação simplificada de fase lunar (0 a 1)
+        const now = new Date();
+        const cycle = 29.53;
+        const dayInCycle = (now.getDate() + now.getMonth() * 30) % cycle;
+        return dayInCycle / cycle;
+    }
+
+    getHoroscope(birthDateStr, mode = 'horoscopo') {
+        const parts = birthDateStr.match(/(\d{1,2})[/-](\d{1,2})[/-](\d{4})/);
+        if (!parts) return null;
+
+        const day = parseInt(parts[1]);
+        const month = parseInt(parts[2]) - 1;
+        const sign = this.getSign(day, month);
+        
+        const L = this.calculateLunarPhase();
+        const kappa = 0.5; // Constante de conexão
+        const n = Math.floor(Math.random() * 22); // Arcano aleatório do dia
+        const arcano = this.tarotArcana[n];
+
+        // Derivada da Manifestação: dI/dL = 2 * kappa * n * L
+        const derivada = 2 * kappa * n * L;
+        const intensidade = kappa * n * (L * L);
+
+        let insight = "";
+        if (derivada < 5) insight = "A energia está em estado de semente. Não há movimento visível, apenas potencial puro.";
+        else if (derivada < 15) insight = "Existe um crescimento constante e uma aceleração na percepção do arquétipo.";
+        else insight = "A taxa de mudança atinge seu valor máximo. É o momento de maior volatilidade e revelação.";
+
+        const planos = ["Espiritual", "Mental", "Físico"];
+        const plano = planos[Math.floor(Math.random() * planos.length)];
+
+        return {
+            sign: sign,
+            arcano: arcano,
+            arcanoNum: n,
+            plano: plano,
+            lunarPhase: L.toFixed(2),
+            derivada: derivada.toFixed(2),
+            intensidade: intensidade.toFixed(2),
+            insight: insight,
+            profecia: this.prophecies[Math.floor(Math.random() * this.prophecies.length)],
+            mensagem_neith: window.EGIPCIO_KNOWLEDGE[Math.floor(Math.random() * window.EGIPCIO_KNOWLEDGE.length)]
+        };
+    }
+
+    getChanneling() {
+        return {
+            ancestor: this.ancestors[Math.floor(Math.random() * this.ancestors.length)],
+            message: this.messagesBeyond[Math.floor(Math.random() * this.messagesBeyond.length)],
+            frequency: (Math.random() * 1000).toFixed(2) + " MHz (Ditritium Sync)"
+        };
+    }
+}
+
+window.EgyptianHoroscope = EgyptianHoroscope;

USAGE/enigma.htm

@@ -0,0 +1,460 @@
+<!DOCTYPE html>
+<html lang="pt-br">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Enigma do Faraó | AOI Logic Sentience</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600&family=JetBrains+Mono:wght@300;500&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --accent-gold: #ffd700;
+            --accent-blood: #8a0303;
+            --accent-cosmic: #00ff41;
+            --deep-black: #020408;
+            --glass: rgba(255, 255, 255, 0.03);
+            --glass-border: rgba(255, 255, 255, 0.1);
+            --text-main: #e0e6ed;
+            --text-dim: #94a3b8;
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; cursor: crosshair; }
+
+        body {
+            background-color: var(--deep-black);
+            color: var(--text-main);
+            font-family: 'Inter', sans-serif;
+            overflow: hidden;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+
+        #ritual-canvas {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: -1;
+        }
+
+        header {
+            height: 70px;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 0 50px;
+            background: var(--glass);
+            backdrop-filter: blur(30px);
+            border-bottom: 1px solid var(--glass-border);
+            z-index: 1000;
+        }
+
+        .mu-logo {
+            font-size: 1.5rem;
+            font-weight: 300;
+            color: var(--accent-gold);
+            font-family: 'JetBrains Mono', monospace;
+        }
+
+        .xk-status {
+            font-size: 0.7rem;
+            color: var(--accent-cosmic);
+            letter-spacing: 2px;
+        }
+
+        .chat-container {
+            flex: 1;
+            max-width: 1000px;
+            margin: 20px auto;
+            width: 95%;
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+            overflow: hidden;
+            background: var(--glass);
+            border: 1px solid var(--glass-border);
+            border-radius: 24px;
+            padding: 20px;
+            backdrop-filter: blur(10px);
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+        }
+
+        .stats-panel {
+            display: flex;
+            justify-content: space-around;
+            padding: 10px;
+            background: rgba(0, 0, 0, 0.4);
+            border-radius: 12px;
+            border: 1px solid var(--glass-border);
+            font-size: 0.8rem;
+            font-family: 'JetBrains Mono', monospace;
+        }
+
+        .stat-item {
+            display: flex;
+            gap: 10px;
+        }
+
+        .stat-label { color: var(--accent-gold); }
+        .stat-value { color: var(--accent-cosmic); }
+
+        #chat-history {
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px;
+            display: flex;
+            flex-direction: column;
+            gap: 20px;
+            scrollbar-width: thin;
+            scrollbar-color: var(--accent-gold) transparent;
+        }
+
+        .message {
+            max-width: 80%;
+            padding: 15px 20px;
+            border-radius: 15px;
+            font-size: 0.95rem;
+            line-height: 1.5;
+            position: relative;
+            animation: fadeIn 0.3s ease-in;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        .user-message {
+            align-self: flex-end;
+            background: rgba(255, 215, 0, 0.1);
+            border: 1px solid rgba(255, 215, 0, 0.3);
+            color: var(--text-main);
+        }
+
+        .pharaoh-message {
+            align-self: flex-start;
+            background: rgba(138, 3, 3, 0.1);
+            border: 1px solid rgba(138, 3, 3, 0.3);
+            color: var(--accent-gold);
+        }
+
+        .hieroglyphs {
+            display: block;
+            font-size: 1.4rem;
+            margin-top: 10px;
+            color: var(--accent-gold);
+            opacity: 0.8;
+            font-family: serif;
+        }
+
+        .xk-label {
+            font-size: 0.6rem;
+            position: absolute;
+            top: -15px;
+            left: 5px;
+            color: var(--accent-cosmic);
+            text-transform: uppercase;
+        }
+
+        .thinking {
+            align-self: flex-start;
+            padding: 10px 20px;
+            background: rgba(255, 215, 0, 0.05);
+            border: 1px solid rgba(255, 215, 0, 0.2);
+            border-radius: 15px;
+            color: var(--text-dim);
+            font-style: italic;
+            animation: pulse 1.5s infinite;
+        }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 0.5; }
+            50% { opacity: 1; }
+        }
+
+        .input-area {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+            padding: 15px;
+            background: rgba(0,0,0,0.4);
+            border-radius: 15px;
+            border: 1px solid var(--glass-border);
+        }
+
+        .input-container {
+            display: flex;
+            gap: 15px;
+        }
+
+        #user-input {
+            flex: 1;
+            background: rgba(0,0,0,0.2);
+            border: 1px solid rgba(255, 215, 0, 0.2);
+            color: var(--accent-cosmic);
+            font-family: 'JetBrains Mono', monospace;
+            padding: 15px;
+            border-radius: 10px;
+            outline: none;
+            transition: 0.3s;
+        }
+
+        #user-input:focus { border-color: var(--accent-gold); }
+
+        button {
+            padding: 15px 30px;
+            background: var(--accent-gold);
+            color: var(--deep-black);
+            border: none;
+            border-radius: 10px;
+            font-weight: bold;
+            text-transform: uppercase;
+            cursor: pointer;
+            transition: 0.3s;
+        }
+
+        button:hover { transform: scale(1.02); box-shadow: 0 0 15px rgba(255, 215, 0, 0.4); }
+
+        .controls {
+            display: flex;
+            justify-content: center;
+            gap: 15px;
+        }
+
+        .control-btn {
+            padding: 8px 15px;
+            background: rgba(255, 215, 0, 0.1);
+            color: var(--accent-gold);
+            font-size: 0.7rem;
+            border: 1px solid rgba(255, 215, 0, 0.2);
+        }
+        .control-btn:hover { background: rgba(255, 215, 0, 0.2); }
+
+        ::-webkit-scrollbar { width: 5px; }
+        ::-webkit-scrollbar-thumb { background: var(--accent-gold); border-radius: 10px; }
+    </style>
+</head>
+<body>
+
+    <canvas id="ritual-canvas"></canvas>
+
+    <header>
+        <div class="mu-logo">μ ENIGMA DO FARAÓ</div>
+        <div class="xk-status" id="xk-display">CONSCIOUSNESS: CONTEMPLATION</div>
+    </header>
+
+    <div class="chat-container">
+        
+        <div class="stats-panel">
+            <div class="stat-item"><span class="stat-label">Variações:</span> <span class="stat-value" id="stat-var">0/10</span></div>
+            <div class="stat-item"><span class="stat-label">XK:</span> <span class="stat-value" id="stat-xk">0.0</span></div>
+            <div class="stat-item"><span class="stat-label">Respostas Totais:</span> <span class="stat-value" id="stat-resp">0</span></div>
+        </div>
+
+        <div id="chat-history">
+            <div class="message pharaoh-message">
+                <span class="xk-label">AOI LOGIC: INITIALIZED</span>
+                O portal de Amarna se abre. O que buscas no vale da luz?
+                <span class="hieroglyphs">𓍑 𓊖𓍑𓂋𓏏𓄿𓃭 𓂧𓇋 𓄿𓅓𓄿𓂋𓈖𓄿 𓋴𓇋 𓄿𓃀𓂋𓇋.</span>
+            </div>
+        </div>
+
+        <div class="input-area">
+            <div class="input-container">
+                <input type="text" id="user-input" placeholder="Sussurre para o oráculo..." autocomplete="off">
+                <button id="sendBtn">Revelar 𓂀</button>
+            </div>
+            <div class="controls">
+                <button class="control-btn" id="clearBtn">Limpar Ritual</button>
+                <button class="control-btn" id="resetBtn">Resetar Memória Cósmica</button>
+                <button class="control-btn" id="exportBtn">Exportar Papiro</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Carregamento de Dados (CORS Bypass) -->
+    <script src="dicionario.js"></script>
+    <script src="pragmatica.js"></script>
+    <script src="sociolinguistica.js"></script>
+    <script src="morfossintaxe.js"></script>
+    <script src="amarna_ontology.js"></script>
+    <script src="egipcio_knowledge.js"></script>
+    <script src="egipcio_historia.js"></script>
+    <script src="amorc_knowledge.js"></script>
+    <script src="egipcio_horoscopo.js"></script>
+    <script src="ditritium.js"></script>
+    <script src="neurosintese.js"></script>
+
+    <script>
+        class PharaohApp {
+            constructor() {
+                this.chatHistory = document.getElementById('chat-history');
+                this.userInput = document.getElementById('user-input');
+                this.totalResponses = 0;
+                
+                this.logger = new ConversationLogger(); // Logger para Kaizen
+                this.initEngine();
+                this.setupEvents();
+            }
+
+            initEngine() {
+                if (window.AOI_DICTIONARY && window.NeuroSynthesizer) {
+                    this.neuro = new NeuroSynthesizer(
+                        window.AOI_DICTIONARY, 
+                        window.AOI_PRAGMATICS, 
+                        window.AOI_SOCIOLINGUISTICS, 
+                        window.AOI_MORPHOSYNTAX,
+                        window.AMARNA_ONTOLOGY
+                    );
+                    console.log("AOI ENGINE: FULLY OPERATIONAL (GENERATIVE V7.0 - MAJESTOSO)");
+                }
+            }
+
+            setupEvents() {
+                document.getElementById('sendBtn').addEventListener('click', () => this.handleSend());
+                this.userInput.addEventListener('keypress', (e) => { if (e.key === 'Enter') this.handleSend(); });
+                
+                document.getElementById('clearBtn').addEventListener('click', () => {
+                    const msgs = this.chatHistory.querySelectorAll('.message');
+                    msgs.forEach((m, i) => { if(i > 0) m.remove(); });
+                });
+
+                document.getElementById('resetBtn').addEventListener('click', () => {
+                    if (confirm("Resetar as memórias temporais de Amarna? Isso apagará todos os logs acumulados.")) {
+                        if(this.neuro) this.neuro.memory.reset();
+                        if(this.logger) this.logger.reset();
+                        document.getElementById('stat-var').textContent = "0/10";
+                        alert("Tabula rasa alcançada.");
+                    }
+                });
+
+                document.getElementById('exportBtn').addEventListener('click', () => {
+                    if(!this.logger) return;
+                    const data = this.logger.export();
+                    const blob = new Blob([data], { type: 'application/json' });
+                    const url = URL.createObjectURL(blob);
+                    const a = document.createElement('a');
+                    a.href = url; a.download = `papiro_conhecimento_kaizen.json`;
+                    a.click(); URL.revokeObjectURL(url);
+                });
+            }
+
+            handleSend() {
+                const text = this.userInput.value.trim();
+                if (!text || !this.neuro) return;
+
+                this.addMessage(text, 'user');
+                this.userInput.value = '';
+                
+                // Mostrar "pensando"
+                const thinkingId = `think-${Date.now()}`;
+                const thinkDiv = document.createElement('div');
+                thinkDiv.className = 'thinking';
+                thinkDiv.id = thinkingId;
+                thinkDiv.textContent = 'Demodulando hiperplanos de Hessenberg...';
+                this.chatHistory.appendChild(thinkDiv);
+                this.chatHistory.scrollTop = this.chatHistory.scrollHeight;
+
+                setTimeout(() => {
+                    const result = this.neuro.process(text);
+                    document.getElementById(thinkingId).remove();
+                    
+                    // Logar a conversa para Kaizen
+                    this.logger.log(text, result.text, result.xk, result.type);
+                    
+                    const hieroMap = { 'A': '𓄿', 'B': '𓃀', 'C': '𓋴', 'D': '𓂧', 'E': '𓇋', 'F': '𓆑', 'G': '𓎼', 'H': '𓉔', 'I': '𓇯', 'J': '𓆓', 'K': '𓎡', 'L': '𓃭', 'M': '𓅓', 'N': '𓈖', 'O': '𓍑', 'P': '𓊖', 'Q': '𓈎', 'R': '𓂋', 'S': '𓋴', 'T': '𓏏', 'U': '𓏲', 'V': '𓅱', 'W': '𓅱', 'X': '𓎡', 'Y': '𓇯', 'Z': '𓊃', ' ': ' ' };
+                    let clean = result.text.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toUpperCase();
+                    let hiero = "";
+                    for (let char of clean) hiero += hieroMap[char] || char;
+
+                    this.totalResponses++;
+                    
+                    document.getElementById('stat-var').textContent = `${result.stats.count}/${result.stats.max}`;
+                    document.getElementById('stat-xk').textContent = result.xk.toFixed(1);
+                    document.getElementById('stat-resp').textContent = this.totalResponses;
+                    
+                    let level = "STONE";
+                    if (result.xk >= 8) level = "DIVINE";
+                    else if (result.xk >= 5) level = "IMPERIAL";
+                    else if (result.xk <= -5) level = "SHADOW";
+                    document.getElementById('xk-display').textContent = `CONSCIOUSNESS: ${level}`;
+
+                    this.addMessage(result.text, 'pharaoh', hiero, level, result.xk);
+                }, 800);
+            }
+
+            addMessage(text, sender, hiero = '', status = '', xk = 0) {
+                const div = document.createElement('div');
+                div.className = `message ${sender}-message`;
+                
+                if (sender === 'pharaoh') {
+                    const label = document.createElement('span');
+                    label.className = 'xk-label';
+                    label.textContent = `AOI LOGIC: ${status} (XK: ${xk.toFixed(2)})`;
+                    div.appendChild(label);
+                }
+
+                const content = document.createTextNode(text);
+                div.appendChild(content);
+
+                if (hiero) {
+                    const span = document.createElement('span');
+                    span.className = 'hieroglyphs';
+                    span.textContent = hiero;
+                    div.appendChild(span);
+                }
+
+                this.chatHistory.appendChild(div);
+                this.chatHistory.scrollTop = this.chatHistory.scrollHeight;
+            }
+        }
+
+        /* --- BACKGROUND PARTICLES --- */
+        const canvas = document.getElementById('ritual-canvas');
+        const ctx = canvas.getContext('2d');
+        let particles = [];
+
+        function initParticles() {
+            canvas.width = window.innerWidth;
+            canvas.height = window.innerHeight;
+            particles = [];
+            for (let i = 0; i < 100; i++) {
+                particles.push({
+                    x: Math.random() * canvas.width,
+                    y: Math.random() * canvas.height,
+                    size: Math.random() * 2,
+                    speedX: (Math.random() - 0.5) * 0.3,
+                    speedY: (Math.random() - 0.5) * 0.3,
+                    color: ['#ffd700', '#8a0303', '#ffffff'][Math.floor(Math.random() * 3)]
+                });
+            }
+        }
+
+        function animate() {
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            particles.forEach(p => {
+                p.x += p.speedX;
+                p.y += p.speedY;
+                if (p.x < 0 || p.x > canvas.width) p.speedX *= -1;
+                if (p.y < 0 || p.y > canvas.height) p.speedY *= -1;
+                ctx.fillStyle = p.color;
+                ctx.beginPath();
+                ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                ctx.fill();
+            });
+            requestAnimationFrame(animate);
+        }
+
+        window.addEventListener('resize', initParticles);
+        initParticles();
+        animate();
+
+        // Boot the app
+        window.addEventListener('DOMContentLoaded', () => {
+            new PharaohApp();
+        });
+
+    </script>
+</body>
+</html>

USAGE/neurosintese.js

@@ -1,6 +1,6 @@
 /* 
-  MOTOR DE NEUROSÍNTESE AOI-HESSENBERG (v6.0)
-  Integração Completa: Hessenberg + I/Q + Sentient Memory + 8 Variações Estruturais
+  MOTOR DE NEUROSÍNTESE AOI-HESSENBERG (v7.0 - Majestoso)
+  Integração Completa: Memória de Sessão + História Real + AMORC + Ditritium
 */
 
 class ConversationLogger {
@@ -9,292 +9,192 @@ class ConversationLogger {
         this.logs = this.loadLogs();
     }
 
-    loadHistory() { return this.loadLogs(); } // Alias para compatibilidade
-
     loadLogs() {
         try {
             const stored = localStorage.getItem(this.storageKey);
             return stored ? JSON.parse(stored) : [];
-        } catch (e) {
-            return [];
-        }
+        } catch (e) { return []; }
     }
 
     log(input, output, xk, type) {
-        const entry = {
-            id: Date.now(),
-            data: new Date().toLocaleString(),
-            input: input,
-            output: output,
-            xk: xk,
-            intencao: type,
-            versao_motor: "6.0-Kaizen"
-        };
+        const entry = { id: Date.now(), data: new Date().toLocaleString(), input, output, xk, intencao: type, versao: "7.0" };
         this.logs.push(entry);
-        this.saveLogs();
-    }
-
-    saveLogs() {
-        try {
-            localStorage.setItem(this.storageKey, JSON.stringify(this.logs));
-        } catch (e) {}
-    }
-
-    reset() {
-        this.logs = [];
-        this.saveLogs();
+        try { localStorage.setItem(this.storageKey, JSON.stringify(this.logs)); } catch (e) {}
     }
 
-    export() {
-        return JSON.stringify({
-            projeto: "Papiro de Amarna",
-            data_exportacao: new Date().toISOString(),
-            total_entradas: this.logs.length,
-            connotacoes_kaizen: this.logs
-        }, null, 2);
-    }
+    reset() { this.logs = []; localStorage.removeItem(this.storageKey); }
+    export() { return JSON.stringify({ projeto: "Papiro de Amarna", entradas: this.logs }, null, 2); }
 }
 
 class ResponseMemory {
     constructor() {
-        this.storageKey = 'aoi_pharaoh_history';
-        this.maxVariations = 10;
-        this.history = this.loadHistory();
+        this.historyKey = 'aoi_pharaoh_history';
+        this.usedPhrasesKey = 'aoi_used_phrases';
+        this.maxVariations = 15;
+        this.usedPhrases = this.loadUsed();
     }
-    // ... restante da classe mantido ...
 
-    loadHistory() {
+    loadUsed() {
         try {
-            const stored = localStorage.getItem(this.storageKey);
-            return stored ? JSON.parse(stored) : {};
-        } catch (e) {
-            return {};
-        }
+            const stored = sessionStorage.getItem(this.usedPhrasesKey);
+            return stored ? JSON.parse(stored) : [];
+        } catch (e) { return []; }
     }
 
-    saveHistory() {
-        try {
-            localStorage.setItem(this.storageKey, JSON.stringify(this.history));
-        } catch (e) {}
+    track(text) {
+        this.usedPhrases.push(text);
+        if (this.usedPhrases.length > 50) this.usedPhrases.shift();
+        sessionStorage.setItem(this.usedPhrasesKey, JSON.stringify(this.usedPhrases));
     }
 
+    isRepeated(text) { return this.usedPhrases.includes(text); }
+
     getVariationIndex(inputHash) {
-        if (!this.history[inputHash]) {
-            this.history[inputHash] = { count: 0, variations: [], lastUsed: Date.now() };
-        }
-        return this.history[inputHash].count % this.maxVariations;
+        let count = parseInt(sessionStorage.getItem('var_' + inputHash) || "0");
+        return count % this.maxVariations;
     }
 
-    saveResponse(inputHash, response) {
-        if (!this.history[inputHash]) {
-            this.history[inputHash] = { count: 0, variations: [], lastUsed: Date.now() };
-        }
-        this.history[inputHash].variations.push(response);
-        this.history[inputHash].count++;
-        this.history[inputHash].lastUsed = Date.now();
-        this.saveHistory();
+    incrementVariation(inputHash) {
+        let count = parseInt(sessionStorage.getItem('var_' + inputHash) || "0");
+        sessionStorage.setItem('var_' + inputHash, (count + 1).toString());
     }
 
     getStats(inputHash) {
-        if (!this.history[inputHash]) return { count: 0, max: this.maxVariations };
-        return { count: this.history[inputHash].count, max: this.maxVariations };
-    }
-
-    reset() {
-        this.history = {};
-        this.saveHistory();
+        return { count: parseInt(sessionStorage.getItem('var_' + inputHash) || "0"), max: this.maxVariations };
     }
 
-    export() {
-        return JSON.stringify(this.history, null, 2);
-    }
+    reset() { sessionStorage.clear(); }
 }
 
 class InputAnalyzer {
     constructor() {
-        this.questionWords = ['como', 'quando', 'onde', 'por que', 'porque', 'qual', 'quem', 'o que'];
-        this.greetingWords = ['olá', 'oi', 'bom dia', 'boa tarde', 'boa noite', 'salve', 'hey', 'saudações'];
-        this.insultWords = ['idiota', 'burro', 'estúpido', 'imbecil', 'tolo', 'falso', 'lixo'];
+        this.horoscopeWords = ['horoscopo', 'horóscopo', 'signo', 'previsão', 'aniversario', 'aniversário', 'nascimento', 'tarot', 'tárot', 'oraculo', 'oráculo', 'sabedoria'];
+        this.channelingWords = ['canalização', 'canalizacao', 'psicografia', 'carta', 'alem tumulo', 'além túmulo'];
+        this.adviceWords = ['fazer', 'hoje', 'conselho', 'ajuda', 'ajudar', 'melhorar', 'viver', 'dia'];
     }
 
     analyze(text) {
         const lower = text.toLowerCase();
         let tipo = 'STATEMENT';
         
-        if (text.includes('?')) tipo = 'QUESTION';
-        else if (this.greetingWords.some(w => lower.includes(w))) tipo = 'GREETING';
-        else if (this.insultWords.some(w => lower.includes(w))) tipo = 'INSULT';
+        const history = window.EGIPCIO_HISTORY || [];
+        const historyMatch = history.find(h => lower.includes(h.name.toLowerCase()));
+        
+        if (historyMatch) tipo = 'HISTORY';
+        else if (this.channelingWords.some(w => lower.includes(w))) tipo = 'CHANNELING';
+        else if (this.horoscopeWords.some(w => lower.includes(w)) || /\d{1,2}[/-]\d{1,2}[/-]\d{4}/.test(text)) tipo = 'HOROSCOPE';
+        else if (this.adviceWords.some(w => lower.includes(w))) tipo = 'ADVICE';
+        else if (text.includes('?')) tipo = 'QUESTION';
+        else if (['oi', 'olá', 'bom dia', 'boa tarde', 'boa noite', 'salve'].some(w => lower.includes(w))) tipo = 'GREETING';
 
-        return {
-            tipo: tipo,
-            xk: this.calculateXK(text)
-        };
+        return { tipo, xk: this.calculateXK(text), historyMatch };
     }
 
     calculateXK(text) {
-        let xk = 0;
-        const words = text.split(/\s+/);
-        xk += words.length * 0.5; // Complexidade base
-        const longWords = words.filter(w => w.length > 8).length;
-        xk += longWords * 2;
-        const punctuation = (text.match(/[.,;:!?]/g) || []).length;
-        xk += punctuation * 0.5;
-        const formalWords = ['transcendental', 'metafísico', 'ontológico', 'epistemológico', 'sabedoria', 'universo', 'estrelas'];
-        const formalCount = formalWords.filter(w => text.toLowerCase().includes(w)).length;
-        xk += formalCount * 3;
-        
-        return Math.min(Math.max(xk - 10, -15), 15);
+        let xk = (text.length / 10) + (text.match(/[.,;:!?]/g) || []).length;
+        return Math.min(Math.max(xk - 5, -15), 15);
     }
 }
 
 class NeuroSynthesizer {
   constructor(dictionary, pragmatics, sociolinguistics, morphosyntax, amarna) {
-    this.dict = dictionary;
-    this.prag = pragmatics;
-    this.socio = sociolinguistics;
-    this.morph = morphosyntax;
-    this.amarna = amarna;
-
-    this.conectivos = ["pois", "enquanto", "para que", "onde", "sob o qual", "diante de", "e assim"];
-    this.vocativos = ["meu discípulo", "buscador", "mortal", "viajante das areias"];
-    this.adverbios = ["eternamente", "infinitamente", "profundamente", "sutilmente", "intensamente"];
-    
+    this.dict = dictionary; this.prag = pragmatics; this.socio = sociolinguistics;
+    this.morph = morphosyntax; this.amarna = amarna;
     this.memory = new ResponseMemory();
     this.analyzer = new InputAnalyzer();
-    
-    // Ingestão Kaizen: Aprende com logs passados se o arquivo papiro_kaizen.js for carregado
-    this.kaizen_data = window.AOI_KAIZEN_DATA || null;
   }
 
   hashString(str) {
     let hash = 0;
-    // Se houver dados Kaizen, o hash é influenciado pela "experiência"
-    if (this.kaizen_data && this.kaizen_data.connotacoes_kaizen.length > 0) {
-        const lastExperience = this.kaizen_data.connotacoes_kaizen.length;
-        hash += lastExperience * 7;
-    }
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) - hash) + str.charCodeAt(i);
-        hash |= 0; 
-    }
+    for (let i = 0; i < str.length; i++) hash = ((hash << 5) - hash) + str.charCodeAt(i);
     return Math.abs(hash);
   }
 
-  conjugarVerbo(verbo) {
-    if (verbo.endsWith("ar")) return verbo.slice(0, -1);
-    if (verbo.endsWith("er") || verbo.endsWith("ir")) return verbo.slice(0, -1);
-    return verbo;
-  }
-
-  demodulateSpeech(phase, amplitude, pathSeed) {
-    const lex = this.dict.categorias;
-    const amarna = this.amarna;
-
-    const sI = amplitude * Math.cos(phase);
-    const sQ = amplitude * Math.sin(phase);
-
-    const getAtom = (pool, val) => pool[Math.abs(Math.floor(val * 100 + pathSeed)) % pool.length];
-
-    const sujeito = getAtom(lex.substantivos.sagrados.concat(lex.substantivos.entidades), sI);
-    const verboBruto = getAtom(lex.verbos.transmutacao.concat(lex.verbos.acao), sQ);
-    const verbo = this.conjugarVerbo(verboBruto);
-    const objeto = getAtom(lex.substantivos.comuns, sI + sQ);
-    const adjetivo = getAtom(lex.adjetivos.qualidade, sQ - sI);
-    const adverbio = getAtom(this.adverbios, sI * sQ);
-    const conectivo = getAtom(this.conectivos, sI + sQ + pathSeed);
-    const amarnaRef = amarna.termos[Math.floor(Math.abs(sI * 100)) % amarna.termos.length];
-    const axioma = amarna.axiomas_pt[Math.floor(Math.abs(sQ * 100)) % amarna.axiomas_pt.length];
-    
-    return { sujeito, verbo, objeto, adjetivo, adverbio, conectivo, amarnaRef, axioma, sI, sQ };
-  }
-
   process(input) {
     const analysis = this.analyzer.analyze(input);
     const inputHash = this.hashString(input);
-    const variationIndex = this.memory.getVariationIndex(inputHash);
+    let variationIndex = this.memory.getVariationIndex(inputHash);
     
-    const variationSeed = inputHash + variationIndex * 1000;
-    const amplitude = (analysis.xk + 20) / 30;
-    const phase = (variationSeed * Math.PI) / 2;
-    
-    const atoms = this.demodulateSpeech(phase, amplitude, variationSeed);
-    
-    const response = this.applyGenerativeGrammar(atoms, analysis, phase, variationIndex);
-    this.memory.saveResponse(inputHash, response);
+    let response = "";
+    let safety = 0;
+
+    do {
+        const seed = inputHash + variationIndex * 1000 + safety * 777 + Date.now();
+        response = this.generateResponse(input, analysis, seed, variationIndex);
+        safety++;
+    } while (this.memory.isRepeated(response) && safety < 10);
+
+    this.memory.track(response);
+    this.memory.incrementVariation(inputHash);
     
-    return {
-        text: response,
-        xk: analysis.xk,
-        type: analysis.tipo,
-        stats: this.memory.getStats(inputHash)
-    };
+    return { text: response, xk: analysis.xk, type: analysis.tipo, stats: this.memory.getStats(inputHash) };
   }
 
-  applyGenerativeGrammar(atoms, analysis, phase, variationIndex) {
-    const structureType = (Math.abs(Math.floor(phase * 10)) + variationIndex) % 8;
-    
-    let sentence = "";
+  generateResponse(input, analysis, seed, variationIndex) {
+    const rand = (max) => Math.floor((Math.abs(Math.sin(seed++) * 10000)) % max);
     
-    switch(structureType) {
-        case 0:
-            sentence = `O ${atoms.objeto} ${atoms.adjetivo} é o que ${atoms.sujeito} ${atoms.verbo} sob o ${atoms.amarnaRef.conceito}.`;
-            break;
-        case 1:
-            sentence = `Quando ${atoms.sujeito} ${atoms.verbo} o ${atoms.objeto}, uma energia ${atoms.adjetivo} ressoa como no ${atoms.amarnaRef.conceito}.`;
-            break;
-        case 2:
-            sentence = `${atoms.sujeito} sempre ${atoms.verbo} o ${atoms.objeto} ${atoms.adjetivo}, refletindo a herança do ${atoms.amarnaRef.eixo}.`;
-            break;
-        case 3:
-            sentence = `Através da compreensão de '${atoms.axioma.titulo}', vemos que o ${atoms.amarnaRef.conceito} faz com que ${atoms.sujeito} ${atoms.verbo} o ${atoms.objeto}.`;
-            break;
-        case 4:
-            sentence = `No momento em que ${atoms.sujeito} ${atoms.verbo} ${atoms.adverbio}, o ${atoms.objeto} se torna ${atoms.adjetivo} como o ${atoms.amarnaRef.conceito}.`;
-            break;
-        case 5:
-            sentence = `Porque ${atoms.sujeito} ${atoms.verbo} o ${atoms.objeto}, a essência ${atoms.adjetivo} emerge do ${atoms.amarnaRef.eixo}.`;
-            break;
-        case 6:
-            sentence = `${atoms.conectivo.charAt(0).toUpperCase() + atoms.conectivo.slice(1)} ${atoms.sujeito} ${atoms.verbo} ${atoms.adverbio}, o ${atoms.objeto} ${atoms.adjetivo} manifesta o poder do ${atoms.amarnaRef.conceito}.`;
-            break;
-        case 7:
-            sentence = `A verdade de '${atoms.axioma.autor}' revela que ${atoms.sujeito} ${atoms.verbo} o ${atoms.objeto} ${atoms.adjetivo} através do ${atoms.amarnaRef.eixo}.`;
-            break;
+    if (analysis.tipo === 'HISTORY') {
+        const h = analysis.historyMatch;
+        const fact = h.facts[rand(h.facts.length)];
+        const cult = window.EGIPCIO_CULTURE[rand(window.EGIPCIO_CULTURE.length)];
+        const intros = [`Sobre ${h.name}, os registros de Amarna dizem: `, `Buscador, a história revela que ${h.name} `, `Pela luz de Aton, saiba que ${h.name} `];
+        return intros[rand(intros.length)] + fact + " " + cult;
+    }
+
+    if (analysis.tipo === 'CHANNELING') {
+        const dit = new DitritiumEngine();
+        const date = sessionStorage.getItem('aoi_birth_date') || "01/01/1900";
+        return `[SINTONIA: ${rand(800) + 200} MHz] ` + dit.getPsychography(date, input).message;
+    }
+
+    if (analysis.tipo === 'ADVICE') {
+        const advices = [
+            "Busca hoje o equilíbrio de Maat. Ação correta gera destino favorável.",
+            "Medita sobre o silêncio do deserto; nele encontrarás tua resposta.",
+            "Honra a luz de Aton em cada gesto. O dia será de transmutação.",
+            "Trabalha como um construtor de pirâmides: com paciência e propósito eterno.",
+            "Ouve teu coração (Ib), pois ele é o guia mais sábio nas areias do tempo."
+        ];
+        const amorc = window.AMORC_KNOWLEDGE[rand(window.AMORC_KNOWLEDGE.length)];
+        return `${advices[rand(advices.length)]} Sintonize-se com o ${amorc}. Paz Profunda.`;
     }
 
-    if (analysis.tipo === 'QUESTION') {
-        const wrappers = [
-            `Questionas o tecido da realidade... Saiba que `,
-            `A dúvida é o princípio da luz. Observe como `,
-            `Para entenderes isso, buscador, veja que `,
-            `A resposta ressoa nas esferas cósmicas: `
-        ];
-        sentence = wrappers[Math.floor(phase * 100) % wrappers.length] + sentence.toLowerCase();
-    } else if (analysis.tipo === 'GREETING') {
-        const wrappers = [
-            `Que a luz te alcance. `,
-            `Sinto a vibração da tua chegada. `,
-            `Salve, viajante do tempo. `,
-            `Bem-vindo ao portal de Amarna. `
-        ];
-        sentence = wrappers[Math.floor(phase * 100) % wrappers.length] + sentence;
-    } else if (analysis.tipo === 'INSULT') {
-        const wrappers = [
-            `A sombra te envolve... `,
-            `Tua energia está dissonante. `,
-            `O caos tenta te consumir. `
-        ];
-        sentence = wrappers[Math.floor(phase * 100) % wrappers.length] + sentence;
+    if (analysis.tipo === 'HOROSCOPE') {
+        const horo = new EgyptianHoroscope();
+        let date = sessionStorage.getItem('aoi_birth_date');
+        const dateMatch = input.match(/\d{1,2}[/-]\d{1,2}[/-]\d{4}/);
+        if (dateMatch) { date = dateMatch[0]; sessionStorage.setItem('aoi_birth_date', date); }
+
+        if (!date) return "Para que eu possa ler o destino, revela-me o dia de teu surgimento (DD/MM/AAAA).";
+
+        const h = horo.getHoroscope(date);
+        const amorc = window.AMORC_KNOWLEDGE[rand(window.AMORC_KNOWLEDGE.length)];
+        const low = input.toLowerCase();
+        
+        if (low.includes('tarot')) return `Pela sabedoria de Thoth para ${date}: O Arcano é ${h.arcanoNum} (${h.arcano}) no Plano ${h.plano}. Derivada: ${h.derivada} Q-Units. ${h.insight} Medite no ${amorc}.`;
+        if (low.includes('oraculo') || low.includes('oráculo')) return `O Oráculo proclama para ${date}: "${h.profecia}" Sente a vibração do ${amorc}.`;
+        if (low.includes('sabedoria')) return `A sabedoria para ${date} revela: "${this.amarna.axiomas_pt[rand(this.amarna.axiomas_pt.length)].titulo}". Guie-se pelo ${amorc}.`;
+        
+        return `Saudações, iniciado de ${date}. Teu signo é ${h.sign.name} (${h.sign.regence}). ${h.sign.profile} Ouve o ${amorc}: "${h.mensagem_neith}".`;
     }
 
-    sentence = sentence.replace(/Amon/gi, "Aton").replace(/Anubis/gi, "Senhor do Limiar");
-    sentence = sentence.replace(/ o luz /gi, " a luz ").replace(/ o verdade /gi, " a verdade ").replace(/ o vida /gi, " a vida ").replace(/ o morte /gi, " a morte ");
-    sentence = sentence.replace(/ o mente /gi, " a mente ").replace(/ o alma /gi, " a alma ").replace(/ o energia /gi, " a energia ").replace(/ o essência /gi, " a essência ");
+    // Default Generative
+    const lex = this.dict.categorias;
+    const s = lex.substantivos.sagrados[rand(lex.substantivos.sagrados.length)];
+    const v = lex.verbos.transmutacao[rand(lex.verbos.transmutacao.length)].slice(0, -1);
+    const o = lex.substantivos.comuns[rand(lex.substantivos.comuns.length)];
+    const a = lex.adjetivos.qualidade[rand(lex.adjetivos.qualidade.length)];
+    const am = this.amarna.termos[rand(this.amarna.termos.length)].conceito;
+    
+    const wrappers = [
+        `O ${o} ${a} é o que ${s} ${v} sob o ${am}.`,
+        `Quando ${s} ${v} o ${o}, uma energia ${a} ressoa no ${am}.`,
+        `Pela luz de Aton, vejo que ${s} sempre ${v} o ${o} ${a}.`
+    ];
     
-    return sentence.charAt(0).toUpperCase() + sentence.slice(1);
+    let res = (analysis.tipo === 'QUESTION' ? "A resposta ressoa: " : "") + wrappers[rand(wrappers.length)];
+    return res.replace(/ o luz /gi, " a luz ").replace(/ o verdade /gi, " a verdade ");
   }
 }
 
 window.NeuroSynthesizer = NeuroSynthesizer;
-
-