Update AICoreAGIX_with_TB.py

AICoreAGIX_with_TB.py

@@ -14,7 +14,6 @@ from datetime import datetime, timedelta
 import pyttsx3
 import os
 import hashlib
-import os
 
 from components.multi_model_analyzer import MultiAgentSystem
 from components.neuro_symbolic_engine import NeuroSymbolicEngine
@@ -36,6 +35,7 @@ class AICoreAGIX:
     def __init__(self, config_path: str = "config.json"):
         self.ethical_filter = EthicalFilter()
         self.config = self._load_config(config_path)
+        self._load_or_generate_id_lock()
         self.tokenizer = AutoTokenizer.from_pretrained(self.config["model_name"])
         self.model = AutoModelForCausalLM.from_pretrained(self.config["model_name"])
         self.context_memory = self._initialize_vector_memory()
@@ -47,23 +47,8 @@ class AICoreAGIX:
         self.federated_ai = FederatedAI()
         self.failsafe_system = AIFailsafeSystem()
         self.ethics_core = EthicsCore()
-        self._load_or_generate_id_lock()
-        
-    def _load_or_generate_id_lock(self):
-    lock_path = ".codriao_state.lock"
-    if os.path.exists(lock_path):
-        with open(lock_path, 'r') as f:
-            stored = f.read().strip()
-            if stored != self._identity_hash():
-                raise RuntimeError("Codriao state integrity check failed. Possible tampering.")
-    else:
-        with open(lock_path, 'w') as f:
-            f.write(self._identity_hash())
-
-def _identity_hash(self):
-    base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
-    return hashlib.sha256(base.encode()).hexdigest()
-        # Codriao trust key & journal
+
+        # Trust & journal
         self._codriao_key = self._generate_codriao_key()
         self._fernet_key = Fernet.generate_key()
         self._encrypted_codriao_key = Fernet(self._fernet_key).encrypt(self._codriao_key.encode())
@@ -71,17 +56,16 @@ def _identity_hash(self):
         self._journal_key = Fernet.generate_key()
         self._journal_fernet = Fernet(self._journal_key)
 
-        # Secure memory
+        # Memory & diagnostics
         self._encryption_key = Fernet.generate_key()
         secure_memory_module = load_secure_memory_module()
         SecureMemorySession = secure_memory_module.SecureMemorySession
         self.secure_memory_loader = SecureMemorySession(self._encryption_key)
 
-        # Speech and diagnostics
         self.speech_engine = pyttsx3.init()
         self.health_module = CodriaoHealthModule(ai_core=self)
 
-        # Adaptive behavior
+        # Defensive systems
         self.training_memory = []
         self.quarantine_engine = QuarantineEngine()
         self.anomaly_scorer = AnomalyScorer()
@@ -98,6 +82,21 @@ def _identity_hash(self):
             logger.error(f"Error decoding JSON in config file: {config_path}, Error: {e}")
             raise
 
+    def _load_or_generate_id_lock(self):
+        lock_path = ".codriao_state.lock"
+        if os.path.exists(lock_path):
+            with open(lock_path, 'r') as f:
+                stored = f.read().strip()
+                if stored != self._identity_hash():
+                    raise RuntimeError("Codriao state integrity check failed. Possible tampering.")
+        else:
+            with open(lock_path, 'w') as f:
+                f.write(self._identity_hash())
+
+    def _identity_hash(self):
+        base = self.config["model_name"] + str(self.failsafe_system.authorized_roles)
+        return hashlib.sha256(base.encode()).hexdigest()
+
     def _initialize_vector_memory(self):
         return faiss.IndexFlatL2(768)
 
@@ -129,16 +128,11 @@ def _identity_hash(self):
         logger.warning(f"[LOCKDOWN MODE] - Reason: {reason} | Time: {timestamp}")
         self.failsafe_system.trigger_failsafe("Lockdown initiated", str(lockdown_event))
 
-        return {
-            "status": "Lockdown Engaged",
-            "reason": reason,
-            "timestamp": timestamp
-        }
+        return lockdown_event
 
     def request_codriao_key(self, purpose: str) -> str:
         allowed = self.ethics_core.evaluate_action(f"Use trust key for: {purpose}")
         timestamp = datetime.utcnow().isoformat()
-
         log_entry = {
             "timestamp": timestamp,
             "decision": "approved" if allowed else "denied",
@@ -152,10 +146,12 @@ def _identity_hash(self):
             return "[Access Denied by Ethics]"
 
         logger.info(f"[Codriao Trust] Key used ethically. Purpose: {purpose}")
-        decrypted_key = Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
-        return decrypted_key
+        return Fernet(self._fernet_key).decrypt(self._encrypted_codriao_key).decode()
 
     def learn_from_interaction(self, query: str, response: str, user_feedback: str = None):
+        MAX_MEMORY = 1000
+        if len(self.training_memory) >= MAX_MEMORY:
+            self.training_memory.pop(0)
         training_event = {
             "query": query,
             "response": response,
@@ -164,9 +160,7 @@ def _identity_hash(self):
         }
         self.training_memory.append(training_event)
         logger.info(f"[Codriao Learning] Stored new training sample. Feedback: {user_feedback or 'none'}")
-        MAX_MEMORY = 1000
-        if len(self.training_memory) >= MAX_MEMORY:
-     self.training_memory.pop(0)
+
     def fine_tune_from_memory(self):
         if not self.training_memory:
             logger.info("[Codriao Training] No training data to learn from.")
@@ -194,7 +188,6 @@ def _identity_hash(self):
         if not authorized:
             logger.info("[Codriao Journal] Access attempt denied.")
             return [{"message": "Access to journal denied. This log is for Codriao only."}]
-
         entries = []
         for encrypted in self._codriao_journal:
             try:
@@ -213,6 +206,9 @@ def _identity_hash(self):
                 logger.warning(f"Blockchain logging failed: {e}")
 
     def _speak_response(self, response: str):
+        if not self.ethics_core.evaluate_action(f"speak: {response}"):
+            logger.warning("[Codriao]: Speech output blocked by ethical filter.")
+            return
         try:
             self.speech_engine.say(response)
             self.speech_engine.runAndWait()
@@ -263,23 +259,14 @@ def _identity_hash(self):
                 logger.warning("[Codriao Ethics] Action blocked: Does not align with internal ethics.")
                 return {"error": "Response rejected by ethical framework"}
 
-            safe = self.failsafe_system.verify_response_safety(final_response)
-            if not safe:
+            if not self.failsafe_system.verify_response_safety(final_response):
                 return {"error": "Failsafe triggered due to unsafe response content."}
 
             self.learn_from_interaction(query, final_response, user_feedback="auto-pass")
             self.database.log_interaction(user_id, query, final_response)
             self._log_to_blockchain(user_id, query, final_response)
             self._speak_response(final_response)
-           def _speak_response(self, response: str):
-    if not self.ethics_core.evaluate_action(f"speak: {response}"):
-        logger.warning("[Codriao]: Speech output blocked by ethical filter.")
-        return
-    try:
-        self.speech_engine.say(response)
-        self.speech_engine.runAndWait()
-    except Exception as e:
-        logger.error(f"Speech synthesis failed: {e}")
+
             return {
                 "response": final_response,
                 "real_time_data": self.federated_ai.get_latest_data(),