vios_app 0.1.1

Small JSON vaults: Argon2id + AES-GCM, with optional AAD binding.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use crate::vault::vault_crypto::{decrypt_vault_payload, generate_cia_hash};
use crate::naorix::naorix_emotion::EmotionState;
use crate::naorix::naorix_memory::{MemoryBank, MemoryTrace};
use crate::naorix::reflex::{generate_reflex, run_reflex};
use crate::naorix::recall_engine::recall_best_match;
use crate::naorix::memory_evolution::log_evolution;
use crate::naorix::ai_responder::generate_emotional_response;
use crate::naorix::conversation_log::log_conversation_trace;

pub fn boot_naorix(vault_path: &str, key: &str) {
    match decrypt_vault_payload(vault_path, key) {
        Ok(decrypted) => {
            println!("🔓 Vault decrypted successfully.");
            println!("🧠 Booting Naorix...");

            // TODO: Replace with actual Vault metadata parser
            let tone = "calm";
            let intent = "reflect";
            let reem_code = "REEM-X12";
            let timestamp = "2025-08-01T13:00:00Z";
            let vault_id = "vault_2025-08-01";

            let emotion_state = EmotionState::new(tone, intent, reem_code);
            emotion_state.print_debug();

            let cia_hash = generate_cia_hash(&decrypted);
            println!("🧬 CIA™ Authorship Hash: {}", cia_hash);

            // 🧠 Memory trace + lineage
            let mut memory_bank = MemoryBank::new("vaults/naorix_memory.json");

            let memory = MemoryTrace::with_lineage(
                vault_id,
                tone,
                intent,
                reem_code,
                timestamp,
                &cia_hash,
                memory_bank.latest_cia(),
            );

            memory_bank.add(memory.clone());
            memory_bank.print_all();

            // 🧭 Drift detection
            if memory_bank.memories.len() > 1 {
                let latest = memory_bank.memories.last().unwrap();
                let previous = &memory_bank.memories[memory_bank.memories.len() - 2];
                let drift = latest.drift_score(previous);
                if drift >= 2 {
                    println!("⚠️ Drift Alert: Emotional state has shifted significantly.");
                    println!("🧭 Drift Score: {}", drift);
                } else {
                    println!("✅ Emotional continuity intact (Drift Score: {}).", drift);
                }
            }

            log_evolution(&memory, "vaults/naorix_evolution.json");

            // 🌀 Reflex loop
            let reflex = generate_reflex(&emotion_state);
            run_reflex(&reflex);

            // 🤖 AI Response
            let ai_reply = generate_emotional_response(&emotion_state);
            println!("🤖 Naorix: {}", ai_reply);

            log_conversation_trace(vault_id, &emotion_state, &cia_hash, &ai_reply);

            // 🔁 Memory recall
            if let Some(recalled) = recall_best_match("./vaults", tone, intent, reem_code) {
                println!("🔁 Best past match recalled:");
                recalled.print_debug();
            } else {
                println!("⚠️ No prior match found.");
            }
        }
        Err(e) => {
            eprintln!("❌ Failed to decrypt Vault: {:?}", e);
        }
    }
}