Refactor MEC MVP pipeline: Integrate Codex Informer, HEIInference, and confidence routing logic

core/codex_informer.py

@@ -3,20 +3,56 @@
 import yaml
 
 class CodexInformer:
-    def __init__(self, emotion_families_path, blend_states_path, sal_triggers_path, meta_mappings_path):
-        self.emotion_families = self.load_yaml(emotion_families_path)
-        self.blend_states = self.load_yaml(blend_states_path)
-        self.sal_triggers = self.load_yaml(sal_triggers_path)
-        self.meta_mappings = self.load_yaml(meta_mappings_path)
+    _instance = None  # Singleton pattern to ensure only one instance
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(CodexInformer, cls).__new__(cls)
+            # Load the emotion families, sal triggers, and meta mappings from YAML files
+            cls._instance.load_data()
+        return cls._instance
+
+    def load_data(self):
+        # Load YAML data for emotion families, sal triggers, and meta mappings
+        self.emotion_families = self.load_yaml('config/emotion_families.yaml')['emotion_families']
+        self.sal_triggers = self.load_yaml('config/sal_triggers.yaml')['sal_triggers']
+        self.meta_mappings = self.load_yaml('config/meta_mappings.yaml')['meta_mappings']
 
     def load_yaml(self, path):
+        # Loads the YAML file and returns the parsed data
         with open(path, 'r', encoding='utf-8') as f:
             return yaml.safe_load(f)
 
+    def get_emotion_family(self, emotion_name):
+        # Retrieve the emotion family code based on emotion name (e.g., "joy" -> "FAM-JOY")
+        for family in self.emotion_families:
+            if family['name'].lower() == emotion_name.lower():
+                return family['code']
+        return "Unknown"
+
+    def get_arc(self, emotion_code):
+        # Retrieve the arc for the given emotion code (this can be enhanced to map arc based on emotion family)
+        return self.get_emotion_family(emotion_code)  # Placeholder for arc mapping logic
+
+    def get_resonance(self, emotion_code):
+        # Retrieve the resonance for the given emotion code (this can be enhanced to map resonance patterns)
+        return self.get_emotion_family(emotion_code)  # Placeholder for resonance mapping logic
+
+    def map_emotion_to_codex(self, emotion):
+        # Logic to map general emotion to Codex key (e.g., 'anger' -> 'FAM-ANG')
+        emotion_map = {
+            "joy": "FAM-JOY",
+            "anger": "FAM-ANG",
+            "fear": "FAM-FEA",
+            "sadness": "FAM-SAD",
+            "love": "FAM-LOV",
+        }
+        return emotion_map.get(emotion.lower(), "Unknown")
+
     def map_tokens_to_codex(self, token_stream):
         codex_hits = []
         for token in token_stream:
