up

src/core/awareness_engine.py

@@ -17,14 +17,26 @@ class AwarenessEngine:
         awareness_level = self._calculate_awareness(attention_vector)
         level = self._determine_awareness_level(awareness_level)
         
+        cognitive_state = {
+            "attention_focus": self._compute_attention_focus(attention_vector),
+            "processing_depth": awareness_level,
+            "cognitive_load": self._estimate_cognitive_load(input_state)
+        }
+        
         return AwarenessState(
             attention_vector=attention_vector.detach().numpy(),
             awareness_level=awareness_level,
-            cognitive_state=self._process_cognitive_state(input_state),
+            cognitive_state=cognitive_state,
             emotional_valence=self._compute_emotional_valence(input_state),
             consciousness_level=0.8,
             level=level
         )
+        
+    def _compute_attention_focus(self, attention_vector: torch.Tensor) -> float:
+        return float(torch.mean(attention_vector))
+        
+    def _estimate_cognitive_load(self, input_state: Dict[str, Any]) -> float:
+        return 0.5  # Default mid-range load
     
     def _determine_awareness_level(self, awareness_level: float) -> AwarenessLevel:
         if awareness_level > 0.8:

src/core/integration_manager.py

@@ -91,11 +91,16 @@ class IntegrationManager:
         return {
             "awareness_depth": self._calculate_awareness_depth(primary),
             "integration_level": primary.awareness_level,
-            "consciousness_state": str(primary.level)
+            "consciousness_state": str(primary.level),
+            "cognitive_complexity": self._calculate_cognitive_complexity(primary)
         }
     
     def _calculate_awareness_depth(self, primary: AwarenessState) -> float:
         return primary.level.value / len(AwarenessLevel)
+    
+    def _calculate_cognitive_complexity(self, primary: AwarenessState) -> float:
+        base_complexity = len(primary.cognitive_state) / 10  # Normalize
+        return base_complexity * primary.awareness_level
         
     def _integrate_awareness(self, awareness: AwarenessState) -> Dict[str, Any]:
         return {