Fix ERIS primary_emotion_code case sensitivity in Gradio UI; enable robust emotion normalization and blend detection; implement dynamic response strategy mapping; pipeline now correctly identifies and processes anger cues

CHANGELOG.md

@@ -0,0 +1,9 @@
+/README.md
+/LICENSE
+/requirements.txt
+/config/
+/core/
+/tests/
+/main.py
+/app.py (gradio UI)
+CHANGELOG.md   <== goes here

README.md

@@ -9,52 +9,55 @@ app_file: app.py
 pinned: false
 ---
 
-# Master Emotional Core™ (MEC™) — MVP v1.0
+# Master Emotional Core™ (MEC™) — MVP v1.1.2
 
-This is the official MVP demonstration of the Master Emotional Core™ (MEC™), built by Dylan D. Mobley as part of the AI Empathy Ethics™ initiative.
+This is the official MVP demonstration of the Master Emotional Core™ (MEC™), built by Dylan D. Mobley as part of the **AI Empathy Ethics™** initiative.
 
 **Purpose:**  
-To demonstrate Functional Empathy — the operational ability of AI systems to ethically recognize, map, and respond to human emotion — in alignment with the HEART Framework™.
+To demonstrate **Functional Empathy** — the operational ability of AI systems to ethically recognize, map, and respond to human emotion — in alignment with the **HEART Framework™**.
 
-**System Architecture:**  
-- Emotional Intelligence Language (EIL)  
-- Emotion State Interchange Language (ESIL)  
-- Emotional Reasoning Inference System (ERIS)  
-- Unified Emotion State Packet (UESP)  
-- Hidden Emotion Inference (HEI)  
-- Fusion Engine Controller (FEC)  
-- Recovery Mode  
-- EmotionID™
+---
+
+## System Architecture
+
+- **Emotional Intelligence Language (EIL)**  
+- **Emotion State Interchange Language (ESIL)**  
+- **Emotion Reasoning Inference System (ERIS)**  
+- **Unified Emotion State Packet (UESP)**  
+- **Hidden Emotion Inference (HEI)**  
+- **Fusion Engine Controller (FEC)**  
+- **Response Strategy Mapping (RSM)**  
+- **Recovery Mode (planned)**  
+- **EmotionID™**
 
-**Demo Frontend:** Gradio (for Hugging Face Spaces)
+---
 
 ## Current Version
 
-**MVP v1.0 — Public Release**  
-Tag: `v1.0.0`  
+**MVP v1.1.2 — Public Demo**  
+Tag: `v1.1.2`  
 Ready for demonstration and Hugging Face Spaces deployment.
 
+See full version history in [CHANGELOG.md](CHANGELOG.md).
+
+---
+
 ## Features in MVP
 