-            for trigger in self.sal_triggers['sal_triggers']:
+            for trigger in self.sal_triggers:
                 if trigger['trigger'].lower() in token.lower():
                     codex_hits.append({
                         'type': 'SAL_TRIGGER',
@@ -27,7 +63,7 @@ class CodexInformer:
         return codex_hits
 
     def lookup_meta_mapping(self, meta_marker):
-        for meta in self.meta_mappings['meta_mappings']:
+        for meta in self.meta_mappings:
             if meta['marker'] == meta_marker:
                 return meta
         return None

core/confidence_gate.py

@@ -1,25 +0,0 @@
-# core/confidence_gate.py
-# Master Emotional Core (MEC) - Confidence Gate
-
-class ConfidenceGate:
-    def __init__(self, confidence_threshold=0.65):
-        self.confidence_threshold = confidence_threshold
-
-    def evaluate_confidence(self, esil_packet):
-        confidence_score = esil_packet.get("confidence_score", 0.0)
-
-        if confidence_score >= self.confidence_threshold:
-            routing_decision = "proceed_to_eris"
-        elif confidence_score >= 0.50:
-            routing_decision = "trigger_llm_assist"
-        else:
-            routing_decision = "escalate_to_hei"
-
-        routing_packet = {
-            "confidence_score": confidence_score,
-            "routing_decision": routing_decision,
-            "source_metadata": esil_packet.get("source_metadata", {})
-        }
-
-        print(f"[ConfidenceGate] Packet: {routing_packet}")
-        return routing_packet

core/eil_processor.py

@@ -1,26 +1,59 @@
 # core/eil_processor.py
-# Master Emotional Core (MEC) - EIL Processor
+
+from core.codex_informer import CodexInformer
 
 class EILProcessor:
-    def __init__(self):
-        pass  # No config needed for MVP starter
+    def __init__(self, signal_floor=0.2, max_token_length=1024, enable_noise_filter=True):
+        self.signal_floor = signal_floor
+        self.max_token_length = max_token_length
+        self.enable_noise_filter = enable_noise_filter
+        # Initialize Codex Informer for shared emotion lookups
+        self.codex_informer = CodexInformer()
+
+    def preprocess_text(self, raw_text):
+        # Basic text normalization (simulating real preprocessing)
+        normalized_text = raw_text.strip().lower()
+
+        # Simulate preprocessing packet
+        preprocessing_packet = {
+            "normalized_text": normalized_text,
+            "length": len(normalized_text)
+        }
+        print(f"[EILProcessor] Preprocessing Packet: {preprocessing_packet}")
+        return preprocessing_packet
 
     def process_eil(self, preprocessing_packet):
+        # Now handle both preprocessing and EIL processing here in a single step
         normalized_text = preprocessing_packet.get("normalized_text", "")
 
-        # Placeholder logic for MVP:
-        # Split into phrases, tag as candidates
-        phrases = normalized_text.split(".")  # Very simple split
+        # Simple placeholder logic: split into phrases and tag emotion candidates
+        phrases = normalized_text.split(".")  # Simple split based on periods
+
+        # Retrieve emotion family, arc, and resonance using Codex Informer
+        # For now, we're mapping to a sample emotion code "happy_code", this should be dynamic
+        emotion_code = "joy"  # Example emotion, this should be extracted based on text analysis
+
+        emotion_family = self.codex_informer.get_emotion_family(emotion_code)  # Resolve emotion family
+        arc = self.codex_informer.get_arc(emotion_code)  # Resolve emotion arc
+        resonance = self.codex_informer.get_resonance(emotion_code)  # Resolve resonance
+
+        # If we don't find a match, we can use a fallback or 'hidden emotion' state
+        if emotion_family == "Unknown":
+            emotion_family = "Hidden Emotion Detected"  # Placeholder for hidden emotion
 
+        # Build the EIL packet with additional emotion data from Codex Informer
         eil_packet = {
             "phrases": phrases,
             "emotion_candidates": [
                 {"phrase": p.strip(), "candidate_emotion": "Pending"} for p in phrases if p.strip()
             ],
             "metadata": {
-                "source": "InputPreprocessor"
-            }
+                "source": "InputPreprocessor + EILProcessor"
+            },
+            "emotion_family": emotion_family,  # From Codex Informer
+            "arc": arc,  # From Codex Informer
+            "resonance": resonance  # From Codex Informer
         }
 
-        print(f"[EILProcessor] Packet: {eil_packet}")
+        print(f"[EILProcessor] EIL Packet: {eil_packet}")
         return eil_packet

core/eris_reasoner.py

@@ -1,10 +1,12 @@
 import hashlib
 import time
+from core.codex_informer import CodexInformer
 from core.hei_inference import HEIInference
 
 class ERISReasoner:
     def __init__(self):
-        pass
+        # Initialize Codex Informer as part of ERIS
+        self.codex_informer = CodexInformer()
 
     def reason_emotion_state(self, esil_packet):
         # Generate EmID (using user_id + primary_emotion + timestamp)
@@ -14,19 +16,24 @@ class ERISReasoner:
         primary_emotion_code = esil_packet.get("primary_emotion_code", "UNK")
         emotion_family = esil_packet.get("emotion_family", "UNK")
 
+        # Retrieve emotion arc and resonance from Codex Informer (shared service)
+        arc = self.codex_informer.get_arc(primary_emotion_code)
+        resonance = self.codex_informer.get_resonance(primary_emotion_code)
+
         # Start building the UESP Packet
         uesp_packet = {
             "Primary Emotion": primary_emotion,
             "Primary Emotion Code": primary_emotion_code,
-            "Emotion Arc Trajectory": esil_packet.get("arc", "ARC-000-UNK"),
-            "Resonance Pattern": esil_packet.get("resonance", "RES-000"),
-            "HEART Compliance Flags": ["HVC-000"],  # You can update based on real conditions
+            "Emotion Arc Trajectory": arc,  # From Codex Informer
+            "Resonance Pattern": resonance,  # From Codex Informer
+            "HEART Compliance Flags": ["HVC-000"],  # Placeholder, can be updated based on conditions
             "Empathy First Response": esil_packet.get("response", "Emotion being processed..."),
             "emotion_family": emotion_family  # Always include this
         }
 
         # If the packet is empty or has no emotion_family, we call HEI for fallback
         if emotion_family == "UNK" or not emotion_family:
+            print("[ERIS] No valid emotion family found — triggering HEI fallback...")
             hei = HEIInference()
             uesp_packet = hei.detect_low_signal(uesp_packet)  # HEI will generate a valid packet if needed
 

core/esil_inference.py

@@ -1,10 +1,15 @@
 # core/esil_inference.py
 # Master Emotional Core (MEC) - ESIL Inference
 
+from core.codex_informer import CodexInformer
+
 class ESILInference:
-    def __init__(self, enable_gradient_blending=True, blend_maximum=3):
+    def __init__(self, enable_gradient_blending=True, blend_maximum=3, confidence_threshold=0.65):
         self.enable_gradient_blending = enable_gradient_blending
         self.blend_maximum = blend_maximum
+        self.confidence_threshold = confidence_threshold
+        # Initialize Codex Informer for shared emotion lookups
+        self.codex_informer = CodexInformer()
 
     def infer_esil(self, eil_packet):
         phrases = eil_packet.get("phrases", [])
@@ -12,21 +17,45 @@ class ESILInference:
 
         # Trigger HEI if vague phrases detected:
         low_conf_phrases = ["meh", "...", "idk", "whatever", "fine"]
-
+        
+        # Check if any low-confidence phrases are present
         if any(lp in phrases for lp in low_conf_phrases):
             confidence_score = 0.3
         else:
             confidence_score = 0.85
 
+        # Retrieve emotion family, arc, and resonance from Codex Informer
+        primary_emotion_code = eil_packet.get("primary_emotion_code", "UNK")
+        emotion_family = self.codex_informer.get_emotion_family(primary_emotion_code)
+        arc = self.codex_informer.get_arc(primary_emotion_code)
+        resonance = self.codex_informer.get_resonance(primary_emotion_code)
+
+        # If no emotion family is found, flag it as a "hidden emotion"
+        if emotion_family == "Unknown":
+            emotion_family = "Hidden Emotion Detected"  # Fallback for hidden emotion logic
+
+        # Build ESIL packet with updated emotion data from Codex Informer
         esil_packet = {
             "blend_weights": [
                 {"emotion": "Pending", "weight": 0.8}
             ],
             "trajectory": "Stable",
             "confidence_score": confidence_score,
-            "source_metadata": eil_packet.get("metadata", {})
+            "emotion_family": emotion_family,  # From Codex Informer
+            "arc": arc,  # From Codex Informer
+            "resonance": resonance,  # From Codex Informer
+            "source_metadata": eil_packet.get("metadata", {}),
+            "tokens": phrases
         }
 
-        esil_packet['tokens'] = phrases
-        print(f"[ESILInference] Packet: {esil_packet}")
+        # Confidence routing logic: Directly to ERIS if confidence is high
+        if confidence_score >= self.confidence_threshold:
+            routing_decision = "proceed_to_eris"
+        # Trigger HEI if confidence is low and unresolved
+        elif confidence_score < self.confidence_threshold:
+            routing_decision = "escalate_to_hei"
+
+        esil_packet['routing_decision'] = routing_decision
+        print(f"[ESILInference] ESIL Packet with Routing Decision: {esil_packet}")
+        
         return esil_packet

core/hei_inference.py

@@ -2,24 +2,30 @@
 
 import yaml
 import datetime
+from core.codex_informer import CodexInformer  # Ensure CodexInformer is imported
 
 class HEIInference:
     def __init__(self):
-        # Load config files
+        # Load config files for SAL triggers and meta mappings
         self.sal_triggers = self.load_yaml('config/sal_triggers.yaml')
         self.meta_mappings = self.load_yaml('config/meta_mappings.yaml')
+        
+        # Initialize Codex Informer as a persistent service
+        self.codex_informer = CodexInformer()
 
     def load_yaml(self, path):
         with open(path, 'r', encoding='utf-8') as f:
             return yaml.safe_load(f)
 
     def lookup_meta_mapping(self, meta_marker):
-        for meta in self.meta_mappings['meta_mappings']:
+        # Look up a META marker in the provided mapping
+        for meta in self.meta_mappings:
             if meta['marker'] == meta_marker:
                 return meta
         return None
 
     def detect_low_signal(self, failed_esil_packet):
+        # Generate a pseudo ESIL packet when low signal is detected
         pseudo_esil_packet = {
             'pseudo_esil_packet_id': f"PSUESP-{datetime.datetime.now().isoformat()}",
             'detected_tokens': failed_esil_packet.get('tokens', []),
@@ -31,10 +37,11 @@ class HEIInference:
 
         # Check for SAL triggers in tokens
         for token in pseudo_esil_packet['detected_tokens']:
-            for trigger in self.sal_triggers['sal_triggers']:
-                if trigger['trigger'].lower() in token.lower():
-                    pseudo_esil_packet['sal_trigger_flags'].append(trigger['flag'])
-                    pseudo_esil_packet['reasoning_flags'].append(f"SAL_MATCH-{trigger['flag']}")
+            for trigger in self.sal_triggers['sal_triggers']:  # Make sure this is a list of dictionaries
+                if isinstance(trigger, dict) and 'trigger' in trigger:
+                    if trigger['trigger'].lower() in token.lower():
+                        pseudo_esil_packet['sal_trigger_flags'].append(trigger['flag'])
+                        pseudo_esil_packet['reasoning_flags'].append(f"SAL_MATCH-{trigger['flag']}")
 
         # Check for META markers if present
         if 'meta_marker' in failed_esil_packet:
@@ -47,12 +54,28 @@ class HEIInference:
                 }
                 pseudo_esil_packet['reasoning_flags'].append(f"META_INFER-{meta['marker']}")
 
+        # Retrieve emotion data (family, arc, resonance) from Codex Informer
+        primary_emotion_code = failed_esil_packet.get("primary_emotion_code", "UNK")
+        emotion_family = self.codex_informer.get_emotion_family(primary_emotion_code)
+        arc = self.codex_informer.get_arc(primary_emotion_code)
+        resonance = self.codex_informer.get_resonance(primary_emotion_code)
+
+        # If no emotion family is found, flag it as a "hidden emotion"
+        if emotion_family == "Unknown":
+            emotion_family = "Hidden Emotion Detected"  # Fallback for hidden emotion logic
+
+        # Add the emotion family, arc, and resonance to the pseudo ESIL packet
+        pseudo_esil_packet['emotion_family'] = emotion_family
+        pseudo_esil_packet['arc'] = arc
+        pseudo_esil_packet['resonance'] = resonance
+
         # Log for audit
         self.log_audit(pseudo_esil_packet)
 
         return pseudo_esil_packet
 
     def log_audit(self, packet):
+        # Log audit for HEI inference process
         print("---- HEI Inference Audit Log ----")
         print(f"Packet ID: {packet['pseudo_esil_packet_id']}")
         print(f"Timestamp: {packet['timestamp']}")

core/input_preprocessor.py

@@ -1,21 +0,0 @@
-# core/input_preprocessor.py
-# Master Emotional Core (MEC) - Input Preprocessor
-
-class InputPreprocessor:
-    def __init__(self, signal_floor=0.2, max_token_length=1024, enable_noise_filter=True):
-        self.signal_floor = signal_floor
-        self.max_token_length = max_token_length
-        self.enable_noise_filter = enable_noise_filter
-
-    def preprocess_text(self, raw_text):
-        # Basic text normalization placeholder
-        normalized_text = raw_text.strip().lower()
-        # Simulate preprocessing packet
-        preprocessing_packet = {
-            "normalized_text": normalized_text,
-            "length": len(normalized_text)
-        }
-        print(f"[InputPreprocessor] Packet: {preprocessing_packet}")
-        return preprocessing_packet
-
-    # Audio and video preprocessing would be added here in full system

main.py

@@ -1,7 +1,5 @@
-from core.input_preprocessor import InputPreprocessor
 from core.eil_processor import EILProcessor
 from core.esil_inference import ESILInference
-from core.confidence_gate import ConfidenceGate
 from core.eris_reasoner import ERISReasoner
 from core.hei_inference import HEIInference
 from core.fec_controller import FECController
@@ -10,50 +8,46 @@ def run_pipeline(user_input_text, force_hei=False):
     print("\n--- MEC MVP Test Run ---")
     print(f"[Main] Pipeline Input: {user_input_text}")
 
-    # 1️⃣ Preprocessor
-    pre = InputPreprocessor()
-    pre_packet = pre.preprocess_text(user_input_text)
-    print(f"[Main] Preprocessing Packet Output: {pre_packet}")
-
-    # 2️⃣ EIL Processor
+    # 1️⃣ EIL Processor (handles both preprocessing and emotion processing)
     eil = EILProcessor()
+    # Preprocess the input text first
+    pre_packet = eil.preprocess_text(user_input_text)
+    # Now pass the preprocessing packet to process_eil
     eil_packet = eil.process_eil(pre_packet)
     print(f"[Main] EIL Packet Output: {eil_packet}")
 
-    # 3️⃣ ESIL Inference
+    # 2️⃣ ESIL Inference
     esil = ESILInference()
     esil_packet = esil.infer_esil(eil_packet)
 
-    # FORCED HEI MODE:
+    # 3️⃣ Forced HEI Mode: Ensure it forces the low confidence path if True
     if force_hei:
         print("\n[Main] FORCE HEI MODE ENABLED — Routing to HEI Inference")
         esil_packet['confidence_score'] = 0.40  # force low confidence to trigger HEI
 
     print(f"[Main] ESIL Packet Output: {esil_packet}")
 
-    # 4️⃣ Confidence Gate
-    gate = ConfidenceGate()
-    route = gate.evaluate_confidence(esil_packet)
-    print(f"[Main] Confidence Gate Output: {route}")
-
     # Routing logic:
-    if route['routing_decision'] == "proceed_to_eris":
+    if esil_packet['confidence_score'] >= 0.65:
         print("\n[Main] Routing: proceed_to_eris")
+        # 4️⃣ ERIS Reasoning (Final UESP Creation)
         eris = ERISReasoner()
         final_uesp = eris.reason_emotion_state(esil_packet)
         print(f"[Main] ERIS Packet Output: {final_uesp}")
 
+        # 5️⃣ FEC Controller (Final Fusion Prompt)
         fec = FECController()
         fusion_prompt = fec.generate_prompt(final_uesp)
         print(f"[Main] Final Fusion Prompt:\n{fusion_prompt}")
 
-    elif route['routing_decision'] == "escalate_to_hei":
+    elif esil_packet['confidence_score'] < 0.65:
         print("\n[Main] Routing: escalate_to_hei")
+        # 6️⃣ Trigger HEI Inference (Fallback for Low Confidence)
         hei = HEIInference()
         pseudo_esil = hei.detect_low_signal(esil_packet)
         print(f"[Main] Pseudo-ESIL Output:\n{pseudo_esil}")
 
-        # ⬇️ Correct architecture: continue to ERIS → UESP → FEC
+        # 7️⃣ Post-HEI Path: Continue to ERIS → UESP → FEC
         print("\n[Main] Continuing to ERIS Reasoner (Post-HEI Path)")
         eris = ERISReasoner()
         final_uesp = eris.reason_emotion_state(pseudo_esil)
@@ -68,7 +62,7 @@ def run_pipeline(user_input_text, force_hei=False):
 
 if __name__ == "__main__":
     # Example input that matches a SAL Trigger:
-    test_input = "I am okay, really"
+    test_input = "I'm okay, really"
 
     # Run in FORCE HEI mode → set to True to test Symbolic Layer
-    run_pipeline(test_input, force_hei=False)
+    run_pipeline(test_input, force_hei=True)