Integrate emotional inference into EFE action selection

Thread Circumplex POMDP outputs (valence beliefs, prediction error)
into coaching readiness, lambda_epist, and EFE action selection so
the agent responds to emotional state rather than just keywords.

src/mindsphere/core/action_dispatcher.py

@@ -48,12 +48,14 @@ def compute_lambda_epist(
     timestep: int,
     tom_reliability: float,
     beliefs: Optional[Dict[str, np.ndarray]] = None,
+    emotion_prediction_error: float = 0.0,
 ) -> float:
     """
     Compute the epistemic drive weight, balancing exploration vs exploitation.
 
     Starts high (explore the user) and decays toward pragmatic (propose actions).
-    Boosted when ToM reliability is low or beliefs are uncertain.
+    Boosted when ToM reliability is low, beliefs are uncertain, or emotional
+    prediction error is high (model is wrong about user's emotional state).
     """
     # Phase-dependent base value
     phase_base = {
@@ -78,7 +80,13 @@ def compute_lambda_epist(
     # Reliability discount: boost epistemic when ToM is unreliable
     reliability_factor = 1.0 + max(0.0, 0.5 - tom_reliability)
 
-    result = phase_base * temporal_factor * uncertainty_factor * reliability_factor
+    # Emotion prediction error boost: when our emotional model is wrong,
+    # increase exploration (ask questions, don't push interventions)
+    emotion_factor = 1.0
+    if emotion_prediction_error > 0.2:
+        emotion_factor = 1.0 + 0.8 * min(emotion_prediction_error, 1.0)
+
+    result = phase_base * temporal_factor * uncertainty_factor * reliability_factor * emotion_factor
     return result
 
 
@@ -95,6 +103,8 @@ def select_coaching_action(
     target_skill: Optional[str] = None,
     current_intervention=None,
     beta: float = 4.0,
+    emotion_prediction_error: float = 0.0,
+    emotion_valence_belief: Optional[np.ndarray] = None,
 ) -> Tuple[int, str, Dict]:
     """
     Full EFE-driven action selection with empathy blending.
@@ -110,6 +120,8 @@ def select_coaching_action(
         target_skill: Currently targeted skill (optional)
         current_intervention: Current intervention dict (optional)
         beta: Inverse temperature for softmax
+        emotion_prediction_error: Magnitude of emotional prediction error [0, ~1.4]
+        emotion_valence_belief: 5-element belief over valence states (optional)
 
     Returns:
         (action_idx, action_name, efe_info_dict)
@@ -117,7 +129,8 @@ def select_coaching_action(
     valid = VALID_ACTIONS.get(phase, [A_ASK_FREE, A_PROPOSE])
 
     lambda_epist = compute_lambda_epist(
-        phase, timestep, tom_reliability, beliefs
+        phase, timestep, tom_reliability, beliefs,
+        emotion_prediction_error=emotion_prediction_error,
     )
 
     # Determine which factors are relevant
@@ -171,6 +184,29 @@ def select_coaching_action(
         action_probs = blended_probs
         efe_values = blended_values
 
+    # Step 3: Emotional valence penalty on intervention actions
+    # When the user is in a negative emotional state, penalize pushing
+    # coaching interventions — prefer softer actions (ask, safety_check)
+    valence_negative_mass = None
+    if emotion_valence_belief is not None and len(emotion_valence_belief) >= 5:
+        valence_negative_mass = float(emotion_valence_belief[0] + emotion_valence_belief[1])
+        if valence_negative_mass > 0.4:
+            penalty = 0.5 * valence_negative_mass
+            for i, v in enumerate(valid):
+                if v in intervention_actions:
+                    efe_values[i] += penalty  # Higher G = worse action
+            # Re-select with penalty applied
+            from .utils import softmax as _softmax
+            q_values = -efe_values
+            penalized_probs = _softmax(q_values, temperature=1.0 / max(beta, 0.01))
+            best_idx = int(np.argmax(penalized_probs))
+            action_idx = valid[best_idx]
+            action_probs = penalized_probs
+            logger.info(
+                f"[EFE] Emotional valence penalty applied (neg_mass={valence_negative_mass:.2f}, "
+                f"penalty={penalty:.2f})"
+            )
+
     action_name = ACTION_NAMES[action_idx]
 
     info = {
@@ -185,6 +221,8 @@ def select_coaching_action(
         },
         "lambda_epist": round(lambda_epist, 3),
         "phase": phase,
+        "emotion_prediction_error": round(emotion_prediction_error, 3),
+        "valence_negative_mass": round(valence_negative_mass, 3) if valence_negative_mass is not None else None,
     }
 
     logger.info(

src/mindsphere/core/agent.py

@@ -254,14 +254,15 @@ class CoachingAgent:
             logger.warning(f"[LLM] Empty response — falling back to template (phase={self.phase})")
         return result
 
-    def _assess_cognitive_load(self, user_message: str = "") -> Dict[str, Any]:
+    def _assess_cognitive_load(self, user_message: str = "", emotional_data: Optional[Dict] = None) -> Dict[str, Any]:
         """
-        Infer cognitive load from ToM dimensions + conversation signals.
+        Infer cognitive load from ToM dimensions + conversation signals + emotional state.
 
         Uses:
         - ToM overwhelm_threshold (low = easily overwhelmed)
         - Recent sentiment signals from conversation
         - Message length and engagement patterns
+        - Emotional valence beliefs and prediction error from Circumplex POMDP
         """
         # ToM-based assessment
         tom_type = self.tom.get_user_type_summary()
@@ -321,6 +322,27 @@ class CoachingAgent:
         if len(user_message.strip()) < 10 and user_message.strip():
             signals.append("low_effort")
 
+        # === Emotional state integration (from Circumplex POMDP) ===
+        if emotional_data:
+            beliefs = emotional_data.get("emotional_beliefs", {})
+            valence_belief = beliefs.get("valence", {}).get("belief", [])
+
+            # Valence belief concentrated on negative states → emotional distress
+            if len(valence_belief) >= 5:
+                negative_mass = valence_belief[0] + valence_belief[1]
+                if negative_mass > 0.6:
+                    signals.append("emotional_distress")
+
+            # High prediction error → our emotional model was wrong
+            error_data = emotional_data.get("error", {})
+            if error_data.get("magnitude", 0) > 0.5:
+                signals.append("emotional_surprise")
+
+            # Current valence strongly negative
+            current = emotional_data.get("current_emotion", {})
+            if current and current.get("valence", 0) < -0.3:
+                signals.append("low_valence")
+
         # Track recent sentiments
         self._recent_sentiments.append(
             "disengaged" if "disengaged" in signals
@@ -344,6 +366,9 @@ class CoachingAgent:
         elif "off_topic" in signals or "deflection" in signals:
             load_level = "redirected"
             coaching_readiness = "not_ready"
+        elif "emotional_distress" in signals or "low_valence" in signals:
+            load_level = "emotionally_vulnerable"
+            coaching_readiness = "not_ready"
         elif "engaged" in signals:
             load_level = "optimal"
             coaching_readiness = "ready"
@@ -965,8 +990,8 @@ class CoachingAgent:
         # Run emotional inference
         emotional_data = self._run_emotional_inference(user_text)
 
-        # Assess cognitive load / intent
-        cog_load = self._assess_cognitive_load(user_text)
+        # Assess cognitive load / intent (with emotional data)
+        cog_load = self._assess_cognitive_load(user_text, emotional_data=emotional_data)
 
         # Update cognitive model
         self._update_user_model_from_text(user_text)
@@ -999,6 +1024,9 @@ class CoachingAgent:
             return result
 
         # === EFE-driven action selection ===
+        emotion_error_mag = emotional_data.get("error", {}).get("magnitude", 0.0)
+        valence_belief = self.emotion.belief_valence
+
         action_idx, action_name, efe_info = select_coaching_action(
             beliefs=self.beliefs,
             model=self.model,
@@ -1009,6 +1037,8 @@ class CoachingAgent:
             tom_filter=self.tom,
             target_skill=self.target_skill,
             current_intervention=self.current_intervention,
+            emotion_prediction_error=emotion_error_mag,
+            emotion_valence_belief=valence_belief,
         )
 
         # Only transition when EFE strongly favors it AND we've had some discussion
@@ -1350,7 +1380,7 @@ class CoachingAgent:
             "another step", "next step", "what else",
             "give me something", "another exercise", "what now",
         ])
-        cog_load = self._assess_cognitive_load(user_text)
+        cog_load = self._assess_cognitive_load(user_text, emotional_data=emotional_data)
         if wants_more_action and cog_load["coaching_readiness"] != "not_ready":
             self._track_conversation("user", user_text)
             result = self._propose_next_coaching_step()
@@ -1382,6 +1412,9 @@ class CoachingAgent:
             }
 
         # === EFE-driven action selection ===
+        emotion_error_mag = emotional_data.get("error", {}).get("magnitude", 0.0)
+        valence_belief = self.emotion.belief_valence
+
         action_idx, action_name, efe_info = select_coaching_action(
             beliefs=self.beliefs,
             model=self.model,
@@ -1392,6 +1425,8 @@ class CoachingAgent:
             tom_filter=self.tom,
             target_skill=self.target_skill,
             current_intervention=self.current_intervention,
+            emotion_prediction_error=emotion_error_mag,
+            emotion_valence_belief=valence_belief,
         )
 
         # Dispatch based on EFE-selected action