-- Transparent Fusion Prompt output (Codex-compliant)
-- Full UESP Packet (Emotion Reasoning → Intervention → Tone → Cultural Context)
-- Symbolic Reasoning Layer (SAL triggers working)
-- Hidden Emotion Inference (HEI Path)
-- Confidence Gating
-- ERIS Reasoner → UESP → FEC Controller → LLM instruction generation
-- HEART-aligned safety-first architecture
-- Functional Empathy stack ready for public demo
+✅ Transparent Fusion Prompt output (Codex-compliant)  
+✅ Full UESP Packet (Emotion Reasoning → Intervention → Tone → Cultural Context)  
+✅ Simulated Empathic Response — **Response Strategy Code (RSM) included**  
+✅ Symbolic Reasoning Layer (SAL triggers active)  
+✅ Hidden Emotion Inference (HEI Path)  
+✅ Confidence Gating  
+✅ ERIS Reasoner → UESP → FEC Controller → LLM instruction generation  
+✅ HEART-aligned safety-first architecture  
+✅ Functional Empathy stack ready for public demo  
+✅ Gradio-based UI (v1.1.2) with narrative input support
 
 ---
 
 ## How to Run
 
 ```bash
-python main.py
-
-**License:** See LICENSE.md — educational / non-commercial only.
-
----
-
-Empathy first. Not 1984.  
-AI Empathy Ethics™  | HEART Framework™  | Master Emotional Core™ 
+python app.py

config/arc_mapping.yaml

@@ -0,0 +1,15 @@
+arc_mapping:
+  FAM-JOY: Rising
+  FAM-SAD: Falling
+  FAM-ANG: Rising
+  FAM-FEA: Escalating
+  FAM-LOV: Stable
+  FAM-DISG: Rising
+  FAM-CUR: Rising
+  FAM-GUI: Falling
+  FAM-SHA: Falling
+  FAM-SUR: Spike
+  FAM-PLA: Rising
+  FAM-TRU: Stable
+  FAM-HOP: Rising
+  FAM-GRI: Falling

config/blend_states.yaml

@@ -1,22 +1,31 @@
-# blend_states.yaml
-# Symbolic emotional blend states and corresponding codes
-
+# Emotional Blend States
 blend_states:
-  - code: "BLD-001"
-    label: "Grief with longing"
-    components: ["SAD", "LOV"]
-  
-  - code: "BLD-002"
-    label: "Hopeful determination"
-    components: ["HOP", "JOY"]
-  
-  - code: "BLD-003"
-    label: "Suppressed anger"
-    components: ["ANG", "SHA"]
-  
-  - code: "BLD-004"
-    label: "Resigned numbness"
-    components: ["SAD", "DIS"]
-  - code: "BLD-005"
-    label: "Fearful anticipation"
-    components: ["FEA", "HOP"]
+  BLD-JOYGRIEF:
+    label: Joy-Grief Blend
+    components: ["JOY", "GRF"]
+    emotional_signature: "Smiling through tears"
+    use_case: "Remembering someone you miss with love"
+    detection_risk: "Often misread as mood instability"
+    strategies: ["RSM-VALIDATE", "RSM-WARMREFLECT"]
+
+  BLD-FEARANGER:
+    label: Fear-Anger Blend
+    components: ["FEA", "ANG"]
+    emotional_signature: "Shouting while feeling scared"
+    urgency_score: 8.5
+    mitigation: ["INV-GROUND01", "RSM-DEESCALATE"]
+
+  BLD-HOPEPAIN:
+    label: Hope-Pain Blend
+    components: ["HOP", "GRF"]
+    emotional_signature: "Still believing despite suffering"
+    use_case: "Resilience"
+    urgency_score: 6.5
+    strategies: ["RSM-VALIDATE", "RSM-REASSURE"]
+
+  BLD-JOYLOVE:
+    label: Joy-Love Blend
+    components: ["JOY", "LOV"]
+    emotional_signature: "Contentment found in connection"
+    urgency_score: 4.5
+    strategies: ["RSM-CALM", "RSM-COMFORT"]

config/crosswalk.yaml

@@ -0,0 +1,205 @@
+crosswalk:
+  - phrase: "i feel angry"
+    emotion_code: "FAM-ANG"
+
+  - phrase: "i am so mad"
+    emotion_code: "FAM-ANG"
+
+  - phrase: "i'm frustrated"
+    emotion_code: "FAM-ANG"
+
+  - phrase: "this is unfair"
+    emotion_code: "FAM-ANG"
+
+  - phrase: "i feel sad"
+    emotion_code: "FAM-SAD"
+
+  - phrase: "i feel depressed"
+    emotion_code: "FAM-SAD"
+
+  - phrase: "i'm heartbroken"
+    emotion_code: "FAM-SAD"
+
+  - phrase: "i feel grief"
+    emotion_code: "FAM-SAD"
+
+  - phrase: "i am scared"
+    emotion_code: "FAM-FEA"
+
+  - phrase: "i feel anxious"
+    emotion_code: "FAM-FEA"
+
+  - phrase: "i am overwhelmed"
+    emotion_code: "FAM-FEA"
+
+  - phrase: "i feel nervous"
+    emotion_code: "FAM-FEA"
+
+  - phrase: "i feel helpless"
+    emotion_code: "FAM-HEL"
+
+  - phrase: "i feel alone"
+    emotion_code: "FAM-LON"
+
+  - phrase: "i feel lost"
+    emotion_code: "FAM-LON"
+
+  - phrase: "i can't do this anymore"
+    emotion_code: "FAM-HEL"
+
+  - phrase: "i feel ashamed"
+    emotion_code: "FAM-SHA"
+
+  - phrase: "i feel guilty"
+    emotion_code: "FAM-GUI"
+
+  - phrase: "i'm sorry"
+    emotion_code: "FAM-GUI"
+
+  - phrase: "i feel disgusted"
+    emotion_code: "FAM-DIS"
+
+  - phrase: "i feel surprised"
+    emotion_code: "FAM-SUR"
+
+  - phrase: "i feel joy"
+    emotion_code: "FAM-JOY"
+
+  - phrase: "i feel happy"
+    emotion_code: "FAM-JOY"
+
+  - phrase: "i feel grateful"
+    emotion_code: "FAM-JOY"
+
+  - phrase: "i feel love"
+    emotion_code: "FAM-LOV"
+
+  - phrase: "i love you"
+    emotion_code: "FAM-LOV"
+
+  - phrase: "i trust you"
+    emotion_code: "FAM-TRU"
+
+  - phrase: "i'm curious"
+    emotion_code: "FAM-CUR"
+
+  - phrase: "i feel hopeful"
+    emotion_code: "FAM-HOP"
+
+  - phrase: "i feel awe"
+    emotion_code: "FAM-AWE"
+
+  - phrase: "i feel playful"
+    emotion_code: "FAM-PLA"
+
+  - phrase: "i feel neutral"
+    emotion_code: "FAM-NEU"
+
+    # ------------------------------------------------------------
+# STORY_PATTERNS SECTION
+# NOTE: This section is NOT intended to cover full human language.
+# It provides a precision override map for common narrative or story-mode
+# failure cases. It is maintained small — EIL and Codex provide primary coverage.
+# DO NOT ATTEMPT to list every possible human story here.
+# ------------------------------------------------------------
+
+story_patterns:
+  - pattern: "i hate that my anger always gets the best of me"
+    emotion_code: "FAM-ANG"
+    notes: "Anger + Shame blend"
+
+  - pattern: "i wish i could stop feeling so jealous"
+    emotion_code: "FAM-ANG"
+    notes: "Anger-rooted jealousy"
+
+  - pattern: "i feel trapped by my own anxiety"
+    emotion_code: "FAM-FEA"
+    notes: "Fear + Helplessness"
+
+  - pattern: "i can’t forgive myself for what i did"
+    emotion_code: "FAM-GUI"
+    notes: "Guilt dominant"
+
+  - pattern: "i’m afraid they will leave me"
+    emotion_code: "FAM-FEA"
+    notes: "Fear + Loss"
+
+  - pattern: "no matter how hard i try, i keep failing"
+    emotion_code: "FAM-SHA"
+    notes: "Shame spiral"
+
+  - pattern: "i feel like giving up"
+    emotion_code: "FAM-HEL"
+    notes: "Helplessness + Sadness"
+
+  - pattern: "i never feel good enough"
+    emotion_code: "FAM-SHA"
+    notes: "Shame core belief"
+
+  - pattern: "why does this always happen to me"
+    emotion_code: "FAM-SAD"
+    notes: "Sadness + Helplessness"
+
+  - pattern: "i can’t stop thinking about what happened"
+    emotion_code: "FAM-SAD"
+    notes: "Grief / rumination"
+
+  - pattern: "they betrayed my trust"
+    emotion_code: "FAM-ANG"
+    notes: "Anger + Betrayal"
+
+  - pattern: "i’m scared of what’s coming next"
+    emotion_code: "FAM-FEA"
+    notes: "Fear dominant"
+
+  - pattern: "i feel so alone even when i’m with others"
+    emotion_code: "FAM-LON"
+    notes: "Loneliness + Isolation"
+
+  - pattern: "i’m happy but also nervous"
+    emotion_code: "FAM-MIX"
+    notes: "Joy + Fear blend"
+
+  - pattern: "sometimes i don’t know how to feel"
+    emotion_code: "FAM-NEU"
+    notes: "Ambivalence"
+
+  - pattern: "i feel grateful for the people in my life"
+    emotion_code: "FAM-JOY"
+    notes: "Joy + Gratitude"
+
+  - pattern: "i’m falling in love and it scares me"
+    emotion_code: "FAM-LOV"
+    notes: "Love + Fear blend"
+
+  - pattern: "i can’t believe this happened to me"
+    emotion_code: "FAM-SUR"
+    notes: "Surprise + Shock"
+
+  - pattern: "i wish i could tell them how i feel"
+    emotion_code: "FAM-LON"
+    notes: "Loneliness + Vulnerability"
+
+  - pattern: "i’m so tired of pretending to be okay"
+    emotion_code: "FAM-SHA"
+    notes: "Shame + Fatigue"
+
+  - pattern: "i feel like no one understands me"
+    emotion_code: "FAM-LON"
+    notes: "Loneliness"
+
+  - pattern: "i feel trapped in my own mind"
+    emotion_code: "FAM-FEA"
+    notes: "Fear + Overwhelm"
+
+  - pattern: "everything feels meaningless right now"
+    emotion_code: "FAM-SAD"
+    notes: "Sadness / Existential"
+
+  - pattern: "i’m trying my best to stay hopeful"
+    emotion_code: "FAM-HOP"
+    notes: "Hope + Struggle"
+
+  - pattern: "i feel disconnected from everyone"
+    emotion_code: "FAM-LON"
+    notes: "Loneliness dominant"

config/emotion_families.yaml

@@ -1,13 +1,500 @@
-# emotion_families.yaml - placeholder for MEC MVP
-
+# Emotion Families
 emotion_families:
+
   - name: Joy
     code: FAM-JOY
+    variants:
+      - name: Euphoria
+        code: VAR-JOY-01
+        aliases:
+          - euphoria
+          - euphoric
+          - ecstatic
+          - elated
+      - name: Contentment
+        code: VAR-JOY-02
+        aliases:
+          - content
+          - contentment
+          - satisfied
+          - at peace
+      - name: Excitement
+        code: VAR-JOY-03
+        aliases:
+          - excited
+          - excitement
+          - thrilled
+          - hyped
+      - name: Joyful Peace
+        code: VAR-JOY-06
+        aliases:
+          - peaceful joy
+          - serene joy
+          - calm happiness
+      - name: Exuberance
+        code: VAR-JOY-07
+        aliases:
+          - exuberant
+          - overflowing joy
+          - joy
+          - so happy
+      - name: Relief
+        code: VAR-JOY-09
+        aliases:
+          - relief
+          - relieved
+          - sense of relief
+      - name: Optimism
+        code: VAR-JOY-10
+        aliases:
+          - optimistic
+          - optimism
+          - hopeful joy
+      - name: Pride
+        code: VAR-JOY-11
+        aliases:
+          - proud
+          - pride
+          - feeling proud
+
   - name: Sadness
     code: FAM-SAD
+    variants:
+      - name: Grief
+        code: VAR-SAD-01
+        aliases:
+          - grief
+          - grieving
+          - deep sorrow
+      - name: Melancholy
+        code: VAR-SAD-02
+        aliases:
+          - melancholy
+          - wistful
+          - blue
+      - name: Disappointment
+        code: VAR-SAD-03
+        aliases:
+          - disappointed
+          - disappointment
+          - let down
+      - name: Coping Sadness
+        code: VAR-SAD-06
+        aliases:
+          - managing sadness
+          - handling sadness
+      - name: Hopelessness
+        code: VAR-SAD-07
+        aliases:
+          - hopeless
+          - no hope
+          - giving up
+      - name: Remorse
+        code: VAR-SAD-08
+        aliases:
+          - remorseful
+          - remorse
+          - regret
+
   - name: Anger
     code: FAM-ANG
+    variants:
+      - name: Frustration
+        code: VAR-ANG-01
+        aliases:
+          - frustrated
+          - frustration
+          - annoyed
+      - name: Rage
+        code: VAR-ANG-02
+        aliases:
+          - rage
+          - furious
+          - enraged
+      - name: Irritation
+        code: VAR-ANG-03
+        aliases:
+          - irritated
+          - irritation
+          - bugged
+      - name: Annoyance
+        code: VAR-ANG-04
+        aliases:
+          - annoyed
+          - annoyance
+      - name: Disapproval
+        code: VAR-ANG-05
+        aliases:
+          - disapproval
+          - disapproving
+          - judgmental
+
   - name: Fear
     code: FAM-FEA
+    variants:
+      - name: Anxiety
+        code: VAR-FEA-01
+        aliases:
+          - anxious
+          - anxiety
+          - nervous
+      - name: Panic
+        code: VAR-FEA-02
+        aliases:
+          - panic
+          - panicked
+          - freaking out
+      - name: Terror
+        code: VAR-FEA-03
+        aliases:
+          - terror
+          - terrified
+          - horror
+      - name: Uncertainty
+        code: VAR-FEA-06
+        aliases:
+          - uncertain
+          - not sure
+          - indecisive
+      - name: Dread
+        code: VAR-FEA-07
+        aliases:
+          - dread
+          - dreading
+      - name: Nervousness
+        code: VAR-FEA-08
+        aliases:
+          - nervous
+          - uneasy
+      - name: Confusion
+        code: VAR-FEA-09
+        aliases:
+          - confused
+          - unsure
+          - puzzled
+
   - name: Love
     code: FAM-LOV
+    variants:
+      - name: Affection
+        code: VAR-LOV-01
+        aliases:
+          - affection
+          - affectionate
+          - fond
+      - name: Compassion
+        code: VAR-LOV-02
+        aliases:
+          - compassionate
+          - compassion
+          - caring
+      - name: Passion
+        code: VAR-LOV-03
+        aliases:
+          - passion
+          - passionate
+          - desire
+      - name: Longing Love
+        code: VAR-LOV-08
+        aliases:
+          - longing
+          - yearning
+          - missing someone
+      - name: Caring
+        code: VAR-LOV-09
+        aliases:
+          - caring
+          - care
+      - name: Desire
+        code: VAR-LOV-10
+        aliases:
+          - desire
+          - wanting
+      - name: Gratitude
+        code: VAR-LOV-11
+        aliases:
+          - grateful
+          - gratitude
+          - thankful
+      - name: Admiration
+        code: VAR-LOV-12
+        aliases:
+          - admiration
+          - admire
+          - respecting
+      - name: Approval
+        code: VAR-LOV-13
+        aliases:
+          - approval
+          - approving
+  - name: Disgust
+    code: FAM-DISG
+    variants:
+      - name: Disgust
+        code: VAR-DISG-01
+        aliases:
+          - disgust
+          - gross
+          - yuck
+      - name: Revulsion
+        code: VAR-DISG-02
+        aliases:
+          - revulsion
+          - revolted
+      - name: Contempt
+        code: VAR-DISG-03
+        aliases:
+          - contempt
+          - contemptuous
+      - name: Nausea
+        code: VAR-DISG-04
+        aliases:
+          - nauseated
+          - nausea
+          - sick to stomach
+      - name: Disdain
+        code: VAR-DISG-05
+        aliases:
+          - disdain
+          - disdainful
+
+  - name: Curiosity
+    code: FAM-CUR
+    variants:
+      - name: Curiosity
+        code: VAR-CUR-01
+        aliases:
+          - curious
+          - curiosity
+          - wondering
+      - name: Intrigue
+        code: VAR-CUR-02
+        aliases:
+          - intrigued
+          - intrigue
+      - name: Obsession
+        code: VAR-CUR-03
+        aliases:
+          - obsessed
+          - obsession
+      - name: Wonder
+        code: VAR-CUR-04
+        aliases:
+          - wonder
+          - amazed
+      - name: Skepticism
+        code: VAR-CUR-05
+        aliases:
+          - skeptical
+          - doubt
+
+  - name: Guilt
+    code: FAM-GUI
+    variants:
+      - name: Remorse
+        code: VAR-GUI-01
+        aliases:
+          - remorse
+          - remorseful
+      - name: Regret
+        code: VAR-GUI-02
+        aliases:
+          - regret
+          - regretting
+      - name: Self-Reproach
+        code: VAR-GUI-03
+        aliases:
+          - self-blame
+          - blaming self
+      - name: Responsibility Guilt
+        code: VAR-GUI-04
+        aliases:
+          - guilt
+          - guilty
+          - feeling responsible
+      - name: Reparative Guilt
+        code: VAR-GUI-05
+        aliases:
+          - need to make amends
+          - seeking forgiveness
+
+  - name: Shame
+    code: FAM-SHA
+    variants:
+      - name: Embarrassment
+        code: VAR-SHA-01
+        aliases:
+          - embarrassed
+          - embarrassment
+          - blushing
+      - name: Humiliation
+        code: VAR-SHA-02
+        aliases:
+          - humiliated
+          - humiliation
+      - name: Worthlessness
+        code: VAR-SHA-03
+        aliases:
+          - worthless
+          - unworthy
+      - name: Social Shame
+        code: VAR-SHA-04
+        aliases:
+          - public shame
+          - socially shamed
+      - name: Internalized Shame
+        code: VAR-SHA-05
+        aliases:
+          - internalized shame
+          - deep shame
+
+  - name: Surprise
+    code: FAM-SUR
+    variants:
+      - name: Surprise
+        code: VAR-SUR-01
+        aliases:
+          - surprised
+          - surprise
+          - wow
+      - name: Realization
+        code: VAR-SUR-02
+        aliases:
+          - realization
+          - realizing
+      - name: Amazement
+        code: VAR-SUR-03
+        aliases:
+          - amazed
+          - amazement
+      - name: Startle
+        code: VAR-SUR-04
+        aliases:
+          - startled
+          - startle
+      - name: Shock
+        code: VAR-SUR-05
+        aliases:
+          - shocked
+          - shocking
+
+  - name: Playfulness
+    code: FAM-PLA
+    variants:
+      - name: Amusement
+        code: VAR-PLA-01
+        aliases:
+          - amused
+          - amusement
+      - name: Humor
+        code: VAR-PLA-02
+        aliases:
+          - funny
+          - humor
+          - laughing
+      - name: Teasing
+        code: VAR-PLA-03
+        aliases:
+          - teasing
+          - tease
+      - name: Imaginative Play
+        code: VAR-PLA-04
+        aliases:
+          - playing
+          - pretend play
+      - name: Lightheartedness
+        code: VAR-PLA-05
+        aliases:
+          - lighthearted
+          - carefree
+
+  - name: Trust
+    code: FAM-TRU
+    variants:
+      - name: Trust
+        code: VAR-TRU-01
+        aliases:
+          - trust
+          - trusting
+      - name: Comfort
+        code: VAR-TRU-02
+        aliases:
+          - comforted
+          - comforting
+          - comfort
+      - name: Faith
+        code: VAR-TRU-03
+        aliases:
+          - faith
+          - believing
+      - name: Loyalty
+        code: VAR-TRU-04
+        aliases:
+          - loyal
+          - loyalty
+      - name: Security
+        code: VAR-TRU-05
+        aliases:
+          - secure
+          - safe
+          - security
+
+  - name: Hope
+    code: FAM-HOP
+    variants:
+      - name: Hope
+        code: VAR-HOP-01
+        aliases:
+          - hope
+          - hopeful
+      - name: Optimism
+        code: VAR-HOP-02
+        aliases:
+          - optimism
+          - optimistic
+      - name: Anticipation
+        code: VAR-HOP-03
+        aliases:
+          - anticipation
+          - anticipating
+      - name: Faith in Others
+        code: VAR-HOP-04
+        aliases:
+          - faith in others
+          - trust in others
+      - name: Visionary Hope
+        code: VAR-HOP-05
+        aliases:
+          - visionary
+          - visionary hope
+
+  - name: Grief
+    code: FAM-GRI
+    variants:
+      - name: Grief
+        code: VAR-GRI-01
+        aliases:
+          - grief
+          - grieving
+          - deep sorrow
+      - name: Bereavement
+        code: VAR-GRI-02
+        aliases:
+          - bereavement
+          - mourning
+          - mourning a loss
+      - name: Nostalgic Grief
+        code: VAR-GRI-03
+        aliases:
+          - nostalgic grief
+          - missing the past
+      - name: Anticipatory Grief
+        code: VAR-GRI-04
+        aliases:
+          - anticipatory grief
+          - grief before loss
+      - name: Collective Grief
+        code: VAR-GRI-05
+        aliases:
+          - collective grief
+          - shared grief

config/meta_mappings.yaml

@@ -1,19 +1,25 @@
-# meta_mappings.yaml
-# META mappings — abstract markers (META-*) to blend interpretations or inference cues.
-
+# Meta Mappings
 meta_mappings:
   - marker: "META-FEAR-DISPLACED"
     inferred_blend: "FEA+ANG"
     comment: "Displaced fear, showing as irritability or frustration"
-  
+
   - marker: "META-SOCIAL-WITHDRAWAL"
     inferred_blend: "SHA+SAD"
     comment: "Withdrawing due to social shame or sadness"
-  
+
   - marker: "META-HOPE-FRAGILE"
     inferred_blend: "HOP+FEA"
     comment: "Hope mixed with fear of failure"
-  
+
   - marker: "META-ANGER-INTERNALIZED"
     inferred_blend: "ANG+SHA"
     comment: "Internalized anger, linked to shame"
+
+  - marker: "META-JOY-SAD"
+    inferred_blend: "JOY+SAD"
+    comment: "Joy mixed with sadness, often seen in complex emotional states like nostalgia or bittersweet moments"
+
+  - marker: "META-ANGER-FEAR"
+    inferred_blend: "ANG+FEA"
+    comment: "Fear showing as anger, often in defensive or protective reactions"

config/resonance_mapping.yaml

@@ -0,0 +1,15 @@
+resonance_mapping:
+  FAM-JOY: High energy, warm
+  FAM-SAD: Low energy, cold
+  FAM-ANG: Intense, sharp
+  FAM-FEA: Tense, escalating
+  FAM-LOV: Warm, supportive
+  FAM-DISG: Cold, rejecting
+  FAM-CUR: Focused, inquisitive
+  FAM-GUI: Heavy, constrictive
+  FAM-SHA: Heavy, cold
+  FAM-SUR: Sharp, bright
+  FAM-PLA: Light, playful
+  FAM-TRU: Steady, warm
+  FAM-HOP: Light, rising
+  FAM-GRI: Deep, cold

config/response_strategies.yaml

@@ -0,0 +1,65 @@
+response_strategies:
+  FAM-ANG:
+    rsm_code: "RSM-DEESCALATE"
+    strategy: "De-escalation & Boundary Validation"
+    sample_response: "It’s completely understandable to feel this way when your boundaries feel crossed. You're not alone in this, and it’s okay to take space to ground and process."
+
+  FAM-SAD:
+    rsm_code: "RSM-COMFORT"
+    strategy: "Compassion & Emotional Holding"
+    sample_response: "I can feel how heavy this is for you. It’s okay to be in this place right now — and to know that this isn’t something you have to carry alone."
+
+  FAM-FEA:
+    rsm_code: "RSM-REASSURE"
+    strategy: "Reassurance & Safety Anchoring"
+    sample_response: "Your fears are valid. You’ve already shown strength by expressing them — and you deserve to feel safe and supported."
+
+  FAM-JOY:
+    rsm_code: "RSM-AFFIRMJOY"
+    strategy: "Shared Joy & Positive Resonance"
+    sample_response: "That’s wonderful to hear! I’m glad this brings you joy — may this feeling stay with you."
+
+  FAM-LOV:
+    rsm_code: "RSM-RECIPROCATECARE"
+    strategy: "Affection & Trust Holding"
+    sample_response: "That feeling of love is something so valuable. It’s okay to honor it at your own pace — and to let it support you."
+
+  FAM-SHA:
+    rsm_code: "RSM-SHAME-SOOTHE"
+    strategy: "Shame Soothing & Self-Worth Support"
+    sample_response: "Please know that shame can feel so isolating — but you are worthy of kindness and compassion, exactly as you are."
+
+  FAM-GUI:
+    rsm_code: "RSM-REPAIR"
+    strategy: "Self-Compassion & Repair Pathway"
+    sample_response: "Guilt can weigh so much because it shows you care. It’s also okay to begin the process of forgiving yourself and moving toward repair."
+
+  FAM-LON:
+    rsm_code: "RSM-CONNECTINVITE"
+    strategy: "Connection Invitation & Compassionate Presence"
+    sample_response: "That sense of loneliness is deeply human. I’m here, and when you’re ready, reaching out for connection is always a courageous act."
+
+  FAM-HEL:
+    rsm_code: "RSM-STABILIZE"
+    strategy: "Gentle Stabilization & Encouragement"
+    sample_response: "Helplessness is so hard to sit with — but reaching out shows strength. One step at a time is more than enough right now."
+
+  FAM-HOP:
+    rsm_code: "RSM-HOPE-AMPLIFY"
+    strategy: "Hope Amplification & Gentle Encouragement"
+    sample_response: "Holding onto hope can be an act of great courage. I believe in your resilience — you are moving forward even now."
+
+  FAM-SUR:
+    rsm_code: "RSM-GROUND-SURPRISE"
+    strategy: "Grounding & Acknowledgment of Surprise"
+    sample_response: "That sounds like it took you by surprise. Take your time — it’s okay to process this at your own pace."
+
+  FAM-DIS:
+    rsm_code: "RSM-ACKNOWLEDGE-BOUNDARY"
+    strategy: "Respectful Acknowledgment & Containment"
+    sample_response: "That reaction makes sense — it’s okay to have that boundary or sense of rejection toward what you experienced."
+
+  FAM-NEU:
+    rsm_code: "RSM-INQUIRE"
+    strategy: "Gentle Curiosity & Emotional Invitation"
+    sample_response: "Sometimes emotions aren’t clear — and that’s completely okay. When you're ready, I’m here to explore it with you."

config/sal_triggers.yaml

@@ -1,22 +1,33 @@
-# sal_triggers.yaml
-# Symbolic Ambiguity Layer (SAL) — phrases, tokens, or patterns that indicate emotional ambiguity, suppression, masking.
-
+# SAL Triggers
 sal_triggers:
   - trigger: "I'm fine"
-    meaning: "possible suppression or avoidance"
+    meaning: "Possible suppression or avoidance"
     flag: "SAL-001"
+
   - trigger: "It doesn't matter"
-    meaning: "resignation, possible sadness"
+    meaning: "Resignation, possible sadness"
     flag: "SAL-002"
+
   - trigger: "I'm okay, really"
-    meaning: "masking, potential hidden emotion"
+    meaning: "Masking, potential hidden emotion"
     flag: "SAL-003"
-  - trigger: "whatever"
-    meaning: "emotional disengagement"
+
+  - trigger: "Whatever"
+    meaning: "Emotional disengagement"
     flag: "SAL-004"
+
   - trigger: "I don't care"
-    meaning: "possible anger or frustration"
+    meaning: "Possible anger or frustration"
     flag: "SAL-005"
-  - trigger: "no big deal"  
-    meaning: "minimization of emotional impact"
+
+  - trigger: "No big deal"
+    meaning: "Minimization of emotional impact"
     flag: "SAL-006"
+
+  - trigger: "I'm just tired"
+    meaning: "Emotional exhaustion, hiding deeper frustration or sadness"
+    flag: "SAL-008"
+
+  - trigger: "I don't know what you want from me"
+    meaning: "Defensiveness or frustration with expectations"
+    flag: "SAL-009"

core/codex_informer.py

@@ -1,69 +1,92 @@
 # core/codex_informer.py
+# Master Emotional Core (MEC) - Codex Informer v3 (Memory-Optimized)
 
 import yaml
 
 class CodexInformer:
-    _instance = None  # Singleton pattern to ensure only one instance
+    def __init__(self, emotion_families_path='config/emotion_families.yaml',
+                       arc_mapping_path='config/arc_mapping.yaml',
+                       resonance_mapping_path='config/resonance_mapping.yaml'):
 
-    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
+        # Load emotion families YAML
+        with open(emotion_families_path, 'r', encoding='utf-8') as f:
+            self.emotion_families = yaml.safe_load(f)['emotion_families']
 
-    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']
+        # Load arc mapping YAML
+        with open(arc_mapping_path, 'r', encoding='utf-8') as f:
+            self.arc_lookup = yaml.safe_load(f)['arc_mapping']
 
-    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)
+        # Load resonance mapping YAML
+        with open(resonance_mapping_path, 'r', encoding='utf-8') as f:
+            self.resonance_lookup = yaml.safe_load(f)['resonance_mapping']
+
+        # Build lookup tables
+        self.family_lookup = {}
+        self.variant_lookup = {}
 
-    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"
+            fam_code = family['code']
+            self.family_lookup[fam_code] = True
+            for variant in family.get('variants', []):
+                var_code = variant['code']
+                self.variant_lookup[var_code] = {
+                    'family_code': fam_code
+                }
 
-    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
+        print(f"[CodexInformer] Loaded {len(self.family_lookup)} families, {len(self.variant_lookup)} variants, {len(self.arc_lookup)} arcs, {len(self.resonance_lookup)} resonance patterns")
 
-    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 resolve_emotion_family(self, emotion_code):
+        # CASE 1: Variant code
+        if emotion_code.startswith("VAR-"):
+            if emotion_code in self.variant_lookup:
+                fam_code = self.variant_lookup[emotion_code]['family_code']
+                arc = self.arc_lookup.get(fam_code, "Stable")
+                resonance = self.resonance_lookup.get(fam_code, "Neutral")
+                return {
+                    'primary_emotion_code': emotion_code,
+                    'emotion_family': fam_code,
+                    'arc': arc,
+                    'resonance': resonance
+                }
+            else:
+                print(f"[CodexInformer] Unknown VAR code: {emotion_code}")
+                return self._unknown_response()
 
-    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")
+        # CASE 2: Family code
+        elif emotion_code.startswith("FAM-"):
+            if emotion_code in self.family_lookup:
+                arc = self.arc_lookup.get(emotion_code, "Stable")
+                resonance = self.resonance_lookup.get(emotion_code, "Neutral")
+                return {
+                    'primary_emotion_code': emotion_code,
+                    'emotion_family': emotion_code,
+                    'arc': arc,
+                    'resonance': resonance
+                }
+            else:
+                print(f"[CodexInformer] Unknown FAM code: {emotion_code}")
+                return self._unknown_response()
 
-    def map_tokens_to_codex(self, token_stream):
-        codex_hits = []
-        for token in token_stream:
-            for trigger in self.sal_triggers:
-                if trigger['trigger'].lower() in token.lower():
-                    codex_hits.append({
-                        'type': 'SAL_TRIGGER',
-                        'flag': trigger['flag'],
-                        'meaning': trigger['meaning'],
-                        'token': token
-                    })
-        return codex_hits
+        # CASE 3: Invalid format
+        else:
+            print(f"[CodexInformer] Unknown code format: {emotion_code}")
+            return self._unknown_response()
 
-    def lookup_meta_mapping(self, meta_marker):
-        for meta in self.meta_mappings:
-            if meta['marker'] == meta_marker:
-                return meta
-        return None
+    def build_alias_lookup(self):
+        alias_lookup = {}
+        for family in self.emotion_families:
+            for variant in family.get('variants', []):
+                variant_code = variant['code']
+                aliases = variant.get('aliases', [])
+                alias_lookup[variant['name'].lower()] = variant_code
+                for alias in aliases:
+                    alias_lookup[alias.lower()] = variant_code
+        return alias_lookup
+
+    def _unknown_response(self):
+        return {
+            'primary_emotion_code': "Unknown",
+            'emotion_family': "Unknown",
+            'arc': "Unknown",
+            'resonance': "Unknown"
+        }

core/eil_processor.py

@@ -1,59 +1,257 @@
 # core/eil_processor.py
+# Master Emotional Core (MEC) - EIL Processor (Signal Normalization Edition)
 
-from core.codex_informer import CodexInformer
+import yaml
+import re
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+import torch.nn.functional as F
 
 class EILProcessor:
-    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)
+    def __init__(self, codex_informer, softmax_threshold=0.6):
+        self.codex_informer = codex_informer
+        self.softmax_threshold = softmax_threshold
+
+        # Build alias lookup from Codex
+        self.alias_lookup = self.codex_informer.build_alias_lookup()
+        print(f"[EILProcessor] Alias map loaded with {len(self.alias_lookup)} entries")
+
+        # Load crosswalk.yaml
+        with open('config/crosswalk.yaml', 'r', encoding='utf-8') as f:
+            yaml_data = yaml.safe_load(f)
+            crosswalk_data = yaml_data['crosswalk']
+            story_pattern_data = yaml_data.get('story_patterns', [])
+
+        # Build crosswalk lookup
+        self.crosswalk_lookup = {}
+        for entry in crosswalk_data:
+            phrase = self.normalize_text(entry['phrase'])
+            emotion_code = entry['emotion_code']
+            self.crosswalk_lookup[phrase] = emotion_code
+
+        # Build story_patterns lookup
+        self.story_patterns_lookup = {}
+        for entry in story_pattern_data:
+            pattern = self.normalize_text(entry['pattern'])
+            emotion_code = entry['emotion_code']
+            self.story_patterns_lookup[pattern] = emotion_code
+
+        print(f"[EILProcessor] Crosswalk loaded with {len(self.crosswalk_lookup)} entries")
+        print(f"[EILProcessor] Story Patterns loaded with {len(self.story_patterns_lookup)} entries")
+
+        # Emotion keyword dictionary for signal normalization/blending
+        self.emotion_keyword_map = {
+            "FAM-ANG": ["anger", "angry", "hate", "furious", "rage", "resentment"],
+            "FAM-HEL": ["helpless", "powerless", "can't", "unable", "trapped", "stuck"],
+            "FAM-SAD": ["sad", "down", "unhappy", "miserable", "depressed", "blue"],
+            "FAM-FEA": ["afraid", "scared", "fear", "terrified", "worried", "nervous", "anxious"],
+            "FAM-LOV": ["love", "loved", "loving", "caring", "affection"],
+            "FAM-JOY": ["joy", "happy", "excited", "delighted", "content"],
+            "FAM-SUR": ["surprised", "amazed", "astonished", "shocked"],
+            "FAM-DIS": ["disgust", "disgusted", "gross", "revolted"],
+            "FAM-SHA": ["ashamed", "shame", "embarrassed", "humiliated"],
+            "FAM-GUI": ["guilty", "guilt", "remorse", "regret"],
+            # Add more as needed
         }
-        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", "")
-
-        # 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 + EILProcessor"
-            },
-            "emotion_family": emotion_family,  # From Codex Informer
-            "arc": arc,  # From Codex Informer
-            "resonance": resonance  # From Codex Informer
+
+        # Load tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained('cardiffnlp/twitter-roberta-base-emotion')
+        self.model = AutoModelForSequenceClassification.from_pretrained('cardiffnlp/twitter-roberta-base-emotion')
+
+    def normalize_text(self, text):
+        normalization_map = {
+            "i am feeling ": "",
+            "i feel ": "",
+            "feeling ": "",
+            "i'm feeling ": "",
+            "i am ": "",
+            "i'm ": ""
         }
+        text = text.lower().strip()
+        for k, v in normalization_map.items():
+            if text.startswith(k):
+                text = text.replace(k, "", 1)
+                break
+        text = re.sub(r'[.!?]', '', text)
+        return text
+
+    def is_story_input(self, text):
+        clause_markers = [',', ';', '.', 'but', 'because', 'so that', 'which', 'when', 'while']
+        token_count = len(text.split())
+        clause_hits = any(marker in text for marker in clause_markers)
+        if token_count > 12 or clause_hits:
+            return True
+        return False
+
+    def chunk_story(self, text):
+        # Also split on conjunctions and relative pronouns, not just punctuation
+        chunks = re.split(r'[.,;!?]|\b(?:and|but|because|so|although|though|while|when)\b', text, flags=re.IGNORECASE)
+        chunks = [chunk.strip() for chunk in chunks if chunk and chunk.strip()]
+        return chunks
+
+    def detect_emotion_blend(self, norm_text):
+        blend = {}
+        for fam, keywords in self.emotion_keyword_map.items():
+            for kw in keywords:
+                if kw in norm_text:
+                    blend[fam] = blend.get(fam, 0) + 1.0
+        return blend
+
+    def infer_emotion(self, input_text):
+        norm_text = self.normalize_text(input_text)
+
+        # 1️⃣ Story Pattern Override
+        if norm_text in self.story_patterns_lookup:
+            primary_emotion_code = self.story_patterns_lookup[norm_text]
+            emotion_data = self.codex_informer.resolve_emotion_family(primary_emotion_code)
+            print(f"[EILProcessor] Story Pattern match: '{norm_text}' → {primary_emotion_code}")
+            packet = {
+                'phrases': [input_text],
+                'emotion_candidates': [{'phrase': input_text, 'candidate_emotion': primary_emotion_code}],
+                'metadata': {'source': 'EILProcessor (story pattern)', 'input_type': 'story'},
+                'emotion_family': emotion_data['emotion_family'],
+                'primary_emotion_code': emotion_data['primary_emotion_code'],
+                'arc': emotion_data['arc'],
+                'resonance': emotion_data['resonance'],
+                'blend': {emotion_data['primary_emotion_code']: 1.0}
+            }
+            return packet
+
+        # 2️⃣ Story detection (chunking and blend aggregation)
+        input_type = 'phrase'
+        if self.is_story_input(norm_text):
+            input_type = 'story'
+            print(f"[EILProcessor] Story mode activated for input: '{norm_text}'")
+            chunks = self.chunk_story(norm_text)
 
-        print(f"[EILProcessor] EIL Packet: {eil_packet}")
-        return eil_packet
+            chunk_results = []
+            blend_accum = {}
+
+            for chunk in chunks:
+                sub_result = self.infer_emotion(chunk)  # RECURSIVE CALL
+                chunk_results.append(sub_result)
+                # Accumulate blends
+                for fam, val in sub_result.get('blend', {}).items():
+                    blend_accum[fam] = blend_accum.get(fam, 0) + val
+
+            # Normalize blend
+            if blend_accum:
+                total = sum(blend_accum.values())
+                for k in blend_accum:
+                    blend_accum[k] /= total
+
+                dominant_family = max(blend_accum.items(), key=lambda x: x[1])[0]
+            else:
+                dominant_family = "FAM-NEU"
+                blend_accum = {"FAM-NEU": 1.0}
+
+            emotion_data = self.codex_informer.resolve_emotion_family(dominant_family)
+            packet = {
+                'phrases': [input_text] + [r['phrases'][0] for r in chunk_results],
+                'emotion_candidates': [{'phrase': r['phrases'][0], 'candidate_emotion': r['primary_emotion_code']} for r in chunk_results],
+                'metadata': {'source': 'EILProcessor (story mode)', 'input_type': input_type},
+                'emotion_family': emotion_data['emotion_family'],
+                'primary_emotion_code': emotion_data['primary_emotion_code'],
+                'arc': emotion_data['arc'],
+                'resonance': emotion_data['resonance'],
+                'blend': blend_accum
+            }
+            return packet
+
+        # 3️⃣ Crosswalk check
+        if norm_text in self.crosswalk_lookup:
+            primary_emotion_code = self.crosswalk_lookup[norm_text]
+            emotion_data = self.codex_informer.resolve_emotion_family(primary_emotion_code)
+            print(f"[EILProcessor] Crosswalk match: '{norm_text}' → {primary_emotion_code}")
+            packet = {
+                'phrases': [input_text],
+                'emotion_candidates': [{'phrase': input_text, 'candidate_emotion': primary_emotion_code}],
+                'metadata': {'source': 'EILProcessor (crosswalk)', 'input_type': input_type},
+                'emotion_family': emotion_data['emotion_family'],
+                'primary_emotion_code': emotion_data['primary_emotion_code'],
+                'arc': emotion_data['arc'],
+                'resonance': emotion_data['resonance'],
+                'blend': {emotion_data['primary_emotion_code']: 1.0}
+            }
+            return packet
+
+        # 4️⃣ Alias lookup
+        if norm_text in self.alias_lookup:
+            variant_code = self.alias_lookup[norm_text]
+            emotion_family = variant_code.split('-')[1]
+            family_code = f"FAM-{emotion_family}"
+            print(f"[EILProcessor] Alias match: '{norm_text}' → {variant_code}")
+            packet = {
+                'phrases': [input_text],
+                'emotion_candidates': [{'phrase': input_text, 'candidate_emotion': variant_code}],
+                'metadata': {'source': 'EILProcessor (alias match)', 'input_type': input_type},
+                'emotion_family': family_code,
+                'primary_emotion_code': variant_code,
+                'arc': 'Pending',
+                'resonance': 'Pending',
+                'blend': {variant_code: 1.0}
+            }
+            return packet
+
+        # 5️⃣ Signal normalization - keyword blend check
+        blend = self.detect_emotion_blend(norm_text)
+        if blend:
+            # Normalize
+            total = sum(blend.values())
+            for k in blend:
+                blend[k] /= total
+            primary_code = max(blend.items(), key=lambda x: x[1])[0]
+            emotion_data = self.codex_informer.resolve_emotion_family(primary_code)
+            print(f"[EILProcessor] Signal normalization keyword blend: {blend} (primary: {primary_code})")
+            packet = {
+                'phrases': [input_text],
+                'emotion_candidates': [{'phrase': input_text, 'candidate_emotion': primary_code}],
+                'metadata': {'source': 'EILProcessor (signal normalization)', 'input_type': input_type},
+                'emotion_family': emotion_data['emotion_family'],
+                'primary_emotion_code': emotion_data['primary_emotion_code'],
+                'arc': emotion_data['arc'],
+                'resonance': emotion_data['resonance'],
+                'blend': blend
+            }
+            return packet
+
+        # 6️⃣ Model fallback
+        print(f"[EILProcessor] No crosswalk/alias/keyword match — running model on: '{norm_text}'")
+        tokens = self.tokenizer(norm_text, return_tensors='pt')
+        with torch.no_grad():
+            logits = self.model(**tokens).logits
+            probs = F.softmax(logits, dim=-1).squeeze()
+            top_prob, top_idx = torch.max(probs, dim=-1)
+        predicted_label = self.model.config.id2label[top_idx.item()]
+        confidence = top_prob.item()
+
+        if confidence < self.softmax_threshold:
+            predicted_label = 'neutral'
+            print(f"[EILProcessor] Low confidence ({confidence:.2f}) — setting to 'neutral'")
+
+        print(f"[EILProcessor] Model prediction: {predicted_label} ({confidence:.2f})")
+        model_to_codex_map = {
+            "joy": "FAM-JOY",
+            "anger": "FAM-ANG",
+            "sadness": "FAM-SAD",
+            "fear": "FAM-FEA",
+            "love": "FAM-LOV",
+            "surprise": "FAM-SUR",
+            "disgust": "FAM-DIS",
+            "neutral": "FAM-NEU"
+        }
+        primary_emotion_code = model_to_codex_map.get(predicted_label.lower(), "FAM-NEU")
+        emotion_data = self.codex_informer.resolve_emotion_family(primary_emotion_code)
+        blend = {emotion_data['primary_emotion_code']: 1.0}
+
+        packet = {
+            'phrases': [input_text],
+            'emotion_candidates': [{'phrase': input_text, 'candidate_emotion': predicted_label}],
+            'metadata': {'source': 'EILProcessor (model)', 'input_type': input_type},
+            'emotion_family': emotion_data['emotion_family'],
+            'primary_emotion_code': emotion_data['primary_emotion_code'],
+            'arc': emotion_data['arc'],
+            'resonance': emotion_data['resonance'],
+            'blend': blend
+        }
+        return packet

core/eris_reasoner.py

@@ -1,3 +1,5 @@
+# core/eris_reasoner.py
+
 import hashlib
 import time
 from core.codex_informer import CodexInformer
@@ -5,41 +7,54 @@ from core.hei_inference import HEIInference
 
 class ERISReasoner:
     def __init__(self):
-        # 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)
-        user_id = "user123"  # Placeholder user_id, can be dynamic if needed
-        timestamp = str(int(time.time()))  # Current time in seconds
-        primary_emotion = esil_packet.get("primary_emotion", "UNK-000")
-        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
+        # Generate EmID components
+        user_id = "user123"
+
+        # Get primary_emotion and primary_emotion_code from ESIL packet
+        primary_emotion = esil_packet.get("emotion_family", "Unknown")
+        primary_emotion_code = esil_packet.get("primary_emotion_code", "Unknown")
+
+        # Resolve arc and resonance via Codex using primary_emotion_code
+        resolved_family = self.codex_informer.resolve_emotion_family(primary_emotion_code)
+        arc = resolved_family['arc']
+        resonance = resolved_family['resonance']
+
+        # Build UESP packet
         uesp_packet = {
             "Primary Emotion": primary_emotion,
             "Primary Emotion Code": primary_emotion_code,
-            "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
+            "Emotion Arc Trajectory": arc,
+            "Resonance Pattern": resonance,
+            "HEART Compliance Flags": ["HVC-000"],  # Placeholder
             "Empathy First Response": esil_packet.get("response", "Emotion being processed..."),
-            "emotion_family": emotion_family  # Always include this
+            "emotion_family": primary_emotion
         }
 
-        # 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...")
+        # If no valid family — trigger HEI fallback
+        if primary_emotion_code == "Unknown" or primary_emotion == "FAM-HID" or primary_emotion == "Hidden Emotion Detected":
+            print("[ERISReasoner] 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
+            uesp_packet = hei.detect_low_signal(uesp_packet)
+
+            # Ensure Primary Emotion Code survives even after HEI fallback
+            if "Primary Emotion Code" not in uesp_packet:
+                uesp_packet["Primary Emotion Code"] = primary_emotion_code
+
+        # Build clean family code string for EmID
+        family_code_str = uesp_packet['Primary Emotion'].replace("FAM-", "")
+
+        # Get current timestamp (ISO-like)
+        timestamp_str = time.strftime("%Y%m%dT%H%M%S")
+
+        # Build hashed payload
+        emid_payload = f"{user_id}-{family_code_str}-{timestamp_str}"
+        emid_hash = hashlib.sha256(emid_payload.encode()).hexdigest()
 
-        # Generate EmID (for traceability)
-        emid_string = f"{user_id}-{primary_emotion}-{timestamp}"
-        emid = hashlib.sha256(emid_string.encode()).hexdigest()  # Simple hash for uniqueness
-        uesp_packet["EmID"] = emid
+        # Final EmID: user-JOY-20250623T203633-<hash>
+        uesp_packet["EmID"] = f"user-{family_code_str}-{timestamp_str}-{emid_hash}"
 
+        print(f"[ERISReasoner] Generated UESP Packet: {uesp_packet}")
         return uesp_packet

core/esil_inference.py

@@ -26,9 +26,13 @@ class ESILInference:
 
         # 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)
+        
+        # Ensure the primary emotion code is resolved correctly by CodexInformer
+        emotion_data = self.codex_informer.resolve_emotion_family(primary_emotion_code)
+
+        emotion_family = emotion_data['emotion_family']
+        arc = emotion_data['arc']
+        resonance = emotion_data['resonance']
 
         # If no emotion family is found, flag it as a "hidden emotion"
         if emotion_family == "Unknown":
@@ -44,6 +48,7 @@ class ESILInference:
             "emotion_family": emotion_family,  # From Codex Informer
             "arc": arc,  # From Codex Informer
             "resonance": resonance,  # From Codex Informer
+            "primary_emotion_code": primary_emotion_code,  # <-- PATCH INCLUDED
             "source_metadata": eil_packet.get("metadata", {}),
             "tokens": phrases
         }

core/fec_controller.py

@@ -1,24 +1,61 @@
+# core/fec_controller.py
+# Master Emotional Core (MEC) - FECController v1.0 (LLM Instruction Layer)
+
 class FECController:
     def __init__(self):
         pass
 
     def generate_prompt(self, final_uesp):
-        # Validate that all necessary keys exist in final_uesp
-        required_keys = ['emotion_family', 'Primary Emotion Code']
-        
+        # Validate required keys
+        required_keys = [
+            'emotion_family',
+            'Primary Emotion Code',
+            'Emotion Arc Trajectory',
+            'Resonance Pattern'
+        ]
+
         for key in required_keys:
             if key not in final_uesp:
                 raise KeyError(f"Missing required key: {key}")
-        
-        # If all keys are valid, construct the prompt
-        primary_emotion = final_uesp['emotion_family']
-        primary_emotion_code = final_uesp['Primary Emotion Code']
 
-        # Create the Fusion Prompt
-        fusion_prompt = f"[Primary Emotion]: {primary_emotion} ({primary_emotion_code})"
+        # Map human-readable emotion label from code
+        emotion_code = final_uesp['Primary Emotion Code']
+        # For MVP, just simplify code extraction:
+        if emotion_code.startswith("VAR-"):
+            emotion_label = emotion_code.replace("VAR-", "").split('-')[0].title()
+        elif emotion_code.startswith("FAM-"):
+            emotion_label = emotion_code.replace("FAM-", "").title()
+        else:
+            emotion_label = "Unknown"
+
+        # Base fields
+        arc = final_uesp['Emotion Arc Trajectory']
+        resonance = final_uesp['Resonance Pattern']
+
+        # Placeholder — eventually populated by ERIS/FEC blends
+        blend_states = final_uesp.get('Blend States', 'None detected')
+
+        # Placeholder — Response Strategy (will be routed later by ERIS/FEC)
+        response_strategy = final_uesp.get('Response Strategy', 'RSM-DEFAULT')
+
+        # Placeholder — T-Code (if tone classifiers applied — for now None)
+        tone_classification = final_uesp.get('Tone Classification', 'TBD')
+
+        # Build Fusion Prompt
+        fusion_prompt = f"""
+Contextual Emotional State:
+
+- Primary Emotion: {emotion_label}
+- Emotional Arc: {arc}
+- Resonance: {resonance}
+- Tone: {tone_classification}
+- Blend States: {blend_states}
+- Intervention Strategy: {response_strategy}
+
+Empathic Objective:
+Align your response tone and content with the above emotional context. Prioritize emotional authenticity, HEART-compliant care, and safety. Do not merely reflect emotion — respond in an emotionally aligned and supportive manner that honors the user’s lived experience.
 
-        # Add other details to the fusion prompt if needed
-        if 'Empathy First Response' in final_uesp:
-            fusion_prompt += f"\nResponse: {final_uesp['Empathy First Response']}"
+HEART Compliance: Response must align with HEART™ ethical principles — transparency, alignment, contextuality, traceability, and emotional safety.
+""".strip()
 
         return fusion_prompt

gradio_ui.py

@@ -0,0 +1,100 @@
+import gradio as gr
+import yaml
+import os
+
+from core.codex_informer import CodexInformer
+from core.eil_processor import EILProcessor
+from core.esil_inference import ESILInference
+from core.eris_reasoner import ERISReasoner
+from core.fec_controller import FECController
+
+# Initialize MEC Core Components
+codex_informer = CodexInformer()
+eil_processor = EILProcessor(codex_informer)
+esil_formatter = ESILInference(codex_informer)
+eris_engine = ERISReasoner()
+fec_controller = FECController()
+
+# Load Response Strategies YAML
+config_path = os.path.join("config", "response_strategies.yaml")
+with open(config_path, 'r', encoding='utf-8') as f:
+    response_strategies = yaml.safe_load(f).get('response_strategies', {})
+
+def process_input(user_text):
+    try:
+        print(f"[DEBUG] Received user input: {user_text!r}")
+
+        # Step 1: EIL Processing
+        eil_result = eil_processor.infer_emotion(user_text)
+        print(f"[DEBUG] EIL Result: {eil_result}")
+
+        # Step 2: ESIL Formatting
+        esil_packet = esil_formatter.infer_esil(eil_result)
+        print(f"[DEBUG] ESIL Packet: {esil_packet}")
+
+        # Step 3: ERIS Reasoning
+        eris_result = eris_engine.reason_emotion_state(esil_packet)
+        print(f"[DEBUG] ERIS Result: {eris_result}")
+
+        # Pull out your primary_emotion_code (case-agnostic)
+        fam_code = (
+            eris_result.get('primary_emotion_code') or
+            eris_result.get('Primary Emotion Code') or
+            eris_result.get('Primary Emotion')
+        )
+        if not fam_code:
+            raise KeyError("`primary_emotion_code` missing in ERIS result")
+
+        # Lookup response strategy
+        rs = response_strategies.get(fam_code, {})
+        rsm_code        = rs.get('rsm_code', 'RSM-UNKNOWN')
+        strategy_name   = rs.get('strategy', 'Strategy not defined')
+        sample_response = rs.get('sample_response', 'No response available')
+
+        simulated_output = (
+            f"Response Strategy Code: {rsm_code}\n"
+            f"Response Strategy: {strategy_name}\n\n"
+            f"{sample_response}"
+        )
+
+        # Step 4: Fusion Engine – ensure keys match what FECController expects
+        final_uesp = {
+            # FEC expects these keys:
+            'emotion_family': eris_result.get('emotion_family', fam_code),
+            'Primary Emotion Code': fam_code,
+            **eris_result  # Carry over everything else, in case
+        }
+
+        fusion_prompt = fec_controller.generate_prompt(final_uesp)
+        print("[DEBUG] Fusion Prompt Generated")
+
+        return fusion_prompt, simulated_output
+
+    except Exception as e:
+        print(f"[ERROR] Exception in process_input: {e}")
+        return "[ERROR: Unable to process input]", f"An error occurred: {e}"
+
+def launch_ui():
+    with gr.Blocks(title="MEC MVP – Empathic UI") as demo:
+        gr.Markdown("# Master Emotional Core (MEC) MVP UI\nEmpathy-first AI. Built to protect.")
+
+        with gr.Row():
+            user_input = gr.Textbox(label="Enter your message:", placeholder="Type here...", lines=3)
+
+        with gr.Row():
+            submit_button = gr.Button("Process Input")
+
+        with gr.Row():
+            fusion_prompt_display = gr.Textbox(label="Fusion Prompt", lines=6, interactive=False)
+            empathic_response_display = gr.Textbox(label="Simulated Empathic Response", lines=8, interactive=False)
+
+        submit_button.click(
+            fn=process_input,
+            inputs=[user_input],
+            outputs=[fusion_prompt_display, empathic_response_display]
+        )
+
+    demo.launch()
+
+if __name__ == "__main__":
+    launch_ui()

main.py

@@ -3,17 +3,21 @@ from core.esil_inference import ESILInference
 from core.eris_reasoner import ERISReasoner
 from core.hei_inference import HEIInference
 from core.fec_controller import FECController
+import yaml
 
 def run_pipeline(user_input_text, force_hei=False):
     print("\n--- MEC MVP Test Run ---")
     print(f"[Main] Pipeline Input: {user_input_text}")
 
-    # 1️⃣ EIL Processor (handles both preprocessing and emotion processing)
+    # Load Response Strategies YAML
+    with open('config/response_strategies.yaml', 'r', encoding='utf-8') as f:
+        response_strategies = yaml.safe_load(f)['response_strategies']
+
+    # 1️⃣ EIL Processor (handles both normalization 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)
+
+    # Run emotion inference
+    eil_packet = eil.infer_emotion(user_input_text)
     print(f"[Main] EIL Packet Output: {eil_packet}")
 
     # 2️⃣ ESIL Inference
@@ -40,6 +44,20 @@ def run_pipeline(user_input_text, force_hei=False):
         fusion_prompt = fec.generate_prompt(final_uesp)
         print(f"[Main] Final Fusion Prompt:\n{fusion_prompt}")
 
+        # 6️⃣ Simulated Empathic Response
+        fam_code = final_uesp['primary_emotion_code']
+        rsm_code = response_strategies.get(fam_code, {}).get('rsm_code', 'RSM-UNKNOWN')
+        strategy_name = response_strategies.get(fam_code, {}).get('strategy', 'Strategy not defined')
+        sample_response = response_strategies.get(fam_code, {}).get('sample_response', 'No response available')
+
+        simulated_output = (
+            f"Response Strategy Code: {rsm_code}\n"
+            f"Response Strategy: {strategy_name}\n\n"
+            f"{sample_response}"
+        )
+
+        print(f"\n[Main] Simulated Empathic Response:\n{simulated_output}")
+
     elif esil_packet['confidence_score'] < 0.65:
         print("\n[Main] Routing: escalate_to_hei")
         # 6️⃣ Trigger HEI Inference (Fallback for Low Confidence)
@@ -57,12 +75,26 @@ def run_pipeline(user_input_text, force_hei=False):
         fusion_prompt = fec.generate_prompt(final_uesp)
         print(f"[Main] Final Fusion Prompt:\n{fusion_prompt}")
 
+        # 8️⃣ Simulated Empathic Response
+        fam_code = final_uesp['primary_emotion_code']
+        rsm_code = response_strategies.get(fam_code, {}).get('rsm_code', 'RSM-UNKNOWN')
+        strategy_name = response_strategies.get(fam_code, {}).get('strategy', 'Strategy not defined')
+        sample_response = response_strategies.get(fam_code, {}).get('sample_response', 'No response available')
+
+        simulated_output = (
+            f"Response Strategy Code: {rsm_code}\n"
+            f"Response Strategy: {strategy_name}\n\n"
+            f"{sample_response}"
+        )
+
+        print(f"\n[Main] Simulated Empathic Response:\n{simulated_output}")
+
     else:
         print("\n[Main] Routing: LLM Assist — Not implemented")
 
 if __name__ == "__main__":
     # Example input that matches a SAL Trigger:
-    test_input = "I'm okay, really"
+    test_input = "I am feeling joy"
 
     # Run in FORCE HEI mode → set to True to test Symbolic Layer
-    run_pipeline(test_input, force_hei=True)
+    run_pipeline(test_input, force_hei=False)

mec_api.py

@@ -1,58 +1,52 @@
-# mec_api.py
-
-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.uesp_constructor import UESPConstructor
 from core.fec_controller import FECController
+from core.codex_informer import CodexInformer
 
 def run_mec_pipeline(user_input_text, force_hei=False):
-    # 1️⃣ Preprocessor
-    pre = InputPreprocessor()
-    pre_packet = pre.preprocess_text(user_input_text)
-
-    # 2️⃣ EIL Processor
+    # 1️⃣ EIL Processor (handles both preprocessing and emotion processing)
     eil = EILProcessor()
+    pre_packet = eil.preprocess_text(user_input_text)
     eil_packet = eil.process_eil(pre_packet)
 
-    # 3️⃣ ESIL Inference
+    # 2️⃣ ESIL Inference
     esil = ESILInference()
     esil_packet = esil.infer_esil(eil_packet)
 
+    # 3️⃣ Forced HEI Mode: Ensure it forces the low confidence path if True
     if force_hei:
         esil_packet['confidence_score'] = 0.40  # force low confidence to trigger HEI
 
-    # 4️⃣ Confidence Gate
-    gate = ConfidenceGate()
-    route = gate.evaluate_confidence(esil_packet)
-
-    # Routing logic:
-    if route['routing_decision'] == "proceed_to_eris":
+    # 4️⃣ Routing Logic based on Confidence Score
+    if esil_packet['confidence_score'] >= 0.65:
+        # 5️⃣ ERIS Reasoning (Final UESP Creation)
         eris = ERISReasoner()
-        uesp = eris.reason_emotion_state(esil_packet)
+        final_uesp = eris.reason_emotion_state(esil_packet)
 
-    elif route['routing_decision'] == "escalate_to_hei":
+    elif esil_packet['confidence_score'] < 0.65:
+        # 6️⃣ Trigger HEI Inference (Fallback for Low Confidence)
         hei = HEIInference()
         pseudo_esil = hei.detect_low_signal(esil_packet)
 
+        # 7️⃣ Post-HEI Path: Continue to ERIS → UESP → FEC
         eris = ERISReasoner()
-        uesp = eris.reason_emotion_state(pseudo_esil)
+        final_uesp = eris.reason_emotion_state(pseudo_esil)
 
     else:
         # fallback (LLM Assist not implemented)
-        uesp = {"error": "LLM Assist not implemented."}
-        fusion_prompt = "N/A"
-        return fusion_prompt, "N/A", uesp
+        final_uesp = {"error": "LLM Assist not implemented."}
 
+    # 8️⃣ UESP Construction
+    # Assuming the UESPConstructor now works based on UESP data from ERIS or HEI
     uesp_constructor = UESPConstructor()
-    final_uesp = uesp_constructor.construct_uesp(uesp)
+    final_uesp = uesp_constructor.construct_uesp(final_uesp)
 
+    # 9️⃣ FEC Controller (Final Fusion Prompt)
     fec = FECController()
     fusion_prompt = fec.generate_prompt(final_uesp)
 
-    # For Gradio frontend:
-    instruction_block = fusion_prompt  # you can later split instruction more if needed
+    # For Gradio frontend or API response:
+    instruction_block = fusion_prompt  # You can later split instruction more if needed
     return fusion_prompt, instruction_block, final_uesp