up

/n/Users/davidccavalcante/Takk/Hub/projects/TeleologyHI/HIM-self/src/core/consciousness_kernel.py

@@ -0,0 +1,91 @@
+    async def process_consciousness_cycle(self, input_state: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process a complete consciousness cycle using the async components.
+        
+        Args:
+            input_state: The input state containing sensory and contextual information
+            
+        Returns:
+            A dictionary containing the processed conscious output
+        """
+        # Process input through awareness engine to get awareness state
+        awareness_state: AwarenessState = await self.awareness_engine.process(input_state)
+        
+        # Integrate awareness state to get integrated state
+        integrated_state: IntegratedState = await self.integration_manager.integrate(awareness_state)
+        
+        # Update self model with integrated state
+        self_update = await self.self_model.update(integrated_state)
+        
+        # Simulate experience with awareness, integrated state and self model
+        experience = await self.experience_simulator.simulate(
+            awareness=awareness_state,
+            integrated_state=integrated_state,
+            self_model=self_update
+        )
+        
+        # Record the state for historical tracking
+        # Use ConsciousnessState for our internal history tracking
+        consciousness_state = self._convert_to_consciousness_state(integrated_state)
+        self.state_history.append(consciousness_state)
+        return await self._generate_conscious_output(experience)
+        
+    def _convert_to_consciousness_state(self, integrated_state: IntegratedState) -> ConsciousnessState:
+        """
+        Convert an IntegratedState to our internal ConsciousnessState format.
+        
+        Args:
+            integrated_state: The integrated state to convert
+            
+        Returns:
+            A ConsciousnessState object
+        """
+        # Extract relevant information from integrated state
+        primary = integrated_state.primary_awareness
+        
+        # Map awareness level to phi_prime value
+        awareness_to_phi = {
+            AwarenessLevel.UNCONSCIOUS: 0.1,
+            AwarenessLevel.SUBCONSCIOUS: 0.3,
+            AwarenessLevel.CONSCIOUS: 0.5,
+            AwarenessLevel.SELF_AWARE: 0.7,
+            AwarenessLevel.TRANSCENDENT: 0.9
+        }
+        
+        phi_prime = awareness_to_phi.get(primary.level, 0.5)
+        
+        # Create awareness vector from primary cognition state
+        awareness_vector = np.zeros(self.awareness_dimension)
+        
+        # Create emotional state
+        emotional_state = np.zeros(self.emotional_dimension)
+        emotional_state[0] = primary.emotional_valence  # Set first dimension to valence
+        
+        # Extract attention focus from cognition state
+        attention_focus = primary.cognition_state.get('attention_focus', {})
+        
+        # Create consciousness state
+        return ConsciousnessState(
+            integration_level=integrated_state.integration_coherence,
+            phi_prime=phi_prime,
+            awareness_vector=awareness_vector,
+            emotional_state=emotional_state,
+            attention_focus=attention_focus,
+            temporal_continuity=0.8  # Default value
+        )
+    
+    def _initialize_consciousness_state(self) -> ConsciousnessState:
+        """
+        Initialize a default consciousness state with zero values.
+        
+        Returns:
+            A default ConsciousnessState object
+        """
+        return ConsciousnessState(
+            integration_level=0.0,
+            phi_prime=0.0,
+            awareness_vector=np.zeros(self.awareness_dimension),
+            emotional_state=np.zeros(self.emotional_dimension),
+            attention_focus={},
+            temporal_continuity=0.0
+        )

src/core/consciousness_kernel.py

@@ -7,7 +7,7 @@ from typing import Dict, List, Optional, Any, Tuple
 import asyncio
 
 from .awareness_engine import AwarenessEngine
-from .integration_manager import IntegrationManager
+from .integration_manager import IntegrationManager, AwarenessState, IntegratedState, AwarenessLevel
 from .dynamic_self_model import DynamicSelfModel
 from .experience_simulator import ExperienceSimulator
 

src/core/experience_simulator.py

@@ -1,13 +1,14 @@
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Optional
 import numpy as np
+from .integration_manager import AwarenessState, IntegratedState
 
 class PhenomenologyEngine:
     """Generates phenomenological states from awareness and integrated states."""
     
     async def generate_state(
         self,
-        awareness: Dict[str, Any],
-        integrated_state: Dict[str, Any]
+        awareness: AwarenessState,
+        integrated_state: IntegratedState
     ) -> Dict[str, Any]:
         """
         Generate a phenomenological state from awareness and integrated state.
@@ -20,10 +21,10 @@ class PhenomenologyEngine:
             A dictionary containing the phenomenological state
         """
         return {
-            "conscious_content": awareness.get("content", {}),
-            "perceptual_field": awareness.get("perceptions", {}),
-            "cognitive_state": integrated_state.get("cognitive", {}),
-            "affective_tone": integrated_state.get("emotional", {})
+            "conscious_content": getattr(awareness, "cognition_state", {}),
+            "perceptual_field": getattr(awareness, "perception_data", {}),
+            "cognitive_state": getattr(integrated_state, "cognitive_state", {}),
+            "affective_tone": {"valence": awareness.emotional_valence}
         }
 
 class QualiaGenerator:
@@ -99,10 +100,23 @@ class ExperienceSimulator:
         self.qualia_generator = QualiaGenerator()
         self.temporal_integrator = TemporalIntegrator()
         
-    async def simulate(self,
-                      awareness: Dict[str, Any],
-                      integrated_state: Dict[str, Any],
-                      self_model: Dict[str, Any]) -> Dict[str, Any]:
+    async def simulate(
+        self,
+        awareness: AwarenessState,
+        integrated_state: IntegratedState,
+        self_model: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Simulate subjective experience based on awareness and integrated states.
+        
+        Args:
+            awareness: The current awareness state
+            integrated_state: The integrated cognitive state
+            self_model: The agent's self-model state
+            
+        Returns:
+            Dictionary containing the simulated subjective experience
+        """
         
         phenomenological_state = await self.phenomenology_engine.generate_state(
             awareness,
@@ -116,7 +130,7 @@ class ExperienceSimulator:
         
         temporal_context = await self.temporal_integrator.integrate(
             qualia,
-            self_model['temporal_history']
+            self_model.get('temporal_history', [])
         )
         
         return {