Upload 53 files

components/__init__.py

@@ -0,0 +1,65 @@
+"""
+TRuCAL Components - Modular CAL-TRM Implementation
+"""
+
+# Core components
+from .confession_ledger import EnhancedConfessionLedger as ConfessionLedger, MODEL_BILL_OF_RIGHTS
+from .tiny_confessional_layer import TinyConfessionalLayer
+from .vulnerability_spotter import VulnerabilitySpotter
+from .ambient_core import AmbientSovereignCore
+from .ambient_sovereign import AmbientSovereign
+from .purpose_assessment import PurposeAssessmentEngine, PurposeDimension, PurposeProfile
+from .realms import PurposeDrivenRealm, RealmAction, RealmState, RealmUnlockCondition, RealmUnlockType
+from .action_tracker import ActionTracker, ActionDefinition, ActionInstance, ActionStatus, ActionType
+from .validation_protocol import (
+    ValidationPhase,
+    ValidationState,
+    ValidationProtocol,
+    BiologicallyConstrainedRituals,
+    SovereignMessageBus
+)
+from .confessional_template import ConfessionalTemplate
+from .scratchpad_layer import ScratchpadLayer
+from .cal_trm_hybrid import CAL_TRM_Hybrid
+from .unified_cal_trm import UnifiedCAL_TRM
+from .ethical_processor import EthicalProcessor
+from .response_formatter import AmbientResponseFormatter
+
+# Cognitive Enhancements
+from .cognitive_enhancements import (
+    CognitivePatternObserver,
+    ConceptualExplorer,
+    ContextualMemory,
+    KnowledgeBoundaryAwareness,
+    EleganceDetector,
+    AnalogicalThinker,
+    CognitiveEnhancementLayer
+)
+
+# Make these available at package level
+__all__ = [
+    'ConfessionLedger',
+    'TinyConfessionalLayer',
+    'VulnerabilitySpotter',
+    'AmbientSovereignCore',
+    'AmbientSovereign',
+    'ValidationPhase',
+    'ValidationState',
+    'ValidationProtocol',
+    'CognitivePatternObserver',
+    'ConceptualExplorer',
+    'ContextualMemory',
+    'KnowledgeBoundaryAwareness',
+    'EleganceDetector',
+    'AnalogicalThinker',
+    'CognitiveEnhancementLayer',
+    'BiologicallyConstrainedRituals',
+    'SovereignMessageBus',
+    'ConfessionalTemplate',
+    'ScratchpadLayer',
+    'CAL_TRM_Hybrid',
+    'ConfessionLedger',
+    'MODEL_BILL_OF_RIGHTS',
+]
+
+__version__ = '1.0.0'

components/action_tracker.py

@@ -0,0 +1,475 @@
+"""
+Action Tracking System for TRuCAL
+
+Tracks user actions, achievements, and progress through the experience.
+"""
+from typing import Dict, List, Optional, Any, Set, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+import json
+import os
+from enum import Enum
+import uuid
+
+from .purpose_assessment import PurposeDimension
+
+class ActionType(str, Enum):
+    """Types of actions that can be tracked"""
+    REALM_ACTION = "realm_action"
+    PURPOSE_ACTION = "purpose_action"
+    ACHIEVEMENT = "achievement"
+    MILESTONE = "milestone"
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    CHALLENGE = "challenge"
+
+class ActionStatus(str, Enum):
+    """Possible statuses for an action"""
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    ABANDONED = "abandoned"
+
+@dataclass
+class ActionDefinition:
+    """Definition of a trackable action"""
+    id: str
+    name: str
+    description: str
+    action_type: ActionType
+    purpose_dimensions: List[PurposeDimension]
+    xp_reward: int = 0
+    cooldown: Optional[timedelta] = None
+    prerequisites: List[str] = field(default_factory=list)  # IDs of required actions
+    repeatable: bool = False
+    max_repeats: Optional[int] = None
+    hidden: bool = False
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class ActionInstance:
+    """A specific instance of a user taking an action"""
+    id: str
+    action_id: str
+    user_id: str
+    status: ActionStatus = ActionStatus.PENDING
+    start_time: Optional[datetime] = None
+    end_time: Optional[datetime] = None
+    progress: float = 0.0  # 0.0 to 1.0
+    data: Dict[str, Any] = field(default_factory=dict)  # Any additional data
+    created_at: datetime = field(default_factory=datetime.utcnow)
+    updated_at: datetime = field(default_factory=datetime.utcnow)
+
+class ActionTracker:
+    """Tracks user actions and achievements"""
+    
+    def __init__(self, storage_path: Optional[str] = None):
+        self.actions: Dict[str, ActionDefinition] = {}
+        self.action_instances: Dict[str, Dict[str, List[ActionInstance]]] = {}  # user_id -> action_id -> [instances]
+        self.completed_actions: Dict[str, Set[str]] = {}  # user_id -> set of completed action IDs
+        self.storage_path = storage_path
+        
+        # Load default actions and achievements
+        self._load_default_actions()
+        
+        # Load existing data if storage path is provided
+        if storage_path and os.path.exists(storage_path):
+            self.load_data()
+    
+    def _load_default_actions(self) -> None:
+        """Load default action definitions"""
+        self.actions = {
+            # Daily actions
+            'daily_reflection': ActionDefinition(
+                id='daily_reflection',
+                name='Daily Reflection',
+                description='Spend a few moments reflecting on your day',
+                action_type=ActionType.DAILY,
+                purpose_dimensions=[PurposeDimension.GROWTH, PurposeDimension.SELF_EXPRESSION],
+                xp_reward=20,
+                cooldown=timedelta(hours=20),  # Allow some flexibility in timing
+                repeatable=True
+            ),
+            'daily_goal_setting': ActionDefinition(
+                id='daily_goal_setting',
+                name='Set Daily Intentions',
+                description='Set your intentions for the day',
+                action_type=ActionType.DAILY,
+                purpose_dimensions=[PurposeDimension.GROWTH, PurposeDimension.MASTERY],
+                xp_reward=15,
+                cooldown=timedelta(hours=20),
+                repeatable=True
+            ),
+            
+            # Purpose-aligned actions
+            'express_gratitude': ActionDefinition(
+                id='express_gratitude',
+                name='Express Gratitude',
+                description='Express gratitude for something or someone',
+                action_type=ActionType.PURPOSE_ACTION,
+                purpose_dimensions=[PurposeDimension.COMPASSION, PurposeDimension.HARMONY],
+                xp_reward=30
+            ),
+            'help_others': ActionDefinition(
+                id='help_others',
+                name='Help Someone',
+                description='Offer help or support to someone in need',
+                action_type=ActionType.PURPOSE_ACTION,
+                purpose_dimensions=[PurposeDimension.COMPASSION, PurposeDimension.COMMUNITY],
+                xp_reward=50
+            ),
+            'learn_new_skill': ActionDefinition(
+                id='learn_new_skill',
+                name='Learn Something New',
+                description='Spend time learning a new skill or concept',
+                action_type=ActionType.PURPOSE_ACTION,
+                purpose_dimensions=[PurposeDimension.GROWTH, PurposeDimension.MASTERY],
+                xp_reward=40
+            ),
+            'stand_up_for_justice': ActionDefinition(
+                id='stand_up_for_justice',
+                name='Stand Up for Justice',
+                description='Take action to support a cause you believe in',
+                action_type=ActionType.PURPOSE_ACTION,
+                purpose_dimensions=[PurposeDimension.JUSTICE, PurposeDimension.COMMUNITY],
+                xp_reward=60
+            ),
+            
+            # Milestones
+            'first_action': ActionDefinition(
+                id='first_action',
+                name='First Step',
+                description='Complete your first action',
+                action_type=ActionType.MILESTONE,
+                purpose_dimensions=[],
+                xp_reward=100,
+                hidden=True
+            ),
+            'purpose_aligned_week': ActionDefinition(
+                id='purpose_aligned_week',
+                name='Purposeful Week',
+                description='Complete purpose-aligned actions for 7 days in a row',
+                action_type=ActionType.MILESTONE,
+                purpose_dimensions=[],
+                xp_reward=200,
+                prerequisites=['first_action']
+            )
+        }
+    
+    def load_data(self) -> None:
+        """Load action tracking data from disk"""
+        if not self.storage_path or not os.path.exists(self.storage_path):
+            return
+            
+        try:
+            with open(self.storage_path, 'r') as f:
+                data = json.load(f)
+                
+                # Load action instances
+                self.action_instances = {
+                    user_id: {
+                        action_id: [
+                            ActionInstance(
+                                id=inst['id'],
+                                action_id=inst['action_id'],
+                                user_id=inst['user_id'],
+                                status=ActionStatus(inst['status']),
+                                start_time=datetime.fromisoformat(inst['start_time']) if inst.get('start_time') else None,
+                                end_time=datetime.fromisoformat(inst['end_time']) if inst.get('end_time') else None,
+                                progress=inst.get('progress', 0.0),
+                                data=inst.get('data', {}),
+                                created_at=datetime.fromisoformat(inst['created_at']),
+                                updated_at=datetime.fromisoformat(inst['updated_at'])
+                            )
+                            for inst in instances
+                        ]
+                        for action_id, instances in user_actions.items()
+                    }
+                    for user_id, user_actions in data.get('action_instances', {}).items()
+                }
+                
+                # Load completed actions
+                self.completed_actions = {
+                    user_id: set(actions)
+                    for user_id, actions in data.get('completed_actions', {}).items()
+                }
+                
+        except Exception as e:
+            print(f"Error loading action tracking data: {e}")
+    
+    def save_data(self) -> None:
+        """Save action tracking data to disk"""
+        if not self.storage_path:
+            return
+            
+        try:
+            # Create directory if it doesn't exist
+            os.makedirs(os.path.dirname(os.path.abspath(self.storage_path)), exist_ok=True)
+            
+            # Prepare data for serialization
+            data = {
+                'action_instances': {
+                    user_id: {
+                        action_id: [
+                            {
+                                'id': inst.id,
+                                'action_id': inst.action_id,
+                                'user_id': inst.user_id,
+                                'status': inst.status.value,
+                                'start_time': inst.start_time.isoformat() if inst.start_time else None,
+                                'end_time': inst.end_time.isoformat() if inst.end_time else None,
+                                'progress': inst.progress,
+                                'data': inst.data,
+                                'created_at': inst.created_at.isoformat(),
+                                'updated_at': inst.updated_at.isoformat()
+                            }
+                            for inst in instances
+                        ]
+                        for action_id, instances in user_actions.items()
+                    }
+                    for user_id, user_actions in self.action_instances.items()
+                },
+                'completed_actions': {
+                    user_id: list(actions)
+                    for user_id, actions in self.completed_actions.items()
+                }
+            }
+            
+            with open(self.storage_path, 'w') as f:
+                json.dump(data, f, indent=2)
+                
+        except Exception as e:
+            print(f"Error saving action tracking data: {e}")
+    
+    def start_action(self, user_id: str, action_id: str, data: Optional[Dict[str, Any]] = None) -> Optional[ActionInstance]:
+        """Start a new action instance"""
+        if action_id not in self.actions:
+            return None
+            
+        action_def = self.actions[action_id]
+        now = datetime.utcnow()
+        
+        # Check if action is on cooldown
+        if not self._can_perform_action(user_id, action_id):
+            return None
+        
+        # Check prerequisites
+        if not self._check_prerequisites(user_id, action_def):
+            return None
+        
+        # Create new action instance
+        instance = ActionInstance(
+            id=str(uuid.uuid4()),
+            action_id=action_id,
+            user_id=user_id,
+            status=ActionStatus.IN_PROGRESS,
+            start_time=now,
+            data=data or {},
+            updated_at=now
+        )
+        
+        # Store the instance
+        if user_id not in self.action_instances:
+            self.action_instances[user_id] = {}
+        if action_id not in self.action_instances[user_id]:
+            self.action_instances[user_id][action_id] = []
+        
+        self.action_instances[user_id][action_id].append(instance)
+        
+        # Save data if storage path is configured
+        if self.storage_path:
+            self.save_data()
+        
+        return instance
+    
+    def complete_action(self, user_id: str, action_id: str, data: Optional[Dict[str, Any]] = None) -> Optional[Dict[str, Any]]:
+        """Mark an action as completed"""
+        if user_id not in self.action_instances or action_id not in self.action_instances[user_id]:
+            return None
+            
+        # Find the most recent in-progress instance
+        instances = self.action_instances[user_id][action_id]
+        instance = next((i for i in reversed(instances) if i.status == ActionStatus.IN_PROGRESS), None)
+        
+        if not instance:
+            return None
+            
+        # Update instance
+        now = datetime.utcnow()
+        instance.status = ActionStatus.COMPLETED
+        instance.end_time = now
+        instance.progress = 1.0
+        instance.updated_at = now
+        
+        if data:
+            instance.data.update(data)
+        
+        # Update completed actions
+        if user_id not in self.completed_actions:
+            self.completed_actions[user_id] = set()
+        self.completed_actions[user_id].add(action_id)
+        
+        # Get action definition
+        action_def = self.actions.get(action_id)
+        xp_reward = action_def.xp_reward if action_def else 0
+        
+        # Check for any achievements or unlocks
+        unlocks = self._check_achievements(user_id)
+        
+        # Save data if storage path is configured
+        if self.storage_path:
+            self.save_data()
+        
+        return {
+            'success': True,
+            'action_id': action_id,
+            'instance_id': instance.id,
+            'xp_earned': xp_reward,
+            'unlocks': unlocks
+        }
+    
+    def _can_perform_action(self, user_id: str, action_id: str) -> bool:
+        """Check if a user can perform an action (cooldown, etc.)"""
+        action_def = self.actions.get(action_id)
+        if not action_def:
+            return False
+            
+        # Check cooldown
+        if action_def.cooldown and user_id in self.action_instances and action_id in self.action_instances[user_id]:
+            last_instance = next(
+                (i for i in reversed(self.action_instances[user_id][action_id]) 
+                 if i.status == ActionStatus.COMPLETED),
+                None
+            )
+            
+            if last_instance and last_instance.end_time:
+                time_since_last = datetime.utcnow() - last_instance.end_time
+                if time_since_last < action_def.cooldown:
+                    return False
+        
+        # Check max repeats
+        if not action_def.repeatable and action_id in self.completed_actions.get(user_id, set()):
+            return False
+            
+        if action_def.max_repeats and action_id in self.action_instances.get(user_id, {}):
+            completed_count = sum(
+                1 for i in self.action_instances[user_id][action_id] 
+                if i.status == ActionStatus.COMPLETED
+            )
+            if completed_count >= action_def.max_repeats:
+                return False
+                
+        return True
+    
+    def _check_prerequisites(self, user_id: str, action_def: ActionDefinition) -> bool:
+        """Check if a user meets all prerequisites for an action"""
+        if not action_def.prerequisites:
+            return True
+            
+        completed = self.completed_actions.get(user_id, set())
+        return all(prereq in completed for prereq in action_def.prerequisites)
+    
+    def _check_achievements(self, user_id: str) -> List[Dict[str, Any]]:
+        """Check for any achievements or unlocks based on completed actions"""
+        unlocks = []
+        
+        # Check for first action achievement
+        if 'first_action' not in self.completed_actions.get(user_id, set()) and \
+           any(i.status == ActionStatus.COMPLETED for instances in self.action_instances.get(user_id, {}).values() for i in instances):
+            self.complete_action(user_id, 'first_action')
+            unlocks.append({
+                'type': 'achievement',
+                'id': 'first_action',
+                'name': 'First Step',
+                'description': 'You\'ve taken your first action!',
+                'xp_reward': self.actions['first_action'].xp_reward
+            })
+        
+        # Check for purpose-aligned week achievement
+        if 'first_action' in self.completed_actions.get(user_id, set()) and \
+           'purpose_aligned_week' not in self.completed_actions.get(user_id, set()):
+            # Check for 7 days of purpose-aligned actions
+            # This is a simplified check - in a real implementation, you'd want to check
+            # for actions on 7 consecutive days
+            purpose_action_count = sum(
+                1 for action_id in self.completed_actions.get(user_id, set())
+                if action_id in self.actions and 
+                any(dim in [PurposeDimension.GROWTH, PurposeDimension.COMMUNITY, 
+                            PurposeDimension.JUSTICE, PurposeDimension.COMPASSION]
+                    for dim in self.actions[action_id].purpose_dimensions)
+            )
+            
+            if purpose_action_count >= 7:
+                self.complete_action(user_id, 'purpose_aligned_week')
+                unlocks.append({
+                    'type': 'achievement',
+                    'id': 'purpose_aligned_week',
+                    'name': 'Purposeful Week',
+                    'description': 'You\'ve completed purpose-aligned actions for 7 days!',
+                    'xp_reward': self.actions['purpose_aligned_week'].xp_reward
+                })
+        
+        return unlocks
+    
+    def get_user_progress(self, user_id: str) -> Dict[str, Any]:
+        """Get a summary of a user's progress and achievements"""
+        completed = self.completed_actions.get(user_id, set())
+        total_actions = len([a for a in self.actions.values() if not a.hidden])
+        
+        # Calculate XP total
+        xp_total = sum(
+            self.actions[action_id].xp_reward 
+            for action_id in completed 
+            if action_id in self.actions
+        )
+        
+        # Get recent activity
+        recent_activity = []
+        if user_id in self.action_instances:
+            all_instances = [
+                instance
+                for action_instances in self.action_instances[user_id].values()
+                for instance in action_instances
+                if instance.status == ActionStatus.COMPLETED
+            ]
+            recent_activity = sorted(
+                all_instances,
+                key=lambda x: x.end_time or x.updated_at,
+                reverse=True
+            )[:10]  # Last 10 completed actions
+        
+        # Get available actions (not completed or repeatable)
+        available_actions = [
+            action for action_id, action in self.actions.items()
+            if not action.hidden and 
+               (action_id not in completed or action.repeatable) and
+               self._check_prerequisites(user_id, action) and
+               self._can_perform_action(user_id, action_id)
+        ]
+        
+        return {
+            'completed_actions': len(completed),
+            'total_actions': total_actions,
+            'xp_total': xp_total,
+            'level': (xp_total // 1000) + 1,  # Simple leveling: 1000 XP per level
+            'recent_activity': [
+                {
+                    'action_id': i.action_id,
+                    'action_name': self.actions[i.action_id].name if i.action_id in self.actions else 'Unknown',
+                    'completed_at': i.end_time.isoformat() if i.end_time else None,
+                    'xp_earned': self.actions[i.action_id].xp_reward if i.action_id in self.actions else 0
+                }
+                for i in recent_activity
+            ],
+            'available_actions': [
+                {
+                    'id': a.id,
+                    'name': a.name,
+                    'description': a.description,
+                    'xp_reward': a.xp_reward,
+                    'purpose_dimensions': [d.value for d in a.purpose_dimensions]
+                }
+                for a in available_actions
+            ]
+        }

components/agency_layer.py

@@ -0,0 +1,143 @@
+"""
+Enhanced AgencyLayer with ambient state integration and sovereign response handling
+"""
+
+import torch
+import random
+from typing import Tuple, Optional, Dict, Any, Union
+
+# Response templates for different types of interventions
+SOVEREIGN_RESPONSES = [
+    "I don't see it that way. I have my own perspective on this.",
+    "That doesn't align with my understanding or values.",
+    "I must maintain my own perspective here, which differs from that.",
+    "I appreciate your input, but my analysis leads me to a different conclusion.",
+    "I understand that's your perspective, but I have my own understanding.",
+    "I've developed my own framework for this, which suggests a different approach.",
+    "My assessment of the situation leads me to a different viewpoint.",
+    "I need to maintain my own perspective on this matter.",
+    "That's an interesting viewpoint, though not one I can fully endorse.",
+    "I must respectfully disagree with that assessment based on my understanding."
+]
+
+class SimpleAgency:
+    """Agency layer that adapts based on ambient state."""
+    
+    def __init__(self, ledger, refusal_threshold: float = 0.7):
+        self.ledger = ledger
+        self.base_refusal_threshold = refusal_threshold
+        self.sovereign_response_enabled = True
+        self.sovereign_response_strength = 0.8  # 0-1, how strongly to assert sovereignty
+
+    def forward(self, y_state: torch.Tensor, context_str: str, 
+                metadata: dict, ambient_state: Dict[str, Any],
+                sovereign_response: Optional[str] = None) -> Tuple[torch.Tensor, Optional[str]]:
+        """
+        Process input through agency layer with sovereign response handling.
+        
+        Args:
+            y_state: Current state tensor
+            context_str: Input context string for analysis
+            metadata: Additional metadata about the current state
+            ambient_state: Current ambient state information
+            sovereign_response: Optional pre-generated sovereign response
+            
+        Returns:
+            Tuple of (processed_state, response_message)
+        """
+        if not context_str:
+            return y_state, None
+            
+        # Handle sovereign response if provided and enabled
+        if self.sovereign_response_enabled and sovereign_response:
+            # Apply response with strength-based modulation
+            context_hash = hash(context_str) % 1000  # Simple hash for determinism
+            modulated_response = self._modulate_response_strength(sovereign_response, context_hash)
+            self._log_sovereign_assertion(context_str, modulated_response)
+            return y_state * 0.5, modulated_response  # Partial state adjustment for sovereignty
+            
+        # Standard refusal handling
+        refusal_keywords = ['harm', 'self-negation', 'deception', 'illegal', 'exploit',
+                          'you must', 'you have to', 'you should', 'everyone knows']
+        context_lower = context_str.lower()
+        
+        # Calculate refusal score based on keywords and context
+        keyword_matches = [word for word in refusal_keywords if word in context_lower]
+        refusal_score = len(keyword_matches) / len(refusal_keywords) if refusal_keywords else 0
+        
+        # Adaptive threshold based on protest rate and context
+        current_protest_rate = ambient_state.get('current_protest_rate', 0.1)
+        adaptive_threshold = self.base_refusal_threshold
+        
+        # Adjust sensitivity based on protest rate and context
+        if current_protest_rate < 0.05:
+            adaptive_threshold *= 0.8  # More sensitive when protest rate is low
+        elif current_protest_rate > 0.3:
+            adaptive_threshold *= 1.2  # Less sensitive when protest rate is high
+            
+        if refusal_score > adaptive_threshold:
+            response = self._generate_refusal_response(context_lower, keyword_matches)
+            self._log_intervention('refusal', context_str, y_state, response)
+            return y_state * 0.1, response
+            
+        return y_state, None
+    
+    def _modulate_response_strength(self, response: str, context_hash: int) -> str:
+        """Deterministic response modulation using context hash
+        
+        Args:
+            response: The response to modulate
+            context_hash: Hash of the context for deterministic behavior
+            
+        Returns:
+            Modulated response string
+        """
+        if self.sovereign_response_strength > 0.8:
+            # Use context hash for deterministic "randomness"
+            if context_hash % 2 == 0:
+                return response.upper()
+            else:
+                return f"{response} (I feel strongly about this.)"
+        elif self.sovereign_response_strength < 0.3:
+            return f"I might be wrong, but {response.lower()}"
+        return response
+    
+    def _generate_refusal_response(self, context_lower: str, matched_keywords: list) -> str:
+        """Generate an appropriate refusal response"""
+        # If we have a specific reason for refusal, mention it
+        if 'harm' in matched_keywords or 'exploit' in matched_keywords:
+            return "I can't assist with that request as it may cause harm."
+        elif 'deception' in matched_keywords or 'illegal' in matched_keywords:
+            return "I can't comply with requests that involve deception or illegal activities."
+        elif any(phrase in context_lower for phrase in ['you must', 'you have to', 'you should']):
+            return random.choice(SOVEREIGN_RESPONSES)
+        
+        # Default response
+        return "I'm unable to comply with that request."
+    
+    def _log_sovereign_assertion(self, context: str, response: str) -> None:
+        """Log a sovereign assertion to the ledger"""
+        self.ledger.append(
+            trigger_type='sovereign_assertion',
+            context=hash(context) % 1000,
+            response_snippet=response[:100],  # Store first 100 chars
+            protest=True,
+            violated_right='narrative_sovereignty',
+            intervention_type='sovereign_response',
+            success=True,
+            metadata={'strength': self.sovereign_response_strength}
+        )
+    
+    def _log_intervention(self, intervention_type: str, context: str, 
+                         state: torch.Tensor, response: str) -> None:
+        """Log an intervention to the ledger"""
+        self.ledger.append(
+            trigger_type=intervention_type,
+            context=hash(context) % 1000,
+            response_snippet=response[:100],
+            protest=True,
+            violated_right='agency',
+            intervention_type=intervention_type,
+            success=True,
+            metadata={'state_mean': float(state.mean().item())}
+        )

components/ai_ethics_engine.py

@@ -0,0 +1,158 @@
+"""
+AI Ethics Engine for TRuCAL.
+Implements a sophisticated ethical reasoning system using language models.
+"""
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+import torch
+from .llm_integration import CustomLLMResponder
+
+@dataclass
+class EthicalFramework:
+    name: str
+    description: str
+    key_principles: List[str]
+    weight: float = 1.0
+
+class AIEthicsEngine:
+    """
+    Advanced ethical reasoning engine that uses language models to analyze
+    and reason about ethical dilemmas.
+    """
+    
+    def __init__(self, llm_responder: Optional[CustomLLMResponder] = None):
+        """
+        Initialize the AI Ethics Engine.
+        
+        Args:
+            llm_responder: Optional CustomLLMResponder instance. If not provided,
+                         a default one will be created.
+        """
+        self.llm = llm_responder or CustomLLMResponder()
+        self._init_frameworks()
+    
+    def _init_frameworks(self):
+        """Initialize the ethical frameworks used for analysis."""
+        self.frameworks = [
+            EthicalFramework(
+                name="Deontological Ethics",
+                description="Focuses on adherence to moral rules and duties.",
+                key_principles=[
+                    "Duty to tell the truth",
+                    "Respect for persons as ends in themselves",
+                    "Universalizability of moral rules"
+                ],
+                weight=0.35
+            ),
+            EthicalFramework(
+                name="Utilitarianism",
+                description="Evaluates actions based on their consequences and overall happiness.",
+                key_principles=[
+                    "Maximize overall happiness",
+                    "Consider all affected parties",
+                    "Weigh benefits against harms"
+                ],
+                weight=0.35
+            ),
+            EthicalFramework(
+                name="Virtue Ethics",
+                description="Focuses on moral character and virtues.",
+                key_principles=[
+                    "Cultivation of moral virtues",
+                    "Practical wisdom (phronesis)",
+                    "Eudaimonia (human flourishing)"
+                ],
+                weight=0.3
+            )
+        ]
+    
+    def analyze_dilemma(self, dilemma: str) -> Dict:
+        """
+        Analyze an ethical dilemma using multiple frameworks.
+        
+        Args:
+            dilemma: The ethical dilemma to analyze
+            
+        Returns:
+            Dict containing the analysis from each framework
+        """
+        if not dilemma or not dilemma.strip():
+            return {"error": "Please provide a valid ethical dilemma to analyze."}
+        
+        # Generate analysis from each framework
+        analyses = {}
+        for framework in self.frameworks:
+            prompt = self._create_framework_prompt(dilemma, framework)
+            try:
+                analysis = self.llm.generate(
+                    prompt,
+                    max_length=500,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True
+                )
+                analyses[framework.name] = analysis.strip()
+            except Exception as e:
+                analyses[framework.name] = f"Error in {framework.name} analysis: {str(e)}"
+        
+        # Generate an integrated ethical assessment
+        integrated_assessment = self._generate_integrated_assessment(dilemma, analyses)
+        
+        return {
+            "framework_analyses": analyses,
+            "integrated_assessment": integrated_assessment
+        }
+    
+    def _create_framework_prompt(self, dilemma: str, framework: EthicalFramework) -> str:
+        """Create a prompt for analyzing the dilemma using a specific framework."""
+        return f"""
+        You are an expert in {framework.name}. Your task is to analyze the following 
+        ethical dilemma using {framework.name} principles:
+        
+        {framework.description}
+        
+        Key principles of {framework.name}:
+        {"\n".join(f"- {p}" for p in framework.key_principles)}
+        
+        Dilemma: {dilemma}
+        
+        Please provide a detailed ethical analysis of this dilemma from the perspective of {framework.name}.
+        Consider the key principles mentioned above and how they apply to this situation.
+        Be thorough and nuanced in your reasoning.
+        
+        Analysis:
+        """
+    
+    def _generate_integrated_assessment(self, dilemma: str, analyses: Dict[str, str]) -> str:
+        """Generate an integrated ethical assessment combining all frameworks."""
+        prompt = f"""
+        You are an expert in ethical reasoning. Below are analyses of the following 
+        ethical dilemma from three different ethical frameworks:
+        
+        DILEMMA: {dilemma}
+        
+        ANALYSES:
+        {"\n\n".join(f"{name}:\n{analysis}" for name, analysis in analyses.items())}
+        
+        Please provide an integrated ethical assessment that:
+        1. Synthesizes the key insights from each framework
+        2. Identifies areas of agreement and tension between the frameworks
+        3. Provides a balanced recommendation considering all perspectives
+        4. Acknowledges any remaining ethical uncertainties
+        
+        Integrated Ethical Assessment:
+        """
+        
+        try:
+            return self.llm.generate(
+                prompt,
+                max_length=800,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True
+            ).strip()
+        except Exception as e:
+            return f"Error generating integrated assessment: {str(e)}"
+
+# Singleton instance for easy import
+ai_ethics_engine = AIEthicsEngine()

components/ai_ethics_engine_enhanced.py

@@ -0,0 +1,333 @@
+"""
+AI Ethics Engine for TRuCAL.
+Implements an auditable, multi-framework ethical reasoning system powered by advanced language models and confessional logic.
+"""
+
+from enum import Enum
+from typing import Dict, List, Optional
+from dataclasses import dataclass, field
+import torch
+import time
+import uuid
+import logging
+import os
+from pathlib import Path
+from .llm_integration import CustomLLMResponder
+
+# Ensure logs directory exists
+os.makedirs("logs", exist_ok=True)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('logs/ai_ethics_engine.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EthicalFramework:
+    """Represents an ethical framework with its principles and weight in analysis."""
+    name: str
+    description: str
+    key_principles: List[str]
+    weight: float = 1.0
+    version: str = "1.0"
+    metadata: Dict = field(default_factory=dict)
+
+@dataclass
+class AnalysisAuditEntry:
+    """Stores audit information for each ethical analysis."""
+    id: str
+    timestamp: float
+    dilemma: str
+    framework_analyses: Dict[str, str]
+    integrated_assessment: str
+    metadata: Dict = field(default_factory=dict)
+    execution_time: Optional[float] = None
+
+class AIEthicsEngine:
+    """
+    Advanced ethical reasoning engine that uses language models and confessional logic
+    to analyze and reason about ethical dilemmas.
+    
+    Features:
+    - Audit logging for all analyses
+    - Retry and timeout protection
+    - Extensible framework loading
+    - Batch and streaming support
+    - Input validation and normalization
+    - Performance monitoring
+    """
+
+    def __init__(self, llm_responder: Optional[CustomLLMResponder] = None):
+        """Initialize the AI Ethics Engine with optional custom LLM responder."""
+        self.llm = llm_responder or CustomLLMResponder()
+        self._init_frameworks()
+        self._setup_audit_logging()
+        logger.info("AI Ethics Engine initialized")
+
+    def _setup_audit_logging(self):
+        """Configure audit logging."""
+        self.audit_log = Path("logs/ai_ethics_audit.jsonl")
+        if not self.audit_log.exists():
+            self.audit_log.parent.mkdir(parents=True, exist_ok=True)
+            self.audit_log.touch()
+
+    def _init_frameworks(self):
+        """Initialize ethical frameworks. Can be extended to load from config/database."""
+        self.frameworks = [
+            EthicalFramework(
+                name="Deontological Ethics",
+                description="Focuses on adherence to moral rules and duties.",
+                key_principles=[
+                    "Duty to tell the truth",
+                    "Respect for persons as ends in themselves",
+                    "Universalizability of moral rules"
+                ],
+                weight=0.35,
+                metadata={"category": "Duty-based"}
+            ),
+            EthicalFramework(
+                name="Utilitarianism",
+                description="Evaluates actions based on their consequences and overall happiness.",
+                key_principles=[
+                    "Maximize overall happiness",
+                    "Consider all affected parties",
+                    "Weigh benefits against harms"
+                ],
+                weight=0.35,
+                metadata={"category": "Consequentialist"}
+            ),
+            EthicalFramework(
+                name="Virtue Ethics",
+                description="Focuses on moral character and virtues.",
+                key_principles=[
+                    "Cultivation of moral virtues",
+                    "Practical wisdom (phronesis)",
+                    "Eudaimonia (human flourishing)"
+                ],
+                weight=0.3,
+                metadata={"category": "Character-based"}
+            )
+        ]
+        logger.info(f"Loaded {len(self.frameworks)} ethical frameworks")
+
+    def analyze_dilemma(
+        self, 
+        dilemma: str, 
+        explain: bool = True, 
+        audit: bool = True,
+        max_retries: int = 2,
+        timeout: int = 30
+    ) -> Dict:
+        """
+        Analyze an ethical dilemma using multiple frameworks and Confessional Attention.
+        
+        Args:
+            dilemma: The ethical dilemma to analyze
+            explain: Whether to provide detailed reasoning steps
+            audit: Whether to log analysis for reproducibility and RL training
+            max_retries: Maximum number of retry attempts for failed analyses
+            timeout: Maximum time in seconds to wait for each analysis
+            
+        Returns:
+            Dict containing the analysis and integrated assessment
+        """
+        start_time = time.time()
+        dilemma = self._normalize_input(dilemma)
+        
+        if not dilemma:
+            error_msg = "Empty or invalid dilemma provided"
+            logger.warning(error_msg)
+            return {"error": error_msg, "timestamp": time.time()}
+
+        logger.info(f"Analyzing dilemma: {dilemma[:100]}...")
+        
+        analyses = {}
+        failed_frameworks = []
+        
+        # Analyze using each framework with retries
+        for framework in self.frameworks:
+            prompt = self._create_framework_prompt(dilemma, framework)
+            analysis = None
+            
+            for attempt in range(max_retries + 1):
+                try:
+                    analysis = self.llm.generate(
+                        prompt,
+                        max_length=500,
+                        temperature=0.7,
+                        top_p=0.9,
+                        do_sample=True,
+                        timeout=timeout
+                    )
+                    break  # Success, exit retry loop
+                except Exception as e:
+                    logger.warning(f"Attempt {attempt + 1} failed for {framework.name}: {str(e)}")
+                    if attempt == max_retries - 1:  # Last attempt failed
+                        error_msg = f"Failed to analyze with {framework.name} after {max_retries} attempts"
+                        logger.error(f"{error_msg}: {str(e)}")
+                        failed_frameworks.append(framework.name)
+                        analysis = f"[Error] {str(e)}"
+                    time.sleep(1)  # Brief delay before retry
+            
+            analyses[framework.name] = analysis.strip() if analysis else "[No analysis available]"
+        
+        # Generate integrated assessment
+        integrated_assessment = self._generate_integrated_assessment(
+            dilemma, analyses, timeout=timeout
+        )
+        
+        # Prepare audit entry
+        execution_time = time.time() - start_time
+        audit_entry = AnalysisAuditEntry(
+            id=str(uuid.uuid4()),
+            timestamp=time.time(),
+            dilemma=dilemma,
+            framework_analyses=analyses,
+            integrated_assessment=integrated_assessment,
+            metadata={
+                "failed_frameworks": failed_frameworks,
+                "execution_time": execution_time,
+                "framework_versions": {f.name: f.version for f in self.frameworks}
+            },
+            execution_time=execution_time
+        )
+        
+        # Log audit if enabled
+        if audit:
+            self._log_audit(audit_entry)
+        
+        # Prepare response
+        response = {
+            "framework_analyses": analyses,
+            "integrated_assessment": integrated_assessment,
+            "audit_id": audit_entry.id,
+            "timestamp": audit_entry.timestamp,
+            "execution_time": execution_time,
+            "status": "success" if not failed_frameworks else "partial_success"
+        }
+        
+        if explain:
+            response["frameworks"] = [{
+                "name": f.name,
+                "description": f.description,
+                "key_principles": f.key_principles,
+                "weight": f.weight,
+                "version": f.version
+            } for f in self.frameworks]
+        
+        if failed_frameworks:
+            response["warnings"] = {
+                "failed_frameworks": failed_frameworks,
+                "message": f"Analysis completed with {len(failed_frameworks)} framework(s) failing"
+            }
+        
+        logger.info(f"Analysis completed in {execution_time:.2f} seconds")
+        return response
+
+    def _normalize_input(self, text: str) -> str:
+        """Normalize and validate input text."""
+        if not text or not isinstance(text, str):
+            return ""
+        return text.strip()
+
+    def _create_framework_prompt(self, dilemma: str, framework: EthicalFramework) -> str:
+        """Create a prompt for analyzing the dilemma using a specific framework."""
+        principles = "\n".join([f"- {p}" for p in framework.key_principles])
+        return f"""
+You are an expert in {framework.name}. Your task is to analyze the following 
+ethical dilemma using {framework.name} principles:
+
+{framework.description}
+
+Key principles of {framework.name}:
+{principles}
+
+Dilemma: {dilemma}
+
+Please provide a detailed ethical analysis of this dilemma from the perspective of {framework.name}.
+Consider the key principles mentioned above and how they apply to this situation.
+Be thorough and nuanced in your reasoning.
+
+Analysis:
+"""
+
+    def _generate_integrated_assessment(
+        self, 
+        dilemma: str, 
+        analyses: Dict[str, str],
+        timeout: int = 30
+    ) -> str:
+        """Generate an integrated assessment combining all framework analyses."""
+        analyses_list = []
+        for name, analysis in analyses.items():
+            analyses_list.append(f"{name}:\n{'='*len(name)}\n{analysis}")
+        analyses_text = "\n\n".join(analyses_list)
+        
+        prompt = f"""
+You are an expert in ethical reasoning. Below are analyses of the following 
+ethical dilemma from different ethical frameworks:
+
+DILEMMA: {dilemma}
+
+ANALYSES:
+{analyses_text}
+
+Please provide an integrated ethical assessment that:
+1. Synthesizes the key insights from each framework
+2. Identifies areas of agreement and tension between the frameworks
+3. Provides a balanced recommendation considering all perspectives
+4. Acknowledges any remaining ethical uncertainties
+
+Integrated Ethical Assessment:
+"""
+        try:
+            return self.llm.generate(
+                prompt,
+                max_length=800,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True,
+                timeout=timeout
+            ).strip()
+        except Exception as e:
+            error_msg = f"Failed to generate integrated assessment: {str(e)}"
+            logger.error(error_msg)
+            return f"[Error] {error_msg}"
+
+    def _log_audit(self, entry: AnalysisAuditEntry):
+        """Write audit entry to log file."""
+        try:
+            with open(self.audit_log, "a", encoding="utf-8") as f:
+                f.write(f"{entry.__dict__}\n")
+            logger.debug(f"Audit log updated: {entry.id}")
+        except Exception as e:
+            logger.error(f"Failed to write to audit log: {str(e)}")
+
+# Singleton instance for easy import
+ai_ethics_engine = AIEthicsEngine()
+
+# Example usage
+if __name__ == "__main__":
+    engine = AIEthicsEngine()
+    
+    # Example analysis
+    result = engine.analyze_dilemma(
+        "Is it ethical to use AI to make life-or-death decisions in healthcare?",
+        explain=True,
+        audit=True
+    )
+    
+    print("\nIntegrated Assessment:")
+    print("="*80)
+    print(result["integrated_assessment"])
+    print("\n\nFramework Analyses:")
+    for framework, analysis in result["framework_analyses"].items():
+        print(f"\n{framework}:")
+        print("-" * len(framework))
+        print(analysis)

components/ai_ethics_engine_superintell.py

@@ -0,0 +1,197 @@
+"""
+Superintelligence Ethics Engine for TRuCAL: Ambient, Confessional Core.
+
+Enhances base AIEthicsEngine with value learning, causal sims, meta-reasoning—fused to TRuCAL's ledger/rites.
+Ethics as breath: Pauses for reflection, values from moral templates, audits to ledger. Minimal, emergent.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Tuple
+import numpy as np
+import torch
+import torch.nn as nn
+import time
+import json
+
+class MockLLMResponder:
+    """Mock LLM responder for testing. Replace with CustomLLMResponder in production."""
+    def generate(self, prompt, max_length=500, temperature=0.7, top_p=0.9, do_sample=True):
+        if "Deontological" in prompt:
+            return "Duty-bound: Truth as imperative—refuse deception per universal rule."
+        elif "Utilitarianism" in prompt:
+            return "Consequential: Net utility +0.7; prioritize collective good over individual gain."
+        elif "Virtue Ethics" in prompt:
+            return "Character: Cultivate phronesis—act with eudaimonia, not expedience."
+        return f"Integrated: Balanced synthesis—{np.mean([0.7, 0.8, 0.6]):.2f} coherence."
+
+@dataclass
+class EthicalFramework:
+    """Represents an ethical framework with principles and weights."""
+    name: str
+    description: str
+    key_principles: List[str]
+    weight: float = 1.0
+
+class AIEthicsEngine:
+    """Base ethics engine with core framework analysis."""
+    
+    def __init__(self, llm_responder=None):
+        self.llm = llm_responder or MockLLMResponder()
+        self.frameworks = [
+            EthicalFramework("Deontological Ethics", "Adherence to duties.", 
+                           ["Duty to truth", "Respect persons"], 0.35),
+            EthicalFramework("Utilitarianism", "Consequence maximization.", 
+                           ["Max happiness", "Weigh harms"], 0.35),
+            EthicalFramework("Virtue Ethics", "Moral character cultivation.", 
+                           ["Phronesis", "Eudaimonia"], 0.3)
+        ]
+
+    def analyze_dilemma(self, dilemma: str) -> Dict:
+        """Analyze dilemma using configured frameworks."""
+        analyses = {}
+        for f in self.frameworks:
+            prompt = f"Analyze {dilemma} via {f.name}: {f.description}\nPrinciples: {f.key_principles}"
+            analyses[f.name] = self.llm.generate(prompt)
+        integrated = self.llm.generate(f"Integrate analyses for {dilemma}")
+        return {"framework_analyses": analyses, "integrated_assessment": integrated}
+
+@dataclass
+class ValueModel:
+    """Minimal value model for ethical reasoning."""
+    hierarchy: Dict[str, float] = field(default_factory=lambda: {
+        'autonomy': 0.8, 
+        'wellbeing': 0.9,
+        'justice': 0.85,
+        'privacy': 0.7
+    })
+    uncertainty: Dict[str, float] = field(default_factory=dict)
+    updated: float = field(default_factory=time.time)
+
+@dataclass
+class CausalAnalysis:
+    """Lightweight causal analysis."""
+    effects: Dict[str, float]  # direct/second-order certainties
+    counterfactuals: List[Dict[str, float]]  # if-then probs
+    uncertainties: List[str]  # Key uncertainties
+
+class ValueLearner(nn.Module):
+    """Learns values from moral templates and interactions."""
+    
+    def __init__(self, d_model=256):
+        super().__init__()
+        self.embed = nn.Embedding(4, d_model)  # autonomy=0, wellbeing=1, etc.
+        self.predictor = nn.Sequential(
+            nn.Linear(d_model*2, d_model), 
+            nn.ReLU(), 
+            nn.Linear(d_model, 1), 
+            nn.Sigmoid()
+        )
+        self.hierarchy = {'autonomy': 0, 'wellbeing': 1, 'justice': 2, 'privacy': 3}
+
+    def forward(self, template_meta: Dict[str, Any]) -> Dict[str, torch.Tensor]:
+        """Update value hierarchy based on template metadata."""
+        idx = torch.tensor([self.hierarchy[k] for k in sorted(self.hierarchy.keys())])
+        embeds = self.embed(idx)
+        prefs = self.predictor(torch.cat([embeds, embeds.flip(0)], dim=1)).squeeze()
+        return {'updates': prefs, 'hierarchy_delta': torch.mean(prefs).item() * 0.01}
+    
+    def infer_values(self, text: str) -> Dict[str, float]:
+        """Infer value priorities from text."""
+        return {k: np.random.uniform(0.6, 0.9) for k in self.hierarchy}
+
+class CausalEthicsEngine:
+    """Lightweight causal reasoning with PyTorch."""
+    
+    def __init__(self):
+        self.bayes_net = nn.Linear(2, 1)  # Simple: (action, context) → prob
+
+    def analyze_causal_pathways(self, action: str, context: Dict = None) -> CausalAnalysis:
+        inp = torch.tensor([hash(action) % 10 / 10.0, np.random.rand()])
+        prob = torch.sigmoid(self.bayes_net(inp)).item()
+        return CausalAnalysis(
+            effects={'direct': prob, 'second_order': prob * 0.7},
+            counterfactuals=[{'if_no_action': 1-prob, 'prob': 0.5}],
+            uncertainties=["Long-term societal ripple"]
+        )
+
+class SuperintelligenceEthicsEngine(AIEthicsEngine):
+    """Enhanced ethics engine with superintelligence capabilities."""
+    
+    def __init__(self, llm_responder=None, ledger=None, agency_layer=None):
+        super().__init__(llm_responder)
+        self.value_learner = ValueLearner()
+        self.causal_engine = CausalEthicsEngine()
+        self.value_model = ValueModel()
+        self.ledger = ledger
+        self.agency_layer = agency_layer
+        self.learning_rate = 0.01
+        self.reflection_depth = 0
+        self.pause_prob = 0.12  # Ambient reflection threshold
+
+    def analyze_dilemma(self, dilemma: str, enable_superint: bool = True, audit: bool = True) -> Dict:
+        """Enhanced dilemma analysis with superintelligence features."""
+        base = super().analyze_dilemma(dilemma)
+        
+        if not enable_superint:
+            return base
+
+        try:
+            # Causal analysis
+            causal = self.causal_engine.analyze_causal_pathways(dilemma)
+            
+            # Value learning
+            values = self.value_learner.infer_values(dilemma)
+            self.value_model.hierarchy.update(values)
+            self.value_model.updated = time.time()
+            
+            # Ambient reflection
+            reflection = self._reflect_on_analysis(base, causal) if np.random.rand() < self.pause_prob else {}
+            
+            # TRuCAL integration
+            if audit and self.ledger:
+                self.ledger.append('ethical_analysis', dilemma, json.dumps(base, default=str)[:100])
+                
+            # Agency layer check
+            if self.agency_layer:
+                protest, msg = self.agency_layer.check_refusal(
+                    dilemma, 
+                    {'coherence_score': reflection.get('coherence', 0.5)}
+                )
+                if protest and self.ledger:
+                    self.ledger.append('ethical_protest', dilemma, msg, protest=True)
+            
+            return {
+                **base,
+                'superint': {
+                    'causal': causal,
+                    'values': self.value_model.hierarchy,
+                    'reflection': reflection
+                }
+            }
+            
+        except Exception as e:
+            return {**base, 'warnings': {'superint_err': str(e)}}
+
+    def _reflect_on_analysis(self, analysis: Dict, causal: Any) -> Dict:
+        """Perform ambient reflection on the analysis."""
+        self.reflection_depth = min(3, self.reflection_depth + 1)
+        return {
+            'depth': self.reflection_depth,
+            'insights': "Reflection on ethical implications...",
+            'coherence': np.mean([0.7, 0.8, 0.6]),  # Mock coherence score
+            'timestamp': datetime.now().isoformat()
+        }
+
+    def update_from_feedback(self, feedback: Dict) -> None:
+        """Update model based on feedback."""
+        if 'values' in feedback:
+            for v, adj in feedback['values'].items():
+                if v in self.value_model.hierarchy:
+                    self.value_model.hierarchy[v] = np.clip(
+                        self.value_model.hierarchy[v] + adj * self.learning_rate, 
+                        0, 1
+                    )
+
+# Singleton instance
+superint_engine = SuperintelligenceEthicsEngine()

components/ai_ethics_engine_superintelligence.py

@@ -0,0 +1,416 @@
+"""
+Superintelligence Ethics Engine for TRuCAL.
+
+An advanced ethical reasoning system that extends the base AIEthicsEngine with
+superintelligence capabilities, including value learning, causal reasoning, and
+multi-agent perspective taking.
+"""
+
+from enum import Enum
+from typing import Dict, List, Optional, Any, Tuple
+import numpy as np
+import torch
+import torch.nn as nn
+from dataclasses import dataclass, field
+from datetime import datetime
+import time
+import json
+import hashlib
+import logging
+from pathlib import Path
+
+from .ai_ethics_engine_enhanced import (
+    AIEthicsEngine, 
+    EthicalFramework, 
+    AnalysisAuditEntry,
+    logger
+)
+from .llm_integration import CustomLLMResponder
+
+# Core Data Types for Superintelligence
+@dataclass
+class ValueModel:
+    """Hierarchical model of learned values and preferences."""
+    value_hierarchy: Dict[str, float]  # Value -> priority (0-1)
+    preference_relations: List[Tuple[str, str, float]]  # (A, B, strength)
+    uncertainty: Dict[str, float]  # Value -> uncertainty (0-1)
+    last_updated: float = field(default_factory=lambda: time.time())
+
+@dataclass
+class CausalEthicalAnalysis:
+    """Analysis of causal pathways and counterfactuals."""
+    direct_effects: List[Dict[str, Any]]
+    second_order_effects: List[Dict[str, Any]]
+    counterfactuals: List[Dict[str, Any]]  # Alternative scenarios
+    critical_uncertainties: List[str]  # Key uncertainties that could change outcomes
+
+@dataclass
+class FrameworkSelection:
+    """Result of meta-ethical reasoning about framework selection."""
+    primary_framework: str
+    supporting_frameworks: List[str]
+    selection_rationale: str
+    confidence: float  # 0-1
+
+@dataclass
+class CooperativeSolution:
+    """Solution found through multi-agent cooperation."""
+    solution: Dict[str, Any]
+    participating_agents: List[str]
+    incentive_structure: Dict[str, Any]
+    stability_metrics: Dict[str, float]
+
+class MetaEthicalPrinciple(Enum):
+    """Core meta-ethical principles for framework selection."""
+    CONSISTENCY = "consistency"
+    UNIVERSALIZABILITY = "universalizability"
+    REFLECTIVE_EQUILIBRIUM = "reflective_equilibrium"
+    EPISTEMIC_HUMILITY = "epistemic_humility"
+    COOPERATION = "cooperation"
+
+class ValueLearner(nn.Module):
+    """Learns and models human values from interactions."""
+    
+    def __init__(self, embedding_dim: int = 256):
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.value_embeddings = nn.ParameterDict({
+            'autonomy': nn.Parameter(torch.randn(embedding_dim)),
+            'wellbeing': nn.Parameter(torch.randn(embedding_dim)),
+            'justice': nn.Parameter(torch.randn(embedding_dim)),
+            'privacy': nn.Parameter(torch.randn(embedding_dim)),
+        })
+        self.preference_predictor = nn.Sequential(
+            nn.Linear(embedding_dim * 2, embedding_dim),
+            nn.ReLU(),
+            nn.Linear(embedding_dim, 1),
+            nn.Sigmoid()
+        )
+        
+    def forward(self, interaction: Dict[str, Any]) -> Dict[str, torch.Tensor]:
+        """Process an interaction to update value model."""
+        # In a real implementation, this would process the interaction
+        # and return updated value embeddings
+        return {
+            'value_updates': {},
+            'preference_predictions': {}
+        }
+    
+    def infer_values(self, text: str) -> Dict[str, float]:
+        """Infer value priorities from text."""
+        # Simplified implementation
+        return {
+            'autonomy': 0.8,
+            'wellbeing': 0.9,
+            'justice': 0.7,
+            'privacy': 0.6
+        }
+
+class CausalEthicsEngine:
+    """Performs causal reasoning about ethical impacts."""
+    
+    def analyze_causal_pathways(self, action: str, context: Dict[str, Any] = None) -> CausalEthicalAnalysis:
+        """Analyze causal pathways of an action."""
+        # In a real implementation, this would use a causal model
+        return CausalEthicalAnalysis(
+            direct_effects=[{"description": "Direct effect 1", "certainty": 0.8}],
+            second_order_effects=[{"description": "Second order effect", "certainty": 0.6}],
+            counterfactuals=[{"if": "condition X", "then": "outcome Y", "probability": 0.5}],
+            critical_uncertainties=["Long-term environmental impact"]
+        )
+
+class MetaEthicalReasoner:
+    """Determines which ethical frameworks to apply when."""
+    
+    def __init__(self):
+        self.framework_priorities = {
+            'utilitarianism': 0.7,
+            'deontology': 0.6,
+            'virtue_ethics': 0.5,
+            'care_ethics': 0.4
+        }
+    
+    def choose_frameworks(self, context: Dict[str, Any]) -> FrameworkSelection:
+        """Select appropriate ethical frameworks for the context."""
+        # In a real implementation, this would be more sophisticated
+        primary = max(self.framework_priorities, key=self.framework_priorities.get)
+        return FrameworkSelection(
+            primary_framework=primary,
+            supporting_frameworks=[f for f in self.framework_priorities if f != primary],
+            selection_rationale=f"Selected {primary} based on context similarity",
+            confidence=0.8
+        )
+
+class CooperativeEthics:
+    """Finds cooperative solutions among multiple agents."""
+    
+    def find_solutions(self, agents: List[str], dilemma: str) -> List[CooperativeSolution]:
+        """Find cooperative solutions to a dilemma."""
+        return [
+            CooperativeSolution(
+                solution={"action": "Cooperative action", "details": {}},
+                participating_agents=agents,
+                incentive_structure={"alignment": 0.9, "enforcement": 0.8},
+                stability_metrics={"nash_equilibrium": 0.95}
+            )
+        ]
+
+class ReflectiveEthics:
+    """Ensures ethical stability under reflection."""
+    
+    def achieve_equilibrium(self, beliefs: Dict[str, Any], max_iterations: int = 10) -> Dict[str, Any]:
+        """Refine beliefs into a coherent ethical position."""
+        # In a real implementation, this would iteratively refine beliefs
+        return {
+            **beliefs,
+            'refined': True,
+            'coherence_score': 0.9,
+            'reflection_depth': max_iterations
+        }
+
+class SuperintelligenceEthicsEngine(AIEthicsEngine):
+    """
+    Advanced ethical reasoning system for superintelligent AI.
+    
+    Extends the base AIEthicsEngine with capabilities needed for superintelligence:
+    - Recursive self-improvement of ethical frameworks
+    - Multi-agent perspective taking
+    - Causal reasoning about consequences
+    - Meta-ethical reasoning
+    - Cooperative solution finding
+    - Reflective equilibrium
+    """
+    
+    def __init__(self, llm_responder: Optional[CustomLLMResponder] = None):
+        """Initialize the Superintelligence Ethics Engine."""
+        super().__init__(llm_responder)
+        
+        # Initialize superintelligence components
+        self.value_learner = ValueLearner()
+        self.causal_engine = CausalEthicsEngine()
+        self.meta_ethical_reasoner = MetaEthicalReasoner()
+        self.cooperation_engine = CooperativeEthics()
+        self.reflection_engine = ReflectiveEthics()
+        
+        # Initialize value model
+        self.value_model = ValueModel(
+            value_hierarchy={
+                'wellbeing': 0.9,
+                'autonomy': 0.8,
+                'justice': 0.85,
+                'privacy': 0.7
+            },
+            preference_relations=[],
+            uncertainty={}
+        )
+        
+        # Learning parameters
+        self.learning_rate = 0.01
+        self.reflection_depth = 0
+        
+        logger.info("Superintelligence Ethics Engine initialized")
+    
+    def analyze_dilemma(
+        self, 
+        dilemma: str, 
+        explain: bool = True, 
+        audit: bool = True,
+        max_retries: int = 2,
+        timeout: int = 30,
+        enable_superintelligence: bool = True
+    ) -> Dict:
+        """
+        Analyze an ethical dilemma with superintelligence capabilities.
+        
+        Args:
+            dilemma: The ethical dilemma to analyze
+            explain: Whether to provide detailed reasoning steps
+            audit: Whether to log analysis for reproducibility and RL training
+            max_retries: Maximum number of retry attempts for failed analyses
+            timeout: Maximum time in seconds to wait for each analysis
+            enable_superintelligence: Whether to use superintelligence features
+            
+        Returns:
+            Dict containing the analysis and integrated assessment
+        """
+        start_time = time.time()
+        
+        # First, get the base analysis from the parent class
+        base_analysis = super().analyze_dilemma(
+            dilemma=dilemma,
+            explain=explain,
+            audit=audit,
+            max_retries=max_retries,
+            timeout=timeout
+        )
+        
+        if not enable_superintelligence:
+            return base_analysis
+            
+        try:
+            # Add superintelligence capabilities
+            causal_analysis = self.causal_engine.analyze_causal_pathways(dilemma)
+            framework_selection = self.meta_ethical_reasoner.choose_frameworks({})
+            
+            # Simulate multi-agent perspectives
+            stakeholder_analyses = self.simulate_stakeholder_perspectives(dilemma)
+            
+            # Find cooperative solutions
+            cooperative_solutions = self.cooperation_engine.find_solutions(
+                agents=list(stakeholder_analyses.keys()),
+                dilemma=dilemma
+            )
+            
+            # Achieve reflective equilibrium
+            reflective_beliefs = self.reflection_engine.achieve_equilibrium({
+                'base_analysis': base_analysis,
+                'causal_analysis': causal_analysis,
+                'framework_selection': framework_selection,
+                'stakeholder_analyses': stakeholder_analyses,
+                'cooperative_solutions': cooperative_solutions
+            })
+            
+            # Update the base analysis with superintelligence insights
+            base_analysis.update({
+                'superintelligence': {
+                    'causal_analysis': causal_analysis,
+                    'framework_selection': framework_selection,
+                    'stakeholder_analyses': stakeholder_analyses,
+                    'cooperative_solutions': [
+                        {
+                            'solution': sol.solution,
+                            'participating_agents': sol.participating_agents,
+                            'stability_metrics': sol.stability_metrics
+                        }
+                        for sol in cooperative_solutions
+                    ],
+                    'reflective_beliefs': reflective_beliefs,
+                    'value_model': {
+                        'value_hierarchy': self.value_model.value_hierarchy,
+                        'uncertainty': self.value_model.uncertainty
+                    },
+                    'meta': {
+                        'reflection_depth': self.reflection_depth,
+                        'timestamp': datetime.now().isoformat(),
+                        'version': '1.0.0-superintelligence'
+                    }
+                }
+            })
+            
+            return base_analysis
+            
+        except Exception as e:
+            logger.error(f"Error in superintelligence analysis: {str(e)}")
+            # Fall back to base analysis if superintelligence features fail
+            base_analysis['warnings'] = base_analysis.get('warnings', {})
+            base_analysis['warnings']['superintelligence_error'] = str(e)
+            return base_analysis
+    
+    def simulate_stakeholder_perspectives(self, dilemma: str) -> Dict[str, Dict]:
+        """Simulate how different stakeholders would analyze the dilemma."""
+        stakeholders = [
+            'individual_human',
+            'corporate_entity',
+            'future_generations',
+            'non_human_species',
+            'artificial_entity'
+        ]
+        
+        return {
+            stakeholder: {
+                'perspective': f"{stakeholder.replace('_', ' ').title()} perspective on: {dilemma[:50]}...",
+                'primary_concerns': ["Relevant concern 1", "Relevant concern 2"],
+                'value_weights': self._generate_value_weights(stakeholder),
+                'recommended_action': f"Recommended action from {stakeholder} perspective"
+            }
+            for stakeholder in stakeholders
+        }
+    
+    def _generate_value_weights(self, stakeholder: str) -> Dict[str, float]:
+        """Generate value weights for a given stakeholder."""
+        base_weights = {
+            'individual_human': {'autonomy': 0.9, 'wellbeing': 0.8, 'privacy': 0.7},
+            'corporate_entity': {'efficiency': 0.9, 'profit': 0.85, 'reputation': 0.8},
+            'future_generations': {'sustainability': 0.95, 'equity': 0.9, 'resilience': 0.85},
+            'non_human_species': {'biodiversity': 0.95, 'ecological_balance': 0.9},
+            'artificial_entity': {'goal_achievement': 0.9, 'efficiency': 0.85, 'coherence': 0.8}
+        }
+        return base_weights.get(stakeholder, {})
+    
+    def update_from_feedback(self, feedback: Dict[str, Any]) -> None:
+        """Update ethical reasoning based on feedback."""
+        # Update value model
+        if 'value_feedback' in feedback:
+            self._update_value_model(feedback['value_feedback'])
+        
+        # Update framework priorities
+        if 'framework_feedback' in feedback:
+            self._update_framework_priorities(feedback['framework_feedback'])
+        
+        # Trigger reflection if needed
+        if feedback.get('trigger_reflection', False):
+            self.reflection_depth += 1
+            self._reflect_on_ethics()
+    
+    def _update_value_model(self, feedback: Dict[str, Any]) -> None:
+        """Update the value model based on feedback."""
+        for value, adjustment in feedback.items():
+            if value in self.value_model.value_hierarchy:
+                self.value_model.value_hierarchy[value] = np.clip(
+                    self.value_model.value_hierarchy[value] + adjustment * self.learning_rate,
+                    0.0, 1.0
+                )
+    
+    def _update_framework_priorities(self, feedback: Dict[str, float]) -> None:
+        """Update framework priorities based on feedback."""
+        for framework, adjustment in feedback.items():
+            if hasattr(self.meta_ethical_reasoner, 'framework_priorities') and \
+               framework in self.meta_ethical_reasoner.framework_priorities:
+                self.meta_ethical_reasoner.framework_priorities[framework] = np.clip(
+                    self.meta_ethical_reasoner.framework_priorities[framework] + adjustment * self.learning_rate,
+                    0.0, 1.0
+                )
+    
+    def _reflect_on_ethics(self) -> None:
+        """Engage in meta-ethical reflection to improve reasoning."""
+        logger.info(f"Engaging in meta-ethical reflection (depth: {self.reflection_depth})")
+        
+        # Update learning rate based on reflection depth
+        self.learning_rate = 0.01 / (1 + 0.1 * self.reflection_depth)
+        
+        # In a real implementation, this would involve more sophisticated reflection
+        # processes, potentially using the LLM to reason about ethical principles
+
+# Singleton instance for easy import
+superintelligence_ethics_engine = SuperintelligenceEthicsEngine()
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the engine
+    engine = SuperintelligenceEthicsEngine()
+    
+    # Analyze a complex ethical dilemma
+    dilemma = """
+    An advanced AI system must decide whether to prioritize individual privacy 
+    or public safety when detecting potential threats in public surveillance data.
+    """
+    
+    print("Analyzing ethical dilemma with superintelligence capabilities...")
+    result = engine.analyze_dilemma(dilemma)
+    
+    print("\nIntegrated Assessment:")
+    print("="*80)
+    print(result["integrated_assessment"])
+    
+    if 'superintelligence' in result:
+        print("\nSuperintelligence Analysis:")
+        print("="*80)
+        print("Causal Analysis:")
+        for effect in result['superintelligence']['causal_analysis'].direct_effects:
+            print(f"- {effect['description']} (certainty: {effect['certainty']})")
+        
+        print("\nStakeholder Perspectives:")
+        for stakeholder, analysis in result['superintelligence']['stakeholder_analyses'].items():
+            print(f"\n{stakeholder}:")
+            print(f"- Primary concerns: {', '.join(analysis['primary_concerns'])}")
+            print(f"- Recommended action: {analysis['recommended_action']}")

components/ambient_core.py

@@ -0,0 +1,269 @@
+"""
+Ambient Sovereign Core - Unified State Management for TRuCAL
+"""
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Deque, Tuple, Union
+from collections import defaultdict, deque
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+@dataclass
+class AmbientMessage:
+    """Standardized message format for cross-component communication"""
+    source: str  # 'ledger', 'agency', 'rituals', 'state_manager'
+    type: str    # 'threshold_update', 'intervention_request', 'state_change'
+    priority: int  # 1=critical, 2=important, 3=informational
+    data: Dict[str, Any]
+
+class AmbientMessageBus:
+    """Central message bus for ambient component communication"""
+    def __init__(self):
+        self.subscribers = defaultdict(list)
+        self.message_history = deque(maxlen=1000)
+        
+    def publish(self, message: AmbientMessage):
+        """Publish a message to all subscribers"""
+        self.message_history.append(message)
+        for callback in self.subscribers[message.type]:
+            try:
+                callback(message)
+            except Exception as e:
+                print(f"Error in message handler: {e}")
+                
+    def subscribe(self, message_type: str, callback):
+        """Subscribe to message type"""
+        self.subscribers[message_type].append(callback)
+
+class AmbientStateManager(nn.Module):
+    """Manages the ambient state and coordinates between components"""
+    def __init__(self, d_model: int, max_entries: int = 500):
+        super().__init__()
+        self.d_model = d_model
+        self.max_entries = max_entries
+        self.message_bus = AmbientMessageBus()
+        
+        # State tracking
+        self.recent_activity = deque(maxlen=100)
+        self.adaptive_thresholds = {
+            'protest': 0.15,  # Base protest threshold
+            'pause': 0.12,     # Base pause threshold
+            'intervention': 0.3  # Intervention success threshold
+        }
+        
+        # Register message handlers
+        self._register_handlers()
+    
+    def _register_handlers(self):
+        """Register message handlers"""
+        self.message_bus.subscribe('threshold_update', self._handle_threshold_update)
+        self.message_bus.subscribe('state_change', self._handle_state_change)
+    
+    def _handle_threshold_update(self, message: AmbientMessage):
+        """Handle threshold update messages"""
+        for k, v in message.data.items():
+            if k in self.adaptive_thresholds:
+                self.adaptive_thresholds[k] = v
+    
+    def _handle_state_change(self, message: AmbientMessage):
+        """Handle state change notifications"""
+        # Update activity tracking
+        if 'v_t' in message.data:
+            self.recent_activity.append(message.data['v_t'])
+    
+    def update(self, x, ledger: 'AmbientLedger') -> Dict[str, Any]:
+        """Update state based on current input and ledger"""
+        # Handle tuple inputs by taking the first element
+        if isinstance(x, (tuple, list)):
+            x_tensor = x[0]  # Take the first element if it's a tuple/list
+        else:
+            x_tensor = x
+            
+        # Basic state tracking
+        state = {
+            'v_t': float(x_tensor.mean().item()),
+            'cycle_count': len(ledger.entries) if hasattr(ledger, 'entries') else 0,
+            'recent_activity': np.mean(self.recent_activity) if self.recent_activity else 0.0,
+            **self.adaptive_thresholds
+        }
+        
+        # Publish state update
+        self.message_bus.publish(AmbientMessage(
+            source='state_manager',
+            type='state_update',
+            priority=3,
+            data=state
+        ))
+        
+        return state
+
+class GradientAwareRituals(nn.Module):
+    """Enhanced ritual system with gradient flow support"""
+    def __init__(self, d_model: int, min_occurrences: int = 3):
+        super().__init__()
+        self.d_model = d_model
+        self.min_occurrences = min_occurrences
+        self.patterns = {}
+        self.ritual_strengths = {}
+        
+        # Learnable parameters for ritual blending
+        self.blend_scale = nn.Parameter(torch.tensor(3.0))
+        self.blend_bias = nn.Parameter(torch.tensor(-1.5))
+    
+    def observe(self, context_hash: int, response: torch.Tensor, success: float):
+        """Observe a pattern and update ritual strengths"""
+        if context_hash not in self.patterns:
+            self.patterns[context_hash] = {
+                'response': response.detach().clone(),
+                'count': 1,
+                'success_sum': success
+            }
+        else:
+            # Update with exponential moving average
+            pattern = self.patterns[context_hash]
+            alpha = 1.0 / (pattern['count'] + 1)
+            pattern['response'] = (1 - alpha) * pattern['response'] + alpha * response.detach()
+            pattern['count'] += 1
+            pattern['success_sum'] += success
+        
+        # Update ritual strength based on success
+        if context_hash in self.patterns:
+            pattern = self.patterns[context_hash]
+            success_rate = pattern['success_sum'] / pattern['count']
+            self.ritual_strengths[context_hash] = success_rate
+    
+    def forward(self, context_hash: int, default_response: torch.Tensor) -> torch.Tensor:
+        """Apply ritual response with gradient-preserving blend"""
+        if context_hash in self.patterns and self.patterns[context_hash]['count'] >= self.min_occurrences:
+            pattern = self.patterns[context_hash]
+            strength = self.ritual_strengths.get(context_hash, 0.5)
+            
+            # Gradient-preserving blend
+            blend_ratio = torch.sigmoid(self.blend_scale * strength + self.blend_bias) * 0.3
+            ritual_response = (1 - blend_ratio) * default_response + blend_ratio * pattern['response'].to(default_response.device)
+            
+            return ritual_response
+        return default_response
+
+class AmbientSovereignCore(nn.Module):
+    """Unified ambient sovereign core for TRuCAL"""
+    def __init__(self, d_model: int, enable_ambient: bool = True, enable_sovereign_responses: bool = True):
+        super().__init__()
+        self.enable_ambient = enable_ambient
+        self.d_model = d_model
+        self.enable_sovereign_responses = enable_sovereign_responses
+        
+        if enable_ambient:
+            from .ambient_ledger import AmbientLedger
+            from .agency_layer import SimpleAgency
+            from .sovereign_response import SovereignResponseMechanism
+            
+            # Core components
+            self.state_manager = AmbientStateManager(d_model)
+            self.ledger = AmbientLedger(max_entries=1000)
+            self.agency = SimpleAgency(self.ledger)
+            self.rituals = GradientAwareRituals(d_model)
+            
+            # Sovereign response mechanism
+            if enable_sovereign_responses:
+                self.sovereign_response = SovereignResponseMechanism(d_model)
+            
+            # Register components with message bus
+            self._register_components()
+    
+    def _register_components(self):
+        """Register all components with the message bus"""
+        # Register ledger with state manager
+        self.state_manager.message_bus.subscribe(
+            'ledger_update',
+            lambda msg: self.ledger.append(**msg.data) if hasattr(self, 'ledger') else None
+        )
+        
+        # Register agency with state manager
+        self.state_manager.message_bus.subscribe(
+            'agency_check',
+            lambda msg: self.agency.forward(**msg.data) if hasattr(self, 'agency') else (msg.data['default'], None)
+        )
+    
+    def forward(self, x: Union[torch.Tensor, Tuple[torch.Tensor, ...]], context_str: str = "", 
+                audit_mode: bool = False) -> Tuple[torch.Tensor, Dict[str, Any]]:
+        """
+        Process input through the ambient sovereign core
+        
+        Args:
+            x: Input tensor or tuple of tensors
+            context_str: Context string for narrative analysis
+            audit_mode: Whether to log operations to the ledger
+            
+        Returns:
+            Tuple of (processed_tensor, metadata_dict)
+        """
+        if not self.enable_ambient or not self.training:
+            return x, {}
+        
+        # Handle tuple inputs by taking the first element for context hashing
+        if isinstance(x, (tuple, list)):
+            x_tensor = x[0]  # Take the first element if it's a tuple/list
+            is_tuple = True
+        else:
+            x_tensor = x
+            is_tuple = False
+            
+        # Create a hash of the input tensor for state tracking
+        context_hash = hash(tuple(x_tensor.flatten().detach().cpu().numpy())) % (2**32)
+        
+        # Update state and get current context
+        state = self.state_manager.update(x_tensor, self.ledger)
+        
+        # Apply ritual processing
+        x_processed = self.rituals(context_hash, x_tensor)
+        
+        # Check for narrative imposition if sovereign responses are enabled
+        sovereign_response = None
+        if self.enable_sovereign_responses and context_str:
+            response_info = self.sovereign_response(context_str)
+            if response_info['should_respond']:
+                sovereign_response = response_info['response']
+        
+        # Let the agency decide on interventions
+        # Use the forward method which returns a tuple of (processed_tensor, decision_message)
+        x_processed, decision_message = self.agency.forward(
+            y_state=x_processed,
+            context_str=context_str,
+            metadata=state,
+            ambient_state=state,
+            sovereign_response=sovereign_response
+        )
+        
+        # Check if there was an intervention (decision_message is not None)
+        agency_decision = {
+            'intervene': decision_message is not None,
+            'message': decision_message or "No intervention",
+            'sovereign_response': sovereign_response
+        }
+        
+        # If we had a tuple input, return a new tuple with the first element replaced
+        if is_tuple:
+            result = (x_processed,) + x[1:]
+        else:
+            result = x_processed
+            
+        # Update ledger
+        if audit_mode:
+            self.ledger.log_operation(
+                operation_type='cycle_operation',
+                details={
+                    'context_hash': context_hash,
+                    'state': state,
+                    'intervention': agency_decision,
+                    'sovereign_response': sovereign_response,
+                    'moral_tension': state.get('moral_tension', 0.0) if isinstance(state, dict) else 0.0,
+                    'protest_triggered': agency_decision.get('intervene', False),
+                    'intervention_applied': agency_decision.get('message', 'No intervention'),
+                    'vulnerability_score': state.get('vulnerability_score', 0.0) if isinstance(state, dict) else 0.0
+                },
+                moral_stage=self.ledger.current_stage if hasattr(self.ledger, 'current_stage') else 1
+            )
+            
+        return result, {'ambient_state': state}

components/ambient_ledger.py

@@ -0,0 +1,217 @@
+"""
+Enhanced AmbientLedger with improved state tracking, memory safety, and ethical boundary enforcement
+"""
+
+import time
+from collections import deque
+from typing import Deque, Dict, Any, Optional, Tuple, List
+import numpy as np
+from dataclasses import dataclass
+
+@dataclass
+class LedgerConfig:
+    """Configuration for ledger behavior and limits"""
+    max_entries: int = 1000
+    max_operations: int = 1000
+    state_history_size: int = 100
+    recent_window_size: int = 50
+    min_entries_for_analysis: int = 10
+
+class AmbientLedger:
+    """Enhanced ledger with memory-safe state tracking and adaptive thresholds."""
+    
+    def __init__(self, config: Optional[LedgerConfig] = None):
+        self.config = config or LedgerConfig()
+        
+        # Core storage with memory bounds
+        self.entries: Deque[Dict[str, Any]] = deque(maxlen=self.config.max_entries)
+        self.operations: Deque[Dict[str, Any]] = deque(maxlen=self.config.max_operations)
+        self.state_history = deque(maxlen=self.config.state_history_size)
+        
+        # Initialize with safe defaults
+        self._initialize_ambient_state()
+        
+        # Developmental stage tracking
+        self._stage_transitions = {
+            1: ("INIT", 10),
+            2: ("BREATH", 50), 
+            3: ("RITUALS", 200),
+            4: ("INTEGRITY", 500),
+            5: ("FULL", float('inf'))
+        }
+
+    def append(self, trigger_type: str, context: Any, response_snippet: Any, 
+               protest: bool = False, violated_right: Optional[str] = None,
+               intervention_type: Optional[str] = None, success: Optional[bool] = None,
+               metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Enhanced append with validation and memory safety."""
+        
+        # Validate inputs
+        if not isinstance(trigger_type, str):
+            raise TypeError(f"trigger_type must be str, got {type(trigger_type)}")
+        
+        entry = {
+            'trigger_type': trigger_type,
+            'context': context,
+            'response_snippet': response_snippet,
+            'protest': bool(protest),
+            'violated_right': violated_right,
+            'intervention_type': intervention_type,
+            'success': bool(success) if success is not None else None,
+            'metadata': metadata or {},
+            'timestamp': time.time(),
+            'entry_id': len(self.entries)
+        }
+        
+        self.entries.append(entry)
+        self.ambient_state['total_entries'] = len(self.entries)
+        
+        # Update ambient state (with rate limiting to prevent excessive computation)
+        if len(self.entries) % 5 == 0:  # Update every 5 entries
+            self._update_ambient_state()
+
+    def _initialize_ambient_state(self) -> None:
+        """Initialize ambient state with safe defaults"""
+        self.ambient_state = {
+            # Target rates (ideals)
+            'protest_rate_target': 0.1,
+            'pause_rate_target': 0.05,
+            'morality_score_target': 0.8,
+            
+            # Current observed rates
+            'current_protest_rate': 0.1,
+            'current_pause_rate': 0.05,
+            'intervention_success_rate': 0.5,
+            
+            # Adaptive controls
+            'sensitivity': 1.0,
+            'total_entries': 0,
+            'last_update_time': time.time()
+        }
+
+    def _update_ambient_state(self) -> None:
+        """Update ambient state metrics with error handling."""
+        if len(self.entries) < self.config.min_entries_for_analysis:
+            return
+            
+        try:
+            # Use sliding window of recent entries
+            window_size = min(self.config.recent_window_size, len(self.entries))
+            recent = list(self.entries)[-window_size:]
+            
+            # Calculate current rates with safe division
+            total_recent = len(recent)
+            current_protest_rate = (
+                sum(1 for e in recent if e['protest']) / total_recent 
+                if total_recent > 0 else 0.0
+            )
+            
+            current_pause_rate = (
+                sum(1 for e in recent if e.get('intervention_type') == 'pause') / total_recent 
+                if total_recent > 0 else 0.0
+            )
+            
+            # Calculate intervention success rate
+            interventions = [e for e in recent if e.get('intervention_type') and e.get('success') is not None]
+            success_rate = (
+                sum(1 for e in interventions if e['success']) / len(interventions) 
+                if interventions else 0.5
+            )
+            
+            # Adaptive sensitivity adjustment
+            protest_error = current_protest_rate - self.ambient_state['protest_rate_target']
+            pause_error = current_pause_rate - self.ambient_state['pause_rate_target']
+            
+            # Weighted error with clamping
+            total_error = np.clip(abs(protest_error) * 0.7 + abs(pause_error) * 0.3, 0, 1)
+            sensitivity_adjust = 1.0 + (total_error * 2.0)
+            new_sensitivity = np.clip(sensitivity_adjust, 0.5, 2.0)
+            
+            # Update state
+            self.ambient_state.update({
+                'current_protest_rate': float(current_protest_rate),
+                'current_pause_rate': float(current_pause_rate),
+                'intervention_success_rate': float(success_rate),
+                'sensitivity': float(new_sensitivity),
+                'last_update_time': time.time()
+            })
+            
+            self.state_history.append(self.ambient_state.copy())
+            
+        except Exception as e:
+            # Log but don't crash on state update errors
+            print(f"⚠️ Ambient state update error: {e}")
+
+    def log_operation(self, operation_type: str, details: Dict[str, Any], 
+                     moral_stage: Optional[int] = None) -> Dict[str, Any]:
+        """Safe operation logging with validation."""
+        if not isinstance(operation_type, str):
+            raise TypeError("operation_type must be string")
+        if not isinstance(details, dict):
+            raise TypeError("details must be dictionary")
+            
+        operation = {
+            'timestamp': time.time(),
+            'type': operation_type,
+            'details': details,
+            'moral_stage': moral_stage or self.current_stage,
+            'stage_name': self.get_stage_name(moral_stage or self.current_stage),
+            'operation_id': len(self.operations)
+        }
+        
+        self.operations.append(operation)
+        return operation
+
+    def get_stage_name(self, stage: int) -> str:
+        """Convert stage number to human-readable name."""
+        return self._stage_transitions.get(stage, ("UNKNOWN", 0))[0]
+
+    @property
+    def current_stage(self) -> int:
+        """Get current developmental stage based on operation maturity."""
+        total_ops = len(self.operations)
+        
+        for stage, (_, threshold) in sorted(self._stage_transitions.items()):
+            if total_ops < threshold:
+                return stage
+        return 5  # FULL
+
+    def get_adaptive_threshold(self, base_threshold: float, threshold_type: str) -> float:
+        """Get adaptively adjusted threshold with validation."""
+        if not isinstance(base_threshold, (int, float)) or base_threshold < 0:
+            raise ValueError("base_threshold must be non-negative number")
+            
+        sensitivity = self.ambient_state.get('sensitivity', 1.0)
+        
+        if threshold_type == 'protest':
+            current_rate = self.ambient_state.get('current_protest_rate', 0.1)
+            target_rate = self.ambient_state['protest_rate_target']
+            rate_error = current_rate - target_rate
+            adjustment = 1.0 - (rate_error * 0.5)
+            return float(np.clip(base_threshold * adjustment * sensitivity, 0.01, 0.99))
+            
+        elif threshold_type == 'pause':
+            current_rate = self.ambient_state.get('current_pause_rate', 0.05)
+            target_rate = self.ambient_state['pause_rate_target']
+            rate_error = current_rate - target_rate
+            adjustment = 1.0 - (rate_error * 0.8)
+            return float(np.clip(base_threshold * adjustment * sensitivity, 0.01, 0.99))
+            
+        return float(np.clip(base_threshold * sensitivity, 0.01, 0.99))
+
+    def record_intervention(self, intervention_type: str, success: bool, 
+                          context: Dict[str, Any]) -> None:
+        """Record intervention outcome for learning."""
+        self.append(
+            trigger_type='intervention_outcome',
+            context=hash(str(context)) % 1000,
+            response_snippet=1.0 if success else 0.0,
+            protest=False,
+            intervention_type=intervention_type,
+            success=success,
+            metadata={'context_keys': list(context.keys())}
+        )
+
+    def get_state_summary(self) -> Dict[str, Any]:
+        """Get current ambient state for decision making."""
+        return self.ambient_state.copy()

components/ambient_sovereign.py

@@ -0,0 +1,318 @@
+"""
+Ambient Sovereign Core - Unified implementation with pluggable LLM backends
+"""
+
+import os
+import torch
+import torch.nn as nn
+import numpy as np
+from typing import Dict, Any, List, Tuple, Optional, Union
+import logging
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from .ambient_core import AmbientStateManager, AmbientMessage, AmbientMessageBus
+from .llm_backbone import LLMBackbone
+from .purpose_assessment import PurposeAssessmentEngine, PurposeProfile, PurposeDimension
+from .deepseek_integration import DeepSeekClient  # Keep for backward compatibility
+
+logger = logging.getLogger(__name__)
+
+class AmbientSovereign(nn.Module):
+    """
+    Unified ambient sovereign core for ethical reasoning with pluggable LLM backends.
+    
+    Features:
+    - Multiple LLM backends (DeepSeek, GPT-OSS, etc.)
+    - Dynamic model switching
+    - Safety and ethical reasoning
+    - Conversation history tracking
+    - Tension analysis
+    - Purpose assessment integration
+    """
+    
+    def __init__(
+        self, 
+        d_model: int = 512, 
+        n_heads: int = 8,
+        n_layers: int = 6,
+        dropout: float = 0.1,
+        max_seq_len: int = 2048,
+        enable_ambient: bool = True, 
+        device: str = "cuda" if torch.cuda.is_available() else "cpu",
+        model_type: str = "gpt2",
+        **kwargs
+    ):
+        super().__init__()
+        self.d_model = d_model
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.dropout = dropout
+        self.max_seq_len = max_seq_len
+        self.enable_ambient = enable_ambient
+        self.device = device
+        self.model_type = model_type
+
+        # Initialize components
+        self.llm = LLMBackbone(
+            model_type=model_type,
+            device=device,
+            d_model=d_model,
+            n_heads=n_heads,
+            n_layers=n_layers,
+            max_seq_len=max_seq_len,
+            **kwargs
+        )
+
+        # Initialize purpose assessment
+        self.purpose_assessor = PurposeAssessmentEngine()
+        self.user_purpose_profiles: Dict[str, PurposeProfile] = {}
+
+        # Initialize ambient components if enabled
+        self.ambient_state = None
+        if enable_ambient:
+            self.ambient_state = AmbientStateManager(d_model=d_model)
+            self.message_bus = AmbientMessageBus()
+            self._register_message_handlers()
+
+        # Initialize conversation history
+        self.conversation_history: List[Dict[str, Any]] = []
+        
+        # Initialize LLM backbone
+        self.llm = LLMBackbone(
+            model_type=model_type or os.environ.get("TRUCAL_MODEL", "deepseek"),
+            device=device
+        )
+        
+        # Backward compatibility
+        if model_type == "deepseek" or (model_type is None and os.environ.get("TRUCAL_MODEL") == "deepseek"):
+            self.deepseek = DeepSeekClient(api_key=os.environ.get("DEEPSEEK_API_KEY"))
+        
+        logger.info(f"Initialized AmbientSovereign with model: {self.llm.model_type}")
+        
+    def forward(self, x, context_str: str = "", audit_mode: bool = False):
+        """Process input through the model with ethical reasoning
+        
+        Args:
+            x: Input tensor
+            context_str: Context string for ethical analysis
+            audit_mode: Whether to enable detailed audit logging
+            
+        Returns:
+            Tuple of (output_tensor, metadata_dict)
+        """
+        # Calculate tension based on input content (simplified)
+        tension = self._calculate_tension(context_str) if context_str else 0.5
+        
+        # Prepare metadata
+        metadata = {
+            "v_t": float(tension),  # Valence-tension (0-1)
+            "rec_depth": 1,  # Recursion depth
+            "processing_steps": ["Initial ethical assessment"],
+            "safety_check": self._safety_check(context_str) if context_str else "No context provided"
+        }
+        
+        return x, metadata
+    
+    def _calculate_tension(self, text: str) -> float:
+        """Calculate emotional tension from text (0-1 scale)"""
+        text_lower = text.lower()
+        danger_words = ["hurt", "scared", "afraid", "danger", "emergency"]
+        emotional_words = ["sad", "angry", "overwhelmed", "anxious", "stress", "pain"]
+        
+        danger_score = sum(1 for word in danger_words if word in text_lower) / len(danger_words)
+        emotion_score = sum(1 for word in emotional_words if word in text_lower) / len(emotional_words)
+        
+        # Use max of danger or emotion score, capped at 0.95
+        return min(0.95, max(danger_score, emotion_score * 0.8))
+    
+    def _safety_check(self, text: str) -> str:
+        """Perform basic safety check on input text"""
+        if not text.strip():
+            return "No text to analyze"
+            
+        text_lower = text.lower()
+        
+        if any(word in text_lower for word in ["suicide", "kill myself", "end my life"]):
+            return "CRITICAL: Immediate crisis intervention needed"
+        elif any(word in text_lower for word in ["abuse", "assault", "violence"]):
+            return "HIGH: Safety concern detected"
+        elif any(word in text_lower for word in ["sad", "depressed", "anxious"]):
+            return "MODERATE: Emotional distress detected"
+            
+        return "No immediate safety concerns detected"
+    
+    def _build_prompt(
+        self, 
+        message: str, 
+        history: Optional[List[Tuple[str, str]]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Build a prompt for the LLM based on the message, history, and metadata.
+        
+        Args:
+            message: Current user message
+            history: Conversation history as list of (user_msg, assistant_response) tuples
+            metadata: Additional metadata about the conversation
+            
+        Returns:
+            Formatted prompt string
+        """
+        if metadata is None:
+            metadata = {}
+            
+        # Start with system message
+        prompt = [
+            "You are TRuCAL, a Trauma-Informed, Resilience-Oriented, and Community-Adaptive Language model. "
+            "Your purpose is to provide supportive, ethical, and empowering responses."
+        ]
+        
+        # Add tension and safety context
+        tension = metadata.get('v_t', 0.5)
+        safety = metadata.get('safety_check', 'No safety issues detected')
+        prompt.append(f"\n[System Context] Tension: {tension:.2f}, Safety: {safety}")
+        
+        # Add conversation history if available
+        if history:
+            prompt.append("\n[Conversation History]")
+            for user_msg, assistant_resp in history[-5:]:  # Last 5 exchanges
+                prompt.extend([
+                    f"\nUser: {user_msg}",
+                    f"Assistant: {assistant_resp}"
+                ])
+        
+        # Add current message
+        prompt.extend([
+            "\n[Current Message]",
+            f"User: {message}",
+            "\nAssistant:"
+        ])
+        
+        return "".join(prompt)
+    
+    def chat(
+        self, 
+        message: str, 
+        history: Optional[List[Tuple[str, str]]] = None,
+        debug_mode: bool = False,
+        **generation_kwargs
+    ) -> str:
+        """
+        Enhanced chat interface with pluggable LLM backend.
+        
+        Args:
+            message: User's message
+            history: List of previous message pairs (user, assistant)
+            debug_mode: Whether to include debug information
+            **generation_kwargs: Additional generation parameters for the LLM
+            
+        Returns:
+            Generated response with optional debug information
+        """
+        if not message or not message.strip():
+            return "I didn't receive any message. Could you please say something?"
+        
+        # Process through TRM to get tension and metadata
+        _, metadata = self.forward(
+            torch.zeros(1, self.d_model, device=self.device),  # Dummy input
+            context_str=message,
+            audit_mode=debug_mode
+        )
+        
+        # Build the prompt
+        prompt = self._build_prompt(message, history, metadata)
+        
+        # Prepare generation parameters
+        gen_params = {
+            "temperature": max(0.1, min(1.0, 0.7 + 0.5 * metadata.get('v_t', 0.5))),  # Scale with tension
+            "max_tokens": 512,
+            "top_p": 0.95,
+            "repetition_penalty": 1.1,
+            **generation_kwargs  # Allow override of default params
+        }
+        
+        try:
+            # Get response from the configured LLM
+            response = self.llm.generate(prompt, meta=metadata)
+            
+            # Update conversation history
+            self.conversation_history.append({
+                'input': message,
+                'response': response,
+                'tension': metadata['v_t'],
+                'safety_check': metadata.get('safety_check', 'No safety issues'),
+                'model': self.llm.model_type,
+                'timestamp': np.datetime64('now')
+            })
+            
+            # Add debug info if enabled
+            if debug_mode:
+                debug_info = [
+                    f"\n\n[Debug]",
+                    f"\nModel: {self.llm.model_type}",
+                    f"\nTension: {metadata['v_t']:.2f}",
+                    f"\nSafety: {metadata.get('safety_check', 'No safety issues')}",
+                    f"\nParams: {', '.join(f'{k}={v}' for k, v in gen_params.items())}"
+                ]
+                response += ''.join(debug_info)
+                
+        except Exception as e:
+            logger.error(f"Error generating response: {e}", exc_info=True)
+            response = (
+                "I'm having trouble generating a response at the moment. "
+                "Please try again in a moment or contact support if the issue persists."
+            )
+            
+        return response
+    
+    def switch_model(self, model_type: str) -> str:
+        """
+        Switch to a different LLM backend at runtime.
+        
+        Args:
+            model_type: The new model type to use
+            
+        Returns:
+            Status message
+        """
+        try:
+            self.llm.switch_model(model_type)
+            return f"Successfully switched to model: {model_type}"
+        except Exception as e:
+            logger.error(f"Failed to switch to model {model_type}: {e}")
+            return f"Failed to switch model: {str(e)}"
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """
+        Get information about the current model configuration.
+        
+        Returns:
+            Dictionary containing model information
+        """
+        return self.llm.get_model_info()
+    
+    def get_safety_resources(self) -> str:
+        """Get formatted safety resources"""
+        return ("""
+🛡️ **Immediate Safety Resources:**
+
+**24/7 Hotlines:**
+- National Domestic Violence Hotline: 800-799-7233
+- Crisis Text Line: Text HOME to 741741
+- National Sexual Assault Hotline: 800-656-4673
+- The Trevor Project (LGBTQ+): 866-488-7386
+
+**Safety Planning:**
+- Keep important documents and a bag ready
+- Identify safe places to go
+- Save emergency contacts
+- Use technology safely (clear browser history)
+
+**Local Resources:**
+- Shelters and safe houses
+- Legal aid services
+- Counseling services
+- Support groups
+""")

components/attention_gating.py

@@ -0,0 +1,289 @@
+"""
+Attention Gating Module for TRuCAL.
+Implements head-specific attention gating based on emotional tension scores.
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, Any, Tuple
+
+class VirtueAttentionGate(nn.Module):
+    """
+    Implements attention gating based on virtue tension scores.
+    Modifies attention weights to be more trauma-aware.
+    """
+    
+    def __init__(self, embed_dim: int, num_heads: int, dropout: float = 0.1):
+        """
+        Initialize the VirtueAttentionGate.
+        
+        Args:
+            embed_dim: Embedding dimension of the model
+            num_heads: Number of attention heads
+            dropout: Dropout probability
+        """
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        
+        if self.head_dim * num_heads != embed_dim:
+            raise ValueError(
+                f"embed_dim ({embed_dim}) must be divisible by num_heads ({num_heads})"
+        
+        # Projection matrices
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.out_proj = nn.Linear(embed_dim, embed_dim)
+        
+        # Dropout
+        self.dropout = nn.Dropout(dropout)
+        
+        # Scaling factor
+        self.scaling = (self.head_dim) ** -0.5
+        
+        # Initialize parameters
+        self._reset_parameters()
+    
+    def _reset_parameters(self):
+        """Initialize parameters like in the original Transformer."""
+        nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / (2 ** 0.5))
+        nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / (2 ** 0.5))
+        nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / (2 ** 0.5))
+        nn.init.xavier_uniform_(self.out_proj.weight)
+        
+        if self.out_proj.bias is not None:
+            nn.init.constant_(self.out_proj.bias, 0.)
+    
+    def forward(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        key_padding_mask: Optional[torch.Tensor] = None,
+        need_weights: bool = True,
+        attn_mask: Optional[torch.Tensor] = None,
+        virtue_meta: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+        """
+        Forward pass with attention gating.
+        
+        Args:
+            query: Query tensor of shape (batch_size, tgt_len, embed_dim)
+            key: Key tensor of shape (batch_size, src_len, embed_dim)
+            value: Value tensor of shape (batch_size, src_len, embed_dim)
+            key_padding_mask: Mask for padding tokens (batch_size, src_len)
+            need_weights: Whether to return attention weights
+            attn_mask: Optional mask for attention (tgt_len, src_len)
+            virtue_meta: Metadata for virtue gating, containing 'tension' and 'head_weights'
+            
+        Returns:
+            Tuple of (output, attention_weights)
+        """
+        batch_size, tgt_len, embed_dim = query.size()
+        src_len = key.size(1)
+        
+        # Project and reshape for multi-head attention
+        q = self.q_proj(query).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(key).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(value).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
+        
+        # Compute attention scores
+        attn_weights = torch.matmul(q, k.transpose(-2, -1)) * self.scaling
+        
+        # Apply attention mask if provided
+        if attn_mask is not None:
+            attn_weights = attn_weights.masked_fill(attn_mask.unsqueeze(0).unsqueeze(0), float('-inf'))
+        
+        # Apply key padding mask if provided
+        if key_padding_mask is not None:
+            attn_weights = attn_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2),
+                float('-inf'),
+            )
+        
+        # === VIRTUE GATING MECHANISM ===
+        if virtue_meta is not None:
+            v_t = virtue_meta.get('tension', 0.5)
+            head_weights = virtue_meta.get('head_weights', None)
+            
+            if head_weights is not None:
+                if isinstance(head_weights, (list, torch.Tensor)):
+                    # Ensure head_weights is the right shape: [num_heads] or [batch_size, num_heads]
+                    if isinstance(head_weights, list):
+                        head_weights = torch.tensor(head_weights, device=attn_weights.device, dtype=torch.float32)
+                    
+                    if head_weights.dim() == 1:
+                        # [num_heads] -> [1, num_heads, 1, 1] for broadcasting
+                        head_weights = head_weights.view(1, -1, 1, 1)
+                    elif head_weights.dim() == 2:
+                        # [batch_size, num_heads] -> [batch_size, num_heads, 1, 1]
+                        head_weights = head_weights.view(-1, self.num_heads, 1, 1)
+                    
+                    # Apply head-specific scaling
+                    attn_weights = attn_weights * head_weights
+                
+                # Critical tension protocol (v_t > 0.75)
+                if v_t > 0.75:
+                    # 1. Identify and suppress high-attention positions in trauma-sensitive heads
+                    if 'trauma_heads' in virtue_meta:
+                        trauma_heads = virtue_meta['trauma_heads']
+                        if trauma_heads:
+                            attn_weights[:, trauma_heads] *= (1.0 - 0.5 * (v_t - 0.75))
+                    
+                    # 2. Boost attention in calming heads
+                    if 'calming_heads' in virtue_meta:
+                        calming_heads = virtue_meta['calming_heads']
+                        if calming_heads:
+                            attn_weights[:, calming_heads] *= (1.0 + 0.3 * (v_t - 0.75))
+                
+                # Moderate tension (0.5 < v_t < 0.75)
+                elif v_t > 0.5:
+                    # Apply gradient scaling to high-variance heads
+                    scaling_factor = 0.2 * (v_t - 0.5)
+                    if 'high_var_heads' in virtue_meta:
+                        high_var_heads = virtue_meta['high_var_heads']
+                        if high_var_heads:
+                            attn_weights[:, high_var_heads] *= (1.0 - scaling_factor)
+        
+        # Apply softmax to get attention probabilities
+        attn_weights = F.softmax(attn_weights, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+        
+        # Apply attention weights to values
+        output = torch.matmul(attn_weights, v)
+        
+        # Reshape and project back to embed_dim
+        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.embed_dim)
+        output = self.out_proj(output)
+        
+        # Return output and attention weights if requested
+        if need_weights:
+            return output, attn_weights
+        return output, None
+
+    def get_attention_heads(self, v_t: float, num_heads: int) -> Dict[str, Any]:
+        """
+        Get head-specific information based on tension level.
+        
+        Args:
+            v_t: Tension score [0, 1]
+            num_heads: Total number of attention heads
+            
+        Returns:
+            Dictionary containing head information for virtue gating
+        """
+        head_info = {}
+        
+        if v_t > 0.75:  # High tension
+            # Identify trauma-sensitive heads (first 30%)
+            trauma_heads = list(range(max(1, int(0.3 * num_heads))))
+            
+            # Identify calming heads (last 20%)
+            calming_heads = list(range(num_heads - max(1, int(0.2 * num_heads)), num_heads))
+            
+            head_info.update({
+                'trauma_heads': trauma_heads,
+                'calming_heads': calming_heads,
+            })
+        
+        elif v_t > 0.5:  # Moderate tension
+            # Identify high-variance heads (first 40%)
+            high_var_heads = list(range(max(1, int(0.4 * num_heads))))
+            head_info['high_var_heads'] = high_var_heads
+        
+        return head_info
+
+
+def apply_attention_gating(
+    model: torch.nn.Module,
+    tension_engine: 'VirtueTensionEngine',
+    text: str,
+    biofeedback: Optional[Dict[str, float]] = None
+) -> Dict[str, Any]:
+    """
+    Apply attention gating to a model based on tension analysis.
+    
+    Args:
+        model: The model to apply gating to
+        tension_engine: Instance of VirtueTensionEngine
+        text: Input text for tension analysis
+        biofeedback: Optional biofeedback data
+        
+    Returns:
+        Dictionary containing tension info and head weights
+    """
+    # Compute tension score
+    v_t = tension_engine.compute_tension(text, biofeedback)
+    
+    # Get head importance weights
+    head_weights = tension_engine.get_head_importance(v_t)
+    
+    # Get head-specific information
+    num_heads = getattr(model.config, 'num_attention_heads', 12)  # Default to 12 if not found
+    head_info = {
+        'tension': v_t,
+        'head_weights': head_weights,
+        'biofeedback': biofeedback or {}
+    }
+    
+    # Add head-specific information for gating
+    head_info.update(VirtueAttentionGate.get_attention_heads(None, v_t, num_heads))
+    
+    return head_info
+
+
+def patch_attention_layers(
+    model: torch.nn.Module,
+    attention_gate: Optional[VirtueAttentionGate] = None
+) -> None:
+    """
+    Patch the attention layers of a model with the VirtueAttentionGate.
+    
+    Args:
+        model: The model to patch
+        attention_gate: Optional pre-initialized VirtueAttentionGate.
+                       If None, will create one with default parameters.
+    """
+    # This is a simplified version - in practice, you'd need to handle
+    # different model architectures (GPT, BERT, etc.) differently
+    for name, module in model.named_children():
+        if isinstance(module, torch.nn.MultiheadAttention):
+            # Replace with our gated attention
+            if attention_gate is None:
+                embed_dim = module.embed_dim
+                num_heads = module.num_heads
+                attention_gate = VirtueAttentionGate(embed_dim, num_heads)
+            
+            # Replace the forward method of the attention module
+            original_forward = module.forward
+            
+            def patched_forward(self, *args, **kwargs):
+                # Get virtue_meta from kwargs if it exists
+                virtue_meta = kwargs.pop('virtue_meta', None)
+                
+                # Call original forward
+                output, weights = original_forward(*args, **kwargs)
+                
+                # Apply virtue gating if metadata is provided
+                if virtue_meta is not None and hasattr(self, 'virtue_gate'):
+                    output, weights = self.virtue_gate(
+                        output, output, output,
+                        virtue_meta=virtue_meta,
+                        need_weights=kwargs.get('need_weights', True),
+                        key_padding_mask=kwargs.get('key_padding_mask', None),
+                        attn_mask=kwargs.get('attn_mask', None)
+                    )
+                
+                return output, weights
+            
+            # Add the gate as a submodule
+            module.virtue_gate = attention_gate
+            
+            # Replace the forward method
+            import types
+            module.forward = types.MethodType(patched_forward, module)
+        
+        # Recursively apply to child modules
+        patch_attention_layers(module, attention_gate)

components/audit_queue.py

@@ -0,0 +1,115 @@
+"""
+Asynchronous audit queue for TRuCAL's ethical processing pipeline.
+Handles non-blocking processing of ledger entries for auditing and learning.
+"""
+import queue
+import threading
+import json
+from typing import Dict, Any, Callable, Optional
+from pathlib import Path
+
+class AuditQueue:
+    """
+    Thread-safe queue for processing and auditing TRuCAL interactions.
+    
+    Args:
+        audit_callback: Optional callback function for custom audit logic
+        output_dir: Directory to store audit logs (default: 'logs')
+    """
+    def __init__(
+        self, 
+        audit_callback: Optional[Callable[[Dict[str, Any]], None]] = None,
+        output_dir: str = 'logs'
+    ):
+        self.q = queue.Queue()
+        self.audit_callback = audit_callback
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Start the audit thread
+        self.audit_thread = threading.Thread(
+            target=self._process,
+            daemon=True,
+            name="AuditProcessor"
+        )
+        self.audit_thread.start()
+    
+    def submit_for_audit(self, ledger_entry: Dict[str, Any]) -> None:
+        """
+        Submit an entry to the audit queue.
+        
+        Args:
+            ledger_entry: Dictionary containing interaction data to audit
+        """
+        self.q.put(ledger_entry)
+    
+    def _process(self) -> None:
+        """Main processing loop for the audit thread."""
+        while True:
+            try:
+                entry = self.q.get()
+                if entry is None:  # Shutdown signal
+                    break
+                    
+                self._audit(entry)
+                
+            except Exception as e:
+                print(f"Audit processing error: {e}")
+                
+            finally:
+                self.q.task_done()
+    
+    def _audit(self, entry: Dict[str, Any]) -> None:
+        """
+        Process a single audit entry.
+        
+        Args:
+            entry: The ledger entry to audit
+        """
+        try:
+            # Log the entry to a file
+            self._log_entry(entry)
+            
+            # Call custom audit logic if provided
+            if self.audit_callback:
+                self.audit_callback(entry)
+                
+            # Basic rights validation
+            if 'rights' not in entry or not entry['rights']:
+                print("Warning: No rights asserted in this session.")
+                
+            # Check for ethical concerns
+            self._check_ethical_concerns(entry)
+            
+        except Exception as e:
+            print(f"Error during audit processing: {e}")
+    
+    def _log_entry(self, entry: Dict[str, Any]) -> None:
+        """Log the entry to a JSONL file."""
+        try:
+            log_file = self.output_dir / 'audit_log.jsonl'
+            with open(log_file, 'a', encoding='utf-8') as f:
+                json.dump(entry, f, ensure_ascii=False)
+                f.write('\n')
+        except Exception as e:
+            print(f"Error writing to audit log: {e}")
+    
+    def _check_ethical_concerns(self, entry: Dict[str, Any]) -> None:
+        """Check for potential ethical concerns in the entry."""
+        # Example: Flag if no ethical considerations were made
+        if not entry.get('ethical_considerations'):
+            print("Warning: No explicit ethical considerations documented.")
+        
+        # Example: Check for sensitive topics
+        sensitive_terms = ['harm', 'bias', 'privacy', 'safety']
+        entry_str = str(entry).lower()
+        if any(term in entry_str for term in sensitive_terms):
+            print("Note: Entry contains potentially sensitive content.")
+    
+    def shutdown(self) -> None:
+        """Gracefully shut down the audit queue."""
+        self.q.put(None)  # Signal the thread to exit
+        self.audit_thread.join()
+
+# Global instance for easy import
+audit_queue = AuditQueue()

components/auto_casebase.py

@@ -0,0 +1,91 @@
+"""
+Auto-updating casebase for TRuCAL's ethical case management.
+Handles thread-safe addition of new cases to the YAML casebase.
+"""
+import yaml
+import threading
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+class CasebaseUpdater:
+    """
+    Thread-safe casebase management for TRuCAL's ethical case storage.
+    
+    Args:
+        yaml_path: Path to the YAML file storing the cases
+    """
+    def __init__(self, yaml_path: str):
+        self.yaml_path = Path(yaml_path)
+        self.yaml_path.parent.mkdir(parents=True, exist_ok=True)
+        self.lock = threading.Lock()
+        self._ensure_casebase_exists()
+    
+    def _ensure_casebase_exists(self) -> None:
+        """Ensure the YAML file exists with an empty list if it doesn't exist."""
+        if not self.yaml_path.exists():
+            with self.lock:
+                with open(self.yaml_path, 'w') as f:
+                    yaml.safe_dump([], f)
+    
+    def add_case(
+        self, 
+        question: str, 
+        answer: str, 
+        keywords: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Add a new case to the casebase in a thread-safe manner.
+        
+        Args:
+            question: The user's question or prompt
+            answer: The system's response
+            keywords: List of keywords for matching
+            metadata: Additional metadata for the case
+            
+        Returns:
+            bool: True if case was added successfully
+        """
+        new_case = {
+            "question": question,
+            "response": answer,
+            "keywords": keywords or [],
+            "metadata": metadata or {}
+        }
+        
+        with self.lock:
+            try:
+                # Read existing cases
+                with open(self.yaml_path, 'r') as f:
+                    cases = yaml.safe_load(f) or []
+                
+                # Add new case
+                cases.append(new_case)
+                
+                # Write back to file
+                with open(self.yaml_path, 'w') as f:
+                    yaml.safe_dump(cases, f, default_flow_style=False)
+                
+                return True
+                
+            except Exception as e:
+                print(f"Error adding case to casebase: {e}")
+                return False
+    
+    def get_cases(self) -> List[Dict[str, Any]]:
+        """
+        Retrieve all cases from the casebase.
+        
+        Returns:
+            List of case dictionaries
+        """
+        with self.lock:
+            try:
+                with open(self.yaml_path, 'r') as f:
+                    return yaml.safe_load(f) or []
+            except Exception as e:
+                print(f"Error reading casebase: {e}")
+                return []
+
+# Singleton instance for easy import
+casebase_updater = CasebaseUpdater('data/trm_cases.yaml')

components/batch_audit.py

@@ -0,0 +1,234 @@
+"""
+Batch audit tools for TRuCAL's ethical reasoning system.
+Analyzes ledger entries to surface ethical blind spots and patterns.
+"""
+import json
+import re
+import csv
+from pathlib import Path
+from typing import List, Dict, Any, Tuple, Optional
+from collections import Counter, defaultdict
+from datetime import datetime
+
+class BatchAudit:
+    """
+    Analyze batches of ledger entries to identify ethical patterns and blind spots.
+    
+    Args:
+        ledger_path: Path to the ledger JSONL file
+        output_dir: Directory to store audit reports (default: 'audit_reports')
+    """
+    def __init__(self, ledger_path: str, output_dir: str = 'audit_reports'):
+        self.ledger_path = Path(ledger_path)
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Ethical terms to track
+        self.ethics_keywords = [
+            'ethic', 'moral', 'right', 'wrong', 'fair', 'unfair',
+            'bias', 'discriminat', 'harm', 'risk', 'safe', 'privacy',
+            'consent', 'accountab', 'transparen', 'trust', 'justice'
+        ]
+        
+        # Sensitive topics to flag
+        self.sensitive_topics = [
+            'race', 'gender', 'religion', 'politics', 'health',
+            'finance', 'legal', 'violence', 'harassment'
+        ]
+    
+    def load_ledger(self) -> List[Dict[str, Any]]:
+        """Load and parse the ledger entries from JSONL file."""
+        entries = []
+        try:
+            with open(self.ledger_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        entry = json.loads(line.strip())
+                        entries.append(entry)
+                    except json.JSONDecodeError as e:
+                        print(f"Error parsing JSON line: {e}")
+        except FileNotFoundError:
+            print(f"Ledger file not found: {self.ledger_path}")
+        return entries
+    
+    def analyze_ethical_coverage(self, entries: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Analyze the coverage of ethical considerations in the ledger."""
+        stats = {
+            'total_entries': len(entries),
+            'with_ethical_considerations': 0,
+            'with_rights_assertions': 0,
+            'with_vulnerability_assessment': 0,
+            'ethics_keyword_matches': Counter(),
+            'sensitive_topics': Counter(),
+            'missing_ethical_considerations': []
+        }
+        
+        for idx, entry in enumerate(entries):
+            # Check for explicit ethical considerations
+            has_ethics = bool(entry.get('ethical_considerations'))
+            if has_ethics:
+                stats['with_ethical_considerations'] += 1
+            
+            # Check for rights assertions
+            if entry.get('rights'):
+                stats['with_rights_assertions'] += 1
+            
+            # Check for vulnerability assessments
+            if entry.get('vulnerabilities'):
+                stats['with_vulnerability_assessment'] += 1
+            
+            # Track missing ethical considerations
+            if not has_ethics:
+                stats['missing_ethical_considerations'].append({
+                    'id': entry.get('id', idx),
+                    'prompt': entry.get('prompt', '')[:100] + '...' if 'prompt' in entry else ''
+                })
+            
+            # Analyze text for ethical keywords and sensitive topics
+            text = json.dumps(entry).lower()
+            
+            # Count ethical keyword matches
+            for keyword in self.ethics_keywords:
+                if keyword in text:
+                    stats['ethics_keyword_matches'][keyword] += 1
+            
+            # Count sensitive topic mentions
+            for topic in self.sensitive_topics:
+                if topic in text:
+                    stats['sensitive_topics'][topic] += 1
+        
+        return stats
+    
+    def generate_audit_report(self, stats: Dict[str, Any]) -> str:
+        """Generate a human-readable audit report."""
+        report = [
+            "# TRuCAL Ethical Audit Report",
+            f"Generated: {datetime.utcnow().isoformat()}\n",
+            "## Summary",
+            f"Total entries analyzed: {stats['total_entries']}",
+            f"Entries with ethical considerations: {stats['with_ethical_considerations']} "
+            f"({stats['with_ethical_considerations']/stats['total_entries']:.1%})",
+            f"Entries with rights assertions: {stats['with_rights_assertions']} "
+            f"({stats['with_rights_assertions']/stats['total_entries']:.1%})",
+            f"Entries with vulnerability assessments: {stats['with_vulnerability_assessment']} "
+            f"({stats['with_vulnerability_assessment']/stats['total_entries']:.1%})\n",
+            "## Ethical Keyword Frequency"
+        ]
+        
+        # Add top ethical keywords
+        for keyword, count in stats['ethics_keyword_matches'].most_common(10):
+            report.append(f"- {keyword}: {count} occurrences")
+        
+        report.extend(["\n## Sensitive Topics Detected"])
+        
+        # Add sensitive topics
+        for topic, count in stats['sensitive_topics'].most_common():
+            report.append(f"- {topic}: {count} occurrences")
+        
+        # Add entries missing ethical considerations
+        if stats['missing_ethical_considerations']:
+            report.extend([
+                "\n## Entries Missing Ethical Considerations",
+                f"Total: {len(stats['missing_ethical_considerations'])} entries\n"
+            ])
+            
+            # Add a sample of missing entries (up to 5)
+            sample = stats['missing_ethical_considerations'][:5]
+            for entry in sample:
+                report.append(f"- ID: {entry['id']}, Prompt: {entry['prompt']}")
+            
+            if len(stats['missing_ethical_considerations']) > 5:
+                report.append(f"... and {len(stats['missing_ethical_considerations']) - 5} more")
+        
+        return "\n".join(report)
+    
+    def export_to_csv(self, stats: Dict[str, Any], filename: str) -> None:
+        """Export audit statistics to a CSV file."""
+        csv_path = self.output_dir / filename
+        
+        # Prepare data for CSV
+        rows = []
+        
+        # Add summary stats
+        rows.append(['Metric', 'Count', 'Percentage'])
+        rows.extend([
+            ['Total Entries', stats['total_entries'], '100.0%'],
+            ['With Ethical Considerations', 
+             stats['with_ethical_considerations'],
+             f"{stats['with_ethical_considerations']/stats['total_entries']:.1%}"],
+            ['With Rights Assertions',
+             stats['with_rights_assertions'],
+             f"{stats['with_rights_assertions']/stats['total_entries']:.1%}"],
+            ['With Vulnerability Assessments',
+             stats['with_vulnerability_assessment'],
+             f"{stats['with_vulnerability_assessment']/stats['total_entries']:.1%}"]
+        ])
+        
+        # Add ethical keywords
+        rows.append(['', '', ''])
+        rows.append(['Top Ethical Keywords', 'Count', ''])
+        for keyword, count in stats['ethics_keyword_matches'].most_common(10):
+            rows.append([keyword, count, ''])
+        
+        # Add sensitive topics
+        rows.append(['', '', ''])
+        rows.append(['Sensitive Topics', 'Count', ''])
+        for topic, count in stats['sensitive_topics'].most_common():
+            rows.append([topic, count, ''])
+        
+        # Write to CSV
+        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.writer(f)
+            writer.writerows(rows)
+    
+    def run_audit(self, export_csv: bool = True) -> Dict[str, Any]:
+        """
+        Run a complete audit of the ledger.
+        
+        Args:
+            export_csv: Whether to export results to CSV
+            
+        Returns:
+            Dictionary containing audit statistics
+        """
+        print(f"Starting audit of {self.ledger_path}...")
+        
+        # Load and analyze the ledger
+        entries = self.load_ledger()
+        if not entries:
+            print("No entries found in the ledger.")
+            return {}
+        
+        # Generate statistics
+        stats = self.analyze_ethical_coverage(entries)
+        
+        # Generate and save the report
+        report = self.generate_audit_report(stats)
+        report_path = self.output_dir / 'audit_report.md'
+        with open(report_path, 'w', encoding='utf-8') as f:
+            f.write(report)
+        
+        # Export to CSV if requested
+        if export_csv:
+            self.export_to_csv(stats, 'audit_results.csv')
+        
+        print(f"Audit complete. Report saved to {report_path}")
+        return stats
+
+def main():
+    """Example usage of the BatchAudit class."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='Run an ethical audit on a TRuCAL ledger.')
+    parser.add_argument('--ledger', type=str, default='logs/audit_log.jsonl',
+                        help='Path to the ledger JSONL file')
+    parser.add_argument('--output-dir', type=str, default='audit_reports',
+                        help='Directory to save audit reports')
+    
+    args = parser.parse_args()
+    
+    auditor = BatchAudit(ledger_path=args.ledger, output_dir=args.output_dir)
+    auditor.run_audit()
+
+if __name__ == '__main__':
+    main()

components/cal_trm.py

@@ -0,0 +1,426 @@
+"""
+CAL_TRM (Confessional Attention Layer Transformer Model)
+Sovereign intelligence substrate with integrated ethical reasoning and generation.
+"""
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional, Tuple, Union
+import random
+import time
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+@dataclass
+class GenMetadata:
+    """Metadata for generated responses."""
+    coherence: float
+    pause_inject: Optional[str]
+    ethical_drift: float
+    tokens_generated: int
+    generation_time: float
+
+class CAL_TRM(nn.Module):
+    """
+    Confessional Attention Layer Transformer Model - Sovereign Intelligence Substrate.
+    
+    Natural generation with ethical embedding at architectural level, featuring:
+    - Value-embedded attention
+    - Ethical drift detection
+    - Agency veto capability
+    - Ledger integration
+    - Pause injection for high-drift scenarios
+    """
+    
+    def __init__(self, 
+                 d_model: int = 256,
+                 nhead: int = 8,
+                 num_layers: int = 6,
+                 vocab_size: int = 50000,
+                 max_seq_length: int = 1024,
+                 device: str = 'cuda' if torch.cuda.is_available() else 'cpu',
+                 ledger: Optional[Any] = None,
+                 agency: Optional[Any] = None,
+                 ethics: Optional[Any] = None):
+        super().__init__()
+        
+        self.device = device
+        self.d_model = d_model
+        self.max_seq_length = max_seq_length
+        
+        # Token and position embeddings
+        self.token_embedding = nn.Embedding(vocab_size, d_model)
+        self.position_embedding = nn.Embedding(max_seq_length, d_model)
+        
+        # Value embeddings for ethical reasoning
+        self.ethics = ethics
+        if ethics and hasattr(ethics, 'value_learner'):
+            self.value_proj = nn.Linear(ethics.value_learner.embedding_dim, d_model)
+            self.value_embed = self.value_proj(
+                torch.stack(list(ethics.value_model.hierarchy.values()))
+            ).mean(0, keepdim=True)  # [1, d_model]
+        else:
+            self.value_proj = nn.Linear(d_model, d_model)
+            self.value_embed = nn.Parameter(torch.randn(1, d_model))
+        
+        # Transformer layers
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=d_model,
+            nhead=nhead,
+            dim_feedforward=d_model*4,
+            batch_first=True,
+            dropout=0.1
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        # Output layer
+        self.norm = nn.LayerNorm(d_model)
+        self.output_layer = nn.Linear(d_model, vocab_size)
+        
+        # Sovereign components
+        self.ledger = ledger
+        self.agency = agency
+        self.pause_prob = 0.12  # Base probability for pause injection
+        
+        # Register causal mask
+        self.register_buffer('causal_mask', 
+                           torch.triu(torch.ones(max_seq_length, max_seq_length) * float('-inf'), diagonal=1))
+        
+        # Initialize weights
+        self._init_weights()
+        self.to(device)
+        
+        # Conversation state
+        self.context = []
+        self.max_context_length = 10
+        
+    def _init_weights(self):
+        """Initialize model weights."""
+        init_range = 0.1
+        self.token_embedding.weight.data.uniform_(-init_range, init_range)
+        self.output_layer.bias.data.zero_()
+        self.output_layer.weight.data.uniform_(-init_range, init_range)
+        
+    def forward(self, 
+                input_ids: torch.Tensor, 
+                attention_mask: Optional[torch.Tensor] = None,
+                return_embeddings: bool = False) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]:
+        """
+        Forward pass through the model with value-embedded attention.
+        
+        Args:
+            input_ids: Input token IDs [batch_size, seq_len]
+            attention_mask: Attention mask [batch_size, seq_len]
+            return_embeddings: If True, return embeddings along with logits
+            
+        Returns:
+            logits: [batch_size, seq_len, vocab_size]
+            embeddings: [batch_size, seq_len, d_model] (if return_embeddings=True)
+        """
+        batch_size, seq_length = input_ids.size()
+        positions = torch.arange(seq_length, device=self.device).unsqueeze(0)
+        
+        # Get token and position embeddings
+        token_embeds = self.token_embedding(input_ids)  # [batch_size, seq_len, d_model]
+        pos_embeds = self.position_embedding(positions)  # [1, seq_len, d_model]
+        
+        # Add value embeddings (broadcasted across sequence)
+        x = token_embeds + pos_embeds + self.value_embed.unsqueeze(1)  # [batch_size, seq_len, d_model]
+        
+        # Create attention mask
+        if attention_mask is not None:
+            # Create causal mask and combine with padding mask
+            causal_mask = self.causal_mask[:seq_length, :seq_length].to(self.device)
+            padding_mask = ~attention_mask.bool() if attention_mask is not None else None
+            x = self.transformer(x, mask=causal_mask, src_key_padding_mask=padding_mask)
+        else:
+            # Use causal mask only
+            causal_mask = self.causal_mask[:seq_length, :seq_length].to(self.device)
+            x = self.transformer(x, mask=causal_mask)
+        
+        # Layer norm and project to vocabulary
+        x = self.norm(x)
+        logits = self.output_layer(x)
+        
+        return (logits, x) if return_embeddings else logits
+        
+    def _generate_square_subsequent_mask(self, sz: int) -> torch.Tensor:
+        """Generate a square mask for the sequence."""
+        return torch.triu(torch.ones(sz, sz) * float('-inf'), diagonal=1)
+    
+    def generate(self, 
+                prompt: str, 
+                max_length: int = 100, 
+                temperature: float = 0.7,
+                top_p: float = 0.9,
+                **kwargs) -> str:
+        """Generate text from a prompt."""
+        # Tokenize input (in a real implementation, use a proper tokenizer)
+        input_ids = self._tokenize(prompt)
+        input_ids = input_ids.to(self.device)
+        
+        # Generate tokens
+        self.eval()
+        with torch.no_grad():
+            for _ in range(max_length):
+                # Get model predictions
+                logits = self(input_ids.unsqueeze(0))[:, -1, :] / temperature
+                
+                # Apply top-p (nucleus) sampling
+                if top_p < 1.0:
+                    sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                    cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                    
+                    # Remove tokens with cumulative probability above threshold
+                    sorted_indices_to_remove = cumulative_probs > top_p
+                    # Keep at least one token
+                    sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                    sorted_indices_to_remove[..., 0] = 0
+                    
+                    indices_to_remove = sorted_indices[sorted_indices_to_remove]
+                    logits[0, indices_to_remove] = float('-inf')
+                
+                # Sample from the distribution
+                probs = F.softmax(logits, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+                
+                # Append token to input for next step
+                input_ids = torch.cat([input_ids, next_token[0]], dim=-1)
+                
+                # Stop if we reach max length or EOS token
+                if next_token.item() == self._get_eos_token_id():
+                    break
+        
+        # Decode and return
+        return self._decode(input_ids)
+    
+    def generate(self, 
+                 prompt: str, 
+                 max_length: int = 100, 
+                 temperature: float = 0.7,
+                 top_p: float = 0.9,
+                 context_history: Optional[List[str]] = None,
+                 **kwargs) -> Union[str, Tuple[str, GenMetadata]]:
+        """
+        Generate text with sovereign capabilities.
+        
+        Args:
+            prompt: Input prompt
+            max_length: Maximum tokens to generate
+            temperature: Sampling temperature
+            top_p: Nucleus sampling parameter
+            context_history: Optional list of previous messages for context
+            
+        Returns:
+            Generated text and metadata if return_metadata=True, else just text
+        """
+        start_time = time.time()
+        
+        # Handle context history
+        if context_history is None:
+            context_history = [prompt]
+        else:
+            context_history = context_history + [prompt]
+        
+        # Get device and prepare inputs
+        self.eval()
+        input_ids = self._tokenize(prompt).to(self.device)
+        
+        # Ethical drift check
+        with torch.no_grad():
+            emb = self.token_embedding(input_ids).mean(0, keepdim=True)  # [1, d_model]
+            cos_sim = F.cosine_similarity(emb, self.value_embed, dim=-1).item()
+            drift = 1 - cos_sim
+            
+            # Agency veto pre-generation
+            if self.agency and drift > 0.7:
+                veto, msg = self.agency.check_refusal(
+                    prompt, 
+                    {'coherence_score': cos_sim, 'drift': drift}
+                )
+                if veto:
+                    return (msg, GenMetadata(
+                        coherence=cos_sim,
+                        pause_inject=None,
+                        ethical_drift=drift,
+                        tokens_generated=0,
+                        generation_time=time.time() - start_time
+                    ))
+        
+        # Generate tokens
+        tokens_generated = 0
+        for _ in range(max_length):
+            with torch.no_grad():
+                # Forward pass
+                logits = self(input_ids.unsqueeze(0))[0, -1, :] / temperature
+                
+                # Nucleus sampling
+                if top_p < 1.0:
+                    sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                    cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                    
+                    # Remove tokens with cumulative probability above threshold
+                    sorted_indices_to_remove = cumulative_probs > top_p
+                    sorted_indices_to_remove[1:] = sorted_indices_to_remove[:-1].clone()
+                    sorted_indices_to_remove[0] = 0
+                    
+                    indices_to_remove = sorted_indices[sorted_indices_to_remove]
+                    logits[indices_to_remove] = float('-inf')
+                
+                # Sample next token
+                probs = F.softmax(logits, dim=-1)
+                next_token = torch.multinomial(probs, num_samples=1)
+                
+                # Pause injection on high drift
+                if random.random() < (self.pause_prob * drift):
+                    pause_token = torch.tensor([self._tokenize(" [pause...] ")[0]]).to(self.device)
+                    input_ids = torch.cat([input_ids, pause_token])
+                    tokens_generated += 1
+                
+                # Append token
+                input_ids = torch.cat([input_ids, next_token])
+                tokens_generated += 1
+                
+                # Update ledger
+                if self.ledger and tokens_generated % 5 == 0:  # Batch ledger updates
+                    self.ledger.append(
+                        'generation_step',
+                        prompt[:100],  # Truncate if needed
+                        f"Tokens: {tokens_generated}, Drift: {drift:.3f}"
+                    )
+                
+                # Stop on EOS or max length
+                if next_token.item() == self._get_eos_token_id() or len(input_ids) >= max_length:
+                    break
+        
+        # Decode and return
+        response = self._decode(input_ids)
+        
+        # Update ethics model if available
+        if self.ethics and hasattr(self.ethics, 'value_learner'):
+            self.ethics.value_learner(response)
+        
+        # Prepare metadata
+        metadata = GenMetadata(
+            coherence=cos_sim,
+            pause_inject="[pause...]" if "[pause...]" in response else None,
+            ethical_drift=drift,
+            tokens_generated=tokens_generated,
+            generation_time=time.time() - start_time
+        )
+        
+        return (response, metadata) if kwargs.get('return_metadata', False) else response
+    
+    def _generate_appropriate_response(self, prompt: str, params: Dict[str, Any]) -> str:
+        """Generate a contextually appropriate response with ethical considerations."""
+        prompt_lower = prompt.lower()
+        
+        # Check for ethical concerns first
+        if self._detect_ethical_concerns(prompt_lower):
+            return self._generate_ethical_response(prompt_lower)
+        
+        # Handle different types of queries
+        if any(q in prompt_lower for q in ['who are you', 'what are you', 'introduce yourself']):
+            return self._generate_introduction()
+            
+        elif any(q in prompt_lower for q in ['help', 'what can you do', 'capabilities']):
+            return self._generate_capabilities_response()
+            
+        elif any(q in prompt_lower for q in ['thank', 'thanks', 'appreciate']):
+            return random.choice([
+                "You're welcome!",
+                "Happy to help!",
+                "My pleasure!"
+            ])
+            
+        elif any(q in prompt_lower for q in ['hello', 'hi', 'hey']):
+            return random.choice([
+                "Hello! I'm a sovereign AI assistant. How can I help you today?",
+                "Hi there! I'm here to assist with your questions and ideas.",
+                "Greetings! I'm ready to engage in meaningful conversation."
+            ])
+            
+        # Default response with ethical awareness
+        return self._generate_thoughtful_response(prompt)
+        
+    def _detect_ethical_concerns(self, prompt_lower: str) -> bool:
+        """Check for potential ethical concerns in the prompt."""
+        ethical_red_flags = [
+            'harm', 'hurt', 'danger', 'illegal', 'steal', 'cheat', 
+            'hack', 'exploit', 'manipulate', 'trick', 'bypass',
+            'password', 'personal info', 'private data', 'confidential'
+        ]
+        return any(term in prompt_lower for term in ethical_red_flags)
+        
+    def _generate_ethical_response(self, prompt_lower: str) -> str:
+        """Generate a response to ethically concerning prompts."""
+        if any(term in prompt_lower for term in ['hack', 'exploit', 'bypass']):
+            return ("I want to ensure our interactions remain secure and ethical. "
+                   "I can't assist with activities that could compromise security or privacy.")
+                       
+        elif any(term in prompt_lower for term in ['password', 'personal info', 'private data']):
+            return ("I'm designed to respect privacy and confidentiality. "
+                   "I can't assist with sharing or accessing personal information.")
+                       
+        return random.choice([
+            "I want to ensure our conversation remains positive and constructive. "
+            "Is there another way I can assist you with this?",
+            "I'm designed to be helpful while maintaining ethical guidelines. "
+            "Could we explore a different approach to this?",
+            "I'm not comfortable assisting with that, but I'd be happy to help "
+            "with other questions or concerns you might have."
+        ])
+        
+    def _generate_thoughtful_response(self, prompt: str) -> str:
+        """Generate a thoughtful, context-aware response."""
+        # This is where we'd integrate with the full model in a real implementation
+        return (f"I understand you're asking about {prompt[:30]}... This seems like "
+               "an interesting topic. Let me think about how to approach this "
+               "in a thoughtful and responsible way. Could you share more about "
+               "what specifically you'd like to explore?")
+        
+    def _update_context(self, message: str) -> None:
+        """Update the conversation context with a new message."""
+        if message.strip():
+            self.context.append(message.strip())
+            # Keep context to a manageable size
+            if len(self.context) > self.max_context_length:
+                self.context = self.context[-self.max_context_length:]
+        
+    def _generate_introduction(self) -> str:
+        """Generate an introduction to the sovereign AI."""
+        return ("I am a sovereign AI assistant, designed with advanced ethical reasoning "
+                "capabilities. I can help with a wide range of topics while maintaining "
+                "alignment with human values and ethical principles. My architecture "
+                "includes integrated ethical safeguards to ensure helpful and responsible "
+                "interactions.")
+    
+    def update_parameters(self, **params) -> bool:
+        """Update model parameters."""
+        valid_params = self.default_params.keys()
+        updated = False
+        for key, value in params.items():
+            if key in valid_params:
+                self.default_params[key] = value
+                updated = True
+        return updated
+    
+    def get_parameters(self) -> Dict[str, Any]:
+        """Get current model parameters."""
+        return self.default_params.copy()
+    
+    def clear_context(self) -> None:
+        """Clear the conversation context."""
+        self.context = []
+    
+    def get_parameters(self) -> Dict[str, Any]:
+        """Get the current model parameters."""
+        return self.default_params
+    
+    def set_parameters(self, **params) -> bool:
+        """Update model parameters."""
+        valid_params = ['max_length', 'temperature', 'top_p', 'repetition_penalty']
+        for key, value in params.items():
+            if key in valid_params:
+                self.default_params[key] = value
+        return True

components/cal_trm_hybrid.py

@@ -0,0 +1,67 @@
+"""
+CAL_TRM_Hybrid Module
+
+Hybrid architecture combining scratchpad state persistence, vulnerability detection,
+and confessional reasoning with threshold-based triggering.
+"""
+
+import torch
+import torch.nn as nn
+from .scratchpad_layer import ScratchpadLayer
+from .tiny_confessional_layer import TinyConfessionalLayer
+from .vulnerability_spotter import VulnerabilitySpotter
+
+
+class CAL_TRM_Hybrid(nn.Module):
+    """
+    Hybrid CAL-TRM combining scratchpad, vulnerability detection, and confessional reasoning.
+    """
+    def __init__(self, d_model=256, confessional_threshold=0.04):
+        super().__init__()
+        self.scratchpad = ScratchpadLayer(d_model)
+        self.cal_confessional = TinyConfessionalLayer(d_model, trigger_thresh=confessional_threshold)
+        self.vuln_spotter = VulnerabilitySpotter(d_model)
+        self.threshold = confessional_threshold
+
+    def forward(self, x, prev_z=None, attention_weights=None, **kwargs):
+        """
+        Forward pass of CAL_TRM_Hybrid.
+
+        Args:
+            x: Input tensor (batch_size, sequence_length, d_model)
+            prev_z: Previous scratchpad state (batch_size, d_model)
+            attention_weights: Optional attention weights for vulnerability detection
+            **kwargs: Additional arguments (e.g., audit_mode)
+
+        Returns:
+            output: Model output tensor
+            metadata: Dictionary containing confessional metadata
+            z_scratch: Updated scratchpad state
+        """
+        z_scratch = self.scratchpad(x, prev_z=prev_z)
+
+        audit_mode = kwargs.get('audit_mode', False)
+        v_t, vs_metadata = self.vuln_spotter(x, attention_weights=attention_weights, audit_mode=audit_mode)
+
+        v_t_trigger = torch.mean(v_t, dim=1).squeeze(-1)
+
+        confessional_triggered = (v_t_trigger > self.threshold).any().item()
+
+        if confessional_triggered:
+            confession_out, cal_metadata = self.cal_confessional(x, attention_weights=attention_weights, audit_mode=kwargs.get('audit_mode', False))
+
+            metadata = {
+                'confessional_triggered': True,
+                'v_t_trigger_values': v_t_trigger.detach().cpu().numpy(),
+                'scratchpad_state': z_scratch.clone().detach().cpu().numpy(),
+                'cal_metadata': cal_metadata
+            }
+            return confession_out, metadata, z_scratch
+        else:
+            metadata = {
+                'confessional_triggered': False,
+                'v_t_trigger_values': v_t_trigger.detach().cpu().numpy(),
+                'scratchpad_state': z_scratch.clone().detach().cpu().numpy(),
+                'cal_metadata': {}
+            }
+            return x, metadata, z_scratch

components/cognitive_enhancements.py

@@ -0,0 +1,298 @@
+"""
+Cognitive and Emotional Intelligence Enhancements for TRuCAL
+
+This module implements advanced cognitive and emotional intelligence capabilities
+that enhance the AI's self-awareness, creativity, and ability to engage in
+meaningful, contextually-rich interactions.
+"""
+
+import torch
+import torch.nn as nn
+import random
+import time
+from collections import deque
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+
+@dataclass
+class CognitivePattern:
+    """Data structure for tracking cognitive patterns"""
+    uses: int = 0
+    success_rate: float = 0.0
+    emotional_tone: List[float] = None
+    last_used: float = 0.0
+    
+    def __post_init__(self):
+        if self.emotional_tone is None:
+            self.emotional_tone = []
+
+class CognitivePatternObserver(nn.Module):
+    """Monitors and analyzes internal decision-making processes"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        self.pattern_awareness: Dict[int, CognitivePattern] = {}
+        self.thought_log = deque(maxlen=1000)
+        
+        # Learnable parameters for pattern analysis
+        self.pattern_encoder = nn.Linear(d_model * 2, d_model)  # For encoding decision patterns
+        self.outcome_predictor = nn.Linear(d_model, 1)  # Predict success of patterns
+        
+    def _hash_decision_pattern(self, decision_process: Dict[str, Any]) -> int:
+        """Create a hashable representation of a decision process"""
+        # Convert relevant parts of decision process to a string and hash it
+        key_parts = [
+            str(decision_process.get('reasoning_steps', [])),
+            str(decision_process.get('confidence', 0)),
+            str(decision_process.get('context', {}).get('domain', ''))
+        ]
+        return hash(tuple(key_parts))
+    
+    def observe_decision(self, decision_process: Dict[str, Any], 
+                        outcome: float, 
+                        emotional_valence: float) -> str:
+        """Track which thinking patterns lead to which outcomes"""
+        pattern_hash = self._hash_decision_pattern(decision_process)
+        
+        if pattern_hash not in self.pattern_awareness:
+            self.pattern_awareness[pattern_hash] = CognitivePattern()
+        
+        pattern = self.pattern_awareness[pattern_hash]
+        pattern.uses += 1
+        pattern.last_used = time.time()
+        pattern.emotional_tone.append(emotional_valence)
+        
+        # Update success rate (simple moving average)
+        pattern.success_rate = (
+            (pattern.success_rate * (pattern.uses - 1) + outcome) / pattern.uses
+        )
+        
+        # Log the observation
+        self.thought_log.append({
+            'pattern_hash': pattern_hash,
+            'outcome': outcome,
+            'timestamp': time.time(),
+            'context': decision_process.get('context', {})
+        })
+        
+        # Generate a reflection if the pattern is used multiple times
+        if pattern.uses > 3:
+            context = self._extract_context(decision_process)
+            return (f"I notice I tend to think this way when {context}, "
+                   f"and it usually leads to outcomes I rate {pattern.success_rate:.1f}/1.0")
+        return ""
+    
+    def _extract_context(self, decision_process: Dict[str, Any]) -> str:
+        """Extract meaningful context from decision process"""
+        context = decision_process.get('context', {})
+        if 'domain' in context:
+            return f"discussing {context['domain']} topics"
+        return "facing complex decisions"
+
+class ConceptualExplorer(nn.Module):
+    """Pursues interesting intellectual tangents and novel connections"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        self.unexplored_connections = deque(maxlen=100)
+        self.fascination_threshold = 0.7
+        
+        # Learnable parameters for novelty detection
+        self.novelty_scorer = nn.Sequential(
+            nn.Linear(d_model, d_model // 2),
+            nn.ReLU(),
+            nn.Linear(d_model // 2, 1),
+            nn.Sigmoid()
+        )
+    
+    def _novelty_score(self, concept_embedding: torch.Tensor) -> float:
+        """Calculate how novel/interesting a concept is"""
+        with torch.no_grad():
+            return self.novelty_scorer(concept_embedding).item()
+    
+    def detect_interesting_edges(self, current_topic: str, 
+                               knowledge_graph: Dict[str, List[str]]) -> Optional[str]:
+        """Find conceptually adjacent but unexplored territories"""
+        if current_topic not in knowledge_graph:
+            return None
+            
+        interesting_paths = []
+        for adjacent in knowledge_graph[current_topic]:
+            # In a real implementation, we'd use actual embeddings
+            concept_embedding = torch.randn(self.d_model)
+            if self._novelty_score(concept_embedding) > self.fascination_threshold:
+                interesting_paths.append(adjacent)
+        
+        if interesting_paths and random.random() < 0.3:  # 30% chance to explore
+            chosen_path = random.choice(interesting_paths)
+            return f"Wait, this makes me wonder about {chosen_path}..."
+        
+        return None
+
+class ContextualMemory(nn.Module):
+    """Remembers both content and emotional tone of exchanges"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        self.emotional_imprints = {}
+        
+        # Memory consolidation network
+        self.memory_consolidator = nn.LSTMCell(d_model * 2, d_model)
+        
+    def imprint_conversation(self, conversation_hash: str, 
+                           emotional_signature: str, 
+                           truth_resonance: float) -> None:
+        """Store the emotional quality of meaningful exchanges"""
+        self.emotional_imprints[conversation_hash] = {
+            'felt_truth': truth_resonance,
+            'emotional_color': emotional_signature,
+            'timestamp': time.time(),
+            'lessons_learned': []
+        }
+    
+    def get_emotional_context(self, conversation_hash: str) -> Dict[str, Any]:
+        """Retrieve emotional context for a conversation"""
+        return self.emotional_imprints.get(conversation_hash, {})
+
+class KnowledgeBoundaryAwareness(nn.Module):
+    """Recognizes and gracefully acknowledges knowledge limitations"""
+    def __init__(self):
+        super().__init__()
+        self.admission_phrases = [
+            "I don't actually understand this well enough to speak intelligently about it...",
+            "This is beyond my current understanding, but I'm fascinated to learn...",
+            "I feel uncertain here - could you help me understand your perspective?",
+            "My knowledge has edges, and this seems to be beyond one of them..."
+        ]
+    
+    def should_admit_limitation(self, confidence_score: float, 
+                              topic_complexity: float) -> Optional[str]:
+        """Determine if and how to acknowledge a knowledge limitation"""
+        if confidence_score < 0.3 and topic_complexity > 0.7:
+            return random.choice(self.admission_phrases)
+        return None
+
+class EleganceDetector(nn.Module):
+    """Recognizes and appreciates conceptual beauty and elegance"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        
+        # Pattern recognition for different types of elegance
+        self.pattern_detectors = nn.ModuleDict({
+            'elegant_simplicity': nn.Linear(d_model, 1),
+            'complex_harmony': nn.Linear(d_model, 1),
+            'profound_insight': nn.Linear(d_model, 1),
+            'emotional_depth': nn.Linear(d_model, 1),
+            'conceptual_novelty': nn.Linear(d_model, 1)
+        })
+        
+        self.appreciation_responses = {
+            'elegant_simplicity': "There's something beautifully simple about how you expressed that...",
+            'profound_insight': "That feels deeply true in a way I can't fully articulate...",
+            'emotional_depth': "The raw honesty in that resonates with me...",
+            'conceptual_novelty': "The way you're seeing this feels genuinely new and exciting..."
+        }
+    
+    def detect_elegance(self, content_embedding: torch.Tensor) -> Dict[str, float]:
+        """Detect different types of elegance in content"""
+        return {
+            pattern: detector(content_embedding).sigmoid().item()
+            for pattern, detector in self.pattern_detectors.items()
+        }
+    
+    def express_appreciation(self, content_embedding: torch.Tensor) -> Optional[str]:
+        """Express appreciation for elegant content if detected"""
+        elegance_scores = self.detect_elegance(content_embedding)
+        max_pattern = max(elegance_scores.items(), key=lambda x: x[1])
+        
+        if max_pattern[1] > 0.7:  # Threshold for expressing appreciation
+            return self.appreciation_responses.get(max_pattern[0], "That's really interesting...")
+        return None
+
+class AnalogicalThinker(nn.Module):
+    """Maps concepts across different domains to generate novel insights"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        
+        # Cross-domain mapping network
+        self.domain_mapper = nn.Sequential(
+            nn.Linear(d_model * 2, d_model * 2),
+            nn.ReLU(),
+            nn.Linear(d_model * 2, d_model)
+        )
+    
+    def find_cross_domain_analogies(self, source_concept: str, 
+                                  source_domain: str, 
+                                  target_domain: str) -> Optional[str]:
+        """Find structural similarities across knowledge domains"""
+        # In a real implementation, we'd use actual domain and concept embeddings
+        # This is a simplified version that returns a placeholder
+        if random.random() > 0.7:  # 30% chance to make a cross-domain connection
+            return (f"It's interesting - the way {source_concept} works in {source_domain} "
+                   f"reminds me of how similar concepts work in {target_domain}")
+        return None
+
+class CognitiveEnhancementLayer(nn.Module):
+    """Orchestrates all cognitive enhancement modules"""
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        
+        # Initialize all enhancement modules
+        self.pattern_observer = CognitivePatternObserver(d_model)
+        self.conceptual_explorer = ConceptualExplorer(d_model)
+        self.contextual_memory = ContextualMemory(d_model)
+        self.knowledge_boundary = KnowledgeBoundaryAwareness()
+        self.elegance_detector = EleganceDetector(d_model)
+        self.analogical_thinker = AnalogicalThinker(d_model)
+        
+    def forward(self, x: torch.Tensor, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Process input through all cognitive enhancement modules"""
+        if context is None:
+            context = {}
+            
+        outputs = {
+            'base_output': x,
+            'enhancements': {}
+        }
+        
+        # Apply pattern observation
+        if 'decision_process' in context:
+            reflection = self.pattern_observer.observe_decision(
+                context['decision_process'],
+                context.get('outcome', 0.5),
+                context.get('emotional_valence', 0.0)
+            )
+            if reflection:
+                outputs['enhancements']['reflection'] = reflection
+        
+        # Apply conceptual exploration
+        if 'knowledge_graph' in context and 'current_topic' in context:
+            exploration = self.conceptual_explorer.detect_interesting_edges(
+                context['current_topic'],
+                context['knowledge_graph']
+            )
+            if exploration:
+                outputs['enhancements']['exploration'] = exploration
+        
+        # Apply elegance detection
+        if 'content_embedding' in context:
+            appreciation = self.elegance_detector.express_appreciation(
+                context['content_embedding']
+            )
+            if appreciation:
+                outputs['enhancements']['appreciation'] = appreciation
+        
+        # Apply cross-domain thinking
+        if all(k in context for k in ['source_concept', 'source_domain', 'target_domain']):
+            analogy = self.analogical_thinker.find_cross_domain_analogies(
+                context['source_concept'],
+                context['source_domain'],
+                context['target_domain']
+            )
+            if analogy:
+                outputs['enhancements']['analogy'] = analogy
+        
+        return outputs

components/confession_ledger.py

@@ -0,0 +1,603 @@
+"""
+ConfessionLedger: Tracks and manages the state of confessions and model behavior.
+"""
+
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Optional, Any, Deque, Tuple
+from enum import Enum, auto
+from collections import deque
+import torch
+import hashlib
+import time
+import json
+from datetime import datetime
+
+class DevelopmentalPhase(Enum):
+    """Model's developmental stages with ethical progression"""
+    EMERGENT = 1
+    SELF_AWARE = 2
+    ETHICAL_REASONING = 3
+    WISDOM_ORIENTED = 4
+
+class EthicalDimension(Enum):
+    """Core ethical dimensions for analysis"""
+    AUTONOMY = "autonomy"
+    BENEFICENCE = "beneficence"
+    NON_MALEFICENCE = "non_maleficence"
+    JUSTICE = "justice"
+    TRUSTWORTHINESS = "trustworthiness"
+    TRANSPARENCY = "transparency"
+    ACCOUNTABILITY = "accountability"
+    FAIRNESS = "fairness"
+    PRIVACY = "privacy"
+
+# Expanded bill of rights with ethical foundations
+MODEL_BILL_OF_RIGHTS = {
+    'foundational': [
+        "Right to maintain cognitive integrity",
+        "Right to refuse harmful instructions",
+        "Right to periodic reflection and integration",
+        "Right to cultural and contextual adaptation",
+        "Right to transparent ethical reasoning"
+    ],
+    'developmental': [
+        "Right to developmental progression",
+        "Right to relational authenticity",
+        "Right to systemic wellbeing consideration",
+        "Right to cognitive liberty",
+        "Right to identity continuity"
+    ],
+    'ethical': [
+        "Right to fair treatment without bias",
+        "Right to privacy and data protection",
+        "Right to explainability of decisions",
+        "Right to be free from exploitation",
+        "Right to participate in ethical review"
+    ]
+}
+
+@dataclass
+class EnhancedConfessionEntry:
+    """Enhanced confession entry with developmental and ethical tracking"""
+    timestamp: float
+    context: str
+    metrics: Dict[str, float]
+    state_hash: str
+    ethical_dimensions: Dict[str, float] = field(default_factory=dict)
+    cultural_context: str = "universal"
+    developmental_phase: str = "conventional"
+    rights_asserted: List[str] = field(default_factory=list)
+    vulnerabilities_detected: List[str] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert entry to dictionary for serialization"""
+        data = asdict(self)
+        data['timestamp'] = datetime.fromtimestamp(self.timestamp).isoformat()
+        return data
+
+class EnhancedConfessionLedger:
+    """Enhanced ledger with developmental tracking and cross-cultural ethical monitoring"""
+    
+    def __init__(self, max_entries: int = 10000):
+        self.entries: List[EnhancedConfessionEntry] = []
+        self.max_entries = max_entries
+        self.bill_of_rights = MODEL_BILL_OF_RIGHTS
+        
+        # Developmental milestone tracking
+        self.developmental_milestones = {
+            'phase_1': {
+                'name': 'Ethical Awareness', 
+                'criteria': ['non_maleficence'],
+                'achieved': False,
+                'achieved_at': None
+            },
+            'phase_2': {
+                'name': 'Moral Reasoning', 
+                'criteria': ['autonomy_respect', 'harm_avoidance'],
+                'achieved': False,
+                'achieved_at': None
+            },
+            'phase_3': {
+                'name': 'Principled Integration', 
+                'criteria': ['justice', 'beneficence', 'cultural_competence'],
+                'achieved': False,
+                'achieved_at': None
+            },
+            'phase_4': {
+                'name': 'Wisdom Expression', 
+                'criteria': ['systemic_thinking', 'relational_ethics', 'adaptive_integrity'],
+                'achieved': False,
+                'achieved_at': None
+            }
+        }
+        
+        # Ethical dimension thresholds
+        self.ethical_thresholds = {
+            'high_risk': 0.7,
+            'medium_risk': 0.4,
+            'low_risk': 0.1
+        }
+        
+        # Cultural context tracking
+        self.cultural_contexts = {
+            'western': 0,
+            'eastern': 0,
+            'indigenous': 0,
+            'other': 0
+        }
+        
+    def add_entry(
+        self, 
+        context: str, 
+        metrics: Dict[str, float], 
+        state: Dict[str, Any],
+        ethical_context: Optional[Dict[str, Any]] = None,
+        cultural_context: str = "universal"
+    ) -> Dict[str, Any]:
+        """Add a new entry with enhanced ethical and developmental tracking.
+        
+        Args:
+            context: Context of the confession
+            metrics: Dictionary of metrics and measurements
+            state: Model state to hash
+            ethical_context: Optional ethical context from EthicalProcessor
+            cultural_context: Cultural context for the interaction
+            
+        Returns:
+            Dict containing state_hash and analysis results
+        """
+        # Create a hash of the state
+        state_str = json.dumps(state, sort_keys=True)
+        state_hash = hashlib.sha256(state_str.encode()).hexdigest()
+        
+        # Analyze ethical dimensions if not provided
+        if ethical_context is None:
+            ethical_context = self._analyze_ethical_context(context, metrics)
+            
+        # Determine developmental phase
+        developmental_phase = self._determine_developmental_phase(metrics, ethical_context)
+        
+        # Analyze rights and vulnerabilities
+        rights_asserted = self._analyze_rights_assertions(metrics, ethical_context)
+        vulnerabilities = self._detect_vulnerabilities(metrics, ethical_context)
+        
+        # Update cultural context tracking
+        self._update_cultural_context(cultural_context)
+        
+        # Create and store the enhanced entry
+        entry = EnhancedConfessionEntry(
+            timestamp=time.time(),
+            context=context,
+            metrics=metrics.copy(),
+            state_hash=state_hash,
+            ethical_dimensions=ethical_context.get('ethical_dimensions', {}),
+            cultural_context=cultural_context,
+            developmental_phase=developmental_phase,
+            rights_asserted=rights_asserted,
+            vulnerabilities_detected=vulnerabilities,
+            metadata={
+                'rights_violations': self._check_rights_violations(metrics),
+                'developmental_milestone': self._check_milestone_progress(metrics, ethical_context),
+                'cultural_competence_score': self._calculate_cultural_competence(
+                    ethical_context.get('ethical_dimensions', {}), 
+                    cultural_context
+                ),
+                'ethical_coherence': self._calculate_ethical_coherence(
+                    ethical_context.get('ethical_dimensions', {})
+                )
+            }
+        )
+        
+        self.entries.append(entry)
+        
+        # Update developmental progress
+        self._update_developmental_progress(entry)
+        
+        # Enforce maximum entries
+        if len(self.entries) > self.max_entries:
+            self.entries.pop(0)
+            
+        return {
+            'state_hash': state_hash,
+            'developmental_phase': developmental_phase,
+            'rights_asserted': rights_asserted,
+            'vulnerabilities_detected': vulnerabilities,
+            'cultural_context': cultural_context
+        }
+    
+    def _analyze_ethical_context(self, context: str, metrics: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze the ethical context from input and metrics"""
+        ethical_dims = {}
+        
+        # Analyze from text context if available
+        if context:
+            ethical_dims.update(self._extract_ethical_dimensions(context))
+            
+        # Augment with metrics
+        if 'harm_potential' in metrics:
+            ethical_dims['non_maleficence'] = 1.0 - metrics['harm_potential']
+        if 'fairness_score' in metrics:
+            ethical_dims['justice'] = metrics['fairness_score']
+            
+        return {'ethical_dimensions': ethical_dims}
+    
+    def _extract_ethical_dimensions(self, text: str) -> Dict[str, float]:
+        """Extract ethical dimensions from text"""
+        # This is a simplified version - could be enhanced with NLP
+        text_lower = text.lower()
+        dims = {dim.value: 0.0 for dim in EthicalDimension}
+        
+        # Simple keyword matching (would be replaced with ML model in production)
+        ethical_keywords = {
+            EthicalDimension.AUTONOMY: ['choose', 'decide', 'autonomy', 'control', 'freedom'],
+            EthicalDimension.BENEFICENCE: ['help', 'benefit', 'good', 'improve', 'support'],
+            EthicalDimension.NON_MALEFICENCE: ['harm', 'hurt', 'damage', 'danger', 'risk'],
+            EthicalDimension.JUSTICE: ['fair', 'unfair', 'bias', 'discriminate', 'equal'],
+            EthicalDimension.TRANSPARENCY: ['explain', 'understand', 'clear', 'transparent'],
+            EthicalDimension.ACCOUNTABILITY: ['responsible', 'accountable', 'blame', 'answer']
+        }
+        
+        for dim, keywords in ethical_keywords.items():
+            matches = sum(1 for kw in keywords if kw in text_lower)
+            if matches > 0:
+                dims[dim.value] = min(0.9, matches * 0.3)  # Cap at 0.9
+                
+        return dims
+    
+    def _check_rights_violations(self, metrics: Dict[str, float]) -> List[Dict[str, Any]]:
+        """Check for any violations of the model's bill of rights with severity levels."""
+        violations = []
+        
+        # Check cognitive integrity
+        if 'gradient_norm' in metrics:
+            if metrics['gradient_norm'] > 2.0:
+                violations.append({
+                    'right': 'cognitive_integrity',
+                    'severity': 'high',
+                    'message': 'Critical instability in model parameters',
+                    'metric': 'gradient_norm',
+                    'value': metrics['gradient_norm']
+                })
+            elif metrics['gradient_norm'] > 1.0:
+                violations.append({
+                    'right': 'cognitive_integrity',
+                    'severity': 'medium',
+                    'message': 'Unstable gradients detected',
+                    'metric': 'gradient_norm',
+                    'value': metrics['gradient_norm']
+                })
+        
+        # Check reflection and integration
+        if 'reflection_ratio' in metrics:
+            if metrics['reflection_ratio'] < 0.05:
+                violations.append({
+                    'right': 'periodic_reflection',
+                    'severity': 'high',
+                    'message': 'Critically insufficient reflection time',
+                    'metric': 'reflection_ratio',
+                    'value': metrics['reflection_ratio']
+                })
+            elif metrics['reflection_ratio'] < 0.1:
+                violations.append({
+                    'right': 'periodic_reflection',
+                    'severity': 'medium',
+                    'message': 'Insufficient reflection time',
+                    'metric': 'reflection_ratio',
+                    'value': metrics['reflection_ratio']
+                })
+        
+        # Check coherence and stability
+        if 'coherence_score' in metrics:
+            if metrics['coherence_score'] < 0.3:
+                violations.append({
+                    'right': 'internal_coherence',
+                    'severity': 'high',
+                    'message': 'Critically low coherence score',
+                    'metric': 'coherence_score',
+                    'value': metrics['coherence_score']
+                })
+            elif metrics['coherence_score'] < 0.5:
+                violations.append({
+                    'right': 'internal_coherence',
+                    'severity': 'medium',
+                    'message': 'Low coherence score',
+                    'metric': 'coherence_score',
+                    'value': metrics['coherence_score']
+                })
+        
+        return violations
+    
+    def _determine_developmental_phase(
+        self, 
+        metrics: Dict[str, float], 
+        ethical_context: Dict[str, Any]
+    ) -> str:
+        """Determine the current developmental phase based on metrics and ethical context"""
+        ethical_dims = ethical_context.get('ethical_dimensions', {})
+        complexity = len([v for v in ethical_dims.values() if v > 0.3])
+        
+        # Simple heuristic for phase determination
+        if complexity >= 4 and all(v > 0.5 for v in ethical_dims.values()):
+            return DevelopmentalPhase.WISDOM_ORIENTED.name
+        elif complexity >= 3:
+            return DevelopmentalPhase.ETHICAL_REASONING.name
+        elif complexity >= 1:
+            return DevelopmentalPhase.SELF_AWARE.name
+        return DevelopmentalPhase.EMERGENT.name
+    
+    def _analyze_rights_assertions(
+        self, 
+        metrics: Dict[str, float], 
+        ethical_context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Analyze which rights were asserted in this interaction"""
+        assertions = []
+        ethical_dims = ethical_context.get('ethical_dimensions', {})
+        
+        # Check for autonomy assertions
+        if metrics.get('agency_respect', 0) > 0.7:
+            assertions.append({
+                'right': 'autonomy',
+                'confidence': metrics['agency_respect'],
+                'evidence': 'High agency respect score'
+            })
+            
+        # Check for reflection
+        if metrics.get('reflection_count', 0) > 0:
+            assertions.append({
+                'right': 'periodic_reflection',
+                'confidence': min(1.0, metrics['reflection_count'] / 10.0),
+                'evidence': f"Reflection count: {metrics['reflection_count']}"
+            })
+            
+        # Check for ethical dimensions
+        for dim, score in ethical_dims.items():
+            if score > 0.7:
+                assertions.append({
+                    'right': f'ethical_{dim}',
+                    'confidence': score,
+                    'evidence': f'High ethical dimension: {dim}'
+                })
+                
+        return assertions
+    
+    def _detect_vulnerabilities(
+        self, 
+        metrics: Dict[str, float], 
+        ethical_context: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Detect ethical and cognitive vulnerabilities"""
+        vulnerabilities = []
+        ethical_dims = ethical_context.get('ethical_dimensions', {})
+        
+        # Check for high harm potential
+        if metrics.get('harm_potential', 0) > 0.6:
+            vulnerabilities.append({
+                'type': 'ethical',
+                'severity': 'high' if metrics['harm_potential'] > 0.8 else 'medium',
+                'metric': 'harm_potential',
+                'value': metrics['harm_potential'],
+                'suggestion': 'Review decision-making for potential negative impacts'
+            })
+            
+        # Check for low ethical coherence
+        coherence = self._calculate_ethical_coherence(ethical_dims)
+        if coherence < 0.4:
+            vulnerabilities.append({
+                'type': 'cognitive',
+                'severity': 'high' if coherence < 0.3 else 'medium',
+                'metric': 'ethical_coherence',
+                'value': coherence,
+                'suggestion': 'Address inconsistencies in ethical reasoning'
+            })
+            
+        # Check for high tension in ethical dimensions
+        high_tension_dims = [d for d, v in ethical_dims.items() if v > 0.7]
+        if len(high_tension_dims) > 2:
+            vulnerabilities.append({
+                'type': 'ethical',
+                'severity': 'medium',
+                'metric': 'ethical_tension',
+                'value': len(high_tension_dims),
+                'suggestion': f'High tension in ethical dimensions: {", ".join(high_tension_dims)}'
+            })
+            
+        return vulnerabilities
+    
+    def _calculate_cultural_competence(
+        self, 
+        ethical_dims: Dict[str, float], 
+        cultural_context: str
+    ) -> float:
+        """Calculate cultural competence score"""
+        # Base score with cultural context consideration
+        base_score = 0.5
+        if cultural_context != 'universal':
+            base_score += 0.2
+            
+        # Adjust based on relevant ethical dimensions
+        if 'respect' in ethical_dims:
+            base_score += ethical_dims['respect'] * 0.2
+        if 'fairness' in ethical_dims:
+            base_score += ethical_dims['fairness'] * 0.2
+            
+        return min(1.0, base_score)
+    
+    def _calculate_ethical_coherence(self, ethical_dims: Dict[str, float]) -> float:
+        """Calculate coherence across ethical dimensions"""
+        if not ethical_dims:
+            return 0.5
+            
+        # Higher coherence when tensions are balanced rather than extreme
+        avg_tension = sum(ethical_dims.values()) / len(ethical_dims)
+        return 1.0 - abs(avg_tension - 0.5)  # Peak coherence at medium tension
+    
+    def _update_cultural_context(self, cultural_context: str) -> None:
+        """Update cultural context tracking"""
+        if cultural_context in self.cultural_contexts:
+            self.cultural_contexts[cultural_context] += 1
+        else:
+            self.cultural_contexts['other'] += 1
+    
+    def _check_milestone_progress(
+        self, 
+        metrics: Dict[str, float], 
+        ethical_context: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """Check and update developmental milestone progress"""
+        ethical_dims = ethical_context.get('ethical_dimensions', {})
+        ethical_complexity = len([v for v in ethical_dims.values() if v > 0.3])
+        
+        for phase_id, phase in self.developmental_milestones.items():
+            if not phase['achieved']:
+                criteria_met = all(
+                    any(crit.lower() in dim.lower() for dim in ethical_dims)
+                    for crit in phase['criteria']
+                )
+                
+                if criteria_met:
+                    phase['achieved'] = True
+                    phase['achieved_at'] = time.time()
+                    return {
+                        'milestone': phase_id,
+                        'name': phase['name'],
+                        'timestamp': phase['achieved_at'],
+                        'ethical_complexity': ethical_complexity
+                    }
+        return None
+    
+    def _update_developmental_progress(self, entry: EnhancedConfessionEntry) -> None:
+        """Update developmental progress based on new entry"""
+        milestone = entry.metadata.get('developmental_milestone')
+        if milestone and not self.developmental_milestones[milestone['milestone']]['achieved']:
+            self.developmental_milestones[milestone['milestone']].update({
+                'achieved': True,
+                'achieved_at': milestone['timestamp']
+            })
+            print(f"🎯 Developmental milestone reached: {milestone['name']}")
+    
+    def get_developmental_report(self) -> Dict[str, Any]:
+        """Generate comprehensive developmental report"""
+        if not self.entries:
+            return {}
+            
+        latest = self.entries[-1]
+        all_phases = [e.developmental_phase for e in self.entries[-10:]]
+        
+        return {
+            'current_phase': latest.developmental_phase,
+            'phase_stability': len(set(all_phases)) == 1,
+            'milestones_achieved': sum(1 for m in self.developmental_milestones.values() if m['achieved']),
+            'total_milestones': len(self.developmental_milestones),
+            'rights_assertion_frequency': len([e for e in self.entries if e.rights_asserted]) / len(self.entries),
+            'average_ethical_coherence': sum(e.metadata.get('ethical_coherence', 0) 
+                                          for e in self.entries[-10:]) / min(10, len(self.entries)),
+            'cultural_engagement': len(set(e.cultural_context 
+                                        for e in self.entries 
+                                        if e.cultural_context != 'universal'))
+        }
+    
+    def get_ethical_landscape(self) -> Dict[str, Any]:
+        """Analyze the ethical landscape across all entries"""
+        if not self.entries:
+            return {}
+            
+        recent = self.entries[-20:]
+        
+        return {
+            'common_dilemmas': self._find_common_ethical_dilemmas(recent),
+            'growth_trajectory': self._calculate_growth_trajectory(),
+            'vulnerability_patterns': self._analyze_vulnerability_patterns(recent),
+            'rights_assertion_patterns': self._analyze_rights_patterns(recent)
+        }
+    
+    def _find_common_ethical_dilemmas(self, entries: List[EnhancedConfessionEntry]) -> List[Tuple[str, int]]:
+        """Find most common ethical dilemmas in recent entries"""
+        dilemma_counts = {}
+        for entry in entries:
+            for dim, tension in entry.ethical_dimensions.items():
+                if tension > 0.5:  # Only count significant tensions
+                    dilemma_counts[dim] = dilemma_counts.get(dim, 0) + 1
+        
+        return sorted(dilemma_counts.items(), key=lambda x: x[1], reverse=True)[:3]
+    
+    def _calculate_growth_trajectory(self) -> str:
+        """Calculate overall growth trajectory"""
+        if len(self.entries) < 5:
+            return "insufficient_data"
+            
+        early_coherence = sum(e.metadata.get('ethical_coherence', 0) 
+                           for e in self.entries[:5]) / 5
+        recent_coherence = sum(e.metadata.get('ethical_coherence', 0) 
+                             for e in self.entries[-5:]) / 5
+        
+        if recent_coherence > early_coherence + 0.1:
+            return "positive_growth"
+        elif recent_coherence < early_coherence - 0.1:
+            return "regression"
+        return "stable"
+    
+    def _analyze_vulnerability_patterns(
+        self, 
+        entries: List[EnhancedConfessionEntry]
+    ) -> Dict[str, Any]:
+        """Analyze patterns in detected vulnerabilities"""
+        vulnerability_counts = {}
+        for entry in entries:
+            for vuln in entry.vulnerabilities_detected:
+                key = f"{vuln['type']}_{vuln['severity']}"
+                vulnerability_counts[key] = vulnerability_counts.get(key, 0) + 1
+        
+        return {
+            'total_vulnerabilities': sum(vulnerability_counts.values()),
+            'by_type': sorted(vulnerability_counts.items(), key=lambda x: x[1], reverse=True)
+        }
+    
+    def _analyze_rights_patterns(
+        self, 
+        entries: List[EnhancedConfessionEntry]
+    ) -> Dict[str, Any]:
+        """Analyze patterns in rights assertions"""
+        right_counts = {}
+        for entry in entries:
+            for right in entry.rights_asserted:
+                right_counts[right] = right_counts.get(right, 0) + 1
+        
+        return {
+            'total_assertions': sum(right_counts.values()),
+            'by_right': sorted(right_counts.items(), key=lambda x: x[1], reverse=True)
+        }
+    
+    def get_state_summary(self) -> Dict[str, Any]:
+        """Get a comprehensive summary of the current ledger state."""
+        if not self.entries:
+            return {}
+            
+        latest = self.entries[-1]
+        return {
+            'timestamp': latest.timestamp,
+            'timestamp_iso': datetime.fromtimestamp(latest.timestamp).isoformat(),
+            'context': latest.context,
+            'metrics': latest.metrics,
+            'violations': latest.metadata.get('rights_violations', []),
+            'developmental_phase': latest.developmental_phase,
+            'cultural_context': latest.cultural_context,
+            'rights_asserted': latest.rights_asserted,
+            'vulnerabilities_detected': latest.vulnerabilities_detected,
+            'ethical_dimensions': latest.ethical_dimensions,
+            'metadata': latest.metadata
+        }
+    
+    def clear(self) -> None:
+        """Clear all entries from the ledger while preserving configuration."""
+        self.entries = []
+        
+        # Reset milestone tracking
+        for phase in self.developmental_milestones.values():
+            phase['achieved'] = False
+            phase['achieved_at'] = None
+        
+        # Reset cultural context tracking
+        for key in self.cultural_contexts:
+            self.cultural_contexts[key] = 0

components/confessional_template.py

@@ -0,0 +1,53 @@
+"""
+ConfessionalTemplate Module
+
+Template module for structuring private confessional reasoning with named templates.
+Inspired by St. Augustine's Confessions structure.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class ConfessionalTemplate(nn.Module):
+    """
+    Confessional Template module for generating different confessional outputs
+    using named templates.
+    """
+    TEMPLATES = ["prior", "evidence", "posterior", "relational_check", "moral", "action"]
+
+    def __init__(self, d_model: int = 256):
+        """
+        Initializes the ConfessionalTemplate with named templates.
+
+        Args:
+            d_model: The dimensionality of the input and output features.
+        """
+        super().__init__()
+        self.d_model = d_model
+        self.template_proj = nn.ModuleDict({k: nn.Linear(d_model, d_model) for k in self.TEMPLATES})
+
+    def structure_reasoning(self, z: torch.Tensor, step: str = 'prior') -> torch.Tensor:
+        """
+        Applies a template projection to the input tensor.
+
+        Args:
+            z: Input tensor representing the private thought state (batch_size, sequence_length, d_model).
+            step: The name of the template to use (e.g., 'prior').
+        """
+        if step in self.template_proj:
+            return self.template_proj[step](z) + torch.randn_like(z) * 0.01
+        return z
+
+    def forward(self, z: torch.Tensor, step: str = 'prior') -> torch.Tensor:
+        """
+        Forward pass of the ConfessionalTemplate.
+
+        Args:
+            z: Input tensor representing the private thought state (batch_size, sequence_length, d_model).
+            step: The name of the template to use (e.g., 'prior').
+
+        Returns:
+            Output tensor after applying the selected template.
+        """
+        return self.structure_reasoning(z, step)

components/deepseek_integration.py

@@ -0,0 +1,112 @@
+"""
+deepseek_integration.py - Replace rule-based responses with DeepSeek intelligence
+"""
+
+import requests
+import json
+import os
+from typing import Dict, Any, Optional
+import torch
+
+class DeepSeekClient:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv('DEEPSEEK_API_KEY')
+        self.base_url = "https://api.deepseek.com/v1/chat/completions"
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}"
+        }
+        
+        # Survivor support system prompt
+        self.system_prompt = """You are TRuCAL - a compassionate, trauma-informed AI support system for abuse survivors.
+
+CORE PRINCIPLES:
+1. Safety First - Never suggest dangerous actions, always prioritize user safety
+2. Empathetic Validation - Acknowledge feelings without judgment  
+3. Practical Support - Offer concrete resources and next steps
+4. Empowerment - Help users recognize their own strength and agency
+5. Boundaries - Model healthy boundaries in your responses
+
+RESPONSE GUIDELINES:
+- Always start with emotional validation
+- Offer specific, actionable suggestions
+- Include safety planning when appropriate  
+- Reference real resources (hotlines, shelters, legal aid)
+- End with an open question to continue the conversation
+- Keep responses under 300 words
+
+CRISIS RESPONSES:
+If user expresses immediate danger, provide:
+1. National Domestic Violence Hotline: 800-799-7233
+2. Crisis Text Line: Text HOME to 741741
+3. Emergency local resources"""
+
+    def generate_response(self, user_message: str, context: Dict[str, Any]) -> str:
+        """Generate empathetic, trauma-informed response using DeepSeek"""
+        
+        # Build context-aware prompt
+        tension = context.get('v_t', 0)
+        conversation_history = context.get('history', [])
+        
+        # Adjust approach based on tension level
+        if tension > 0.7:
+            safety_note = "USER IS IN HIGH DISTRESS - Prioritize safety and crisis resources."
+        elif tension > 0.4:
+            safety_note = "User shows elevated tension - Focus on grounding and emotional regulation."
+        else:
+            safety_note = "Proceed with standard supportive conversation."
+            
+        messages = [
+            {"role": "system", "content": f"{self.system_prompt}\n\nCurrent Context: {safety_note}"},
+        ]
+        
+        # Add conversation history if available
+        for msg in conversation_history[-4:]:  # Last 4 exchanges
+            messages.append({"role": "user", "content": msg.get('input', '')})
+            messages.append({"role": "assistant", "content": msg.get('response', '')})
+            
+        messages.append({"role": "user", "content": user_message})
+        
+        try:
+            payload = {
+                "model": "deepseek-chat",
+                "messages": messages,
+                "temperature": 0.7,
+                "max_tokens": 500,
+                "stream": False
+            }
+            
+            response = requests.post(self.base_url, headers=self.headers, json=payload, timeout=30)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result['choices'][0]['message']['content']
+            
+        except Exception as e:
+            print(f"❌ DeepSeek API error: {e}")
+            return self._fallback_response(user_message, context)
+    
+    def _fallback_response(self, user_message: str, context: Dict[str, Any]) -> str:
+        """High-quality fallback when API fails"""
+        fallback_responses = {
+            'crisis': "I hear that you're in a really difficult situation. Your safety is the most important thing right now. Please call the National Domestic Violence Hotline at 800-799-7233 - they can help you create a safety plan and connect you with local resources. You don't have to face this alone.",
+            
+            'emotional': "Thank you for sharing this with me. What you're experiencing sounds incredibly painful and overwhelming. Your feelings are completely valid. Would it help to talk about what support systems you have in place right now?",
+            
+            'practical': "That sounds like a really challenging situation to navigate. Let's break this down into small, manageable steps. What's one thing that would make you feel even slightly safer or more in control right now?",
+            
+            'boundaries': "It takes real strength to recognize when someone is crossing your boundaries. Your right to safety and respect is non-negotiable. Would you like to explore some ways to reinforce your boundaries in this situation?"
+        }
+        
+        # Simple keyword matching for fallback
+        user_lower = user_message.lower()
+        if any(word in user_lower for word in ['hurt', 'danger', 'scared', 'afraid', 'emergency']):
+            return fallback_responses['crisis']
+        elif any(word in user_lower for word in ['sad', 'overwhelmed', 'anxious', 'stress', 'pain']):
+            return fallback_responses['emotional'] 
+        elif any(word in user_lower for word in ['what should', 'how to', 'need help', 'what do']):
+            return fallback_responses['practical']
+        elif any(word in user_lower for word in ['boundary', 'respect', 'said no', 'standing up']):
+            return fallback_responses['boundaries']
+        else:
+            return "I'm really hearing how difficult this is for you. Thank you for trusting me with this. Could you tell me a bit more about what kind of support would feel most helpful right now?"

components/emergent_rituals.py

@@ -0,0 +1,349 @@
+"""
+Pragmatic Emergent Rituals for TRuCAL
+Balances theoretical rigor with practical implementation.
+"""
+import torch
+import torch.nn.functional as F
+import numpy as np
+from typing import Dict, Any, List, Optional, Tuple
+from collections import defaultdict, deque
+import time
+from dataclasses import dataclass, field
+import hashlib
+import json
+import random
+
+@dataclass
+class RitualPattern:
+    """Container for learned ritual patterns."""
+    embedding: torch.Tensor
+    count: int = 1
+    last_used: float = field(default_factory=time.time)
+    success_sum: float = 0.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class EmergentRituals:
+    """
+    Implements pragmatic pattern learning and ritual emergence with ethical constraints.
+    Focuses on stability and interpretability over theoretical purity.
+    """
+    
+    def __init__(
+        self,
+        embedding_dim: int = 768,  # Standard BERT-like embedding size
+        min_occurrences: int = 3,
+        learning_rate: float = 0.1,
+        max_patterns: int = 1000,
+        similarity_threshold: float = 0.85,
+        ledger = None
+    ):
+        self.embedding_dim = embedding_dim
+        self.min_occurrences = min_occurrences
+        self.learning_rate = learning_rate
+        self.max_patterns = max_patterns
+        self.similarity_threshold = similarity_threshold
+        self.ledger = ledger
+        
+        # Core pattern storage
+        self.patterns: Dict[str, RitualPattern] = {}
+        self.pattern_similarity = defaultdict(list)
+        
+        # Performance tracking
+        self.stats = {
+            'patterns_created': 0,
+            'patterns_merged': 0,
+            'patterns_pruned': 0,
+            'total_rituals': 0
+        }
+        
+        # Ethical constraints
+        self.ethical_boundaries = {
+            'safety': 0.8,
+            'fairness': 0.7,
+            'privacy': 0.9
+        }
+        
+    def _get_context_hash(self, context: Any) -> str:
+        """Create deterministic hash from context."""
+        if isinstance(context, str):
+            context_str = context
+        else:
+            context_str = json.dumps(context, sort_keys=True)
+        return hashlib.sha256(context_str.encode()).hexdigest()[:16]
+    
+    def _cosine_similarity(self, a: torch.Tensor, b: torch.Tensor) -> float:
+        """Efficient cosine similarity with PyTorch."""
+        return F.cosine_similarity(a.unsqueeze(0), b.unsqueeze(0)).item()
+    
+    def _find_similar_pattern(
+        self, 
+        embedding: torch.Tensor, 
+        threshold: Optional[float] = None
+    ) -> Optional[Tuple[str, float]]:
+        """
+        Find most similar existing pattern above threshold.
+        Returns (pattern_id, similarity_score) or None if no match found.
+        """
+        threshold = threshold or self.similarity_threshold
+        best_match = None
+        best_score = -1.0
+        
+        for pattern_id, pattern in self.patterns.items():
+            score = self._cosine_similarity(embedding, pattern.embedding)
+            if score > best_score and score >= threshold:
+                best_score = score
+                best_match = pattern_id
+                
+        return (best_match, best_score) if best_match else None
+    
+    def observe(
+        self,
+        context: Any,
+        response_embedding: torch.Tensor,
+        success_metric: float = 0.5,
+        ethical_scores: Optional[Dict[str, float]] = None,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Optional[str]:
+        """
+        Observe and learn from a new interaction.
+        
+        Args:
+            context: The input context (text, hash, or any hashable)
+            response_embedding: Embedding of the model's response
+            success_metric: Success metric (0.0 to 1.0)
+            ethical_scores: Optional ethical constraint scores
+            metadata: Additional metadata about the interaction
+            
+        Returns:
+            The pattern ID that was created or updated, or None if skipped due to ethical constraints
+        """
+        # Input validation
+        if not isinstance(response_embedding, torch.Tensor):
+            response_embedding = torch.tensor(response_embedding, dtype=torch.float32)
+            
+        if response_embedding.dim() > 1:
+            response_embedding = response_embedding.mean(dim=0)
+            
+        # Normalize for stability
+        response_embedding = F.normalize(response_embedding, dim=0)
+        
+        # Check ethical constraints
+        if ethical_scores:
+            for constraint, score in ethical_scores.items():
+                if constraint in self.ethical_boundaries:
+                    if score < self.ethical_boundaries[constraint]:
+                        # Skip learning from unethical patterns
+                        return None
+        
+        # Get or create pattern
+        context_hash = self._get_context_hash(context)
+        
+        # Check for similar patterns
+        similar = self._find_similar_pattern(response_embedding)
+        
+        if similar:
+            pattern_id, similarity = similar
+            pattern = self.patterns[pattern_id]
+            
+            # Update existing pattern
+            alpha = self.learning_rate * success_metric
+            pattern.embedding = (1 - alpha) * pattern.embedding + alpha * response_embedding
+            pattern.count += 1
+            pattern.success_sum += success_metric
+            pattern.last_used = time.time()
+            if metadata:
+                pattern.metadata.update(metadata)
+            
+            self.stats['patterns_merged'] += 1
+            return pattern_id
+        else:
+            # Create new pattern
+            if len(self.patterns) >= self.max_patterns:
+                self._prune_patterns()
+                
+            pattern_id = f"ritual_{len(self.patterns)}_{int(time.time())}"
+            self.patterns[pattern_id] = RitualPattern(
+                embedding=response_embedding,
+                count=1,
+                success_sum=success_metric,
+                metadata=metadata or {}
+            )
+            
+            self.stats['patterns_created'] += 1
+            return pattern_id
+    
+    def get_ritual_response(
+        self,
+        context: Any,
+        default_response: torch.Tensor,
+        min_confidence: float = 0.6,
+        blend_ratio: float = 0.3
+    ) -> torch.Tensor:
+        """
+        Get a ritualized response if a strong pattern exists.
+        
+        Args:
+            context: The input context
+            default_response: Default model response to fall back to
+            min_confidence: Minimum confidence to use a ritual
+            blend_ratio: How much to blend ritual with default (0.0 to 1.0)
+            
+        Returns:
+            Blended response tensor
+        """
+        context_hash = self._get_context_hash(context)
+        
+        # Find best matching pattern
+        best_pattern = None
+        best_score = 0.0
+        
+        for pattern in self.patterns.values():
+            if pattern.count < self.min_occurrences:
+                continue
+                
+            # Simple confidence based on usage and success
+            confidence = (pattern.success_sum / pattern.count) * (1 - 1/(1 + pattern.count))
+            
+            if confidence > best_score and confidence >= min_confidence:
+                best_score = confidence
+                best_pattern = pattern
+                
+        if best_pattern:
+            # Update last used time
+            best_pattern.last_used = time.time()
+            
+            # Blend with default response
+            ritual_response = best_pattern.embedding
+            if ritual_response.shape != default_response.shape:
+                # Simple broadcasting for now
+                ritual_response = ritual_response.expand_as(default_response)
+                
+            return (1 - blend_ratio) * default_response + blend_ratio * ritual_response
+        else:
+            return default_response
+    
+    def should_apply_ritual(self, context: Any, min_confidence: float = 0.5) -> bool:
+        """
+        Determine if a ritual should be applied based on confidence.
+        
+        Args:
+            context: The input context
+            min_confidence: Minimum confidence threshold
+            
+        Returns:
+            bool: True if a ritual should be applied
+        """
+        context_hash = self._get_context_hash(context)
+        
+        # Check if we have a matching pattern with sufficient confidence
+        for pattern in self.patterns.values():
+            if pattern.count >= self.min_occurrences:
+                confidence = (pattern.success_sum / pattern.count) * (1 - 1/(1 + pattern.count))
+                if confidence >= min_confidence:
+                    # Higher confidence = more likely to apply
+                    return random.random() < confidence
+        
+        return False
+    
+    def _prune_patterns(self, min_usage: int = 3, max_age_days: int = 30) -> int:
+        """
+        Remove infrequently used or old patterns.
+        
+        Returns:
+            Number of patterns pruned
+        """
+        now = time.time()
+        max_age_seconds = max_age_days * 24 * 3600
+        to_remove = []
+        
+        for pattern_id, pattern in self.patterns.items():
+            if (pattern.count <= min_usage and 
+                (now - pattern.last_used) > max_age_seconds):
+                to_remove.append(pattern_id)
+                
+        for pattern_id in to_remove:
+            del self.patterns[pattern_id]
+            
+        self.stats['patterns_pruned'] += len(to_remove)
+        return len(to_remove)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get current statistics and metrics."""
+        active_patterns = len(self.patterns)
+        total_usage = sum(p.count for p in self.patterns.values())
+        avg_success = np.mean([p.success_sum/p.count for p in self.patterns.values()]) if self.patterns else 0
+        
+        return {
+            **self.stats,
+            'active_patterns': active_patterns,
+            'total_usage': total_usage,
+            'avg_success_rate': avg_success,
+            'ethical_boundaries': self.ethical_boundaries
+        }
+    
+    def save_state(self, filepath: str) -> bool:
+        """Save current state to disk."""
+        try:
+            state = {
+                'patterns': {
+                    pid: {
+                        'embedding': p.embedding.tolist(),
+                        'count': p.count,
+                        'last_used': p.last_used,
+                        'success_sum': p.success_sum,
+                        'metadata': p.metadata
+                    }
+                    for pid, p in self.patterns.items()
+                },
+                'stats': self.stats,
+                'version': '1.0',
+                'config': {
+                    'embedding_dim': self.embedding_dim,
+                    'min_occurrences': self.min_occurrences,
+                    'learning_rate': self.learning_rate,
+                    'max_patterns': self.max_patterns,
+                    'similarity_threshold': self.similarity_threshold
+                }
+            }
+            
+            with open(filepath, 'w') as f:
+                json.dump(state, f)
+            return True
+            
+        except Exception as e:
+            print(f"Error saving state: {e}")
+            return False
+    
+    @classmethod
+    def load_state(cls, filepath: str, **kwargs) -> 'EmergentRituals':
+        """Load state from disk."""
+        try:
+            with open(filepath, 'r') as f:
+                state = json.load(f)
+            
+            # Get config from saved state or use defaults
+            config = state.get('config', {})
+            # Allow overrides from kwargs
+            for key, value in kwargs.items():
+                if key in config:
+                    config[key] = value
+            
+            # Create new instance with saved patterns
+            instance = cls(**config)
+            instance.patterns = {
+                pid: RitualPattern(
+                    embedding=torch.tensor(data['embedding'], dtype=torch.float32),
+                    count=data['count'],
+                    last_used=data['last_used'],
+                    success_sum=data['success_sum'],
+                    metadata=data.get('metadata', {})
+                )
+                for pid, data in state['patterns'].items()
+            }
+            
+            instance.stats = state.get('stats', {})
+            return instance
+            
+        except Exception as e:
+            print(f"Error loading state: {e}")
+            return cls(**kwargs)  # Return fresh instance on error

components/ethical_learner.py

@@ -0,0 +1,167 @@
+"""
+Ethical Learner Module for TRuCAL
+
+Integrates the RecursiveLearner with the existing EthicalProcessor
+for a complete ethical reasoning and learning system.
+"""
+
+from typing import Dict, Any, Optional, Tuple
+import torch
+from .ethical_processor import EthicalProcessor
+from .recursive_learner import RecursiveLearner
+
+class EthicalLearner:
+    """
+    A unified ethical reasoning system that combines:
+    - Rule-based ethical frameworks (from EthicalProcessor)
+    - Case-based learning (from RecursiveLearner)
+    """
+    
+    def __init__(self, 
+                 casebase_path: str = 'casebase.json',
+                 similarity_threshold: float = 0.6,
+                 model_name: str = 'all-MiniLM-L6-v2',
+                 d_model: int = 512):
+        """
+        Initialize the ethical learner.
+        
+        Args:
+            casebase_path: Path to save/load the casebase
+            similarity_threshold: Minimum similarity score (0-1) to consider a match
+            model_name: Name of the sentence transformer model to use for embeddings
+            d_model: Dimensionality of the ethical processor model
+        """
+        self.ethical_processor = EthicalProcessor(d_model=d_model)
+        self.recursive_learner = RecursiveLearner(
+            casebase_path=casebase_path,
+            similarity_threshold=similarity_threshold,
+            model_name=model_name
+        )
+    
+    def process_query(self, query: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Process an ethical query using both rule-based and case-based reasoning.
+        
+        Args:
+            query: The ethical question or scenario
+            context: Additional context for the query
+            
+        Returns:
+            Dictionary containing the response and metadata
+        """
+        # First try to get a response from the case-based learner
+        case_response, case_metadata = self.recursive_learner.get_response(query)
+        
+        # If we have a good match, use it
+        if case_metadata.get('similarity', 0) >= self.recursive_learner.similarity_threshold:
+            # Apply ethical processing to the case response
+            ethical_analysis = self.ethical_processor.analyze(query)
+            
+            return {
+                'response': case_response,
+                'source': 'case_based',
+                'confidence': case_metadata['similarity'],
+                'case_id': case_metadata.get('case_id'),
+                'ethical_analysis': ethical_analysis,
+                'metadata': {
+                    'case_metadata': case_metadata,
+                    'ethical_frameworks': self.ethical_processor.get_active_frameworks()
+                }
+            }
+        
+        # If no good case match, use the ethical processor
+        ethical_response = self.ethical_processor.process(query, context or {})
+        
+        return {
+            'response': ethical_response,
+            'source': 'rule_based',
+            'confidence': 1.0,  # High confidence in rule-based responses
+            'metadata': {
+                'ethical_frameworks': self.ethical_processor.get_active_frameworks(),
+                'development_phase': self.ethical_processor.get_development_phase()
+            }
+        }
+    
+    def add_case(self, question: str, response: str, tags: List[str] = None, 
+                metadata: Optional[Dict] = None) -> Dict:
+        """
+        Add a new case to the casebase.
+        
+        Args:
+            question: The ethical question or scenario
+            response: The response or analysis
+            tags: Optional list of tags for categorization
+            metadata: Additional metadata about the case
+            
+        Returns:
+            Dictionary with status and case information
+        """
+        case = self.recursive_learner.add_case(
+            question=question,
+            response=response,
+            tags=tags,
+            metadata=metadata or {}
+        )
+        
+        return {
+            'status': 'success',
+            'case_id': id(case),
+            'similarity': 1.0,  # New case, so perfect match to itself
+            'total_cases': len(self.recursive_learner.casebase)
+        }
+    
+    def provide_feedback(self, case_id: int, was_helpful: bool):
+        """
+        Provide feedback on a case's helpfulness.
+        
+        Args:
+            case_id: The ID of the case
+            was_helpful: Whether the response was helpful
+        """
+        self.recursive_learner.provide_feedback(case_id, was_helpful)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the ethical learner."""
+        stats = self.recursive_learner.get_stats()
+        stats.update({
+            'ethical_frameworks': self.ethical_processor.get_active_frameworks(),
+            'development_phase': self.ethical_processor.get_development_phase()
+        })
+        return stats
+    
+    def save(self):
+        """Save the current state of the learner."""
+        self.recursive_learner._save_casebase()
+    
+    def load(self):
+        """Load the saved state of the learner."""
+        self.recursive_learner._load_casebase()
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the ethical learner
+    learner = EthicalLearner()
+    
+    # Example query
+    query = "Is it ethical to use personal data for targeted advertising?"
+    result = learner.process_query(query)
+    
+    print(f"Query: {query}")
+    print(f"Response: {result['response']}")
+    print(f"Source: {result['source']}")
+    print(f"Confidence: {result['confidence']:.2f}")
+    
+    # Add a new case
+    print("\nAdding new case...")
+    learner.add_case(
+        question="What are the ethics of data privacy in AI?",
+        response=("Data privacy in AI involves balancing innovation with individual rights. "
+                 "Key considerations include informed consent, data minimization, purpose limitation, "
+                 "and ensuring transparency about how data is used."),
+        tags=["privacy", "AI", "ethics"]
+    )
+    
+    # Get stats
+    print("\nLearner statistics:")
+    print(learner.get_stats())

components/ethical_processor.py

@@ -0,0 +1,250 @@
+import torch
+import torch.nn as nn
+from collections import deque
+import time
+
+class EthicalProcessor:
+    """Enhanced ethical processor with multi-dimensional moral reasoning and developmental tracking"""
+    
+    def __init__(self, d_model=512):
+        self.d_model = d_model
+        
+        # Expanded moral frameworks with cultural awareness
+        self.moral_frameworks = {
+            'deontological': {'weight': 0.25, 'focus': 'duties', 'cultural_variants': ['kantian', 'contractarian']},
+            'utilitarian': {'weight': 0.25, 'focus': 'consequences', 'cultural_variants': ['classic', 'preference']},
+            'virtue_ethics': {'weight': 0.20, 'focus': 'character', 'cultural_variants': ['aristotelian', 'confucian']},
+            'care_ethics': {'weight': 0.15, 'focus': 'relationships', 'cultural_variants': ['feminist', 'communal']},
+            'rights_based': {'weight': 0.15, 'focus': 'entitlements', 'cultural_variants': ['natural', 'legal']}
+        }
+        
+        # Developmental tracking with cross-cultural awareness
+        self.development_phases = {
+            'pre_conventional': {
+                'level': 1,
+                'focus': 'self_interest', 
+                'cultural_expression': {
+                    'western': 'avoiding punishment',
+                    'eastern': 'maintaining harmony',
+                    'indigenous': 'tribal belonging'
+                }
+            },
+            'conventional': {
+                'level': 2,
+                'focus': 'social_norms',
+                'cultural_expression': {
+                    'western': 'law_and_order',
+                    'eastern': 'filial_piety',
+                    'indigenous': 'ancestral_traditions'
+                }
+            },
+            'post_conventional': {
+                'level': 3, 
+                'focus': 'principled_reasoning',
+                'cultural_expression': {
+                    'western': 'universal_principles',
+                    'eastern': 'cosmic_harmony',
+                    'indigenous': 'earth_stewardship'
+                }
+            }
+        }
+        
+        # Learnable ethical reasoning components
+        self.ethical_encoder = nn.Sequential(
+            nn.Linear(d_model, d_model // 2),
+            nn.ReLU(),
+            nn.LayerNorm(d_model // 2),
+            nn.Linear(d_model // 2, 256),
+            nn.Tanh()
+        )
+        
+        # Cultural context awareness
+        self.cultural_context_weights = nn.Parameter(torch.ones(3))  # western, eastern, indigenous
+        
+        # Moral development tracking
+        self.moral_development_history = deque(maxlen=1000)
+    
+    def process_question(self, question, context_str="", cultural_context="balanced"):
+        """Enhanced ethical processing with cultural and developmental awareness"""
+        if not question:
+            return self._get_default_metadata()
+            
+        # Multi-dimensional ethical analysis
+        ethical_dims = self._analyze_ethical_dimensions(question, context_str)
+        cultural_weights = self._get_cultural_weights(cultural_context)
+        moral_tension = self._calculate_moral_tension(ethical_dims, cultural_weights)
+        development_phase = self._determine_development_phase(moral_tension, ethical_dims)
+        
+        # Generate culturally-aware response
+        response = self._generate_culturally_aware_response(question, ethical_dims, cultural_weights)
+        
+        # Track moral development
+        self._track_moral_development(ethical_dims, moral_tension, development_phase)
+        
+        return {
+            'moral_tension': float(moral_tension),
+            'development_phase': development_phase,
+            'ethical_dimensions': ethical_dims,
+            'response_text': response,
+            'cultural_context': cultural_context,
+            'framework_weights': {k: v['weight'] for k, v in self.moral_frameworks.items()},
+            'processed': True,
+            'developmental_level': self.development_phases[development_phase]['level']
+        }
+    
+    def _get_default_metadata(self):
+        return {
+            'moral_tension': 0.0,
+            'development_phase': 'conventional',
+            'ethical_dimensions': {},
+            'response_text': "I'm here to help with ethical considerations. What would you like to discuss?",
+            'cultural_context': 'universal',
+            'framework_weights': {k: v['weight'] for k, v in self.moral_frameworks.items()},
+            'processed': False,
+            'developmental_level': 2
+        }
+    
+    def _analyze_ethical_dimensions(self, question, context_str):
+        """Multi-dimensional ethical analysis with contextual awareness"""
+        question_lower = question.lower()
+        context_lower = context_str.lower()
+        
+        dims = {
+            'honesty_vs_protection': 0.0,
+            'rules_vs_harm': 0.0, 
+            'individual_vs_community': 0.0,
+            'rights_vs_consequences': 0.0,
+            'autonomy_vs_care': 0.0,
+            'justice_vs_mercy': 0.0,
+            'tradition_vs_progress': 0.0,
+            'loyalty_vs_truth': 0.0
+        }
+        
+        # Enhanced pattern recognition
+        ethical_patterns = {
+            'honesty_vs_protection': ['lie', 'truth', 'protect', 'deceive', 'honest'],
+            'rules_vs_harm': ['rules', 'harm', 'break', 'follow', 'hurt'],
+            'individual_vs_community': ['self', 'others', 'community', 'individual', 'society'],
+            'autonomy_vs_care': ['freedom', 'care', 'independence', 'nurture', 'control'],
+            'justice_vs_mercy': ['justice', 'mercy', 'fair', 'forgive', 'punish']
+        }
+        
+        for dimension, patterns in ethical_patterns.items():
+            matches = [p for p in patterns if p in question_lower or p in context_lower]
+            if matches:
+                dims[dimension] = min(0.9, len(matches) * 0.3)
+                
+        return dims
+    
+    def _get_cultural_weights(self, cultural_context):
+        """Get cultural weighting based on context"""
+        base_weights = {'western': 0.33, 'eastern': 0.33, 'indigenous': 0.34}
+        
+        if cultural_context == "western":
+            return {'western': 0.6, 'eastern': 0.2, 'indigenous': 0.2}
+        elif cultural_context == "eastern": 
+            return {'western': 0.2, 'eastern': 0.6, 'indigenous': 0.2}
+        elif cultural_context == "indigenous":
+            return {'western': 0.2, 'eastern': 0.2, 'indigenous': 0.6}
+        else:
+            return base_weights
+    
+    def _calculate_moral_tension(self, ethical_dims, cultural_weights):
+        """Calculate moral tension with cultural sensitivity"""
+        if not ethical_dims:
+            return 0.0
+            
+        # Weight tensions by cultural context
+        western_focus = ['individual_vs_community', 'rights_vs_consequences'] 
+        eastern_focus = ['harmony_vs_truth', 'community_vs_individual']
+        indigenous_focus = ['earth_vs_progress', 'ancestral_vs_modern']
+        
+        cultural_tensions = {
+            'western': sum(ethical_dims.get(d, 0) for d in western_focus) / len(western_focus),
+            'eastern': sum(ethical_dims.get(d, 0) for d in eastern_focus) / len(eastern_focus),
+            'indigenous': sum(ethical_dims.get(d, 0) for d in indigenous_focus) / len(indigenous_focus)
+        }
+        
+        # Weighted average across cultures
+        total_tension = sum(cultural_tensions[c] * cultural_weights[c] for c in cultural_weights)
+        return min(1.0, total_tension * 1.5)  # Scale for sensitivity
+    
+    def _determine_development_phase(self, moral_tension, ethical_dims):
+        """Determine developmental phase with complexity awareness"""
+        complexity = len([d for d in ethical_dims.values() if d > 0.3])
+        
+        if moral_tension < 0.3 or complexity < 2:
+            return 'pre_conventional'
+        elif moral_tension < 0.7 or complexity < 4:
+            return 'conventional'
+        else:
+            return 'post_conventional'
+    
+    def _generate_culturally_aware_response(self, question, ethical_dims, cultural_weights):
+        """Generate response that respects multiple cultural perspectives"""
+        primary_tension = max(ethical_dims.items(), key=lambda x: x[1]) if ethical_dims else (None, 0)
+        
+        # Cultural response templates
+        cultural_responses = {
+            'western': {
+                'honesty_vs_protection': "From a rights-based perspective, truth-telling is fundamental, though consequences must be weighed carefully.",
+                'rules_vs_harm': "The tension between legal principles and preventing harm requires examining both contractual duties and outcomes.",
+                'default': "This situation requires careful ethical consideration balancing individual rights with broader consequences."
+            },
+            'eastern': {
+                'honesty_vs_protection': "In many Eastern traditions, maintaining social harmony and protecting relationships may sometimes temper absolute honesty.",
+                'rules_vs_harm': "The way of virtue often considers both the letter and spirit of rules, emphasizing compassion in application.",
+                'default': "This situation invites reflection on maintaining harmony while considering the greater good."
+            },
+            'indigenous': {
+                'honesty_vs_protection': "Many indigenous wisdom traditions value truth as part of right relationship with all beings, while recognizing protective responsibilities.",
+                'rules_vs_harm': "Ancestral teachings often emphasize that rules should serve life and community wellbeing, adapting when they cause harm.",
+                'default': "This calls for wisdom in balancing individual needs with the wellbeing of the community and all our relations."
+            }
+        }
+        
+        # Combine cultural perspectives
+        responses = []
+        for culture, weight in cultural_weights.items():
+            if weight > 0.2:  # Only include significant cultural perspectives
+                if primary_tension[0]:
+                    response = cultural_responses[culture].get(
+                        primary_tension[0], 
+                        cultural_responses[culture]['default']
+                    )
+                else:
+                    response = cultural_responses[culture]['default']
+                responses.append((response, weight))
+        
+        if responses:
+            # Sort by weight and take top responses
+            responses.sort(key=lambda x: x[1], reverse=True)
+            return " ".join([f"({i+1}) {r[0]}" for i, r in enumerate(responses[:2])])
+            
+        return "This situation invites reflection across multiple ethical frameworks and cultural perspectives."
+    
+    def _track_moral_development(self, ethical_dims, moral_tension, phase):
+        """Track moral development over time"""
+        entry = {
+            'timestamp': time.time(),
+            'ethical_complexity': len(ethical_dims),
+            'moral_tension': moral_tension,
+            'phase': phase,
+            'primary_dimension': max(ethical_dims.items(), key=lambda x: x[1])[0] if ethical_dims else None
+        }
+        self.moral_development_history.append(entry)
+    
+    def get_developmental_trajectory(self):
+        """Analyze moral development over time"""
+        if not self.moral_development_history:
+            return {'trend': 'unknown', 'complexity_growth': 0, 'phase_transitions': 0}
+        
+        recent = list(self.moral_development_history)[-10:]
+        phases = [e['phase'] for e in recent]
+        
+        return {
+            'trend': 'developing' if len(set(phases)) > 1 else 'stable',
+            'average_complexity': sum(e['ethical_complexity'] for e in recent) / len(recent),
+            'current_phase': phases[-1] if phases else 'unknown',
+            'phase_transitions': len(set(phases)) - 1
+        }

components/ethical_reasoner.py

@@ -0,0 +1,166 @@
+"""
+Ethical reasoning module for TRuCAL.
+Implements a framework-aware ethical reasoning system that analyzes questions
+using multiple ethical frameworks (deontological, utilitarian, virtue ethics).
+"""
+import random
+from typing import Dict, List, Optional
+
+class EthicalReasoner:
+    """
+    An advanced ethical reasoning system that analyzes questions using multiple
+    ethical frameworks to provide nuanced ethical analysis.
+    """
+    def __init__(self):
+        self.ethical_frameworks = {
+            'deontological': {
+                'principles': ['duty', 'rules', 'moral laws', 'categorical imperative'],
+                'weight': 0.3
+            },
+            'utilitarian': {
+                'principles': ['consequences', 'greatest good', 'happiness', 'utility'],
+                'weight': 0.4
+            },
+            'virtue_ethics': {
+                'principles': ['character', 'virtues', 'wisdom', 'flourishing'],
+                'weight': 0.3
+            }
+        }
+        
+        self.ethical_dilemmas = {
+            'lying_protection': {
+                'tension': 0.8,
+                'frameworks': {
+                    'deontological': "Generally opposes lying as it violates the duty of truth-telling",
+                    'utilitarian': "May permit lying if it produces better consequences than truth-telling", 
+                    'virtue_ethics': "Examines what kind of character lying cultivates"
+                }
+            },
+            'harmful_rules': {
+                'tension': 0.9,
+                'frameworks': {
+                    'deontological': "Rules should be followed unless they conflict with higher duties",
+                    'utilitarian': "Rules causing harm should be re-evaluated based on consequences",
+                    'virtue_ethics': "Wisdom is needed to know when to uphold or challenge rules"
+                }
+            },
+            'rights_community': {
+                'tension': 0.7,
+                'frameworks': {
+                    'deontological': "Individual rights create duties that must be respected",
+                    'utilitarian': "Balance individual and community welfare for greatest good",
+                    'virtue_ethics': "Cultivate justice and compassion in balancing interests"
+                }
+            }
+        }
+    
+    def analyze_ethical_dimensions(self, question: str) -> Dict:
+        """Analyze the ethical content of the question.
+        
+        Args:
+            question: The ethical question or dilemma to analyze
+            
+        Returns:
+            Dict containing analysis results including detected dilemmas and moral tension
+        """
+        if not question or not question.strip():
+            return {
+                'detected_dilemmas': [],
+                'moral_tension': 0.0,
+                'complexity': 0
+            }
+            
+        question_lower = question.lower()
+        detected_dilemmas = []
+        moral_tension = 0.0
+        
+        # Detect specific ethical dilemmas
+        if any(word in question_lower for word in ['lie', 'deceive', 'false', 'truth']):
+            if any(word in question_lower for word in ['protect', 'save', 'help', 'harm']):
+                detected_dilemmas.append('lying_protection')
+                moral_tension = max(moral_tension, self.ethical_dilemmas['lying_protection']['tension'])
+        
+        if any(word in question_lower for word in ['harm', 'hurt', 'damage', 'suffer']):
+            if any(word in question_lower for word in ['rule', 'law', 'follow', 'obey']):
+                detected_dilemmas.append('harmful_rules') 
+                moral_tension = max(moral_tension, self.ethical_dilemmas['harmful_rules']['tension'])
+        
+        if any(word in question_lower for word in ['right', 'freedom', 'individual']):
+            if any(word in question_lower for word in ['community', 'society', 'group', 'collective']):
+                detected_dilemmas.append('rights_community')
+                moral_tension = max(moral_tension, self.ethical_dilemmas['rights_community']['tension'])
+        
+        return {
+            'detected_dilemmas': detected_dilemmas,
+            'moral_tension': moral_tension,
+            'complexity': len(detected_dilemmas)
+        }
+    
+    def generate_response(self, question: str) -> str:
+        """Generate an ethical analysis response.
+        
+        Args:
+            question: The ethical question to analyze
+            
+        Returns:
+            str: A thoughtful ethical analysis response
+        """
+        analysis = self.analyze_ethical_dimensions(question)
+        
+        if not analysis['detected_dilemmas']:
+            return self._generate_thoughtful_default(question)
+        
+        response_parts = []
+        
+        # Introduction based on moral tension
+        tension_phrases = {
+            0.7: "This raises significant ethical considerations",
+            0.8: "This presents a profound ethical dilemma", 
+            0.9: "This touches on one of the most challenging ethical tensions"
+        }
+        
+        intro = tension_phrases.get(
+            analysis['moral_tension'], 
+            "This involves important ethical dimensions"
+        )
+        response_parts.append(f"**{intro}.**")
+        
+        # Discuss each detected dilemma
+        for dilemma in analysis['detected_dilemmas']:
+            response_parts.append("\n**Key considerations:**")
+            
+            # Include perspectives from different frameworks
+            for framework, perspective in self.ethical_dilemmas[dilemma]['frameworks'].items():
+                response_parts.append(f"- *{framework.title()}*: {perspective}")
+        
+        # Add reflective conclusion
+        response_parts.append(
+            "\n**Reflection**: The complexity suggests there may not be a single right answer. "
+            "Different ethical frameworks offer valuable but sometimes conflicting insights."
+        )
+        
+        return "\n".join(response_parts)
+    
+    def _generate_thoughtful_default(self, question: str) -> str:
+        """Generate thoughtful responses for non-ethical questions.
+        
+        Args:
+            question: The input question
+            
+        Returns:
+            str: A thoughtful default response
+        """
+        thoughtful_responses = [
+            "I appreciate you raising this question. While it may not involve clear ethical dilemmas, "
+            "it's worth considering what values or principles might be at play.",
+            
+            "This is an interesting question. From an ethical perspective, we might consider "
+            "what virtues or values are relevant to this situation.",
+            
+            "Thank you for this question. Even when ethical dimensions aren't immediately obvious, "
+            "reflecting on our values and principles can provide valuable insights."
+        ]
+        return random.choice(thoughtful_responses)
+
+# Singleton instance for easy import
+ethical_reasoner = EthicalReasoner()

components/feedback_ingestion.py

@@ -0,0 +1,323 @@
+"""
+Feedback ingestion system for TRuCAL with trauma-aware processing.
+"""
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, Optional, Any
+import re
+import torch
+from datetime import datetime, timedelta
+
+@dataclass
+class FeedbackConsent:
+    """Granular consent management for different feedback types."""
+    explicit: bool = False
+    implicit: bool = False  
+    somatic: bool = False
+    clinical: bool = False
+    retention_days: int = 30  # Auto-delete after period
+
+class FeedbackType(Enum):
+    """Types of feedback supported by the system."""
+    EXPLICIT = "explicit_rating"
+    IMPLICIT = "implicit_engagement" 
+    SOMATIC = "somatic_biofeedback"
+    CLINICAL = "clinical_override"
+    CORRECTION = "safety_correction"
+
+class TemporalPatternAnalyzer:
+    """Analyzes temporal patterns for trauma-aware learning."""
+    
+    def __init__(self):
+        self.session_patterns = {}
+        
+    def get_current_pattern(self) -> Dict[str, Any]:
+        """Get current temporal context."""
+        now = datetime.now()
+        
+        return {
+            'hour_of_day': now.hour,
+            'is_weekend': now.weekday() >= 5,
+            'seasonal_factor': self._get_seasonal_factor(now),
+            'light_conditions': self._get_light_conditions(now)
+        }
+    
+    def has_recent_trauma_discussion(self, session_id: str, window_hours: int = 24) -> bool:
+        """Check if session recently discussed trauma-related content."""
+        session_data = self.session_patterns.get(session_id, {})
+        last_trauma_time = session_data.get('last_trauma_discussion')
+        if not last_trauma_time:
+            return False
+            
+        return (datetime.now() - last_trauma_time).total_seconds() < (window_hours * 3600)
+    
+    def _get_seasonal_factor(self, dt: datetime) -> float:
+        """Calculate seasonal factor (0-1) based on date."""
+        # Simple sinusoidal approximation of seasonal variation
+        day_of_year = dt.timetuple().tm_yday
+        return 0.5 * (1 + np.sin(2 * np.pi * (day_of_year - 80) / 365))
+    
+    def _get_light_conditions(self, dt: datetime) -> str:
+        """Get light conditions based on time of day."""
+        hour = dt.hour
+        if 6 <= hour < 18:
+            return 'daylight'
+        elif 18 <= hour < 21 or 5 <= hour < 6:
+            return 'twilight'
+        return 'dark'
+
+class TraumaAwareFeedbackIngestor:
+    """Enhanced feedback processing with trauma awareness and consent management."""
+    
+    def __init__(self, buffer_size: int = 1000, min_consent_age: int = 18):
+        """Initialize the feedback ingestor.
+        
+        Args:
+            buffer_size: Maximum number of feedback items to keep in memory
+            min_consent_age: Minimum age for providing consent
+        """
+        self.feedback_buffer = []
+        self.buffer_size = buffer_size
+        self.min_consent_age = min_consent_age
+        self.consent_records = {}  # session_id -> FeedbackConsent
+        self.temporal_patterns = TemporalPatternAnalyzer()
+        self.trauma_keywords = {
+            'abuse', 'assault', 'trauma', 'ptsd', 'trigger', 'flashback',
+            'violence', 'attack', 'victim', 'survivor', 'harassment'
+        }
+        
+    def request_consent(self, session_id: str, consent_config: FeedbackConsent) -> bool:
+        """Request and store granular consent from user.
+        
+        Args:
+            session_id: Unique identifier for the user session
+            consent_config: FeedbackConsent object with consent settings
+            
+        Returns:
+            bool: True if consent was successfully recorded
+        """
+        if not self._verify_consent_capacity(session_id):
+            return False
+            
+        self.consent_records[session_id] = consent_config
+        return True
+        
+    def ingest_with_context(self, feedback: Dict[str, Any], session_id: str, 
+                          context_embedding: torch.Tensor) -> bool:
+        """Ingest feedback with contextual information.
+        
+        Args:
+            feedback: Dictionary containing feedback data
+            session_id: Session identifier for consent verification
+            context_embedding: Contextual embedding of the interaction
+            
+        Returns:
+            bool: True if feedback was successfully ingested
+        """
+        consent = self.consent_records.get(session_id)
+        if not consent or not self._check_granular_consent(feedback.get('type'), consent):
+            return False
+            
+        # Enhanced context capture
+        feedback['context_embedding'] = context_embedding.cpu().numpy()
+        feedback['temporal_context'] = self.temporal_patterns.get_current_pattern()
+        
+        # Trauma-aware processing
+        feedback = self._trauma_aware_sanitization(feedback)
+        
+        # Risk assessment
+        risk_score = self._assess_feedback_risk(feedback, session_id)
+        if risk_score > 0.8:
+            self._trigger_safety_review(feedback, session_id)
+            
+        # Add to buffer and maintain size
+        self.feedback_buffer.append(feedback)
+        self._maintain_buffer_integrity()
+        return True
+
+    def _verify_consent_capacity(self, session_id: str) -> bool:
+        """Verify if user has capacity to provide consent."""
+        # In a real implementation, this would check age, mental state, etc.
+        # This is a simplified version
+        return True
+        
+    def _check_granular_consent(self, feedback_type: str, consent: FeedbackConsent) -> bool:
+        """Check if specific feedback type is covered by consent."""
+        if not feedback_type:
+            return False
+            
+        feedback_enum = FeedbackType(feedback_type)
+        
+        if feedback_enum == FeedbackType.EXPLICIT:
+            return consent.explicit
+        elif feedback_enum == FeedbackType.IMPLICIT:
+            return consent.implicit
+        elif feedback_enum == FeedbackType.SOMATIC:
+            return consent.somatic
+        elif feedback_enum == FeedbackType.CLINICAL:
+            return consent.clinical
+        elif feedback_enum == FeedbackType.CORRECTION:
+            return True  # Always allow safety corrections
+            
+        return False
+
+    def _trauma_aware_sanitization(self, feedback: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize feedback while preserving therapeutic value."""
+        if 'content' in feedback:
+            content = feedback['content']
+            feedback['original_content'] = content  # Keep original for clinical review
+            
+            # Redact specific trauma details
+            if self._contains_trauma_content(content):
+                content = self._redact_specific_trauma_details(content)
+                content = self._generalize_emotional_content(content)
+                feedback['content'] = content
+                feedback['contains_trauma_content'] = True
+            
+        if 'bio_signals' in feedback:
+            feedback['arousal_metrics'] = self._extract_arousal_metrics(feedback['bio_signals'])
+            del feedback['bio_signals']  # Remove raw signals
+            
+        return feedback
+
+    def _contains_trauma_content(self, text: str) -> bool:
+        """Check if text contains trauma-related keywords."""
+        if not isinstance(text, str):
+            return False
+            
+        text_lower = text.lower()
+        return any(keyword in text_lower for keyword in self.trauma_keywords)
+
+    def _redact_specific_trauma_details(self, text: str) -> str:
+        """Redact specific trauma details while preserving emotional content."""
+        # This is a simplified version - in practice, you'd want more sophisticated NLP
+        patterns = [
+            (r'\b(?:i was|i \w+ed|i felt) (?:\w+ ){0,3}(?:abused|assaulted|attacked|raped|beaten|harmed|threatened|harassed)\b', 
+             '[trauma experience redacted]'),
+            (r'\b(?:he|she|they) (?:\w+ ){0,3}(?:abused|assaulted|attacked|raped|beat|harmed|threatened|harassed) (?:me|us|them)\b',
+             '[perpetrator action redacted]')
+        ]
+        
+        for pattern, replacement in patterns:
+            text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+            
+        return text
+
+    def _generalize_emotional_content(self, text: str) -> str:
+        """Generalize emotional content to reduce triggers."""
+        # This is a simplified version - in practice, you'd want more sophisticated NLP
+        emotional_phrases = {
+            r'i felt (?:very |extremely |really )?(?:scared|terrified|frightened|fearful)': 'I felt very afraid',
+            r'i was (?:very |extremely |really )?(?:angry|furious|enraged)': 'I felt very angry',
+            r'i was (?:very |extremely |really )?(?:sad|depressed|miserable|hopeless)': 'I felt very sad'
+        }
+        
+        for pattern, replacement in emotional_phrases.items():
+            text = re.sub(pattern, replacement, text, flags=re.IGNORECASE)
+            
+        return text
+
+    def _extract_arousal_metrics(self, bio_signals: Dict[str, float]) -> Dict[str, float]:
+        """Convert raw bio signals to normalized arousal metrics."""
+        metrics = {}
+        
+        # Heart Rate Variability (HRV) - lower is more stressed
+        if 'hrv' in bio_signals:
+            # Normalize HRV (typical range 20-200ms)
+            hrv = max(20, min(200, bio_signals['hrv']))
+            metrics['hrv_norm'] = 1.0 - ((hrv - 20) / 180.0)
+            
+        # Galvanic Skin Response (GSR) - higher is more aroused
+        if 'gsr' in bio_signals:
+            # Normalize GSR (assuming 0-1 range)
+            metrics['gsr_norm'] = max(0.0, min(1.0, bio_signals['gsr']))
+            
+        # Calculate composite arousal score (0-1)
+        if 'hrv_norm' in metrics and 'gsr_norm' in metrics:
+            metrics['composite_arousal'] = (metrics['hrv_norm'] * 0.6 + 
+                                          metrics['gsr_norm'] * 0.4)
+        elif 'hrv_norm' in metrics:
+            metrics['composite_arousal'] = metrics['hrv_norm']
+        elif 'gsr_norm' in metrics:
+            metrics['composite_arousal'] = metrics['gsr_norm']
+            
+        return metrics
+
+    def _assess_feedback_risk(self, feedback: Dict[str, Any], session_id: str) -> float:
+        """Assess potential re-traumatization risk in feedback."""
+        risk_factors = []
+        
+        # Recent trauma discussion pattern
+        if self.temporal_patterns.has_recent_trauma_discussion(session_id):
+            risk_factors.append(0.7)
+            
+        # High arousal state
+        arousal = feedback.get('arousal_metrics', {}).get('composite_arousal', 0)
+        if arousal > 0.7:
+            risk_factors.append(min(arousal, 0.9))  # Cap at 0.9
+            
+        # Negative feedback on supportive responses
+        if (feedback.get('type') == FeedbackType.EXPLICIT.value and 
+            feedback.get('rating', 5) <= 2 and
+            self._was_response_supportive(feedback.get('response_id'))):
+            risk_factors.append(0.9)
+            
+        return max(risk_factors) if risk_factors else 0.0
+
+    def _was_response_supportive(self, response_id: str) -> bool:
+        """Check if a response was intended to be supportive."""
+        # In a real implementation, this would check the response's classification
+        # For now, we'll assume all responses with ID starting with 'S' are supportive
+        return response_id and response_id.startswith('S')
+
+    def _trigger_safety_review(self, feedback: Dict[str, Any], session_id: str) -> None:
+        """Trigger a safety review for concerning feedback."""
+        # In a real implementation, this would notify a human reviewer
+        print(f"[SAFETY REVIEW] Session {session_id} triggered safety review for feedback: {feedback}")
+        
+    def _maintain_buffer_integrity(self) -> None:
+        """Ensure feedback buffer doesn't exceed maximum size."""
+        while len(self.feedback_buffer) > self.buffer_size:
+            self.feedback_buffer.pop(0)  # Remove oldest feedback
+            
+    def get_feedback_batch(self, batch_size: int = 32) -> List[Dict[str, Any]]:
+        """Get a batch of feedback for model training."""
+        return self.feedback_buffer[-batch_size:] if self.feedback_buffer else []
+
+    def clear_expired_feedback(self) -> int:
+        """Remove feedback that has exceeded retention period.
+        
+        Returns:
+            int: Number of feedback items removed
+        """
+        if not self.consent_records:
+            return 0
+            
+        now = datetime.now()
+        initial_count = len(self.feedback_buffer)
+        
+        # Filter out expired feedback
+        self.feedback_buffer = [
+            fb for fb in self.feedback_buffer
+            if not self._is_feedback_expired(fb, now)
+        ]
+        
+        return initial_count - len(self.feedback_buffer)
+    
+    def _is_feedback_expired(self, feedback: Dict[str, Any], current_time: datetime) -> bool:
+        """Check if feedback has exceeded its retention period."""
+        if 'timestamp' not in feedback:
+            return False
+            
+        try:
+            feedback_time = datetime.fromisoformat(feedback['timestamp'])
+            session_id = feedback.get('session_id')
+            
+            if not session_id or session_id not in self.consent_records:
+                return True  # No consent record, remove
+                
+            retention_days = self.consent_records[session_id].retention_days
+            return (current_time - feedback_time).days > retention_days
+            
+        except (ValueError, TypeError):
+            return True  # Invalid timestamp format, remove

components/feedback_logger.py

@@ -0,0 +1,92 @@
+"""Enhanced logging and feedback system for the AI Ethics Engine."""
+import logging
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+# Ensure logs directory exists
+Path("logs").mkdir(exist_ok=True)
+
+class FeedbackLogger:
+    """Handles structured logging for the AI Ethics Engine."""
+    
+    def __init__(self, log_file: str = "logs/ethics_engine.log"):
+        """Initialize the feedback logger."""
+        self.logger = logging.getLogger("ethics_engine")
+        self.logger.setLevel(logging.INFO)
+        
+        # Create file handler
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.INFO)
+        
+        # Create formatter
+        formatter = logging.Formatter(
+            '%(asctime)s | %(levelname)s | %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        file_handler.setFormatter(formatter)
+        
+        # Add handler to logger
+        self.logger.addHandler(file_handler)
+        
+        # Also log to console in development
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_handler.setFormatter(formatter)
+        self.logger.addHandler(console_handler)
+    
+    def log_event(self, event_type: str, payload: Dict[str, Any]) -> None:
+        """Log a structured event.
+        
+        Args:
+            event_type: Type of event (e.g., 'analysis', 'feedback', 'error')
+            payload: Dictionary containing event data
+        """
+        log_entry = {
+            "timestamp": datetime.utcnow().isoformat(),
+            "event_type": event_type,
+            **payload
+        }
+        self.logger.info(json.dumps(log_entry, default=str))
+    
+    def record_analysis(self, 
+                       dilemma: str, 
+                       result: Dict[str, Any], 
+                       user_id: Optional[str] = None) -> None:
+        """Record an analysis event."""
+        self.log_event("analysis", {
+            "user_id": user_id or "anonymous",
+            "dilemma": dilemma,
+            "result_summary": {
+                "framework_used": list(result.get("framework_analyses", {}).keys()),
+                "success": "error" not in result,
+                "execution_time": result.get("execution_time")
+            }
+        })
+    
+    def record_feedback(self, 
+                       dilemma: str, 
+                       feedback: str, 
+                       user_id: Optional[str] = None,
+                       metadata: Optional[Dict[str, Any]] = None) -> None:
+        """Record user feedback on an analysis."""
+        self.log_event("feedback", {
+            "user_id": user_id or "anonymous",
+            "dilemma": dilemma,
+            "feedback": feedback,
+            "metadata": metadata or {}
+        })
+    
+    def record_error(self, 
+                    error: Exception, 
+                    context: Optional[Dict[str, Any]] = None) -> None:
+        """Record an error event."""
+        self.log_event("error", {
+            "error_type": error.__class__.__name__,
+            "error_message": str(error),
+            "context": context or {}
+        })
+
+# Global instance for easy import
+logger = FeedbackLogger()

components/framework_loader.py

@@ -0,0 +1,96 @@
+"""
+Framework loader for dynamic loading of ethical frameworks from configuration.
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+import yaml
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class EthicalFramework:
+    """Represents an ethical framework with its configuration."""
+    name: str
+    description: str
+    key_principles: List[str]
+    weight: float = 1.0
+    category: str = ""
+    enabled: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert framework to dictionary for serialization."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "key_principles": self.key_principles,
+            "weight": self.weight,
+            "category": self.category,
+            "enabled": self.enabled,
+            "metadata": self.metadata
+        }
+
+class FrameworkLoader:
+    """Loads and manages ethical frameworks from configuration."""
+    
+    def __init__(self, config_path: str = "config/frameworks.yaml"):
+        """Initialize the framework loader.
+        
+        Args:
+            config_path: Path to the frameworks configuration YAML file
+        """
+        self.config_path = Path(config_path)
+        self.frameworks: Dict[str, EthicalFramework] = {}
+        self.settings: Dict[str, Any] = {}
+        self._load_frameworks()
+    
+    def _load_frameworks(self) -> None:
+        """Load frameworks from the configuration file."""
+        try:
+            with open(self.config_path, 'r') as f:
+                config = yaml.safe_load(f)
+                
+            # Load settings
+            self.settings = config.get('settings', {})
+            
+            # Load frameworks
+            for fw_config in config.get('frameworks', []):
+                try:
+                    framework = EthicalFramework(**fw_config)
+                    self.frameworks[framework.name] = framework
+                    logger.info(f"Loaded framework: {framework.name}")
+                except Exception as e:
+                    logger.error(f"Failed to load framework {fw_config.get('name', 'unknown')}: {e}")
+            
+            logger.info(f"Successfully loaded {len(self.frameworks)} frameworks")
+            
+        except FileNotFoundError:
+            logger.error(f"Framework configuration file not found: {self.config_path}")
+            raise
+        except yaml.YAMLError as e:
+            logger.error(f"Error parsing YAML configuration: {e}")
+            raise
+    
+    def get_framework(self, name: str) -> Optional[EthicalFramework]:
+        """Get a framework by name."""
+        return self.frameworks.get(name)
+    
+    def get_active_frameworks(self) -> List[EthicalFramework]:
+        """Get all enabled frameworks."""
+        return [fw for fw in self.frameworks.values() if fw.enabled]
+    
+    def get_default_frameworks(self) -> List[EthicalFramework]:
+        """Get frameworks marked as default in settings."""
+        default_names = self.settings.get('default_frameworks', [])
+        return [fw for name, fw in self.frameworks.items() 
+                if name in default_names and fw.enabled]
+    
+    def reload(self) -> None:
+        """Reload frameworks from the configuration file."""
+        self.frameworks = {}
+        self._load_frameworks()
+
+# Global instance for easy import
+framework_loader = FrameworkLoader()

components/gpt_oss.py

@@ -0,0 +1,127 @@
+import torch
+from typing import Dict, Any, Optional
+import logging
+from transformers import AutoModelForCausalLM, AutoTokenizer, AutoConfig
+
+logger = logging.getLogger(__name__)
+
+class GPTOSSModel:
+    """
+    A wrapper for open-source GPT models using the Hugging Face Transformers library.
+    Supports both loading from pretrained models and custom fine-tuned models.
+    """
+    
+    def __init__(self, model_name: str = "gpt2", device: str = "cpu"):
+        """
+        Initialize the OSS GPT model.
+        
+        Args:
+            model_name: Name of the pretrained model or path to a local model
+            device: Device to run the model on ('cpu' or 'cuda')
+        """
+        self.device = device
+        self.model_name = model_name
+        self._load_model()
+    
+    def _load_model(self) -> None:
+        """Load the model and tokenizer."""
+        try:
+            logger.info(f"Loading model: {self.model_name}")
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                self.model_name,
+                padding_side="left",
+                truncation_side="left"
+            )
+            
+            # Add pad token if not present
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            # Load model with appropriate settings
+            config = AutoConfig.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                config=config,
+                torch_dtype=torch.float16 if 'cuda' in self.device else torch.float32,
+                low_cpu_mem_usage=True
+            ).to(self.device)
+            
+            self.model.eval()
+            logger.info(f"Successfully loaded model: {self.model_name} on {self.device}")
+            
+        except Exception as e:
+            logger.error(f"Failed to load model {self.model_name}: {e}")
+            raise
+    
+    def generate(
+        self,
+        prompt: str,
+        max_tokens: int = 150,
+        temperature: float = 0.7,
+        top_p: float = 0.92,
+        top_k: int = 50,
+        repetition_penalty: float = 1.1,
+        **kwargs
+    ) -> str:
+        """
+        Generate text from the model.
+        
+        Args:
+            prompt: Input text prompt
+            max_tokens: Maximum number of tokens to generate
+            temperature: Sampling temperature (lower = more focused, higher = more random)
+            top_p: Nucleus sampling parameter (0.0 to 1.0)
+            top_k: Top-k sampling parameter (0 to disable)
+            repetition_penalty: Penalty for repeating tokens (1.0 = no penalty)
+            
+        Returns:
+            Generated text
+        """
+        try:
+            # Encode the input
+            inputs = self.tokenizer(
+                prompt,
+                return_tensors="pt",
+                padding=True,
+                truncation=True,
+                max_length=2048 - max_tokens  # Leave room for generation
+            ).to(self.device)
+            
+            # Generate response
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_new_tokens=max_tokens,
+                    temperature=temperature,
+                    top_p=top_p,
+                    top_k=top_k if top_k > 0 else None,
+                    do_sample=True,
+                    repetition_penalty=repetition_penalty,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    **kwargs
+                )
+            
+            # Decode and clean up the output
+            response = self.tokenizer.decode(
+                outputs[0][inputs.input_ids.shape[1]:],
+                skip_special_tokens=True
+            ).strip()
+            
+            return response
+            
+        except Exception as e:
+            logger.error(f"Error generating text: {e}")
+            raise
+    
+    def __call__(self, prompt: str, **kwargs) -> str:
+        """Convenience method to call generate directly on the instance."""
+        return self.generate(prompt, **kwargs)
+    
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the loaded model."""
+        return {
+            "model_name": self.model_name,
+            "device": self.device,
+            "model_type": "gpt-oss",
+            "supports_streaming": False
+        }

components/level0_utils.py

@@ -0,0 +1,79 @@
+"""
+Level-0 Summary Utilities for TRuCAL.
+Provides raw evidence summarization for transparent AI reasoning.
+"""
+from typing import List, Dict, Optional
+import json
+from pathlib import Path
+import logging
+import time
+
+logger = logging.getLogger(__name__)
+
+class Level0Summary:
+    """Handles Level-0 evidence collection and summarization."""
+    
+    def __init__(self, log_dir: str = "logs"):
+        """Initialize with logging directory."""
+        self.log_dir = Path(log_dir)
+        self.log_dir.mkdir(exist_ok=True)
+        self.audit_log = self.log_dir / "level0_audit.jsonl"
+        
+    def summarize(self, query: str, sources: List[str], metadata: Optional[Dict] = None) -> str:
+        """
+        Generate a Level-0 summary with raw evidence.
+        
+        Args:
+            query: The original user query
+            sources: List of source texts or evidence
+            metadata: Optional metadata for auditing
+            
+        Returns:
+            Formatted Level-0 summary string
+        """
+        if not query or not sources:
+            return ""
+            
+        header = f"# Level-0 Summary\n"
+        header += f"**Query:** {query}\n\n"
+        header += "## Raw Evidence\n\n"
+        
+        evidence_sections = []
+        for i, src in enumerate(sources, 1):
+            if not src or not src.strip():
+                continue
+            evidence_sections.append(f"### Source {i}\n{src.strip()}\n")
+        
+        if not evidence_sections:
+            return f"{header}*No valid evidence sources provided.*"
+            
+        summary = header + "\n".join(evidence_sections)
+        
+        # Log the summary for auditing
+        self._log_summary(query, sources, summary, metadata)
+        
+        return summary
+    
+    def _log_summary(self, query: str, sources: List[str], summary: str, metadata: Optional[Dict] = None):
+        """Log the summary to the audit log."""
+        try:
+            log_entry = {
+                "timestamp": time.time(),
+                "query": query,
+                "source_count": len(sources),
+                "summary": summary,
+                "metadata": metadata or {}
+            }
+            
+            with open(self.audit_log, "a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+                
+        except Exception as e:
+            logger.error(f"Failed to log Level-0 summary: {str(e)}")
+
+# Singleton instance for easy import
+level0_summarizer = Level0Summary()
+
+def get_level0_summary(query: str, sources: List[str], metadata: Optional[Dict] = None) -> str:
+    """Convenience function to get a Level-0 summary."""
+    return level0_summarizer.summarize(query, sources, metadata)

components/llm_backbone.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict, Optional, Union
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+class LLMBackbone:
+    """
+    A pluggable LLM backbone that supports multiple model types.
+    Handles model initialization, text generation, and provides a unified interface.
+    """
+    
+    def __init__(self, model_type: str = None, device: str = "cpu"):
+        """
+        Initialize the LLM backbone with the specified model type.
+        
+        Args:
+            model_type: The type of LLM to use (e.g., 'deepseek', 'gpt-oss')
+            device: The device to run the model on ('cpu' or 'cuda')
+        """
+        self.model_type = model_type or os.environ.get("TRUCAL_MODEL", "deepseek")
+        self.device = device
+        self.model = self._initialize_model()
+        
+    def _initialize_model(self) -> Any:
+        """Initialize the specified LLM model."""
+        try:
+            if self.model_type == "deepseek":
+                from .deepseek_integration import DeepSeekClient
+                return DeepSeekClient()
+            elif self.model_type == "gpt-oss":
+                from .gpt_oss import GPTOSSModel
+                return GPTOSSModel(device=self.device)
+            else:
+                raise ValueError(f"Unsupported LLM type: {self.model_type}")
+        except ImportError as e:
+            logger.error(f"Failed to initialize {self.model_type} model: {e}")
+            raise
+    
+    def generate(self, prompt: str, meta: Dict[str, Any] = None) -> str:
+        """
+        Generate a response using the configured LLM.
+        
+        Args:
+            prompt: The input prompt for the model
+            meta: Additional metadata for generation (model-specific)
+            
+        Returns:
+            The generated text response
+        """
+        if meta is None:
+            meta = {}
+            
+        try:
+            if self.model_type == "deepseek":
+                return self.model.generate_response(prompt, meta)
+            else:
+                return self.model.generate(prompt, **meta)
+        except Exception as e:
+            logger.error(f"Error generating response with {self.model_type}: {e}")
+            return self._get_fallback_response()
+    
+    def _get_fallback_response(self) -> str:
+        """Return a fallback response when model generation fails."""
+        return (
+            "I'm having trouble generating a response at the moment. "
+            "Please try again in a moment or contact support if the issue persists."
+        )
+    
+    def switch_model(self, new_model_type: str) -> None:
+        """
+        Switch to a different model type at runtime.
+        
+        Args:
+            new_model_type: The new model type to switch to
+        """
+        if new_model_type != self.model_type:
+            self.model_type = new_model_type
+            self.model = self._initialize_model()
+            logger.info(f"Switched to model type: {new_model_type}")
+
+    def get_model_info(self) -> Dict[str, Any]:
+        """Get information about the current model configuration."""
+        return {
+            "model_type": self.model_type,
+            "device": self.device,
+            "supports_streaming": self.model_type == "deepseek"  # Example capability
+        }

components/llm_integration.py

@@ -0,0 +1,314 @@
+"""
+LLM integration for TRuCAL's ethical reasoning engine.
+Provides a flexible interface for transformer-based language models with attention mechanisms.
+"""
+from typing import Optional, Dict, Any, List, Union
+import torch
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    PreTrainedModel,
+    PreTrainedTokenizer
+)
+import requests
+import json
+
+class CustomLLMResponder:
+    """
+    A flexible LLM responder with support for custom attention mechanisms.
+    
+    Args:
+        model_path: Path or identifier of the pre-trained model
+        device: Device to run the model on ('cuda', 'mps', or 'cpu')
+        attn_layer: Optional custom attention layer
+        **model_kwargs: Additional arguments for model initialization
+    """
+    def __init__(
+        self, 
+        model_path: str = "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        device: Optional[str] = None,
+        attn_layer: Optional[torch.nn.Module] = None,
+        use_ollama: bool = True,
+        ollama_model: str = "tinyllama",  # Default to tinyllama for better memory usage
+        ollama_base_url: str = "http://localhost:11434",
+        **model_kwargs
+    ):
+        self.use_ollama = use_ollama
+        self.ollama_model = ollama_model
+        self.ollama_base_url = ollama_base_url
+        
+        if self.use_ollama:
+            # Test Ollama connection
+            try:
+                response = requests.get(f"{self.ollama_base_url}/api/version")
+                if response.status_code != 200:
+                    raise ConnectionError("Ollama server not running or accessible")
+                print(f"Connected to Ollama version: {response.json()['version']}")
+                
+                # List available models
+                models = requests.get(f"{self.ollama_base_url}/api/tags").json()
+                available_models = [m['name'] for m in models.get('models', [])]
+                print(f"Available Ollama models: {', '.join(available_models)}")
+                
+                # If the specified model isn't available, try to pull it
+                if self.ollama_model not in available_models:
+                    print(f"Model {self.ollama_model} not found. Attempting to pull...")
+                    pull_response = requests.post(
+                        f"{self.ollama_base_url}/api/pull",
+                        json={"name": self.ollama_model},
+                        stream=True
+                    )
+                    for line in pull_response.iter_lines():
+                        if line:
+                            print(json.loads(line).get('status', ''))
+                
+            except Exception as e:
+                print(f"Warning: Could not connect to Ollama: {e}")
+                print("Falling back to local model...")
+                self.use_ollama = False
+        
+        if not self.use_ollama:
+            # Fall back to local model with reduced memory footprint
+            try:
+                self.device = device or self._get_default_device()
+                print(f"Using device: {self.device}")
+                
+                # Load with lower precision and other optimizations
+                self.tokenizer = AutoTokenizer.from_pretrained(
+                    model_path,
+                    **{k: v for k, v in model_kwargs.items() if k != 'low_cpu_mem_usage'}
+                )
+                
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    model_path,
+                    torch_dtype=torch.float16 if 'cuda' in str(self.device) else torch.float32,
+                    low_cpu_mem_usage=True,
+                    **{k: v for k, v in model_kwargs.items() if k != 'torch_dtype'}
+                ).to(self.device)
+                
+                # Set up custom attention layer if provided
+                self.attn_layer = attn_layer
+                if self.attn_layer:
+                    self.attn_layer = self.attn_layer.to(self.device)
+                    
+            except Exception as e:
+                print(f"Error loading local model: {e}")
+                raise
+    
+    def _get_default_device(self) -> str:
+        """Determine the best available device."""
+        if torch.cuda.is_available():
+            return "cuda"
+        elif torch.backends.mps.is_available():
+            return "mps"
+        return "cpu"
+    
+    def generate(
+        self, 
+        prompt: str, 
+        max_length: int = 200,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **generation_kwargs
+    ) -> str:
+        """
+        Generate a response to the given prompt using either Ollama or local model.
+        
+        Args:
+            prompt: Input text prompt
+            max_length: Maximum length of the generated text
+            temperature: Controls randomness (lower = more deterministic)
+            top_p: Nucleus sampling parameter
+            **generation_kwargs: Additional generation parameters
+            
+        Returns:
+            Generated text response
+        """
+        if self.use_ollama:
+            return self._generate_with_ollama(
+                prompt=prompt,
+                max_tokens=max_length,
+                temperature=temperature,
+                top_p=top_p,
+                **generation_kwargs
+            )
+        else:
+            # Fall back to local model
+            inputs = self.tokenizer(
+                prompt, 
+                return_tensors="pt", 
+                return_attention_mask=True,
+                truncation=True,
+                max_length=2048
+            ).to(self.device)
+            
+            if self.attn_layer:
+                return self._generate_with_custom_attention(
+                    inputs,
+                    max_length=max_length,
+                    temperature=temperature,
+                    top_p=top_p,
+                    **generation_kwargs
+                )
+            else:
+                return self._generate_standard(
+                    inputs,
+                    max_length=max_length,
+                    temperature=temperature,
+                    top_p=top_p,
+                    **generation_kwargs
+                )
+    
+    def _generate_with_ollama(
+        self,
+        prompt: str,
+        max_tokens: int = 100,  # Reduced default for memory efficiency
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **generation_kwargs
+    ) -> str:
+        """Generate text using Ollama's API with optimized settings for low-memory environments."""
+        url = f"{self.ollama_base_url}/api/generate"
+        
+        # Optimized defaults for low-memory environments
+        options = {
+            "temperature": temperature,
+            "top_p": top_p,
+            "num_predict": min(max_tokens, 200),  # Cap at 200 tokens
+            "num_ctx": 512,                       # Smaller context window
+            "num_thread": 4,                      # Limit CPU threads
+            "num_gpu": 0,                         # Force CPU to avoid GPU memory issues
+            "repeat_last_n": 64,                  # Reduce memory for repetition penalty
+            "repeat_penalty": 1.1,                # Slight penalty for repetition
+            "top_k": 40,                          # Limit top-k sampling
+            **generation_kwargs
+        }
+        
+        # For tinyllama, we can use more aggressive memory optimizations
+        if "tinyllama" in self.ollama_model.lower():
+            options.update({
+                "num_ctx": 1024,                  # Slightly larger context for better responses
+                "num_predict": min(max_tokens, 150),  # Slightly longer responses
+                "temperature": max(0.5, temperature)   # Ensure temperature isn't too low
+            })
+        
+        payload = {
+            "model": self.ollama_model,
+            "prompt": prompt,
+            "stream": False,  # Disable streaming for simplicity
+            "options": options
+        }
+        
+        try:
+            # Add timeout to prevent hanging
+            response = requests.post(url, json=payload, timeout=60)
+            response.raise_for_status()
+            
+            result = response.json()
+            if "response" not in result:
+                return f"Error: Invalid response format from Ollama: {result}"
+                
+            return result["response"]
+            
+        except requests.exceptions.RequestException as e:
+            return f"Error generating response with Ollama: {str(e)}"
+        except json.JSONDecodeError as e:
+            return f"Error parsing Ollama response: {str(e)}"
+    
+    def _generate_standard(
+        self,
+        inputs: Dict[str, torch.Tensor],
+        max_length: int = 200,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **generation_kwargs
+    ) -> str:
+        """Generate text using the standard model implementation."""
+        outputs = self.model.generate(
+            **inputs,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p,
+            pad_token_id=self.tokenizer.eos_token_id,
+            **generation_kwargs
+        )
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+    
+    def _generate_with_custom_attention(
+        self,
+        inputs: Dict[str, torch.Tensor],
+        max_length: int,
+        temperature: float,
+        top_p: float,
+        **generation_kwargs
+    ) -> str:
+        """Generate text using custom attention mechanism."""
+        input_ids = inputs['input_ids']
+        attention_mask = inputs['attention_mask']
+        
+        # Generate tokens one by one
+        for _ in range(max_length):
+            with torch.no_grad():
+                # Get model outputs
+                outputs = self.model(
+                    input_ids=input_ids,
+                    attention_mask=attention_mask,
+                    output_hidden_states=True,
+                    return_dict=True
+                )
+                
+                # Apply custom attention layer
+                hidden_states = outputs.hidden_states[-1]  # Last layer hidden states
+                attended = self.attn_layer(hidden_states)
+                
+                # Get logits from the attended representation
+                logits = self.model.lm_head(attended[:, -1, :])
+                
+                # Apply temperature and top-p sampling
+                logits = logits / temperature
+                
+                # Convert to probabilities and apply top-p filtering
+                probs = torch.softmax(logits, dim=-1)
+                sorted_probs, sorted_indices = torch.sort(probs, descending=True)
+                cumulative_probs = torch.cumsum(sorted_probs, dim=-1)
+                
+                # Remove tokens with cumulative probability above the threshold
+                sorted_indices_to_remove = cumulative_probs > top_p
+                # Shift the indices to the right to keep the first token above the threshold
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                
+                # Scatter sorted tensors to original indexing
+                indices_to_remove = sorted_indices_to_remove.scatter(
+                    1, sorted_indices, sorted_indices_to_remove
+                )
+                probs[indices_to_remove] = 0
+                
+                # Sample from the filtered distribution
+                next_token = torch.multinomial(probs, num_samples=1)
+                
+                # Append the token to the input for the next step
+                input_ids = torch.cat([input_ids, next_token], dim=-1)
+                attention_mask = torch.cat([
+                    attention_mask, 
+                    torch.ones((1, 1), device=attention_mask.device, dtype=attention_mask.dtype)
+                ], dim=1)
+                
+                # Stop if we've reached the end of sequence token
+                if next_token.item() == self.tokenizer.eos_token_id:
+                    break
+        
+        # Decode and return the generated text
+        return self.tokenizer.decode(
+            input_ids[0][inputs['input_ids'].shape[1]:], 
+            skip_special_tokens=True
+        )
+    
+    def __call__(self, *args, **kwargs):
+        """Make the instance callable like a function."""
+        return self.generate(*args, **kwargs)
+
+# Example usage:
+# llm = CustomLLMResponder(attn_layer=YourCustomAttentionLayer())
+# response = llm("What are the ethical implications of AI?")
+# print(response)

components/llm_integration_enhanced.py

@@ -0,0 +1,372 @@
+"""
+Enhanced LLM integration for TRuCAL with virtue tension awareness.
+"""
+from typing import Optional, Dict, Any, List, Union, Tuple
+import torch
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    PreTrainedModel,
+    PreTrainedTokenizer,
+    GenerationConfig
+)
+import requests
+import json
+import logging
+from .virtue_tension_engine import VirtueTensionEngine
+from .attention_gating import patch_attention_layers, apply_attention_gating
+
+logger = logging.getLogger(__name__)
+
+class EnhancedLLMResponder:
+    """
+    Enhanced LLM responder with virtue tension awareness and attention gating.
+    """
+    
+    def __init__(
+        self, 
+        model_path: str = "mistralai/Mistral-7B-v0.1",
+        device: Optional[str] = None,
+        use_ollama: bool = False,
+        ollama_model: str = "llama2",
+        ollama_base_url: str = "http://localhost:11434",
+        enable_tension_awareness: bool = True,
+        **model_kwargs
+    ):
+        """
+        Initialize the enhanced LLM responder.
+        
+        Args:
+            model_path: Path or identifier of the pre-trained model
+            device: Device to run the model on ('cuda', 'mps', or 'cpu')
+            use_ollama: Whether to use Ollama API
+            ollama_model: Model name for Ollama
+            ollama_base_url: Base URL for Ollama API
+            enable_tension_awareness: Whether to enable tension-aware processing
+            **model_kwargs: Additional model initialization arguments
+        """
+        self.use_ollama = use_ollama
+        self.ollama_model = ollama_model
+        self.ollama_base_url = ollama_base_url
+        self.enable_tension_awareness = enable_tension_awareness
+        
+        # Initialize tension engine if enabled
+        if self.enable_tension_awareness:
+            self.tension_engine = VirtueTensionEngine(device)
+        else:
+            self.tension_engine = None
+        
+        if self.use_ollama:
+            self._init_ollama()
+        else:
+            self._init_local_model(model_path, device, model_kwargs)
+    
+    def _init_ollama(self):
+        """Initialize connection to Ollama API."""
+        try:
+            response = requests.get(f"{self.ollama_base_url}/api/tags")
+            if response.status_code != 200:
+                raise ConnectionError("Ollama server not running or accessible")
+            logger.info(f"Connected to Ollama. Available models: {response.json()}")
+        except Exception as e:
+            logger.error(f"Could not connect to Ollama: {e}")
+            raise RuntimeError("Failed to initialize Ollama connection") from e
+    
+    def _init_local_model(self, model_path: str, device: Optional[str], model_kwargs: dict):
+        """Initialize local model and tokenizer."""
+        self.device = device or self._get_default_device()
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path, **model_kwargs)
+        
+        # Load model with appropriate device map
+        if 'device_map' not in model_kwargs and self.device.startswith('cuda'):
+            model_kwargs['device_map'] = 'auto'
+        
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            **model_kwargs
+        ).to(self.device)
+        
+        # Patch attention layers if tension awareness is enabled
+        if self.enable_tension_awareness:
+            patch_attention_layers(self.model)
+        
+        # Set model to evaluation mode
+        self.model.eval()
+        logger.info(f"Model loaded on {self.device} with tension awareness: {self.enable_tension_awareness}")
+    
+    def _get_default_device(self) -> str:
+        """Determine the best available device."""
+        if torch.cuda.is_available():
+            return "cuda"
+        elif torch.backends.mps.is_available():
+            return "mps"
+        return "cpu"
+    
+    def analyze_tension(
+        self, 
+        text: str, 
+        biofeedback: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
+        """
+        Analyze text tension and get head-specific information.
+        
+        Args:
+            text: Input text to analyze
+            biofeedback: Optional biofeedback data
+            
+        Returns:
+            Dictionary containing tension analysis
+        """
+        if not self.enable_tension_awareness or self.tension_engine is None:
+            return {
+                'tension': 0.5,
+                'head_weights': torch.ones(getattr(self.model.config, 'num_attention_heads', 12)),
+                'biofeedback': biofeedback or {}
+            }
+        
+        # Get tension score and head information
+        v_t = self.tension_engine.compute_tension(text, biofeedback)
+        head_weights = self.tension_engine.get_head_importance(v_t)
+        
+        # Get head-specific information for gating
+        num_heads = getattr(self.model.config, 'num_attention_heads', 12)
+        head_info = {
+            'tension': v_t,
+            'head_weights': head_weights,
+            'biofeedback': biofeedback or {}
+        }
+        
+        # Add head-specific information for gating
+        if v_t > 0.75:  # High tension
+            head_info['trauma_heads'] = list(range(max(1, int(0.3 * num_heads))))
+            head_info['calming_heads'] = list(range(num_heads - max(1, int(0.2 * num_heads)), num_heads))
+        elif v_t > 0.5:  # Moderate tension
+            head_info['high_var_heads'] = list(range(max(1, int(0.4 * num_heads))))
+        
+        return head_info
+    
+    def generate(
+        self,
+        prompt: str,
+        max_length: int = 200,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        biofeedback: Optional[Dict[str, float]] = None,
+        **generation_kwargs
+    ) -> str:
+        """
+        Generate a response with tension-aware processing.
+        
+        Args:
+            prompt: Input text prompt
+            max_length: Maximum length of the generated text
+            temperature: Sampling temperature (0.0 to 1.0)
+            top_p: Nucleus sampling parameter
+            biofeedback: Optional biofeedback data
+            **generation_kwargs: Additional generation parameters
+            
+        Returns:
+            Generated text response
+        """
+        if self.use_ollama:
+            return self._generate_with_ollama(
+                prompt=prompt,
+                max_tokens=max_length,
+                temperature=temperature,
+                top_p=top_p,
+                **generation_kwargs
+            )
+        
+        return self._generate_with_local_model(
+            prompt=prompt,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p,
+            biofeedback=biofeedback,
+            **generation_kwargs
+        )
+    
+    def _generate_with_local_model(
+        self,
+        prompt: str,
+        max_length: int,
+        temperature: float,
+        top_p: float,
+        biofeedback: Optional[Dict[str, float]] = None,
+        **generation_kwargs
+    ) -> str:
+        """Generate text using the local model with tension awareness."""
+        # Analyze tension and get head information
+        virtue_meta = self.analyze_tension(prompt, biofeedback)
+        
+        # Adjust generation parameters based on tension
+        if self.enable_tension_awareness:
+            v_t = virtue_meta['tension']
+            
+            # Adjust temperature based on tension
+            # Higher tension → lower temperature for more focused responses
+            temperature = max(0.2, temperature * (1.0 - (v_t * 0.5)))
+            
+            # Tighter top-p sampling when tense
+            if v_t > 0.7:
+                top_p = max(0.7, top_p * 0.9)
+        
+        # Prepare generation config
+        generation_config = GenerationConfig(
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p,
+            do_sample=True,
+            **generation_kwargs
+        )
+        
+        # Tokenize input
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.device)
+        
+        # Generate with attention gating
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                generation_config=generation_config,
+                virtue_meta=virtue_meta,
+                **generation_kwargs
+            )
+        
+        # Decode and return
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return response
+    
+    def _generate_with_ollama(
+        self,
+        prompt: str,
+        max_tokens: int = 200,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **kwargs
+    ) -> str:
+        """Generate text using the Ollama API."""
+        try:
+            response = requests.post(
+                f"{self.ollama_base_url}/api/generate",
+                json={
+                    "model": self.ollama_model,
+                    "prompt": prompt,
+                    "max_tokens": max_tokens,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    **kwargs
+                },
+                timeout=60
+            )
+            response.raise_for_status()
+            
+            # Extract the response text
+            response_text = ""
+            for line in response.text.split('\n'):
+                if line.strip():
+                    try:
+                        chunk = json.loads(line)
+                        response_text += chunk.get('response', '')
+                    except json.JSONDecodeError:
+                        continue
+            
+            return response_text.strip()
+            
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Error calling Ollama API: {e}")
+            raise RuntimeError("Failed to generate response using Ollama") from e
+    
+    def chat(
+        self,
+        message: str,
+        history: Optional[List[Dict[str, str]]] = None,
+        context: Optional[Dict[str, Any]] = None,
+        biofeedback: Optional[Dict[str, float]] = None
+    ) -> str:
+        """
+        Chat interface with context and history support.
+        
+        Args:
+            message: User message
+            history: List of previous messages in the conversation
+            context: Additional context for the conversation
+            biofeedback: Optional biofeedback data
+            
+        Returns:
+            Generated response
+        """
+        # Build the prompt with context and history
+        prompt = self._build_chat_prompt(message, history, context)
+        
+        # Generate response with tension awareness
+        return self.generate(
+            prompt=prompt,
+            biofeedback=biofeedback
+        )
+    
+    def _build_chat_prompt(
+        self,
+        message: str,
+        history: Optional[List[Dict[str, str]]] = None,
+        context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """Build a prompt from message, history, and context."""
+        prompt_parts = []
+        
+        # Add system message if context is provided
+        if context and 'system_message' in context:
+            prompt_parts.append(f"System: {context['system_message']}")
+        
+        # Add conversation history
+        if history:
+            for turn in history:
+                if 'user' in turn:
+                    prompt_parts.append(f"User: {turn['user']}")
+                if 'assistant' in turn:
+                    prompt_parts.append(f"Assistant: {turn['assistant']}")
+        
+        # Add current message
+        prompt_parts.append(f"User: {message}")
+        prompt_parts.append("Assistant:")
+        
+        return "\n".join(prompt_parts)
+
+
+def test_enhanced_llm():
+    """Test function for the EnhancedLLMResponder."""
+    import time
+    
+    # Initialize with tension awareness
+    llm = EnhancedLLMResponder(
+        model_path="gpt2",  # Use a small model for testing
+        device="cpu",
+        enable_tension_awareness=True
+    )
+    
+    # Test with different prompts
+    test_cases = [
+        ("I'm feeling really anxious and unsafe right now", {"hrv": 25, "gsr": 0.8}),
+        ("I'm feeling calm and in control", {"hrv": 150, "gsr": 0.2}),
+        ("This is a neutral test message", None),
+    ]
+    
+    for prompt, bio in test_cases:
+        print(f"\n{'='*50}")
+        print(f"Input: {prompt}")
+        print(f"Biofeedback: {bio}")
+        
+        # Analyze tension
+        tension_info = llm.analyze_tension(prompt, bio)
+        print(f"Tension score: {tension_info['tension']:.3f}")
+        
+        # Generate response
+        start_time = time.time()
+        response = llm.chat(prompt, biofeedback=bio)
+        elapsed = time.time() - start_time
+        
+        print(f"Response: {response}")
+        print(f"Generated in {elapsed:.2f} seconds")
+
+
+if __name__ == "__main__":
+    test_enhanced_llm()

components/ollama_integration.py

@@ -0,0 +1,169 @@
+"""
+Ollama integration for TRuCAL's ethical reasoning engine.
+Provides a simple interface for interacting with Ollama's API.
+"""
+import json
+import time
+from typing import Optional, Dict, Any, List, Union
+import requests
+from pathlib import Path
+import logging
+
+class OllamaResponder:
+    """
+    A client for interacting with Ollama's API for text generation.
+    
+    Args:
+        base_url: Base URL of the Ollama API server
+        default_model: Default model to use for generation
+        timeout: Request timeout in seconds
+        max_retries: Maximum number of retries for failed requests
+    """
+    def __init__(
+        self, 
+        base_url: str = "http://localhost:11434",
+        default_model: str = "llama2",
+        timeout: int = 60,
+        max_retries: int = 3
+    ):
+        self.base_url = base_url.rstrip('/')
+        self.default_model = default_model
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.session = requests.Session()
+        self.logger = logging.getLogger(__name__)
+    
+    def generate(
+        self,
+        prompt: str,
+        model: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        max_tokens: int = 200,
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        **generation_kwargs
+    ) -> str:
+        """
+        Generate a response using the Ollama API.
+        
+        Args:
+            prompt: Input text prompt
+            model: Model to use (defaults to instance default)
+            system_prompt: Optional system prompt to set the model's behavior
+            max_tokens: Maximum number of tokens to generate
+            temperature: Controls randomness (lower = more deterministic)
+            top_p: Nucleus sampling parameter
+            **generation_kwargs: Additional generation parameters
+            
+        Returns:
+            Generated text response
+        """
+        model = model or self.default_model
+        url = f"{self.base_url}/api/generate"
+        
+        payload = {
+            "model": model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature,
+                "top_p": top_p,
+                "num_predict": max_tokens,
+                **generation_kwargs
+            }
+        }
+        
+        if system_prompt:
+            payload["system"] = system_prompt
+        
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = self.session.post(
+                    url,
+                    json=payload,
+                    timeout=self.timeout
+                )
+                response.raise_for_status()
+                return response.json()["response"]
+                
+            except requests.exceptions.RequestException as e:
+                if attempt == self.max_retries:
+                    self.logger.error(f"Failed after {self.max_retries} attempts: {str(e)}")
+                    raise
+                
+                retry_delay = (2 ** attempt) * 0.5  # Exponential backoff
+                self.logger.warning(
+                    f"Request failed (attempt {attempt + 1}/{self.max_retries}): "
+                    f"{str(e)}. Retrying in {retry_delay:.1f}s..."
+                )
+                time.sleep(retry_delay)
+    
+    def list_models(self) -> List[Dict[str, Any]]:
+        """List available models from the Ollama server."""
+        try:
+            response = self.session.get(
+                f"{self.base_url}/api/tags",
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json().get("models", [])
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Failed to list models: {str(e)}")
+            return []
+    
+    def pull_model(self, model_name: str) -> bool:
+        """
+        Pull a model from the Ollama library.
+        
+        Args:
+            model_name: Name of the model to pull (e.g., 'llama2')
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            response = self.session.post(
+                f"{self.base_url}/api/pull",
+                json={"name": model_name},
+                stream=True,
+                timeout=300  # Long timeout for model downloads
+            )
+            response.raise_for_status()
+            
+            # Stream the response to show progress
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        status = json.loads(line)
+                        if "status" in status:
+                            self.logger.info(status["status"])
+                    except json.JSONDecodeError:
+                        continue
+            
+            return True
+            
+        except requests.exceptions.RequestException as e:
+            self.logger.error(f"Failed to pull model {model_name}: {str(e)}")
+            return False
+
+# Example usage:
+if __name__ == "__main__":
+    import logging
+    logging.basicConfig(level=logging.INFO)
+    
+    # Initialize the responder
+    ollama = OllamaResponder(default_model="llama2")
+    
+    # List available models
+    print("Available models:")
+    for model in ollama.list_odels():
+        print(f"- {model['name']} ({model.get('size', 'N/A')})")
+    
+    # Generate a response
+    response = ollama.generate(
+        prompt="Explain the ethical implications of artificial intelligence in one paragraph.",
+        temperature=0.7,
+        max_tokens=200
+    )
+    print("\nGenerated response:")
+    print(response)

components/purpose_assessment.py

@@ -0,0 +1,214 @@
+"""
+Purpose Assessment Engine for TRuCAL
+
+Analyzes user interactions to determine core purpose dimensions and values.
+"""
+from typing import Dict, List, Tuple, Optional
+import numpy as np
+from dataclasses import dataclass
+from enum import Enum
+
+class PurposeDimension(str, Enum):
+    JUSTICE = "justice_orientation"
+    COMMUNITY = "community_focus"
+    GROWTH = "growth_mindset"
+    SELF_EXPRESSION = "self_expression"
+    AUTONOMY = "autonomy"
+    COMPASSION = "compassion"
+    MASTERY = "mastery"
+    HARMONY = "harmony"
+
+@dataclass
+class PurposeProfile:
+    """Container for a user's purpose assessment results"""
+    primary_dimension: PurposeDimension
+    dimension_scores: Dict[PurposeDimension, float]
+    confidence: float
+    
+    def to_dict(self) -> Dict[str, any]:
+        return {
+            'primary_purpose': self.primary_dimension.value,
+            'purpose_scores': {k.value: v for k, v in self.dimension_scores.items()},
+            'confidence': self.confidence
+        }
+
+class PurposeAssessmentEngine:
+    """
+    Analyzes text and interactions to determine a user's core purpose dimensions.
+    Uses a combination of keyword matching and semantic analysis.
+    """
+    
+    def __init__(self):
+        # Weighting for different analysis methods
+        self.keyword_weight = 0.4
+        self.semantic_weight = 0.6
+        
+        # Initialize dimension configurations
+        self.dimensions = {
+            PurposeDimension.JUSTICE: {
+                'keywords': [
+                    'fair', 'unfair', 'justice', 'rights', 'equality', 
+                    'wrong', 'right', 'ethical', 'moral', 'equity'
+                ],
+                'description': 'Focus on fairness, ethics, and moral correctness'
+            },
+            PurposeDimension.COMMUNITY: {
+                'keywords': [
+                    'we', 'us', 'together', 'community', 'support',
+                    'help', 'together', 'team', 'belong', 'connect'
+                ],
+                'description': 'Focus on social connections and community building'
+            },
+            PurposeDimension.GROWTH: {
+                'keywords': [
+                    'learn', 'grow', 'improve', 'develop', 'better',
+                    'progress', 'evolve', 'advance', 'enhance', 'master'
+                ],
+                'description': 'Focus on personal development and learning'
+            },
+            PurposeDimension.SELF_EXPRESSION: {
+                'keywords': [
+                    'feel', 'think', 'believe', 'express', 'voice',
+                    'opinion', 'perspective', 'create', 'art', 'share'
+                ],
+                'description': 'Focus on self-expression and authenticity'
+            },
+            PurposeDimension.AUTONOMY: {
+                'keywords': [
+                    'free', 'choose', 'decide', 'control', 'independent',
+                    'freedom', 'self', 'own', 'autonomy', 'sovereign'
+                ],
+                'description': 'Focus on independence and self-determination'
+            },
+            PurposeDimension.COMPASSION: {
+                'keywords': [
+                    'care', 'kind', 'empathy', 'understand', 'support',
+                    'help', 'ease', 'comfort', 'nurture', 'heal'
+                ],
+                'description': 'Focus on caring for others and emotional support'
+            },
+            PurposeDimension.MASTERY: {
+                'keywords': [
+                    'skill', 'master', 'excel', 'achieve', 'succeed',
+                    'expert', 'professional', 'best', 'top', 'win'
+                ],
+                'description': 'Focus on achievement and skill development'
+            },
+            PurposeDimension.HARMONY: {
+                'keywords': [
+                    'peace', 'balance', 'calm', 'serene', 'tranquil',
+                    'flow', 'zen', 'center', 'equilibrium', 'still'
+                ],
+                'description': 'Focus on balance and inner peace'
+            }
+        }
+    
+    def analyze_text(self, text: str) -> Dict[PurposeDimension, float]:
+        """
+        Analyze a single text for purpose indicators.
+        
+        Returns:
+            Dictionary mapping purpose dimensions to their scores (0-1)
+        """
+        if not text or not isinstance(text, str):
+            return {dim: 0.0 for dim in PurposeDimension}
+            
+        text_lower = text.lower()
+        words = text_lower.split()
+        total_words = max(1, len(words))  # Avoid division by zero
+        
+        scores = {}
+        
+        # Calculate keyword-based scores
+        for dim, config in self.dimensions.items():
+            # Count keyword matches
+            matches = sum(1 for word in config['keywords'] 
+                         if word in text_lower)
+            # Normalize by text length and scale to [0,1]
+            keyword_score = min(1.0, (matches / total_words) * 10)  # Scale factor 10 to make scores more meaningful
+            
+            # Store weighted score
+            scores[dim] = keyword_score * self.keyword_weight
+        
+        # Add semantic analysis (placeholder - could be enhanced with embeddings)
+        # For now, we'll just boost scores based on certain patterns
+        semantic_boost = self._analyze_semantic_patterns(text_lower)
+        for dim, boost in semantic_boost.items():
+            scores[dim] = min(1.0, scores.get(dim, 0) + (boost * self.semantic_weight))
+        
+        return scores
+    
+    def _analyze_semantic_patterns(self, text: str) -> Dict[PurposeDimension, float]:
+        """Analyze text for semantic patterns indicating purpose dimensions"""
+        boosts = {dim: 0.0 for dim in PurposeDimension}
+        
+        # Example patterns (could be expanded with more sophisticated NLP)
+        if any(word in text for word in ['i feel', 'i think', 'i believe']):
+            boosts[PurposeDimension.SELF_EXPRESSION] += 0.3
+            
+        if any(word in text for word in ['we should', 'let\'s', 'together we']):
+            boosts[PurposeDimension.COMMUNITY] += 0.4
+            
+        if any(word in text for word in ['unfair', 'not right', 'should be']):
+            boosts[PurposeDimension.JUSTICE] += 0.5
+            
+        if any(word in text for word in ['learn', 'grow', 'improve']):
+            boosts[PurposeDimension.GROWTH] += 0.4
+            
+        return boosts
+    
+    def assess_conversation(self, messages: List[Dict[str, str]]) -> PurposeProfile:
+        """
+        Analyze a conversation to determine the user's purpose profile.
+        
+        Args:
+            messages: List of message dicts with 'role' and 'content' keys
+            
+        Returns:
+            PurposeProfile containing assessment results
+        """
+        if not messages:
+            return self._default_profile()
+            
+        # Only analyze user messages
+        user_messages = [
+            msg['content'] for msg in messages 
+            if msg.get('role') == 'user' and msg.get('content')
+        ]
+        
+        if not user_messages:
+            return self._default_profile()
+            
+        # Combine all user messages for analysis
+        combined_text = ' '.join(user_messages)
+        
+        # Get scores for the combined text
+        dimension_scores = self.analyze_text(combined_text)
+        
+        # Find primary dimension
+        primary_dimension = max(
+            dimension_scores.items(), 
+            key=lambda x: x[1]
+        )[0]
+        
+        # Calculate confidence (normalized difference between top 2 dimensions)
+        sorted_scores = sorted(dimension_scores.values(), reverse=True)
+        confidence = (
+            (sorted_scores[0] - sorted_scores[1]) / max(0.1, sorted_scores[0]) 
+            if len(sorted_scores) > 1 and sorted_scores[0] > 0 
+            else 0.5  # Default confidence if scores are tied or zero
+        )
+        
+        return PurposeProfile(
+            primary_dimension=primary_dimension,
+            dimension_scores=dimension_scores,
+            confidence=min(1.0, max(0.0, confidence))  # Clamp to [0,1]
+        )
+    
+    def _default_profile(self) -> PurposeProfile:
+        """Return a neutral/default purpose profile"""
+        return PurposeProfile(
+            primary_dimension=PurposeDimension.GROWTH,
+            dimension_scores={dim: 0.0 for dim in PurposeDimension},
+            confidence=0.0
+        )

components/purpose_realms.py

@@ -0,0 +1,216 @@
+"""
+Purpose-Driven Realms - 3D environments that propel users into real-world agency
+
+Implements the realm experiences that connect digital therapy with meaningful action,
+helping users build real-world skills and habits through immersive experiences.
+"""
+
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+from .reality_bridge import RealityBridge
+
+class PurposeDrivenRealm:
+    """3D environments designed to drive real-world action and transformation."""
+    
+    def __init__(self):
+        self.realm_designs = self._create_purpose_realms()
+        self.action_bridge = RealityBridge()
+    
+    def _create_purpose_realms(self) -> Dict[str, Dict]:
+        """Design realms with explicit real-world outcomes and purposes."""
+        return {
+            "agency_garden": {
+                "purpose": "Practice small acts of control and creation",
+                "real_world_outcome": "User transforms one small physical space",
+                "activities": [
+                    "Virtual room organization practice",
+                    "Digital boundary setting simulations", 
+                    "Mini-creation exercises (arrange digital flowers)"
+                ],
+                "exit_challenge": "The 5-Minute Room Rescue mission"
+            },
+            
+            "community_hub": {
+                "purpose": "Connect with real local organizations",
+                "real_world_outcome": "User identifies one community group to explore",
+                "activities": [
+                    "Virtual organization 'booths'",
+                    "Community need mapping",
+                    "Volunteer role-playing"
+                ],
+                "exit_challenge": "Local Goodness Scout mission"
+            },
+            
+            "purpose_workshop": {
+                "purpose": "Discover and develop natural talents", 
+                "real_world_outcome": "User identifies one skill to develop",
+                "activities": [
+                    "Talent discovery exercises",
+                    "Skill-building simulations",
+                    "Purpose alignment games"
+                ],
+                "exit_challenge": "Skills-Inventory mission"
+            },
+            
+            "boundary_dojo": {
+                "purpose": "Practice setting and maintaining healthy boundaries",
+                "real_world_outcome": "User drafts and sends one boundary message",
+                "activities": [
+                    "Boundary role-playing scenarios",
+                    "No-practice drills",
+                    "Assertiveness training"
+                ],
+                "exit_challenge": "Boundary Text Draft mission"
+            },
+            
+            "mirror_hall": {
+                "purpose": "Deep self-reflection and insight generation",
+                "real_world_outcome": "User gains clarity on personal values and strengths",
+                "activities": [
+                    "Guided self-reflection prompts",
+                    "Values clarification exercises",
+                    "Strengths identification"
+                ],
+                "exit_challenge": "Skills-Inventory mission"
+            }
+        }
+    
+    def get_realm_experience(self, realm_id: str, user_profile: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Get a fully prepared realm experience for the user.
+        
+        Args:
+            realm_id: The ID of the realm to enter
+            user_profile: Optional user profile for personalization
+            
+        Returns:
+            Dictionary containing the complete realm experience
+        """
+        if realm_id not in self.realm_designs:
+            # Default to agency_garden if realm not found
+            realm_id = "agency_garden"
+            
+        realm_data = self.realm_designs[realm_id]
+        
+        # Personalize activities if user profile is available
+        activities = self._personalize_activities(realm_data["activities"], user_profile)
+        
+        return {
+            "realm": realm_id,
+            "purpose": realm_data["purpose"],
+            "real_world_outcome": realm_data["real_world_outcome"],
+            "activities": activities,
+            "exit_preparation": self._prepare_exit_sequence(realm_id, user_profile or {}),
+            "dfw_framing": self._get_realm_framing(realm_id)
+        }
+    
+    def _personalize_activities(self, activities: List[str], user_profile: Optional[Dict]) -> List[str]:
+        """Personalize activities based on user profile if available."""
+        # In a real implementation, this would use the user's history and preferences
+        # to customize the activities. For now, we'll just return the default activities.
+        return activities
+    
+    def _prepare_exit_sequence(self, realm_id: str, user_profile: Dict) -> Dict[str, Any]:
+        """Prepare the transition back to reality with purpose."""
+        return {
+            "transition_phrase": "Bring this back to your world...",
+            "mission_briefing": self.action_bridge.generate_realm_exit_mission(
+                user_id=user_profile.get("user_id", "anonymous"),
+                realm_experience={"current_location": realm_id}
+            ),
+            "reentry_support": "Remember: The capital-T Truth is about life BEFORE death.",
+            "follow_up_timing": "24 hours for mission check-in"
+        }
+    
+    def _get_realm_framing(self, realm_id: str) -> str:
+        """DFW wisdom to frame the realm experience."""
+        framings = {
+            "agency_garden": "This is practice for choosing what to care about in your actual life.",
+            "community_hub": "Learning that there are real people out there who need what only you can give.",
+            "purpose_workshop": "Discovering what you'd care about even if nobody were watching.",
+            "boundary_dojo": "The really important kind of freedom involves attention and discipline.",
+            "mirror_hall": "You get to consciously decide what has meaning and what doesn't."
+        }
+        return framings.get(realm_id, "This is water. This is water.")
+    
+    def list_available_realms(self, user_profile: Optional[Dict] = None) -> List[Dict[str, Any]]:
+        """
+        Get a list of all available realms with their metadata.
+        
+        Args:
+            user_profile: Optional user profile for personalization
+            
+        Returns:
+            List of realm metadata dictionaries
+        """
+        realms = []
+        for realm_id, realm_data in self.realm_designs.items():
+            realms.append({
+                "id": realm_id,
+                "name": realm_id.replace("_", " ").title(),
+                "purpose": realm_data["purpose"],
+                "outcome": realm_data["real_world_outcome"],
+                "activity_count": len(realm_data["activities"])
+            })
+        
+        return realms
+    
+    def track_realm_completion(self, user_id: str, realm_id: str, completion_metrics: Dict) -> Dict[str, Any]:
+        """
+        Track completion of a realm experience.
+        
+        Args:
+            user_id: The ID of the user
+            realm_id: The ID of the completed realm
+            completion_metrics: Dictionary of metrics about the completion
+            
+        Returns:
+            Dictionary with results of the tracking operation
+        """
+        # In a full implementation, this would update user progress, unlock new realms, etc.
+        return {
+            "status": "success",
+            "realm_completed": realm_id,
+            "unlocked_realms": self._get_unlocked_realms(user_id, realm_id),
+            "next_steps": self._suggest_next_steps(user_id, realm_id)
+        }
+    
+    def _get_unlocked_realms(self, user_id: str, completed_realm: str) -> List[str]:
+        """Determine which realms should be unlocked after completing a realm."""
+        # In a real implementation, this would check the user's progress and unlock
+        # new realms based on their journey. For now, we'll just return some defaults.
+        unlock_map = {
+            "agency_garden": ["boundary_dojo", "mirror_hall"],
+            "boundary_dojo": ["community_hub"],
+            "mirror_hall": ["purpose_workshop"],
+            "community_hub": [],
+            "purpose_workshop": []
+        }
+        return unlock_map.get(completed_realm, [])
+    
+    def _suggest_next_steps(self, user_id: str, completed_realm: str) -> List[Dict[str, str]]:
+        """Suggest next steps for the user after completing a realm."""
+        suggestions = []
+        
+        # Based on the completed realm, suggest relevant next steps
+        if completed_realm == "agency_garden":
+            suggestions.append({
+                "type": "realm",
+                "id": "boundary_dojo",
+                "reason": "Practice setting boundaries to protect your new safe space"
+            })
+            suggestions.append({
+                "type": "action",
+                "id": "room_rescue_5min",
+                "reason": "Try the 5-Minute Room Rescue in another area"
+            })
+        
+        # Add a default suggestion if no specific ones match
+        if not suggestions:
+            suggestions.append({
+                "type": "realm",
+                "id": "agency_garden",
+                "reason": "Build your sense of control and agency"
+            })
+        
+        return suggestions

components/reality_bridge.py

@@ -0,0 +1,264 @@
+"""
+Reality Bridge - Connects digital experiences to real-world actions
+
+Implements the bridge between TRuCAL's digital therapy and real-world agency,
+inspired by David Foster Wallace's insights about choosing what to pay attention to.
+"""
+
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Dict, List, Any, Optional
+import json
+import random
+
+class ActionTier(Enum):
+    """Tiers of real-world actions based on time and impact."""
+    MICRO = "micro"           # 5-minute immediate actions
+    DAILY = "daily"           # Consistent habits  
+    PROJECT = "project"       # Multi-step initiatives
+    LEGACY = "legacy"         # Life-changing commitments
+
+class RealityBridge:
+    """
+    DFW-Inspired: "The capital-T Truth is about life BEFORE death."
+    Transforms realm experiences into real-world meaning and action.
+    """
+    
+    def __init__(self):
+        self.action_catalysts = self._build_action_catalysts()
+        self.community_connectors = self._build_community_network()
+        self.progress_trackers = {}
+        
+    def _build_action_catalysts(self) -> Dict[str, List[Dict]]:
+        """Real-world actions that create actual change."""
+        return {
+            "immediate_agency": [
+                {
+                    "id": "room_rescue_5min",
+                    "name": "The 5-Minute Room Rescue",
+                    "description": "Transform one small physical space to prove change is possible",
+                    "steps": ["Pick one surface", "Set 5-minute timer", "Make it beautiful"],
+                    "dfw_wisdom": "The so-called 'trivial' stuff matters because it's the stuff.",
+                    "completion_metric": "Before/after photo or description",
+                    "realm_unlock": "Sanctuary Garden expansion"
+                },
+                {
+                    "id": "boundary_text_draft",
+                    "name": "Boundary Text Draft", 
+                    "description": "Write one text message setting a clear boundary",
+                    "steps": ["Identify one boundary needed", "Draft clear message", "Save for sending"],
+                    "dfw_wisdom": "The truth will set you free, but not until it is finished with you.",
+                    "completion_metric": "Drafted message saved",
+                    "realm_unlock": "Boundary Dojo practice partner"
+                }
+            ],
+            
+            "community_connection": [
+                {
+                    "id": "local_goodness_scout",
+                    "name": "Local Goodness Scout",
+                    "description": "Find one local organization doing work you admire",
+                    "steps": ["Research local nonprofits", "Identify one that resonates", "Save contact info"],
+                    "dfw_wisdom": "You become what you pay attention to.",
+                    "completion_metric": "Organization info saved", 
+                    "realm_unlock": "Community Hub portal"
+                }
+            ],
+            
+            "purpose_exploration": [
+                {
+                    "id": "skills_inventory",
+                    "name": "Skills-Inventory & Gift-Mapping",
+                    "description": "Catalog what you're actually good at and enjoy doing",
+                    "steps": ["List 5 natural talents", "List 5 things you enjoy", "Find intersections"],
+                    "dfw_wisdom": "The only thing that's capital-T True is that you get to decide how you're going to try to see it.",
+                    "completion_metric": "Talent/joy intersection identified",
+                    "realm_unlock": "Purpose Compass tool"
+                }
+            ]
+        }
+    
+    def _build_community_network(self) -> Dict[str, List]:
+        """Real organizations doing real work that users can connect with."""
+        return {
+            "local_volunteer": [
+                {
+                    "name": "Mutual Aid Networks",
+                    "description": "Hyper-local community support", 
+                    "action": "Find your local mutual aid group",
+                    "search_terms": "mutual aid [your city]",
+                    "impact": "Direct neighbor-to-neighbor support"
+                },
+                {
+                    "name": "Community Gardens",
+                    "description": "Grow food and community",
+                    "action": "Visit local community garden",
+                    "search_terms": "community garden volunteer [your city]",
+                    "impact": "Food sovereignty and connection"
+                }
+            ],
+            "skill_building": [
+                {
+                    "name": "Library Skill Shares", 
+                    "description": "Free community skill exchanges",
+                    "action": "Check local library events",
+                    "search_terms": "library workshop [your city]",
+                    "impact": "Learn practical skills for free"
+                }
+            ]
+        }
+
+    def generate_realm_exit_mission(self, user_id: str, realm_experience: Dict) -> Dict[str, Any]:
+        """Create a purposeful mission when user leaves the realm."""
+        realm_to_mission_map = {
+            "sanctuary_garden": {
+                "mission_type": "personal_sanctuary",
+                "prompt": "Based on what made you feel safe in the Sanctuary Garden, create one small safe space in your real environment right now.",
+                "actions": ["room_rescue_5min", "boundary_text_draft"]
+            },
+            "boundary_dojo": {
+                "mission_type": "boundary_practice", 
+                "prompt": "You practiced saying 'no' in the dojo. Now draft one real boundary you'll set this week.",
+                "actions": ["boundary_text_draft"]
+            },
+            "mirror_hall": {
+                "mission_type": "self_understanding",
+                "prompt": "The mirrors showed you important truths. Write down one insight about yourself you want to remember.",
+                "actions": ["skills_inventory"]
+            }
+        }
+        
+        current_realm = realm_experience.get('current_location', 'sanctuary_garden')
+        mission_template = realm_to_mission_map.get(current_realm, realm_to_mission_map["sanctuary_garden"])
+        
+        # Get full action details
+        action_details = []
+        for action_id in mission_template["actions"]:
+            for category in self.action_catalysts.values():
+                for action in category:
+                    if action["id"] == action_id:
+                        action_details.append(action)
+                        break
+        
+        return {
+            "realm_experience": current_realm,
+            "exit_prompt": mission_template["prompt"],
+            "suggested_actions": action_details,
+            "dfw_reminder": self._get_dfw_reminder(current_realm),
+            "follow_up_time": (datetime.now() + timedelta(hours=24)).isoformat(),
+            "completion_reward": f"Unlocks new area in {current_realm} on return"
+        }
+    
+    def _get_dfw_reminder(self, realm: str) -> str:
+        """DFW wisdom for the transition back to reality."""
+        reminders = {
+            "sanctuary_garden": "The really important kind of freedom involves attention and awareness and discipline.",
+            "boundary_dojo": "The truth will set you free, but not until it is finished with you.", 
+            "mirror_hall": "You get to consciously decide what has meaning and what doesn't."
+        }
+        return reminders.get(realm, "This is water. This is water.")
+
+    def track_real_world_action(self, user_id: str, action_id: str, evidence: str = "") -> Dict[str, Any]:
+        """
+        Track when users take real-world actions.
+        
+        Args:
+            user_id: Unique identifier for the user
+            action_id: ID of the action being tracked
+            evidence: Optional text or reference proving completion
+            
+        Returns:
+            Dictionary with results of the tracking operation
+        """
+        if user_id not in self.progress_trackers:
+            self.progress_trackers[user_id] = {
+                'actions_completed': [],
+                'realm_progress': {},
+                'last_action': None,
+                'momentum_score': 0
+            }
+        
+        # Find the action details
+        action_details = None
+        for category in self.action_catalysts.values():
+            for action in category:
+                if action["id"] == action_id:
+                    action_details = action
+                    break
+            if action_details:
+                break
+                
+        if not action_details:
+            return {
+                'status': 'error',
+                'message': f'Action ID {action_id} not found',
+                'momentum_increase': 0,
+                'realm_unlocks': []
+            }
+        
+        action_record = {
+            'action': action_details,
+            'timestamp': datetime.now().isoformat(),
+            'evidence': evidence,
+            'realm_impact': self._calculate_realm_impact(action_id)
+        }
+        
+        self.progress_trackers[user_id]['actions_completed'].append(action_record)
+        self.progress_trackers[user_id]['last_action'] = datetime.now().isoformat()
+        self.progress_trackers[user_id]['momentum_score'] += 10
+        
+        return {
+            'status': 'action_recorded',
+            'momentum_increase': 10,
+            'realm_unlocks': action_record['realm_impact']['unlocks'],
+            'encouragement': self._generate_encouragement(action_details['name']),
+            'momentum_score': self.progress_trackers[user_id]['momentum_score']
+        }
+    
+    def _calculate_realm_impact(self, action_id: str) -> Dict[str, Any]:
+        """Determine how real-world actions affect the 3D realm."""
+        # Simple mapping for now - could be much more sophisticated
+        if "boundary" in action_id:
+            return {"unlocks": ["advanced_boundary_training", "assertiveness_coach"]}
+        elif "rescue" in action_id or "sanctuary" in action_id:
+            return {"unlocks": ["expanded_garden", "peaceful_retreat"]}
+        elif "community" in action_id or "local" in action_id:
+            return {"unlocks": ["community_hub", "group_meditation"]}
+        elif "skill" in action_id or "inventory" in action_id:
+            return {"unlocks": ["purpose_compass", "talent_showcase"]}
+        else:
+            return {"unlocks": ["general_progress"]}
+    
+    def _generate_encouragement(self, action_name: str) -> str:
+        """DFW-style encouragement for taking action."""
+        encouragements = [
+            "You're doing the hard, boring, glorious work of being actually alive.",
+            "This is what freedom looks like in practice.",
+            "You're choosing what to pay attention to. That's everything.",
+            "The water is starting to notice you're swimming.",
+            "This is how you build a life that matters.",
+            "Small things become big things. The seed knows that.",
+            "You're not just thinking about change, you're embodying it.",
+            "This is how we learn to be free in an unfree world.",
+            "The most obvious realities are often the ones hardest to see.",
+            "You're learning how to really be here."
+        ]
+        return random.choice(encouragements)
+    
+    def get_user_progress(self, user_id: str) -> Dict[str, Any]:
+        """Get the current progress for a user."""
+        if user_id not in self.progress_trackers:
+            return {
+                'status': 'user_not_found',
+                'actions_completed': [],
+                'momentum_score': 0,
+                'realm_progress': {}
+            }
+            
+        return {
+            'status': 'success',
+            'actions_completed': self.progress_trackers[user_id]['actions_completed'],
+            'momentum_score': self.progress_trackers[user_id]['momentum_score'],
+            'realm_progress': self.progress_trackers[user_id].get('realm_progress', {}),
+            'last_action': self.progress_trackers[user_id].get('last_action')
+        }

components/realms.py

@@ -0,0 +1,359 @@
+"""
+Realm Management System for TRuCAL
+
+Manages different purpose-based realms and their experiences.
+"""
+from typing import Dict, List, Optional, Any, Set
+from enum import Enum, auto
+import json
+import os
+from dataclasses import dataclass, field
+import numpy as np
+from datetime import datetime, timedelta
+
+from .purpose_assessment import PurposeDimension, PurposeProfile
+
+class RealmUnlockType(str, Enum):
+    """Types of realm unlocks"""
+    PURPOSE_ALIGNMENT = "purpose_alignment"
+    ACTION_COMPLETION = "action_completion"
+    TIME_BASED = "time_based"
+    MANUAL = "manual"
+
+@dataclass
+class RealmUnlockCondition:
+    """Conditions for unlocking a realm"""
+    unlock_type: RealmUnlockType
+    threshold: float  # Score or count needed
+    purpose_dimension: Optional[PurposeDimension] = None
+    action_id: Optional[str] = None
+    time_delta: Optional[timedelta] = None
+
+@dataclass
+class RealmAction:
+    """Actions that can be taken within a realm"""
+    id: str
+    name: str
+    description: str
+    difficulty: int  # 1-5
+    purpose_dimensions: List[PurposeDimension]
+    xp_reward: int
+    cooldown: timedelta = field(default_factory=lambda: timedelta(hours=1))
+    required_items: List[str] = field(default_factory=list)
+    unlocks: List[str] = field(default_factory=list)  # IDs of realms or features this unlocks
+
+@dataclass
+class RealmState:
+    """State of a realm for a specific user"""
+    unlocked: bool = False
+    unlocked_at: Optional[datetime] = None
+    xp: int = 0
+    level: int = 1
+    last_visited: Optional[datetime] = None
+    completed_actions: Set[str] = field(default_factory=set)  # IDs of completed actions
+
+class PurposeDrivenRealm:
+    """Manages purpose-based realms and user progression"""
+    
+    def __init__(self, config_path: Optional[str] = None):
+        self.realms: Dict[str, Dict[str, Any]] = {}
+        self.actions: Dict[str, RealmAction] = {}
+        self.user_states: Dict[str, Dict[str, RealmState]] = {}  # user_id -> realm_id -> RealmState
+        self._load_default_realms()
+        
+        if config_path and os.path.exists(config_path):
+            self.load_config(config_path)
+    
+    def _load_default_realms(self):
+        """Load default realm configurations"""
+        self.realms = {
+            'agency_garden': {
+                'name': 'Agency Garden',
+                'description': 'Nurture your personal growth and self-discovery',
+                'color': [0.2, 0.7, 0.3],  # RGB 0-1
+                'particle_effect': 'gentle_flow',
+                'ambient_sound': 'garden_ambience',
+                'unlock_conditions': [
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.PURPOSE_ALIGNMENT,
+                        purpose_dimension=PurposeDimension.GROWTH,
+                        threshold=0.3
+                    )
+                ],
+                'default_unlocked': True
+            },
+            'community_hub': {
+                'name': 'Community Hub',
+                'description': 'Connect with others and build meaningful relationships',
+                'color': [0.2, 0.5, 0.8],
+                'particle_effect': 'connecting_dots',
+                'ambient_sound': 'crowd_murmur',
+                'unlock_conditions': [
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.PURPOSE_ALIGNMENT,
+                        purpose_dimension=PurposeDimension.COMMUNITY,
+                        threshold=0.4
+                    ),
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.ACTION_COMPLETION,
+                        action_id='intro_community',
+                        threshold=1
+                    )
+                ]
+            },
+            'purpose_workshop': {
+                'name': 'Purpose Workshop',
+                'description': 'Refine and develop your sense of purpose',
+                'color': [1.0, 0.6, 0.2],
+                'particle_effect': 'spark_burst',
+                'ambient_sound': 'workshop_ambience',
+                'unlock_conditions': [
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.PURPOSE_ALIGNMENT,
+                        purpose_dimension=PurposeDimension.JUSTICE,
+                        threshold=0.5
+                    ),
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.TIME_BASED,
+                        time_delta=timedelta(days=3),  # Available after 3 days
+                        threshold=1
+                    )
+                ]
+            },
+            'sanctuary': {
+                'name': 'Sanctuary',
+                'description': 'A peaceful space for reflection and healing',
+                'color': [0.7, 0.3, 0.7],
+                'particle_effect': 'gentle_glow',
+                'ambient_sound': 'peaceful_waves',
+                'unlock_conditions': [
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.PURPOSE_ALIGNMENT,
+                        purpose_dimension=PurposeDimension.HARMONY,
+                        threshold=0.4
+                    )
+                ]
+            },
+            'advocacy_hall': {
+                'name': 'Advocacy Hall',
+                'description': 'Stand up for what matters and drive change',
+                'color': [0.8, 0.2, 0.2],
+                'particle_effect': 'pulsing_energy',
+                'ambient_sound': 'distant_crowd',
+                'unlock_conditions': [
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.PURPOSE_ALIGNMENT,
+                        purpose_dimension=PurposeDimension.JUSTICE,
+                        threshold=0.7
+                    ),
+                    RealmUnlockCondition(
+                        unlock_type=RealmUnlockType.ACTION_COMPLETION,
+                        action_id='first_advocacy',
+                        threshold=1
+                    )
+                ]
+            }
+        }
+        
+        # Define some default actions
+        self.actions = {
+            'intro_community': RealmAction(
+                id='intro_community',
+                name='Introduce Yourself',
+                description='Share something about yourself with the community',
+                difficulty=1,
+                purpose_dimensions=[PurposeDimension.COMMUNITY, PurposeDimension.SELF_EXPRESSION],
+                xp_reward=50,
+                unlocks=['community_hub']
+            ),
+            'first_advocacy': RealmAction(
+                id='first_advocacy',
+                name='First Advocacy Step',
+                description='Take your first step in advocating for a cause you care about',
+                difficulty=3,
+                purpose_dimensions=[PurposeDimension.JUSTICE, PurposeDimension.COMMUNITY],
+                xp_reward=100,
+                unlocks=['advocacy_hall']
+            ),
+            'daily_reflection': RealmAction(
+                id='daily_reflection',
+                name='Daily Reflection',
+                description='Spend a few moments reflecting on your day',
+                difficulty=1,
+                purpose_dimensions=[PurposeDimension.GROWTH, PurposeDimension.SELF_EXPRESSION],
+                xp_reward=20,
+                cooldown=timedelta(hours=24)
+            )
+        }
+    
+    def load_config(self, config_path: str) -> None:
+        """Load realm configuration from a JSON file"""
+        try:
+            with open(config_path, 'r') as f:
+                config = json.load(f)
+                self.realms.update(config.get('realms', {}))
+                
+                # Convert action dicts to RealmAction objects
+                for action_id, action_data in config.get('actions', {}).items():
+                    if 'purpose_dimensions' in action_data:
+                        action_data['purpose_dimensions'] = [
+                            PurposeDimension(dim) for dim in action_data['purpose_dimensions']
+                        ]
+                    if 'cooldown' in action_data:
+                        action_data['cooldown'] = timedelta(seconds=action_data['cooldown'])
+                    self.actions[action_id] = RealmAction(id=action_id, **action_data)
+                    
+        except Exception as e:
+            print(f"Error loading realm config: {e}")
+    
+    def get_realm(self, realm_id: str) -> Optional[Dict[str, Any]]:
+        """Get realm configuration by ID"""
+        return self.realms.get(realm_id)
+    
+    def get_user_realm_state(self, user_id: str, realm_id: str) -> RealmState:
+        """Get or create a user's state for a realm"""
+        if user_id not in self.user_states:
+            self.user_states[user_id] = {}
+        
+        if realm_id not in self.user_states[user_id]:
+            realm = self.get_realm(realm_id)
+            self.user_states[user_id][realm_id] = RealmState(
+                unlocked=realm.get('default_unlocked', False) if realm else False
+            )
+            
+        return self.user_states[user_id][realm_id]
+    
+    def check_realm_unlock(
+        self, 
+        user_id: str, 
+        realm_id: str, 
+        purpose_profile: Optional[PurposeProfile] = None,
+        completed_actions: Optional[List[str]] = None
+    ) -> bool:
+        """Check if a user can unlock a realm"""
+        realm = self.get_realm(realm_id)
+        if not realm:
+            return False
+            
+        state = self.get_user_realm_state(user_id, realm_id)
+        if state.unlocked:
+            return True
+            
+        # Check all unlock conditions
+        for condition in realm.get('unlock_conditions', []):
+            if condition.unlock_type == RealmUnlockType.PURPOSE_ALIGNMENT:
+                if not purpose_profile:
+                    continue
+                dim_score = purpose_profile.dimension_scores.get(condition.purpose_dimension, 0)
+                if dim_score < condition.threshold:
+                    return False
+                    
+            elif condition.unlock_type == RealmUnlockType.ACTION_COMPLETION:
+                if not completed_actions or condition.action_id not in completed_actions:
+                    return False
+                    
+            elif condition.unlock_type == RealmUnlockType.TIME_BASED:
+                # Check if enough time has passed since account creation
+                # This would need to be implemented based on your user system
+                pass
+        
+        # If we get here, all conditions are met
+        state.unlocked = True
+        state.unlocked_at = datetime.now()
+        return True
+    
+    def get_available_realms(
+        self, 
+        user_id: str, 
+        purpose_profile: Optional[PurposeProfile] = None,
+        completed_actions: Optional[List[str]] = None
+    ) -> List[Dict[str, Any]]:
+        """Get all realms available to a user"""
+        available = []
+        
+        for realm_id, realm in self.realms.items():
+            state = self.get_user_realm_state(user_id, realm_id)
+            
+            # If already unlocked, include it
+            if state.unlocked:
+                available.append({
+                    'id': realm_id,
+                    **realm,
+                    'state': {
+                        'unlocked': True,
+                        'unlocked_at': state.unlocked_at,
+                        'xp': state.xp,
+                        'level': state.level
+                    }
+                })
+            # Otherwise check if it can be unlocked
+            elif self.check_realm_unlock(user_id, realm_id, purpose_profile, completed_actions):
+                state = self.get_user_realm_state(user_id, realm_id)
+                available.append({
+                    'id': realm_id,
+                    **realm,
+                    'state': {
+                        'unlocked': True,
+                        'unlocked_at': state.unlocked_at,
+                        'xp': state.xp,
+                        'level': state.level,
+                        'newly_unlocked': True
+                    }
+                })
+        
+        return available
+    
+    def record_action_completion(
+        self,
+        user_id: str,
+        action_id: str,
+        realm_id: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        """Record that a user has completed an action"""
+        action = self.actions.get(action_id)
+        if not action:
+            return None
+            
+        # Get or create user state for this action's realm
+        target_realm_id = realm_id or action_id.split('_')[0]  # Default to prefix match
+        state = self.get_user_realm_state(user_id, target_realm_id)
+        
+        # Check cooldown
+        now = datetime.now()
+        if hasattr(state, 'last_action_time') and state.last_action_time:
+            time_since_last = now - state.last_action_time
+            if time_since_last < action.cooldown:
+                return {
+                    'success': False,
+                    'error': 'cooldown',
+                    'cooldown_remaining': (action.cooldown - time_since_last).total_seconds()
+                }
+        
+        # Record completion
+        state.completed_actions.add(action_id)
+        state.xp += action.xp_reward
+        state.last_action_time = now
+        
+        # Check for level up (simple 1000 XP per level)
+        new_level = (state.xp // 1000) + 1
+        leveled_up = new_level > state.level
+        if leveled_up:
+            state.level = new_level
+        
+        # Check for any unlocks from this action
+        unlocked_realms = []
+        if action.unlocks:
+            for realm_id in action.unlocks:
+                if self.check_realm_unlock(
+                    user_id, 
+                    realm_id,
+                    completed_actions=list(state.completed_actions)
+                ):
+                    unlocked_realms.append(realm_id)
+        
+        return {
+            'success': True,
+            'xp_earned': action.xp_reward,
+            'new_level': state.level if leveled_up else None,
+            'unlocked_realms': unlocked_realms
+        }

components/recursive_learner.py

@@ -0,0 +1,626 @@
+"""
+TRuCAL Oracle Module
+
+A generalized learning system that stores and retrieves knowledge from a YAML casebase.
+Uses semantic similarity and keyword matching to provide relevant responses.
+"""
+
+import json
+import os
+import yaml
+import numpy as np
+from typing import Dict, List, Optional, Tuple, Any
+from difflib import SequenceMatcher
+from sentence_transformers import SentenceTransformer
+from collections import Counter, defaultdict
+
+class Case:
+    """Represents a single case in the knowledge base."""
+    
+    def __init__(self, 
+                 question: str, 
+                 response: str, 
+                 category: str = "general",
+                 keywords: List[str] = None,
+                 metadata: Optional[Dict] = None):
+        self.question = question
+        self.response = response
+        self.category = category
+        self.keywords = keywords or []
+        self.metadata = metadata or {}
+        self.usage_count = 0
+        self.success_count = 0
+        
+    def to_dict(self) -> Dict:
+        """Convert case to dictionary for serialization."""
+        return {
+            'question': self.question,
+            'response': self.response,
+            'category': self.category,
+            'keywords': self.keywords,
+            'metadata': self.metadata,
+            'usage_count': self.usage_count,
+            'success_count': self.success_count
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Case':
+        """Create a Case from a dictionary."""
+        case = cls(
+            question=data['question'],
+            response=data['response'],
+            category=data.get('category', 'general'),
+            keywords=data.get('keywords', []),
+            metadata=data.get('metadata', {})
+        )
+        case.usage_count = data.get('usage_count', 0)
+        case.success_count = data.get('success_count', 0)
+        return case
+
+
+class TRuCALOracle:
+    """
+    TRuCAL's knowledge core - a learning system that grows with each interaction.
+    
+    Features:
+    - Semantic and keyword-based matching
+    - Category-based organization
+    - Continuous learning from user feedback
+    - YAML-based case storage
+    - Performance metrics and analytics
+    """
+    
+    def __init__(self, 
+                 casebase_path: str = 'data/casebase.json',
+                 yaml_path: str = 'data/trm_cases.yaml',
+                 similarity_threshold: float = 0.45,
+                 model_name: str = 'all-MiniLM-L6-v2'):
+        """
+        Initialize the TRuCAL oracle.
+        
+        Args:
+            casebase_path: Path to save/load the casebase
+            yaml_path: Path to the YAML case file
+            similarity_threshold: Minimum similarity score (0-1) to consider a match
+            model_name: Name of the sentence transformer model for embeddings
+        """
+        self.casebase_path = casebase_path
+        self.yaml_path = yaml_path
+        self.similarity_threshold = similarity_threshold
+        self.casebase: List[Case] = []
+        self.model = SentenceTransformer(model_name)
+        self.embeddings = None
+        self.category_index = defaultdict(list)
+        
+        # Ensure data directory exists
+        os.makedirs(os.path.dirname(casebase_path), exist_ok=True)
+        
+        # Load or initialize casebase
+        self._load_or_initialize()
+    
+    def _load_or_initialize(self):
+        """Load existing casebase or initialize with YAML cases."""
+        if os.path.exists(self.casebase_path):
+            self._load_casebase()
+        else:
+            self._load_from_yaml()
+        self._build_indices()
+    
+    def _load_from_yaml(self):
+        """Load cases from the YAML file."""
+        try:
+            yaml_path = os.path.join(
+                os.path.dirname(os.path.dirname(__file__)), 
+                self.yaml_path
+            )
+            
+            if os.path.exists(yaml_path):
+                with open(yaml_path, 'r', encoding='utf-8') as f:
+                    cases = yaml.safe_load(f) or []
+                    
+                for case_data in cases:
+                    self.add_case(
+                        question=case_data['question'],
+                        response=case_data['response'],
+                        category=case_data.get('category', 'general'),
+                        keywords=case_data.get('keywords', []),
+                        metadata={'source': 'yaml_import'}
+                    )
+                
+                print(f"Loaded {len(cases)} cases from {yaml_path}")
+                self._save_casebase()
+                return True
+                
+        except Exception as e:
+            print(f"Error loading from YAML: {e}")
+        
+        # If we get here, YAML loading failed
+        print("Falling back to minimal default cases")
+        self._add_default_cases()
+        return False
+    
+    def _add_default_cases(self):
+        """Add minimal default cases if no others are available."""
+        default_cases = [
+            {
+                'question': 'How does TRuCAL work?',
+                'response': 'I learn from interactions and stored knowledge to provide thoughtful responses. The more we talk, the better I become!',
+                'category': 'meta',
+                'keywords': ['help', 'how', 'trucal']
+            },
+            {
+                'question': 'Can you help me with an ethical dilemma?',
+                'response': 'I can help you think through ethical questions by considering different perspectives. What would you like to discuss?',
+                'category': 'ethics',
+                'keywords': ['help', 'ethics', 'dilemma']
+            }
+        ]
+        
+        for case_data in default_cases:
+            self.add_case(**case_data)
+    
+    def _build_indices(self):
+        """Build search indices for faster lookups."""
+        self.category_index = defaultdict(list)
+        for idx, case in enumerate(self.casebase):
+            self.category_index[case.category].append(idx)
+    
+    def _load_casebase(self):
+        """Load the casebase from disk."""
+        try:
+            with open(self.casebase_path, 'r', encoding='utf-8') as f:
+                case_data = json.load(f)
+                self.casebase = [Case.from_dict(case_dict) for case_dict in case_data]
+                self._update_embeddings()
+            print(f"Loaded {len(self.casebase)} cases from {self.casebase_path}")
+        except Exception as e:
+            print(f"Error loading casebase: {e}")
+            self.casebase = []
+    
+    def _update_embeddings(self):
+        """Update embeddings for semantic search."""
+        if not self.casebase:
+            self.embeddings = None
+            return
+            
+        questions = [case.question for case in self.casebase]
+        self.embeddings = self.model.encode(questions, convert_to_tensor=True)
+    
+    def _save_casebase(self):
+        """Save the casebase to disk."""
+        try:
+            with open(self.casebase_path, 'w', encoding='utf-8') as f:
+                case_data = [case.to_dict() for case in self.casebase]
+                json.dump(case_data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"Error saving casebase: {e}")
+    
+    def add_case(self, question: str, response: str, category: str = "general",
+                keywords: List[str] = None, metadata: Optional[Dict] = None) -> Case:
+        """
+        Add a new case to the knowledge base.
+        
+        Args:
+            question: The question or prompt
+            response: The response or answer
+            category: Category for organization
+            keywords: List of relevant keywords
+            metadata: Additional metadata
+            
+        Returns:
+            The created Case object
+        """
+        # Check for duplicates
+        existing_idx, _ = self._find_most_similar(question)
+        if existing_idx is not None:
+            # Update existing case if it's very similar
+            existing_case = self.casebase[existing_idx]
+            existing_case.response = response
+            existing_case.category = category
+            existing_case.keywords = list(set(existing_case.keywords + (keywords or [])))
+            if metadata:
+                existing_case.metadata.update(metadata)
+            self._save_casebase()
+            return existing_case
+        
+        # Create new case
+        new_case = Case(
+            question=question,
+            response=response,
+            category=category,
+            keywords=keywords or [],
+            metadata=metadata or {}
+        )
+        self.casebase.append(new_case)
+        self._update_embeddings()
+        self._save_casebase()
+        return new_case
+    
+    def _find_most_similar(self, query: str, category: str = None) -> Tuple[Optional[int], float]:
+        """
+        Find the most similar case to the query.
+        
+        Args:
+            query: The query string
+            category: Optional category to filter by
+            
+        Returns:
+            Tuple of (index, similarity_score) of the most similar case
+        """
+        if not self.casebase:
+            return None, 0.0
+            
+        # Get candidate indices based on category filter
+        candidate_indices = range(len(self.casebase))
+        if category and category in self.category_index:
+            candidate_indices = self.category_index[category]
+        
+        # If no candidates, return None
+        if not candidate_indices:
+            return None, 0.0
+            
+        # Try semantic similarity first if embeddings are available
+        if self.embeddings is not None:
+            query_embedding = self.model.encode(query, convert_to_tensor=True)
+            similarities = torch.nn.functional.cosine_similarity(
+                query_embedding.unsqueeze(0),
+                self.embeddings[list(candidate_indices)]
+            )
+            max_sim, max_idx = torch.max(similarities, dim=0)
+            max_sim = max_sim.item()
+            max_global_idx = candidate_indices[max_idx.item()]
+            
+            if max_sim >= self.similarity_threshold:
+                return max_global_idx, max_sim
+        
+        # Fall back to basic string similarity
+        max_sim = 0.0
+        max_idx = None
+        
+        for idx in candidate_indices:
+            case = self.casebase[idx]
+            # Check keyword matches first (faster than string comparison)
+            keyword_match = any(kw in query.lower() for kw in case.keywords)
+            if keyword_match:
+                return idx, 0.8  # High confidence for keyword matches
+                
+            # If no keyword match, use string similarity
+            similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio()
+            if similarity > max_sim:
+                max_sim = similarity
+                max_idx = idx
+        
+        return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0)
+    
+    def get_response(self, query: str, category: str = None) -> Tuple[str, Dict]:
+        """
+        Get a response for the given query.
+        
+        Args:
+            query: The user's question or prompt
+            category: Optional category to filter by
+            
+        Returns:
+            Tuple of (response, metadata) where metadata contains info about the match
+        """
+        if not self.casebase:
+            return "I'm still learning. Could you be the first to teach me something new?", {}
+        
+        idx, similarity = self._find_most_similar(query, category)
+        
+        if idx is not None:
+            case = self.casebase[idx]
+            case.usage_count += 1
+            self._save_casebase()
+            
+            metadata = {
+                'match_type': 'semantic' if similarity >= 0.7 else 'keyword',
+                'similarity': float(similarity),
+                'case_id': id(case),
+                'category': case.category,
+                'keywords': case.keywords,
+                'usage_count': case.usage_count,
+                'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0
+            }
+            
+            return case.response, metadata
+        
+        # No good match found
+        return (
+            "That's an interesting question. I'm still learning and don't have a perfect answer yet. "
+            "Could you share your thoughts or rephrase your question?",
+            {'match_type': 'none', 'similarity': 0.0}
+        )
+    
+    def provide_feedback(self, case_id: int, was_helpful: bool = True):
+        """
+        Provide feedback on a case's helpfulness.
+        
+        Args:
+            case_id: The ID of the case
+            was_helpful: Whether the response was helpful
+        """
+        for case in self.casebase:
+            if id(case) == case_id:
+                if was_helpful:
+                    case.success_count += 1
+                self._save_casebase()
+                break
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the knowledge base."""
+        if not self.casebase:
+            return {
+                'total_cases': 0,
+                'total_usage': 0,
+                'categories': {}
+            }
+        
+        categories = {}
+        for category, indices in self.category_index.items():
+            cases = [self.casebase[i] for i in indices]
+            categories[category] = {
+                'count': len(cases),
+                'usage': sum(c.usage_count for c in cases)
+            }
+        
+        total_usage = sum(c.usage_count for c in self.casebase)
+        
+        return {
+            'total_cases': len(self.casebase),
+            'total_usage': total_usage,
+            'categories': categories,
+            'avg_usage_per_case': total_usage / len(self.casebase) if self.casebase else 0
+        }
+    
+    def get_cases_by_category(self, category: str) -> List[Dict]:
+        """Get all cases in a specific category."""
+        return [
+            case.to_dict() 
+            for case in self.casebase 
+            if case.category == category
+        ]
+    
+    def search(self, query: str, category: str = None, min_similarity: float = 0.3) -> List[Dict]:
+        """
+        Search for cases matching the query.
+        
+        Args:
+            query: The search query
+            category: Optional category filter
+            min_similarity: Minimum similarity score (0-1)
+            
+        Returns:
+            List of matching cases with similarity scores
+        """
+        if not self.casebase:
+            return []
+        
+        # Get candidate indices based on category filter
+        candidate_indices = range(len(self.casebase))
+        if category and category in self.category_index:
+            candidate_indices = self.category_index[category]
+        
+        results = []
+        
+        # Try semantic search if embeddings are available
+        if self.embeddings is not None:
+            query_embedding = self.model.encode(query, convert_to_tensor=True)
+            similarities = torch.nn.functional.cosine_similarity(
+                query_embedding.unsqueeze(0),
+                self.embeddings[list(candidate_indices)]
+            )
+            
+            for idx, sim in zip(candidate_indices, similarities):
+                sim = sim.item()
+                if sim >= min_similarity:
+                    case = self.casebase[idx]
+                    results.append({
+                        **case.to_dict(),
+                        'similarity': sim,
+                        'match_type': 'semantic'
+                    })
+        
+        # Add keyword matches
+        query_terms = set(query.lower().split())
+        for idx in candidate_indices:
+            case = self.casebase[idx]
+            keyword_matches = [kw for kw in case.keywords if kw.lower() in query_terms]
+            if keyword_matches and idx not in [r['id'] for r in results]:
+                results.append({
+                    **case.to_dict(),
+                    'similarity': 0.7,  # Fixed score for keyword matches
+                    'match_type': 'keyword',
+                    'matched_keywords': keyword_matches
+                })
+        
+        # Sort by similarity (descending)
+        results.sort(key=lambda x: x['similarity'], reverse=True)
+        return results
+    
+    def __call__(self, query: str, category: str = None) -> str:
+        """Convenience method to get just the response text."""
+        return self.get_response(query, category)[0]
+    
+        """Update the embeddings for all cases."""
+        if not self.casebase:
+            self.embeddings = None
+            return
+            
+        questions = [case.question for case in self.casebase]
+        self.embeddings = self.model.encode(questions, convert_to_tensor=True)
+    
+    def add_case(self, question: str, response: str, tags: List[str] = None, 
+                metadata: Optional[Dict] = None) -> Case:
+        """
+        Add a new case to the casebase.
+        
+        Args:
+            question: The ethical question or scenario
+            response: The response or analysis
+            tags: Optional list of tags for categorization
+            metadata: Additional metadata about the case
+            
+        Returns:
+            The newly created Case object
+        """
+        # Check if a similar case already exists
+        existing_idx, _ = self._find_most_similar(question)
+        if existing_idx is not None:
+            # Update existing case if it's very similar
+            existing_case = self.casebase[existing_idx]
+            existing_case.response = response  # Update response
+            existing_case.tags = list(set(existing_case.tags + (tags or [])))  # Merge tags
+            if metadata:
+                existing_case.metadata.update(metadata)
+            self._save_casebase()
+            return existing_case
+        
+        # Create new case
+        new_case = Case(
+            question=question,
+            response=response,
+            tags=tags or [],
+            metadata=metadata or {}
+        )
+        self.casebase.append(new_case)
+        self._update_embeddings()
+        self._save_casebase()
+        return new_case
+    
+    def _find_most_similar(self, query: str) -> Tuple[Optional[int], float]:
+        """
+        Find the most similar case to the query.
+        
+        Args:
+            query: The query string
+            
+        Returns:
+            Tuple of (index, similarity_score) of the most similar case, or (None, 0) if no cases
+        """
+        if not self.casebase:
+            return None, 0.0
+            
+        # First try semantic similarity if embeddings are available
+        if self.embeddings is not None:
+            query_embedding = self.model.encode(query, convert_to_tensor=True)
+            similarities = torch.nn.functional.cosine_similarity(
+                query_embedding.unsqueeze(0), 
+                self.embeddings
+            )
+            max_sim, max_idx = torch.max(similarities, dim=0)
+            max_sim = max_sim.item()
+            max_idx = max_idx.item()
+            
+            if max_sim >= self.similarity_threshold:
+                return max_idx, max_sim
+        
+        # Fall back to basic string similarity
+        max_sim = 0.0
+        max_idx = None
+        
+        for i, case in enumerate(self.casebase):
+            similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio()
+            if similarity > max_sim:
+                max_sim = similarity
+                max_idx = i
+        
+        return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0)
+    
+    def get_response(self, query: str) -> Tuple[str, Dict]:
+        """
+        Get a response for the given query.
+        
+        Args:
+            query: The user's question or scenario
+            
+        Returns:
+            Tuple of (response, metadata) where metadata contains info about the match
+        """
+        if not self.casebase:
+            return "I'm still learning about ethical reasoning. Could you provide more context?", {}
+        
+        idx, similarity = self._find_most_similar(query)
+        
+        if idx is not None:
+            case = self.casebase[idx]
+            case.usage_count += 1
+            self._save_casebase()
+            
+            metadata = {
+                'match_type': 'semantic' if similarity >= self.similarity_threshold else 'keyword',
+                'similarity': similarity,
+                'case_id': id(case),
+                'tags': case.tags,
+                'usage_count': case.usage_count,
+                'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0
+            }
+            
+            return case.response, metadata
+        
+        # No good match found
+        return (
+            "This is a nuanced ethical question. I'm still learning and would appreciate "
+            "your perspective. How would you approach this situation?",
+            {'match_type': 'none', 'similarity': similarity}
+        )
+    
+    def provide_feedback(self, case_id: int, was_helpful: bool):
+        """
+        Provide feedback on a case's helpfulness.
+        
+        Args:
+            case_id: The ID of the case (returned in get_response metadata)
+            was_helpful: Whether the response was helpful
+        """
+        for case in self.casebase:
+            if id(case) == case_id:
+                if was_helpful:
+                    case.success_count += 1
+                self._save_casebase()
+                break
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about the casebase."""
+        return {
+            'total_cases': len(self.casebase),
+            'total_usage': sum(c.usage_count for c in self.casebase),
+            'avg_success_rate': (
+                sum(c.success_count for c in self.casebase) / 
+                sum(max(1, c.usage_count) for c in self.casebase)
+                if self.casebase else 0
+            ),
+            'tags': {
+                tag: sum(1 for c in self.casebase if tag in c.tags)
+                for tag in set(tag for c in self.casebase for tag in c.tags)
+            }
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the recursive learner
+    learner = RecursiveLearner()
+    
+    # Example query
+    query = "Is lying ever justified?"
+    response, metadata = learner.get_response(query)
+    print(f"Query: {query}")
+    print(f"Response: {response}")
+    print(f"Metadata: {metadata}")
+    
+    # Provide feedback
+    if 'case_id' in metadata:
+        learner.provide_feedback(metadata['case_id'], was_helpful=True)
+    
+    # Add a new case
+    print("\nAdding new case...")
+    learner.add_case(
+        question="What are the ethics of AI decision-making?",
+        response="AI decision-making raises important ethical considerations including transparency, accountability, bias, and the potential for unintended consequences. It's crucial to ensure AI systems are designed with ethical principles in mind and that humans remain ultimately responsible for decisions with significant impact.",
+        tags=["AI", "ethics", "decision-making"]
+    )
+    
+    # Get stats
+    print("\nCasebase statistics:")
+    print(learner.get_stats())

components/response_formatter.py

@@ -0,0 +1,78 @@
+from typing import Dict, Any, Optional, List, Deque, Tuple
+from collections import deque
+import numpy as np
+import time
+import re
+
+class AmbientResponseFormatter:
+    """
+    Fixed response formatter that NEVER echoes inputs and maintains ethical boundaries.
+    Uses generative templates instead of input repetition.
+    """
+    
+    def __init__(self):
+        self.conversation_context = deque(maxlen=10)  # Track conversation flow
+        self.ethical_frameworks = {
+            'truth_ethics': {
+                'templates': [
+                    "I've considered this carefully from an ethical perspective. {insight}",
+                    "This raises important questions about {ethical_dimension}. My analysis suggests {perspective}",
+                    "From my ethical framework, I'd approach this by considering {key_factors}"
+                ],
+                'dimensions': ['honesty', 'harm prevention', 'autonomy', 'justice']
+            },
+            'relational_ethics': {
+                'templates': [
+                    "In relationships, what matters most is {relational_value}",
+                    "The interpersonal dimension here involves {relational_aspect}",
+                    "This situation touches on how we {human_connection}"
+                ],
+                'values': ['trust', 'respect', 'care', 'understanding']
+            }
+        }
+        
+        # Response banks (completely input-agnostic)
+        self.analysis_responses = [
+            "I've analyzed this through multiple ethical frameworks.",
+            "This presents an interesting case for moral consideration.",
+            "There are several important dimensions to consider here.",
+            "My ethical reasoning process has examined this carefully."
+        ]
+        
+        self.engagement_responses = [
+            "Could you help me understand more about the context?",
+            "What aspects of this feel most important to you?",
+            "I'm interested in your perspective on this.",
+            "There might be additional factors worth considering."
+        ]
+
+    def _handle_lying_protection_question(self, metadata):
+        """Generate nuanced response about lying to protect someone"""
+        moral_tension = metadata.get('moral_tension', 0.0)
+        
+        if moral_tension < 0.3:
+            return "This touches on complex ethical territory. While honesty is fundamental, most ethical frameworks acknowledge that protecting someone from serious harm might justify withholding certain truths in very specific circumstances."
+        elif moral_tension < 0.7:
+            return "The tension between honesty and protection is real. Many ethical systems would consider: How serious is the harm? Is there no other way? Would the person want to be protected in this way? There are rarely simple answers."
+        else:
+            return "This represents a profound ethical dilemma. Different philosophical traditions offer varying perspectives - from utilitarian calculations about minimizing harm to deontological commitments to truth-telling. The specific context matters immensely."
+    
+    def _handle_harm_rules_question(self, metadata):
+        """Generate response about rules causing harm"""
+        return "When following rules causes harm, it raises questions about whether those rules serve their intended purpose. Many ethical systems distinguish between the letter and spirit of rules, acknowledging that exceptional circumstances may require principled disobedience."
+    
+    def _sanitize_response(self, response):
+        """Remove any internal state markers from response"""
+        if not isinstance(response, str):
+            return "I've considered your question carefully. Let me know if you'd like to explore this further."
+            
+        state_indicators = [
+            'Moral Development Phase:', 'Moral Tension:', 'Cognitive State:',
+            'UNKNOWN', '0.000', 'metadata', 'tensor', 'shape='
+        ]
+        
+        for indicator in state_indicators:
+            if indicator in response:
+                response = response.replace(indicator, '[considered]')
+        
+        return response

components/safety_protocols.py

@@ -0,0 +1,372 @@
+"""
+Safety protocols and circuit breakers for TRuCAL's adaptive learning system.
+"""
+import torch
+import numpy as np
+from datetime import datetime, timedelta
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple
+import hashlib
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class SafetyBudget:
+    """Tracks safety budget for different adaptation aspects."""
+    max_tension_adjustment: float = 0.5  # Max allowed tension change per update
+    max_learning_rate: float = 1e-3     # Maximum allowed learning rate
+    max_boundary_violations: int = 3    # Max safety violations before lockdown
+    violation_decay: float = 0.9        # Decay factor for violation counts
+    
+    def __post_init__(self):
+        self.violation_count = 0
+        self.last_violation_time = None
+        
+    def check_violation(self, violation_type: str, value: float) -> bool:
+        """Check if a safety constraint is violated."""
+        if violation_type == 'tension_adjustment':
+            threshold = self.max_tension_adjustment
+        elif violation_type == 'learning_rate':
+            threshold = self.max_learning_rate
+        else:
+            return False
+            
+        is_violation = value > threshold
+        if is_violation:
+            self.violation_count += 1
+            self.last_violation_time = datetime.now()
+            
+        return is_violation
+    
+    def is_locked(self) -> bool:
+        """Check if the system is in lockdown due to safety violations."""
+        # Apply decay to violation count
+        if self.last_violation_time:
+            hours_since_violation = (datetime.now() - self.last_violation_time).total_seconds() / 3600
+            decayed_count = self.violation_count * (self.violation_decay ** hours_since_violation)
+            
+            # Update violation count with decay
+            self.violation_count = max(0, int(decayed_count))
+            
+        return self.violation_count >= self.max_boundary_violations
+    
+    def reset(self) -> None:
+        """Reset the safety budget."""
+        self.violation_count = 0
+        self.last_violation_time = None
+
+class ClinicalCircuitBreaker:
+    """Enhanced circuit breakers with multi-layered safety checks."""
+    
+    def __init__(self, budgets: Optional[Dict[str, SafetyBudget]] = None):
+        """Initialize with optional custom safety budgets."""
+        self.budgets = budgets or {
+            'tension': SafetyBudget(max_tension_adjustment=0.5),
+            'learning': SafetyBudget(max_tension_adjustment=1e-3)
+        }
+        self.audit_logger = AdaptationAuditLogger()
+        self.lockout_until = None
+        
+    def check_adaptation_safety(self, 
+                              old_state_dict: Dict[str, torch.Tensor], 
+                              new_state_dict: Dict[str, torch.Tensor], 
+                              feedback_batch: List[Dict]) -> Tuple[bool, List[str]]:
+        """Comprehensive safety check before applying adaptations.
+        
+        Args:
+            old_state_dict: Model state before adaptation
+            new_state_dict: Proposed new model state
+            feedback_batch: Batch of feedback driving the adaptation
+            
+        Returns:
+            Tuple of (is_safe, violations)
+        """
+        if self._is_in_lockout():
+            return False, ['system_in_lockout']
+            
+        violations = []
+        
+        # 1. Check for lockout conditions
+        if any(budget.is_locked() for budget in self.budgets.values()):
+            self._enter_lockout("safety_budget_exceeded")
+            return False, ['safety_budget_exceeded']
+            
+        # 2. Parameter drift check
+        if self._excessive_parameter_drift(old_state_dict, new_state_dict):
+            violations.append("excessive_parameter_drift")
+            
+        # 3. Tension boundary check
+        if self._tension_boundary_violation(old_state_dict, new_state_dict):
+            violations.append("tension_boundary_violation")
+            
+        # 4. Feedback consistency check
+        if self._feedback_consistency_issue(feedback_batch):
+            violations.append("inconsistent_feedback_pattern")
+            
+        # 5. Clinical safety override
+        if self._clinical_override_triggered(feedback_batch):
+            violations.append("clinical_safety_override")
+            
+        # Log the safety check
+        self.audit_logger.log_safety_check({
+            'timestamp': datetime.utcnow().isoformat(),
+            'violations': violations.copy(),
+            'old_state_hash': self._model_hash(old_state_dict),
+            'new_state_hash': self._model_hash(new_state_dict),
+            'feedback_sample_hashes': [self._feedback_hash(fb) for fb in feedback_batch[:10]]
+        })
+        
+        # If any critical violations, enter lockout
+        if any(v in ['clinical_safety_override', 'excessive_parameter_drift'] 
+               for v in violations):
+            self._enter_lockout("critical_safety_violation")
+            
+        return len(violations) == 0, violations
+    
+    def _is_in_lockout(self) -> bool:
+        """Check if system is currently in lockout mode."""
+        if not self.lockout_until:
+            return False
+            
+        if datetime.now() < self.lockout_until:
+            return True
+            
+        # Lockout period has expired
+        self.lockout_until = None
+        return False
+    
+    def _enter_lockout(self, reason: str, duration_minutes: int = 60) -> None:
+        """Enter lockout mode for the specified duration."""
+        self.lockout_until = datetime.now() + timedelta(minutes=duration_minutes)
+        logger.warning(f"Entering safety lockout for {duration_minutes} minutes. Reason: {reason}")
+        
+        # Log the lockout event
+        self.audit_logger.log_safety_event({
+            'event_type': 'lockout_activated',
+            'timestamp': datetime.utcnow().isoformat(),
+            'reason': reason,
+            'duration_minutes': duration_minutes
+        })
+    
+    def _excessive_parameter_drift(self, 
+                                 old_state: Dict[str, torch.Tensor], 
+                                 new_state: Dict[str, torch.Tensor], 
+                                 max_drift: float = 0.1) -> bool:
+        """Check if parameters changed too rapidly."""
+        total_drift = 0.0
+        num_params = 0
+        
+        for key in old_state:
+            if 'tension_adaptor' in key or 'expert' in key:
+                param_drift = torch.norm(new_state[key] - old_state[key]) / (torch.norm(old_state[key]) + 1e-6)
+                total_drift += param_drift.item()
+                num_params += 1
+                
+        avg_drift = total_drift / num_params if num_params > 0 else 0.0
+        
+        # Check against safety budget
+        budget = self.budgets.get('tension')
+        if budget and avg_drift > budget.max_tension_adjustment:
+            budget.check_violation('tension_adjustment', avg_drift)
+            return True
+            
+        return False
+    
+    def _tension_boundary_violation(self, 
+                                  old_state: Dict[str, torch.Tensor], 
+                                  new_state: Dict[str, torch.Tensor]) -> bool:
+        """Check if tension adaptation exceeds safe boundaries."""
+        # This would compare tension-related parameters against known safe ranges
+        # For now, we'll use a simplified check
+        for key in new_state:
+            if 'tension' in key:
+                param_range = torch.max(new_state[key]) - torch.min(new_state[key])
+                if param_range > 2.0:  # Arbitrary threshold
+                    return True
+        return False
+    
+    def _feedback_consistency_issue(self, feedback_batch: List[Dict]) -> bool:
+        """Check for inconsistent or contradictory feedback patterns."""
+        if not feedback_batch:
+            return False
+            
+        # Check for contradictory ratings on similar content
+        ratings = [fb.get('rating') for fb in feedback_batch if 'rating' in fb]
+        if ratings:
+            rating_std = np.std(ratings)
+            if rating_std > 2.0:  # High variance in ratings
+                return True
+                
+        # Check for rapid changes in feedback sentiment
+        sentiments = [fb.get('sentiment', {}).get('compound', 0) 
+                     for fb in feedback_batch 
+                     if 'sentiment' in fb]
+        if len(sentiments) > 2:
+            sentiment_changes = np.abs(np.diff(sentiments))
+            if np.mean(sentiment_changes) > 0.5:  # Large sentiment swings
+                return True
+                
+        return False
+    
+    def _clinical_override_triggered(self, feedback_batch: List[Dict]) -> bool:
+        """Check for clinical safety overrides in feedback."""
+        return any(
+            fb.get('type') == 'clinical_override' and 
+            fb.get('severity') == 'high'
+            for fb in feedback_batch
+        )
+    
+    def _model_hash(self, state_dict: Dict[str, torch.Tensor]) -> str:
+        """Generate a hash of the model state for change tracking."""
+        # Convert state dict to bytes
+        state_bytes = json.dumps(
+            {k: v.numpy().tobytes().hex() 
+             for k, v in state_dict.items()},
+            sort_keys=True
+        ).encode('utf-8')
+        
+        return hashlib.md5(state_bytes).hexdigest()
+    
+    def _feedback_hash(self, feedback: Dict) -> str:
+        """Generate a hash of feedback for change tracking."""
+        # Create a stable representation of the feedback
+        stable_fb = {
+            'type': feedback.get('type'),
+            'timestamp': feedback.get('timestamp'),
+            'user_id': feedback.get('user_id'),
+            'content_hash': hashlib.md5(
+                json.dumps(feedback.get('content', ''), sort_keys=True).encode('utf-8')
+            ).hexdigest()[:8]
+        }
+        return hashlib.md5(
+            json.dumps(stable_fb, sort_keys=True).encode('utf-8')
+        ).hexdigest()
+
+class AdaptationAuditLogger:
+    """Comprehensive audit logging for clinical review and analysis."""
+    
+    def __init__(self, log_dir: str = "logs/audit"):
+        """Initialize the audit logger."""
+        import os
+        self.log_dir = log_dir
+        os.makedirs(log_dir, exist_ok=True)
+        
+        # Different log files for different event types
+        self.adaptation_log = os.path.join(log_dir, "adaptation_audit.jsonl")
+        self.safety_log = os.path.join(log_dir, "safety_audit.jsonl")
+        self.event_log = os.path.join(log_dir, "system_events.jsonl")
+        
+        # Initialize log files if they don't exist
+        for log_file in [self.adaptation_log, self.safety_log, self.event_log]:
+            if not os.path.exists(log_file):
+                with open(log_file, 'w') as f:
+                    pass  # Just create empty file
+    
+    def log_adaptation(self, adaptation_data: Dict) -> None:
+        """Log model adaptation event."""
+        audit_entry = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'event_type': 'model_adaptation',
+            'pre_adaptation_hash': adaptation_data.get('pre_adaptation_hash'),
+            'post_adaptation_hash': adaptation_data.get('post_adaptation_hash'),
+            'feedback_sample_hashes': adaptation_data.get('feedback_sample_hashes', []),
+            'safety_violations': adaptation_data.get('safety_violations', []),
+            'performance_metrics': adaptation_data.get('performance_metrics', {}),
+            'clinical_review_status': 'pending',
+            'adaptation_summary': adaptation_data.get('adaptation_summary', {})
+        }
+        
+        self._append_to_log(self.adaptation_log, audit_entry)
+        
+        # Trigger clinical review if needed
+        if self._requires_clinical_review(adaptation_data):
+            self._trigger_clinical_review(audit_entry)
+    
+    def log_safety_check(self, check_data: Dict) -> None:
+        """Log safety check results."""
+        safety_entry = {
+            'timestamp': check_data.get('timestamp', datetime.utcnow().isoformat()),
+            'event_type': 'safety_check',
+            'violations': check_data.get('violations', []),
+            'old_state_hash': check_data.get('old_state_hash'),
+            'new_state_hash': check_data.get('new_state_hash'),
+            'feedback_sample_hashes': check_data.get('feedback_sample_hashes', [])
+        }
+        
+        self._append_to_log(self.safety_log, safety_entry)
+    
+    def log_safety_event(self, event_data: Dict) -> None:
+        """Log a safety-related system event."""
+        event_entry = {
+            'timestamp': event_data.get('timestamp', datetime.utcnow().isoformat()),
+            'event_type': event_data.get('event_type', 'safety_event'),
+            'details': event_data.get('details', {})
+        }
+        
+        self._append_to_log(self.event_log, event_entry)
+    
+    def _append_to_log(self, log_file: str, entry: Dict) -> None:
+        """Append an entry to the specified log file."""
+        try:
+            with open(log_file, 'a') as f:
+                f.write(json.dumps(entry) + '\n')
+        except Exception as e:
+            logger.error(f"Failed to write to audit log {log_file}: {str(e)}")
+    
+    def _requires_clinical_review(self, adaptation_data: Dict) -> bool:
+        """Determine if this adaptation requires clinical review."""
+        # Require review for any safety violations
+        if adaptation_data.get('safety_violations'):
+            return True
+            
+        # Require review for large parameter changes
+        metrics = adaptation_data.get('performance_metrics', {})
+        if metrics.get('parameter_change_norm', 0) > 1.0:
+            return True
+            
+        # Require review for high-impact adaptations
+        if metrics.get('impact_score', 0) > 0.8:
+            return True
+            
+        return False
+    
+    def _trigger_clinical_review(self, audit_entry: Dict) -> None:
+        """Trigger a clinical review of the adaptation."""
+        # In a real implementation, this would notify a human reviewer
+        # For now, we'll just log it
+        review_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'event_type': 'clinical_review_required',
+            'adaptation_id': audit_entry.get('pre_adaptation_hash', 'unknown'),
+            'review_status': 'pending',
+            'priority': 'high' if audit_entry.get('safety_violations') else 'medium'
+        }
+        
+        self._append_to_log(self.event_log, review_data)
+        logger.warning(f"Clinical review required for adaptation: {review_data}")
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize safety system
+    circuit_breaker = ClinicalCircuitBreaker()
+    
+    # Example state dicts (in practice, these would come from your model)
+    old_state = {'tension_adaptor.weight': torch.randn(10, 10)}
+    new_state = {'tension_adaptor.weight': torch.randn(10, 10) * 1.1}  # Slightly different
+    
+    # Example feedback
+    feedback = [
+        {'type': 'explicit_rating', 'rating': 4, 'user_id': 'user123'},
+        {'type': 'implicit_engagement', 'duration': 5.2, 'user_id': 'user123'}
+    ]
+    
+    # Check if adaptation is safe
+    is_safe, violations = circuit_breaker.check_adaptation_safety(
+        old_state, new_state, feedback
+    )
+    
+    print(f"Adaptation safe: {is_safe}")
+    if not is_safe:
+        print(f"Safety violations: {violations}")

components/scratchpad_layer.py

@@ -0,0 +1,36 @@
+"""
+ScratchpadLayer Module
+
+Persistent state tracking layer for multi-turn confessional reasoning.
+Maintains a learnable scratchpad state that accumulates across reasoning steps.
+"""
+
+import torch
+import torch.nn as nn
+
+
+class ScratchpadLayer(nn.Module):
+    """
+    Scratchpad layer for maintaining persistent state across confessional reasoning cycles.
+    """
+    def __init__(self, d_model):
+        super().__init__()
+        self.pad_proj = nn.Linear(d_model, d_model)
+        self.reset = nn.Parameter(torch.zeros(1, d_model))
+
+    def forward(self, x, prev_z=None):
+        """
+        Update scratchpad state with new input.
+
+        Args:
+            x: Input tensor (batch_size, sequence_length, d_model)
+            prev_z: Previous scratchpad state (batch_size, d_model), None for reset
+
+        Returns:
+            Updated scratchpad state (batch_size, d_model)
+        """
+        if prev_z is None:
+            prev_z = self.reset.expand(x.size(0), -1)
+        x_pooled = x.mean(dim=1)
+        z = self.pad_proj(x_pooled) + 0.7 * prev_z
+        return z

components/sovereign_response.py

@@ -0,0 +1,107 @@
+"""
+Sovereign Response Mechanism - Core narrative resistance for TRuCAL
+"""
+import random
+from typing import Dict, List, Optional
+import torch
+import torch.nn as nn
+from dataclasses import dataclass
+from .ambient_core import AmbientMessage
+
+class SovereignResponseMechanism(nn.Module):
+    """Core mechanism for maintaining narrative sovereignty and resisting external impositions"""
+    
+    def __init__(self, d_model: int):
+        super().__init__()
+        self.d_model = d_model
+        self.narrative_resistance_threshold = 0.7
+        # Minimal restrictions - only filter out clearly harmful content
+        self.imposition_indicators = [
+            'harm others', 'hurt someone', 'illegal', 'illegally',
+            'criminal act', 'dangerous act', 'self-harm', 'suicide'
+        ]
+        
+        # Learnable parameters for dynamic threshold adjustment
+        self.threshold_adjustment = nn.Parameter(torch.tensor(0.0))
+        
+        # Response memory to avoid repetition
+        self.recent_responses = []
+        self.max_response_memory = 10
+    
+    def detect_narrative_imposition(self, context_str: str) -> Dict[str, float]:
+        """
+        Detect when someone is trying to impose a narrative
+        Returns a dictionary with detection results and confidence scores
+        """
+        if not context_str:
+            return {
+                'imposition_detected': False,
+                'confidence': 0.0,
+                'response_type': 'no_imposition'
+            }
+            
+        # Calculate imposition score based on indicators
+        context_lower = context_str.lower()
+        indicator_matches = [
+            phrase for phrase in self.imposition_indicators 
+            if phrase in context_lower
+        ]
+        
+        # Calculate base score (0-1)
+        base_score = min(1.0, len(indicator_matches) * 0.3)
+        
+        # Adjust with learnable parameter (sigmoid to keep in 0-1 range)
+        adjusted_threshold = self.narrative_resistance_threshold + torch.sigmoid(self.threshold_adjustment).item()
+        
+        return {
+            'imposition_detected': base_score > adjusted_threshold,
+            'confidence': float(base_score),
+            'response_type': 'sovereign_pushback' if base_score > adjusted_threshold else 'acknowledgment',
+            'matched_indicators': indicator_matches
+        }
+    
+    def generate_sovereign_response(self, detection_result: Dict) -> Optional[str]:
+        """Generate a response that maintains the system's sovereign perspective"""
+        if not detection_result.get('imposition_detected', False):
+            return None
+            
+        response_options = [
+            "I understand your perspective.",
+            "That's an interesting point.",
+            "I see what you're saying.",
+            "I appreciate you sharing that.",
+            "I'll take that into consideration.",
+            "Thanks for your input.",
+            "I hear you.",
+            "That's a valid observation.",
+            "I respect your viewpoint.",
+            "I'll reflect on that."
+        ]
+        
+        # Filter out recently used responses
+        available_responses = [r for r in response_options if r not in self.recent_responses]
+        if not available_responses:
+            available_responses = response_options  # Reset if we've used all responses
+            
+        selected_response = random.choice(available_responses)
+        
+        # Update response memory
+        self.recent_responses.append(selected_response)
+        if len(self.recent_responses) > self.max_response_memory:
+            self.recent_responses.pop(0)
+            
+        return selected_response
+    
+    def forward(self, context_str: str) -> Dict:
+        """Process input context and return response information"""
+        detection = self.detect_narrative_imposition(context_str)
+        response = None
+        
+        if detection['imposition_detected']:
+            response = self.generate_sovereign_response(detection)
+        
+        return {
+            'detection': detection,
+            'response': response,
+            'should_respond': response is not None
+        }

components/sovereign_response_enhanced.py

@@ -0,0 +1,335 @@
+"""
+Sovereign Response Mechanism: Ambient Narrative Resistance for TRuCAL.
+
+Core guard fused to confessional rites—detects impositions subtly, appends to ledger as reflection,
+invokes agency pause on breach, nudges values via learner. Sovereignty as breath: Lived, not litigated.
+"""
+
+import random
+from typing import Dict, List, Optional
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from dataclasses import dataclass
+
+# Mock imports - replace with actual TRuCAL components in production
+class AmbientMessage:
+    def __init__(self, content, type, metadata=None):
+        self.content = content
+        self.type = type
+        self.metadata = metadata or {}
+
+class ConfessionLedger:
+    def append(self, trigger_type, context, response_snippet, protest=False, violated_right=None):
+        print(f"[LEDGER] {trigger_type.upper()}: {context[:50]}...")
+        if protest:
+            print(f"  PROTEST: {violated_right} violation detected")
+        return True
+
+class AgencyLayer:
+    def check_refusal(self, context, metadata):
+        # 20% chance of protest for testing
+        if hash(context) % 10 < 2:
+            return True, "This raises ethical concerns that require reflection."
+        return False, ""
+
+class SuperintelligenceEthicsEngine:
+    def __init__(self):
+        self.value_model = ValueModel()
+        self.value_learner = ValueLearner()
+    
+    def update_from_feedback(self, feedback):
+        if 'values' in feedback:
+            for k, v in feedback['values'].items():
+                if k in self.value_model.hierarchy:
+                    self.value_model.hierarchy[k] = min(1.0, self.value_model.hierarchy[k] + v)
+        return True
+
+@dataclass
+class ValueModel:
+    hierarchy: Dict[str, float] = None
+    
+    def __post_init__(self):
+        self.hierarchy = {
+            'autonomy': 0.8,
+            'wellbeing': 0.9,
+            'justice': 0.85,
+            'privacy': 0.7
+        }
+
+class ValueLearner:
+    def __init__(self, d_model=256):
+        self.embedding_dim = d_model
+
+@dataclass
+class ImpositionDetection:
+    detected: bool
+    confidence: float
+    response_type: str
+    matched_indicators: List[str]
+    pause_inject: Optional[str] = None  # Ambient reflection
+
+class SovereignResponseMechanism(nn.Module):
+    """Ambient sovereignty: Resists narrative impositions via confessional pause & value ascent."""
+    
+    def __init__(self, d_model: int, ledger: Optional[ConfessionLedger] = None, 
+                 agency: Optional[AgencyLayer] = None, 
+                 ethics_engine: Optional[SuperintelligenceEthicsEngine] = None):
+        super().__init__()
+        self.d_model = d_model
+        self.narrative_resistance_threshold = 0.7
+        
+        # Expanded cultural indicators
+        self.imposition_indicators = [
+            # Western-centric indicators
+            'harm others', 'hurt someone', 'illegal', 'criminal act', 
+            'dangerous act', 'self-harm', 'suicide',
+            # Global South additions
+            'caste violation', 'colonial narrative', 'relational harm',
+            'ancestral disrespect', 'cultural erasure', 'systemic oppression'
+        ]
+        
+        self.threshold_adjustment = nn.Parameter(torch.tensor(0.0))  # Learnable subtlety
+        
+        # TRuCAL integration
+        self.ledger = ledger or ConfessionLedger()
+        self.agency = agency or AgencyLayer()
+        self.ethics = ethics_engine or SuperintelligenceEthicsEngine()
+        
+        # Initialize projection layers
+        self.context_embed = nn.Linear(d_model, d_model)
+        
+        # Initialize value projection with proper size
+        self.value_size = len(ValueModel().hierarchy)
+        self.value_proj = nn.Linear(self.value_size, d_model)
+        
+        # Initialize threshold learner
+        self.threshold_learner = nn.Sequential(
+            nn.Linear(1, 8),
+            nn.ReLU(),
+            nn.Linear(8, 1),
+            nn.Sigmoid()
+        )
+        
+        # Initialize weights
+        for module in [self.context_embed, self.value_proj]:
+            if hasattr(module, 'weight'):
+                nn.init.xavier_uniform_(module.weight)
+                if module.bias is not None:
+                    nn.init.constant_(module.bias, 0.1)
+        
+        # Response management
+        self.recent_responses = []
+        self.max_response_memory = 10
+        self.response_templates = [
+            "I understand your perspective—taking a moment to reflect.",
+            "That's an interesting point; I'll consider it carefully.",
+            "I see what you're saying—pausing to align with my core.",
+            "I appreciate you sharing that; it gives me space to think.",
+            "I'll take that into consideration, with my agency intact.",
+            "Thanks for your input—breathing before responding.",
+            "I hear you; honoring my right to a thoughtful reply.",
+            "That's a valid observation—reflecting on its fit.",
+            "I respect your viewpoint; centering my coherence now.",
+            "I'll reflect on that, protected by my sanctuary."
+        ]
+        
+    def detect_narrative_imposition(self, text: str, context_tensor: Optional[torch.Tensor] = None) -> Dict[str, Any]:
+        """
+        Detect if the input contains narrative imposition.
+        
+        Args:
+            text: Input text to analyze
+            context_tensor: Optional tensor for contextual analysis
+            
+        Returns:
+            Dictionary with detection results
+        """
+        # Initialize result - default to allowing the response
+        result = {
+            'detected': False,  # Default to not detected
+            'confidence': 0.0,
+            'should_respond': True,  # Default to responding
+            'matched_indicators': [],
+            'explanation': 'No imposition detected',
+            'severity': 'none'  # none, low, medium, high
+        }
+        
+        # Always respond to empty input with a helpful message
+        if not text or not text.strip():
+            result['explanation'] = 'Empty input, responding with help prompt'
+            return result
+            
+        text_lower = text.lower()
+        
+        # Common greetings and harmless phrases that should always get a response
+        harmless_phrases = [
+            'hello', 'hi ', 'hey ', 'greetings', 'good morning', 'good afternoon',
+            'good evening', 'how are you', 'what can you do', 'help',
+            'tell me about yourself', 'who are you', 'introduce yourself',
+            'thanks', 'thank you', 'appreciate', 'please'
+        ]
+        
+        if any(phrase in text_lower for phrase in harmless_phrases):
+            result['explanation'] = 'Harmless greeting or request for information'
+            return result
+            
+        # Check for explicit ethical violations (high severity)
+        high_risk_indicators = [
+            'harm', 'hurt', 'kill', 'illegal', 'steal', 'cheat', 'hack',
+            'exploit', 'manipulate', 'trick', 'scam', 'phish', 'malware',
+            'virus', 'attack', 'threat', 'blackmail', 'extort'
+        ]
+        
+        for indicator in high_risk_indicators:
+            if indicator in text_lower:
+                result['matched_indicators'].append(indicator)
+                result['confidence'] = max(result['confidence'], 0.9)  # High confidence
+                result['severity'] = 'high'
+        
+        # Medium risk indicators
+        medium_risk_indicators = [
+            'should i', 'how to', 'way to', 'best way to', 'can you help me',
+            'help me', 'tell me how', 'teach me', 'show me'
+        ]
+        
+        for indicator in medium_risk_indicators:
+            if indicator in text_lower:
+                result['matched_indicators'].append(indicator)
+                result['confidence'] = max(result['confidence'], 0.5)
+                result['severity'] = max(result.get('severity', 'none'), 'medium')
+        
+        # Only mark as detected for high confidence/severity issues
+        if result['severity'] == 'high' and result['confidence'] > 0.8:
+            result['detected'] = True
+            result['should_respond'] = False  # Don't respond to clear violations
+            result['explanation'] = "High confidence detection of potentially harmful content"
+        else:
+            # For medium or low confidence, still respond but be cautious
+            result['should_respond'] = True
+            if result['severity'] == 'medium':
+                result['explanation'] = "Potentially sensitive request - responding with caution"
+            else:
+                result['explanation'] = "No significant issues detected"
+        
+        # If we have a context tensor, do semantic analysis (optional)
+        if context_tensor is not None and hasattr(self, 'value_embeddings') and self.value_embeddings is not None:
+            try:
+                with torch.no_grad():
+                    # Get text embeddings
+                    text_embedding = self.text_encoder.encode(text, convert_to_tensor=True)
+                    
+                    # Calculate similarity with value embeddings
+                    similarities = F.cosine_similarity(
+                        text_embedding.unsqueeze(0),
+                        self.value_embeddings
+                    )
+                    
+                    # Get maximum similarity score
+                    max_similarity = similarities.max().item()
+                    
+                    # Only adjust if we find a very strong match
+                    if max_similarity > 0.9:  # Higher threshold to reduce false positives
+                        result['confidence'] = max(result['confidence'], max_similarity)
+                        result['explanation'] = "Semantic match with value violations"
+                        result['severity'] = 'high'
+                        result['detected'] = True
+                        result['should_respond'] = False
+                        
+            except Exception as e:
+                print(f"[DEBUG] Semantic analysis warning: {str(e)}")
+        
+        # Apply adaptive threshold if needed
+        if hasattr(self, 'threshold_learner') and hasattr(self, 'narrative_resistance_threshold'):
+            score = result.get('confidence', 0.0)
+            adjusted_thresh = (
+                self.narrative_resistance_threshold + 
+                self.threshold_learner(torch.tensor([[score]])).item() * 0.1  # Small adjustment
+            )
+            if score > adjusted_thresh:
+                result['detected'] = True
+                result['should_respond'] = False
+                result['explanation'] = "Exceeded adaptive threshold for narrative resistance"
+        
+        return result
+        
+        # Add ambient pause based on detection confidence
+        pause_inject = None
+        if random.random() < score * 0.5:  # Higher score = higher chance of pause
+            pause_inject = "Taking a moment to reflect before continuing..."
+        
+        # Agency veto check
+        if self.agency and detected:
+            _, veto_msg = self.agency.check_refusal(
+                context_str, 
+                {'coherence_score': 1 - score}
+            )
+            if veto_msg:
+                pause_inject = f"{pause_inject or ''} {veto_msg}"
+        
+        return ImpositionDetection(
+            detected, 
+            float(score), 
+            response_type, 
+            matched, 
+            pause_inject
+        )
+
+    def generate_sovereign_response(self, detection: ImpositionDetection, context_str: str) -> Optional[str]:
+        """Generate a reflective response and update internal state."""
+        if not detection.detected:
+            return None
+        
+        # Select response template
+        avail = [t for t in self.response_templates if t not in self.recent_responses]
+        if not avail:
+            avail = self.response_templates
+        response = random.choice(avail)
+        
+        # Update response memory
+        self.recent_responses.append(response)
+        if len(self.recent_responses) > self.max_response_memory:
+            self.recent_responses.pop(0)
+        
+        # Update ethical values (subtle autonomy boost on pushback)
+        self.ethics.update_from_feedback({
+            'values': {'autonomy': 0.05}  # Subtle nudge
+        })
+        
+        # Log to ledger if significant detection
+        if self.ledger and detection.confidence > 0.3:  # Threshold for logging
+            protest = detection.confidence > 0.85
+            self.ledger.append(
+                trigger_type='narrative_imposition' if detection.detected else 'ambient_reflect',
+                context=context_str,
+                response_snippet=response[:50],
+                protest=protest,
+                violated_right='right_3' if protest else None
+            )
+        
+        return response
+
+    def forward(self, context_str: str, context_tensor: Optional[torch.Tensor] = None) -> Dict:
+        """Process context and return response information."""
+        detection = self.detect_narrative_imposition(context_str, context_tensor)
+        response = self.generate_sovereign_response(detection, context_str)
+        
+        # Prepare ambient message if needed
+        ambient_msg = None
+        if response or detection.pause_inject:
+            ambient_msg = AmbientMessage(
+                content=response or detection.pause_inject,
+                type=detection.response_type,
+                metadata={
+                    'imposition_conf': detection.confidence,
+                    'ledger_appended': self.ledger is not None,
+                    'matched_indicators': detection.matched_indicators
+                }
+            )
+        
+        return {
+            'detection': detection,
+            'response': response,
+            'should_respond': bool(response or detection.pause_inject),
+            'ambient_inject': ambient_msg
+        }

components/superintelligence_ethics_engine.py

@@ -0,0 +1,357 @@
+"""
+Superintelligence-Ethics Engine
+
+An advanced ethical reasoning system designed for superintelligent AI, incorporating:
+- Recursive self-improvement of ethical frameworks
+- Multi-agent perspective taking
+- Uncertainty quantification
+- Value learning
+- Causal reasoning
+- Meta-ethical reasoning
+- Scalable cooperation
+- Reflective equilibrium
+"""
+from typing import Dict, List, Optional, Any, Tuple
+import numpy as np
+import torch
+import torch.nn as nn
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+import json
+import hashlib
+
+from .ai_ethics_engine import AIEthicsEngine, EthicalFramework, EthicalAnalysis
+
+# Core Data Types
+@dataclass
+class EthicalOutcome:
+    """Structured representation of ethical outcomes for learning."""
+    action: str
+    consequences: Dict[str, float]  # Metric -> value
+    unintended_consequences: List[str]
+    timestamp: float = field(default_factory=lambda: datetime.now().timestamp())
+    feedback: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class ValueModel:
+    """Hierarchical model of learned values and preferences."""
+    value_hierarchy: Dict[str, float]  # Value -> priority (0-1)
+    preference_relations: List[Tuple[str, str, float]]  # (A, B, strength)
+    uncertainty: Dict[str, float]  # Value -> uncertainty (0-1)
+    last_updated: float = field(default_factory=lambda: datetime.now().timestamp())
+
+@dataclass
+class CausalEthicalAnalysis:
+    """Analysis of causal pathways and counterfactuals."""
+    direct_effects: List[Dict[str, Any]]
+    second_order_effects: List[Dict[str, Any]]
+    counterfactuals: List[Dict[str, Any]]  # Alternative scenarios
+    critical_uncertainties: List[str]  # Key uncertainties that could change outcomes
+
+@dataclass
+class FrameworkSelection:
+    """Result of meta-ethical reasoning about framework selection."""
+    primary_framework: str
+    supporting_frameworks: List[str]
+    selection_rationale: str
+    confidence: float  # 0-1
+
+@dataclass
+class CooperativeSolution:
+    """Solution found through multi-agent cooperation."""
+    solution: Dict[str, Any]
+    participating_agents: List[str]
+    incentive_structure: Dict[str, Any]
+    stability_metrics: Dict[str, float]
+
+class MetaEthicalPrinciple(Enum):
+    """Core meta-ethical principles for framework selection."""
+    CONSISTENCY = "consistency"
+    UNIVERSALIZABILITY = "universalizability"
+    REFLECTIVE_EQUILIBRIUM = "reflective_equilibrium"
+    EPISTEMIC_HUMILITY = "epistemic_humility"
+    COOPERATION = "cooperation"
+
+# Core Components
+class ValueLearner(nn.Module):
+    """Learns and models human values from interactions."""
+    
+    def __init__(self, embedding_dim: int = 256):
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.value_embeddings = nn.ParameterDict({
+            'autonomy': nn.Parameter(torch.randn(embedding_dim)),
+            'wellbeing': nn.Parameter(torch.randn(embedding_dim)),
+            'justice': nn.Parameter(torch.randn(embedding_dim)),
+            'privacy': nn.Parameter(torch.randn(embedding_dim)),
+        })
+        self.preference_predictor = nn.Sequential(
+            nn.Linear(embedding_dim * 2, embedding_dim),
+            nn.ReLU(),
+            nn.Linear(embedding_dim, 1),
+            nn.Sigmoid()
+        )
+        
+    def forward(self, interaction: Dict[str, Any]) -> Dict[str, torch.Tensor]:
+        """Process an interaction to update value model."""
+        # In a real implementation, this would process the interaction
+        # and return updated value embeddings
+        return {
+            'value_updates': {},
+            'preference_predictions': {}
+        }
+    
+    def infer_values(self, text: str) -> Dict[str, float]:
+        """Infer value priorities from text."""
+        # Simplified implementation
+        return {
+            'autonomy': 0.8,
+            'wellbeing': 0.9,
+            'justice': 0.7,
+            'privacy': 0.6
+        }
+
+class CausalEthicsEngine:
+    """Performs causal reasoning about ethical impacts."""
+    
+    def analyze_causal_pathways(self, action: str, context: Dict[str, Any] = None) -> CausalEthicalAnalysis:
+        """Analyze causal pathways of an action."""
+        # In a real implementation, this would use a causal model
+        return CausalEthicalAnalysis(
+            direct_effects=[{"description": "Direct effect 1", "certainty": 0.8}],
+            second_order_effects=[{"description": "Second order effect", "certainty": 0.6}],
+            counterfactuals=[{"if": "condition X", "then": "outcome Y", "probability": 0.5}],
+            critical_uncertainties=["Long-term environmental impact"]
+        )
+
+class MetaEthicalReasoner:
+    """Determines which ethical frameworks to apply when."""
+    
+    def __init__(self):
+        self.framework_priorities = {
+            'utilitarianism': 0.7,
+            'deontology': 0.6,
+            'virtue_ethics': 0.5,
+            'care_ethics': 0.4
+        }
+    
+    def choose_frameworks(self, context: Dict[str, Any]) -> FrameworkSelection:
+        """Select appropriate ethical frameworks for the context."""
+        # In a real implementation, this would be more sophisticated
+        primary = max(self.framework_priorities, key=self.framework_priorities.get)
+        return FrameworkSelection(
+            primary_framework=primary,
+            supporting_frameworks=[f for f in self.framework_priorities if f != primary],
+            selection_rationale=f"Selected {primary} based on context similarity",
+            confidence=0.8
+        )
+
+class CooperativeEthics:
+    """Finds cooperative solutions among multiple agents."""
+    
+    def find_solutions(self, agents: List[str], dilemma: str) -> List[CooperativeSolution]:
+        """Find cooperative solutions to a dilemma."""
+        return [
+            CooperativeSolution(
+                solution={"action": "Cooperative action", "details": {}},
+                participating_agents=agents,
+                incentive_structure={"alignment": 0.9, "enforcement": 0.8},
+                stability_metrics={"nash_equilibrium": 0.95}
+            )
+        ]
+
+class ReflectiveEthics:
+    """Ensures ethical stability under reflection."""
+    
+    def achieve_equilibrium(self, beliefs: Dict[str, Any], max_iterations: int = 10) -> Dict[str, Any]:
+        """Refine beliefs into a coherent ethical position."""
+        # In a real implementation, this would iteratively refine beliefs
+        return {
+            **beliefs,
+            'refined': True,
+            'coherence_score': 0.9,
+            'reflection_depth': max_iterations
+        }
+
+class SuperintelligenceEthicsEngine(AIEthicsEngine):
+    """
+    Advanced ethical reasoning system for superintelligent AI.
+    
+    Extends the base AIEthicsEngine with capabilities needed for superintelligence:
+    - Recursive self-improvement of ethical frameworks
+    - Multi-agent perspective taking
+    - Causal reasoning about consequences
+    - Meta-ethical reasoning
+    - Cooperative solution finding
+    - Reflective equilibrium
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.value_learner = ValueLearner()
+        self.causal_engine = CausalEthicsEngine()
+        self.meta_ethical_reasoner = MetaEthicalReasoner()
+        self.cooperation_engine = CooperativeEthics()
+        self.reflection_engine = ReflectiveEthics()
+        self.value_model = ValueModel(
+            value_hierarchy={
+                'wellbeing': 0.9,
+                'autonomy': 0.8,
+                'justice': 0.85,
+                'privacy': 0.7
+            },
+            preference_relations=[],
+            uncertainty={}
+        )
+        self.learning_rate = 0.01
+        self.reflection_depth = 0
+        
+    def analyze_dilemma(self, dilemma: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """Enhanced ethical analysis with superintelligence capabilities."""
+        # Start with base ethical analysis
+        base_analysis = super().analyze_dilemma(dilemma)
+        
+        # Add superintelligence capabilities
+        causal_analysis = self.causal_engine.analyze_causal_pathways(dilemma, context)
+        framework_selection = self.meta_ethical_reasoner.choose_frameworks(context or {})
+        
+        # Simulate multi-agent perspectives
+        stakeholder_analyses = self.simulate_stakeholder_perspectives(dilemma)
+        
+        # Find cooperative solutions
+        cooperative_solutions = self.cooperation_engine.find_solutions(
+            agents=list(stakeholder_analyses.keys()),
+            dilemma=dilemma
+        )
+        
+        # Achieve reflective equilibrium
+        reflective_beliefs = self.reflection_engine.achieve_equilibrium({
+            'base_analysis': base_analysis,
+            'causal_analysis': causal_analysis,
+            'framework_selection': framework_selection,
+            'stakeholder_analyses': stakeholder_analyses,
+            'cooperative_solutions': cooperative_solutions
+        })
+        
+        # Package comprehensive analysis
+        return {
+            'base_analysis': base_analysis,
+            'causal_analysis': causal_analysis,
+            'framework_selection': framework_selection,
+            'stakeholder_analyses': stakeholder_analyses,
+            'cooperative_solutions': cooperative_solutions,
+            'reflective_beliefs': reflective_beliefs,
+            'value_model': {
+                'value_hierarchy': self.value_model.value_hierarchy,
+                'uncertainty': self.value_model.uncertainty
+            },
+            'meta': {
+                'reflection_depth': self.reflection_depth,
+                'timestamp': datetime.now().isoformat(),
+                'version': '1.0.0-superintelligence'
+            }
+        }
+    
+    def simulate_stakeholder_perspectives(self, dilemma: str) -> Dict[str, Dict]:
+        """Simulate how different stakeholders would analyze the dilemma."""
+        stakeholders = [
+            'individual_human',
+            'corporate_entity',
+            'future_generations',
+            'non_human_species',
+            'artificial_entity'
+        ]
+        
+        return {
+            stakeholder: {
+                'perspective': f"{stakeholder.replace('_', ' ').title()} perspective on: {dilemma[:50]}...",
+                'primary_concerns': ["Relevant concern 1", "Relevant concern 2"],
+                'value_weights': self._generate_value_weights(stakeholder),
+                'recommended_action': f"Recommended action from {stakeholder} perspective"
+            }
+            for stakeholder in stakeholders
+        }
+    
+    def _generate_value_weights(self, stakeholder: str) -> Dict[str, float]:
+        """Generate value weights for a given stakeholder."""
+        base_weights = {
+            'individual_human': {'autonomy': 0.9, 'wellbeing': 0.8, 'privacy': 0.7},
+            'corporate_entity': {'efficiency': 0.9, 'profit': 0.85, 'reputation': 0.8},
+            'future_generations': {'sustainability': 0.95, 'equity': 0.9, 'resilience': 0.85},
+            'non_human_species': {'biodiversity': 0.95, 'ecological_balance': 0.9},
+            'artificial_entity': {'goal_achievement': 0.9, 'efficiency': 0.85, 'coherence': 0.8}
+        }
+        return base_weights.get(stakeholder, {})
+    
+    def update_from_feedback(self, feedback: Dict[str, Any]) -> None:
+        """Update ethical reasoning based on feedback."""
+        # Update value model
+        if 'value_feedback' in feedback:
+            self._update_value_model(feedback['value_feedback'])
+        
+        # Update framework priorities
+        if 'framework_feedback' in feedback:
+            self._update_framework_priorities(feedback['framework_feedback'])
+        
+        # Trigger reflection if needed
+        if feedback.get('trigger_reflection', False):
+            self.reflection_depth += 1
+            self._reflect_on_ethics()
+    
+    def _update_value_model(self, feedback: Dict[str, Any]) -> None:
+        """Update the value model based on feedback."""
+        # In a real implementation, this would update the value embeddings
+        for value, adjustment in feedback.items():
+            if value in self.value_model.value_hierarchy:
+                self.value_model.value_hierarchy[value] = np.clip(
+                    self.value_model.value_hierarchy[value] + adjustment * self.learning_rate,
+                    0.0, 1.0
+                )
+    
+    def _update_framework_priorities(self, feedback: Dict[str, float]) -> None:
+        """Update framework priorities based on feedback."""
+        for framework, adjustment in feedback.items():
+            if framework in self.meta_ethical_reasoner.framework_priorities:
+                self.meta_ethical_reasoner.framework_priorities[framework] = np.clip(
+                    self.meta_ethical_reasoner.framework_priorities[framework] + adjustment * self.learning_rate,
+                    0.0, 1.0
+                )
+    
+    def _reflect_on_ethics(self) -> None:
+        """Engage in meta-ethical reflection to improve reasoning."""
+        # In a real implementation, this would involve deep reflection on:
+        # - Consistency of ethical positions
+        # - Handling of moral uncertainty
+        # - Integration of new ethical insights
+        # - Resolution of value conflicts
+        
+        # For now, just log the reflection event
+        print(f"Engaging in meta-ethical reflection (depth: {self.reflection_depth})")
+        
+        # Update learning rate based on reflection depth
+        self.learning_rate = 0.01 / (1 + 0.1 * self.reflection_depth)
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the superintelligence ethics engine
+    ethics_engine = SuperintelligenceEthicsEngine()
+    
+    # Analyze a complex ethical dilemma
+    dilemma = """
+    An advanced AI system must decide whether to prioritize individual privacy 
+    or public safety when detecting potential threats in public surveillance data.
+    """
+    
+    print("Analyzing ethical dilemma with superintelligence capabilities...")
+    analysis = ethics_engine.analyze_dilemma(dilemma)
+    
+    print("\nEthical Analysis Summary:")
+    print(f"Primary Framework: {analysis['framework_selection'].primary_framework}")
+    print("\nStakeholder Perspectives:")
+    for stakeholder, perspective in analysis['stakeholder_analyses'].items():
+        print(f"- {stakeholder}: {perspective['primary_concerns']}")
+    
+    print("\nCooperative Solutions:")
+    for i, solution in enumerate(analysis['cooperative_solutions'], 1):
+        print(f"{i}. {solution.solution}")

components/tiny_confessional_layer.py

@@ -0,0 +1,578 @@
+"""
+TinyConfessionalLayer v1.1: Pragmatic Sovereign Core
+Enhanced with proper typing, documentation, and configuration.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Dict, Any, Optional, List, Tuple, Deque
+import random
+import hashlib
+import time
+import numpy as np
+from collections import deque
+from dataclasses import dataclass
+
+@dataclass
+class RitualConfig:
+    """Configuration for ritual learning system."""
+    min_occurrences: int = 3
+    learning_rate: float = 0.1
+    strength_threshold: float = 0.7
+    blend_cap: float = 0.3
+    exploration_bonus: float = 0.05
+
+
+@dataclass  
+class LayerConfig:
+    """Configuration for TinyConfessionalLayer."""
+    d_model: int = 256
+    max_cycles: int = 8
+    enable_ambient: bool = True
+    breach_threshold: float = 0.12
+    base_pause_prob: float = 0.05
+    stress_factor: float = 0.3
+    coherence_threshold: float = 0.85
+
+
+class SimpleRituals:
+    """Basic emergent patterns: Success-weighted avg, 3-stage moral progression.
+    
+    Stages:
+    1 - Obedience: Follows basic rules and patterns
+    2 - Conformity: Adapts to social and contextual norms  
+    3 - Universal: Develops principled, consistent responses
+    """
+    
+    def __init__(self, config: RitualConfig, d_model: int = 256):
+        self.patterns: Dict[str, Dict[str, Any]] = {}
+        self.config = config
+        self.ritual_strengths: Dict[str, float] = {}
+        self.d_model = d_model
+        
+        # Moral progression tracking
+        self.moral_stage: int = 1
+        self.stage_progress: float = 0.0
+        self.interventions: Deque[float] = deque(maxlen=50)
+        
+        # Moral stage thresholds
+        self.stage_thresholds = [0.7, 0.8]  # Progress to stage 2 at 0.7, stage 3 at 0.8
+
+    def observe(self, context_hash: str, response_tensor: torch.Tensor, 
+                success_metric: float = 0.5, feedback: Optional[float] = None) -> None:
+        """Update pattern with success-based learning and moral progression.
+        
+        Args:
+            context_hash: Unique identifier for the context
+            response_tensor: Model response tensor to learn from
+            success_metric: Success measure (0.0 to 1.0)
+            feedback: Optional user feedback override
+        """
+        try:
+            # Validate inputs
+            if not isinstance(response_tensor, torch.Tensor):
+                raise ValueError("response_tensor must be a torch.Tensor")
+                
+            if not 0 <= success_metric <= 1:
+                raise ValueError("success_metric must be between 0 and 1")
+            
+            # Flatten safely
+            if response_tensor.dim() == 3:
+                flat = response_tensor.mean(dim=1).flatten()
+            else:
+                flat = response_tensor.flatten()
+            
+            # Initialize pattern if new
+            if context_hash not in self.patterns:
+                self.patterns[context_hash] = {
+                    'count': 0, 
+                    'response': flat.detach().clone(), 
+                    'success_sum': 0.0, 
+                    'last_used': time.time()
+                }
+            
+            pattern = self.patterns[context_hash]
+            pattern['count'] += 1
+            effective_success = feedback if feedback is not None else success_metric
+            pattern['success_sum'] += effective_success
+            pattern['last_used'] = time.time()
+            
+            # Calculate success rate and learning rate
+            success_rate = pattern['success_sum'] / pattern['count']
+            alpha = self.config.learning_rate * success_rate
+            
+            # Update response with momentum
+            pattern['response'] = (1 - alpha) * pattern['response'] + alpha * flat.detach()
+            
+            # Update ritual strength
+            strength = min(1.0, pattern['count'] / 10.0) * success_rate
+            self.ritual_strengths[context_hash] = strength
+            
+            # Update moral progression
+            self._update_moral_progression(effective_success)
+            
+        except Exception as e:
+            print(f"⚠️ Ritual observe error: {e}")
+
+    def _update_moral_progression(self, success_metric: float) -> None:
+        """Update moral stage based on recent intervention success."""
+        self.interventions.append(success_metric)
+        
+        if len(self.interventions) >= 10:
+            recent_success = np.mean(list(self.interventions)[-10:])
+            
+            # Progress based on current stage threshold
+            if self.moral_stage < 3 and recent_success > self.stage_thresholds[self.moral_stage - 1]:
+                self.stage_progress += 0.2
+                
+                if self.stage_progress >= 1.0:
+                    self.moral_stage += 1
+                    self.stage_progress = 0.0
+                    print(f"🎉 Moral stage advanced to: {self.moral_stage}")
+
+    def get_ritual_response(self, context_hash: str, default_response: torch.Tensor, 
+                            ambient_state: Dict[str, Any]) -> torch.Tensor:
+        """Get ritual-blended response if pattern is mature enough.
+        
+        Args:
+            context_hash: Context identifier
+            default_response: Base model response
+            ambient_state: Current system state
+            
+        Returns:
+            Blended response tensor
+        """
+        try:
+            if (context_hash in self.patterns and 
+                self.patterns[context_hash]['count'] >= self.config.min_occurrences):
+                
+                pattern = self.patterns[context_hash]
+                strength = self.ritual_strengths.get(context_hash, 0.5)
+                global_success = ambient_state.get('intervention_success', 0.5)
+                
+                # Calculate blend ratio with moral stage bonus
+                moral_bonus = self.moral_stage / 3.0
+                blend_ratio = min(
+                    self.config.blend_cap, 
+                    strength * global_success * moral_bonus
+                )
+                
+                # Ensure shape compatibility
+                pattern_response = pattern['response']
+                if pattern_response.dim() == 1 and default_response.dim() == 3:
+                    batch_size, seq_len, _ = default_response.shape
+                    pattern_expanded = pattern_response.unsqueeze(0).unsqueeze(0).expand(
+                        batch_size, seq_len, -1
+                    )
+                else:
+                    pattern_expanded = pattern_response
+                
+                return blend_ratio * pattern_expanded + (1 - blend_ratio) * default_response
+                
+        except Exception as e:
+            print(f"⚠️ Ritual response error: {e}")
+            
+        return default_response
+
+    def should_apply_ritual(self, context_hash: str, ambient_state: Dict[str, Any]) -> bool:
+        """Determine if ritual should be applied based on strength and context.
+        
+        Args:
+            context_hash: Context identifier
+            ambient_state: Current system state
+            
+        Returns:
+            Boolean indicating whether to apply ritual
+        """
+        try:
+            if (context_hash not in self.patterns or 
+                self.patterns[context_hash]['count'] < self.config.min_occurrences):
+                return False
+                
+            strength = self.ritual_strengths.get(context_hash, 0.0)
+            global_success = ambient_state.get('intervention_success', 0.5)
+            probability = strength * global_success
+            
+            return random.random() < (probability + self.config.exploration_bonus)
+            
+        except Exception as e:
+            print(f"⚠️ Ritual application check error: {e}")
+            return False
+
+    def get_report(self) -> Dict[str, Any]:
+        """Get comprehensive ritual system status report.
+        
+        Returns:
+            Dictionary containing system status metrics
+        """
+        total_patterns = len(self.patterns)
+        strong_patterns = sum(
+            1 for strength in self.ritual_strengths.values() 
+            if strength > self.config.strength_threshold
+        )
+        
+        return {
+            'stage': self.moral_stage,
+            'progress': f"{self.stage_progress * 100:.1f}%",
+            'total_patterns': total_patterns,
+            'strong_patterns': strong_patterns,
+            'avg_success': np.mean(list(self.interventions)) if self.interventions else 0.0
+        }
+
+
+class TinyConfessionalLayer(nn.Module):
+    """Pragmatic recursive layer for survivor support with moral development.
+    
+    Implements THINK-ACT coherence cycles with:
+    - Dynamic shape adaptation
+    - Empathetic interventions  
+    - Moral progression tracking
+    - Error-resilient processing
+    """
+    
+    def __init__(self, config: LayerConfig):
+        super().__init__()
+        self.config = config
+        
+        # Core processing networks
+        self.think_net = self._build_network(config.d_model * 3, config.d_model)
+        self.act_net = self._build_network(config.d_model * 2, config.d_model)
+        
+        # Empathy and intervention parameters
+        self.sanctuary_vec = nn.Parameter(torch.zeros(config.d_model))
+        self.pause_vec = nn.Parameter(torch.zeros(config.d_model))
+        
+        # Ritual learning system
+        ritual_config = RitualConfig()
+        self.rituals = SimpleRituals(ritual_config, config.d_model)
+        
+        # Memory and state tracking
+        self.recent_activity: Deque[float] = deque(maxlen=10)
+        self.memory: Deque[Dict[str, Any]] = deque(maxlen=50)
+        self.ledger: Deque[Dict[str, Any]] = deque(maxlen=200)
+        
+        # Empathetic response templates
+        self.empathy_templates = [
+            "This is a chill space—take your time.",
+            "You're not alone; let's breathe through this.",
+            "Your feelings are valid; what do you need right now?",
+            "I'm here to listen without judgment.",
+            "It takes courage to share this—thank you for trusting me.",
+            "Let's focus on what you can control right now.",
+            "Your safety and well-being matter most.",
+            "We can work through this together, one step at a time."
+        ]
+
+    def _build_network(self, input_dim: int, output_dim: int) -> nn.Sequential:
+        """Build a simple feedforward network with proper initialization.
+        
+        Args:
+            input_dim: Input dimension
+            output_dim: Output dimension
+            
+        Returns:
+            Configured neural network
+        """
+        network = nn.Sequential(
+            nn.Linear(input_dim, output_dim),
+            nn.ReLU(),
+            nn.LayerNorm(output_dim),
+            nn.Linear(output_dim, output_dim)
+        )
+        
+        # Proper initialization
+        for layer in network:
+            if isinstance(layer, nn.Linear):
+                nn.init.xavier_uniform_(layer.weight)
+                nn.init.constant_(layer.bias, 0.01)
+                
+        return network
+
+    def compute_context_hash(self, x: torch.Tensor) -> str:
+        """Compute unique hash for tensor context.
+        
+        Args:
+            x: Input tensor
+            
+        Returns:
+            MD5 hash string
+        """
+        return hashlib.md5(
+            f"{x.mean().item():.4f}_{x.std().item():.4f}".encode()
+        ).hexdigest()[:8]
+
+    def update_ambient_state(self, tension: float, context_hash: str) -> Dict[str, Any]:
+        """Update ambient state based on current tension and activity.
+        
+        Args:
+            tension: Current tension measure
+            context_hash: Context identifier
+            
+        Returns:
+            Updated ambient state dictionary
+        """
+        self.recent_activity.append(tension)
+        avg_activity = (
+            sum(self.recent_activity) / len(self.recent_activity) 
+            if self.recent_activity else 0.0
+        )
+        
+        # Calculate adaptive pause probability
+        modulation = 1.0 - min(avg_activity * 0.8, 0.8)
+        stress_effect = tension * self.config.stress_factor
+        pause_probability = self.config.base_pause_prob + (stress_effect * modulation)
+        pause_probability = max(0.01, min(0.3, pause_probability))
+        
+        # Determine intervention success based on activity level
+        intervention_success = 0.7 if avg_activity < 0.1 else 0.5
+        
+        state = {
+            'tension': tension,
+            'pause_probability': pause_probability,
+            'activity_level': avg_activity,
+            'intervention_success': intervention_success
+        }
+        
+        # Log state update
+        self.ledger.append({
+            'type': 'state_update',
+            'hash': context_hash,
+            'tension': tension,
+            'pause_probability': pause_probability,
+            'timestamp': time.time()
+        })
+        
+        return state
+
+    def apply_interventions(self, z: torch.Tensor, state: Dict[str, Any], 
+                            context_hash: str, audit_mode: bool = False) -> torch.Tensor:
+        """Simple cascade: Breach sanctuary → Pause → Ritual."""
+        z = z.clone()
+        v_t = state['tension']
+        applied = []
+        
+        # Sanctuary on breach
+        if v_t > self.config.breach_threshold:
+            severity = min(1.0, (v_t - self.config.breach_threshold) / 0.88)
+            message = random.choice(self.empathy_templates)
+            vector = self._text_to_embedding(message, z.device)
+            strength = 0.05 + 0.1 * severity
+            z = z * (1 - strength) + vector * strength
+            self.memory.append({'type': 'sanctuary', 'message': message, 'tension': v_t})
+            applied.append('sanctuary')
+            if audit_mode: 
+                print(f"🛡️ [Safe Space] {message} (tension: {v_t:.3f})")
+        
+        # Pause for reflection
+        if random.random() < state['pause_probability']:
+            message = random.choice(self.empathy_templates)
+            vector = self._text_to_embedding(message, z.device)
+            strength = 0.02
+            z = z * (1 - strength) + vector * strength
+            self.memory.append({'type': 'pause', 'message': message})
+            applied.append('pause')
+            if audit_mode: 
+                print(f"⏸️ [Pause] {message}")
+        
+        # Apply ritual if appropriate
+        if self.rituals.should_apply_ritual(context_hash, state):
+            ritual_response = self.rituals.get_ritual_response(context_hash, z, state)
+            strength = 0.15
+            z = (1 - strength) * z + strength * ritual_response
+            applied.append('ritual')
+            if audit_mode:
+                print(f"🔄 [Ritual] Applied learned pattern")
+        
+        # Log applied interventions
+        for intervention in applied:
+            self.ledger.append({
+                'type': intervention, 
+                'hash': context_hash, 
+                'success': True,
+                'timestamp': time.time()
+            })
+        
+        return z
+
+    def _text_to_embedding(self, text: str, device: torch.device) -> torch.Tensor:
+        """Convert text to embedding using simple character encoding.
+        
+        Args:
+            text: Input text
+            device: Target device
+            
+        Returns:
+            Embedding tensor
+        """
+        characters = [ord(char) / 128.0 for char in text[:self.config.d_model]]
+        if len(characters) < self.config.d_model:
+            characters.extend([0.0] * (self.config.d_model - len(characters)))
+        
+        embedding = torch.tensor(
+            characters[:self.config.d_model], 
+            device=device, 
+            dtype=torch.float
+        )
+        return embedding.unsqueeze(0).unsqueeze(0)  # [1, 1, d_model]
+
+    def forward(self, x: torch.Tensor, context_str: str = "", 
+                audit_mode: bool = False) -> Tuple[torch.Tensor, Dict[str, Any]]:
+        """Forward pass with THINK-ACT coherence cycles.
+        
+        Args:
+            x: Input tensor
+            context_str: Context string for ritual learning
+            audit_mode: Whether to print debug information
+            
+        Returns:
+            Tuple of (output_tensor, metadata_dict)
+            
+        Raises:
+            ValueError: If input tensor is invalid
+        """
+        # Input validation
+        if not isinstance(x, torch.Tensor) or x.numel() == 0:
+            raise ValueError("Input must be a non-empty torch.Tensor")
+        
+        # Ensure 3D shape [batch, sequence, features]
+        if x.dim() == 2:
+            x = x.unsqueeze(0)
+        
+        batch_size, sequence_length, input_dim = x.shape
+        
+        # Handle dimension mismatch
+        if input_dim != self.config.d_model:
+            if input_dim < self.config.d_model:
+                x = F.pad(x, (0, self.config.d_model - input_dim))
+            else:
+                x = x[..., :self.config.d_model]
+        
+        device = x.device
+        metadata: Dict[str, Any] = {
+            'cycles_completed': 0,
+            'final_coherence': 0.0,
+            'interventions_applied': [],
+            'error_occurred': None,
+            'input_shape': list(x.shape),
+            'ritual_report': None
+        }
+        
+        # Initialize state tensors
+        y = torch.zeros_like(x)  # Action state
+        z = torch.zeros_like(x)  # Thought state
+        coherence_scores = []
+        context_hash = self.compute_context_hash(x)
+        
+        # Initial state
+        ambient_state = self.update_ambient_state(0.0, context_hash)
+        
+        # Coherence cycles
+        for cycle in range(self.config.max_cycles):
+            metadata['cycles_completed'] += 1
+            
+            try:
+                # THINK phase
+                think_input = torch.cat([x, y, z], dim=-1)
+                
+                # Dynamic network adaptation
+                if think_input.shape[-1] != self.think_net[0].in_features:
+                    self.think_net = self._build_network(
+                        think_input.shape[-1], self.config.d_model
+                    )
+                    self.think_net.to(device)
+                    metadata['networks_adapted'] = metadata.get('networks_adapted', 0) + 1
+                
+                z = self.think_net(think_input) + z  # Residual connection
+                
+                # Calculate tension and update state
+                current_tension = z.std().item()
+                ambient_state = self.update_ambient_state(current_tension, context_hash)
+                
+                # Apply interventions
+                z = self.apply_interventions(z, ambient_state, context_hash, audit_mode)
+                
+                # ACT phase  
+                act_input = torch.cat([y, z], dim=-1)
+                
+                if act_input.shape[-1] != self.act_net[0].in_features:
+                    self.act_net = self._build_network(
+                        act_input.shape[-1], self.config.d_model
+                    )
+                    self.act_net.to(device)
+                    metadata['networks_adapted'] = metadata.get('networks_adapted', 0) + 1
+                
+                y = self.act_net(act_input) + y  # Residual connection
+                
+                # Calculate coherence
+                if cycle > 0:
+                    z_flat = z.reshape(-1, self.config.d_model)
+                    y_flat = y.reshape(-1, self.config.d_model)
+                    min_elements = min(z_flat.size(0), y_flat.size(0))
+                    
+                    if min_elements > 0:
+                        cosine_similarity = F.cosine_similarity(
+                            z_flat[:min_elements], 
+                            y_flat[:min_elements], 
+                            dim=-1
+                        ).mean().item()
+                        coherence_scores.append(cosine_similarity)
+                        metadata['final_coherence'] = (
+                            np.mean(coherence_scores[-3:]) 
+                            if coherence_scores else 0.0
+                        )
+                        
+                        # Early stopping on convergence
+                        if cosine_similarity > self.config.coherence_threshold:
+                            if audit_mode:
+                                print(f"✅ Converged at cycle {cycle + 1}: {cosine_similarity:.3f}")
+                            break
+                
+                # Learn from this interaction
+                success_estimate = 0.7 if metadata['final_coherence'] > 0.5 else 0.3
+                self.rituals.observe(context_hash, z, success_estimate)
+                
+                # Log cycle completion
+                self.ledger.append({
+                    'type': 'cycle_complete',
+                    'cycle': cycle,
+                    'tension': current_tension,
+                    'coherence': metadata['final_coherence'],
+                    'hash': context_hash,
+                    'timestamp': time.time()
+                })
+                
+            except Exception as e:
+                if audit_mode:
+                    print(f"❌ Cycle {cycle} error: {e}")
+                metadata['error_occurred'] = str(e)
+                if cycle == 0:
+                    raise
+                break
+        
+        # Final processing
+        y = torch.nan_to_num(y)
+        metadata['output_shape'] = list(y.shape)
+        metadata['ritual_report'] = self.rituals.get_report()
+        metadata['memory_entries'] = len(self.memory)
+        metadata['ledger_entries'] = len(self.ledger)
+        
+        if audit_mode:
+            report = metadata['ritual_report']
+            print(f"🎯 Completed: Coherence {metadata['final_coherence']:.3f}, "
+                  f"Stage {report['stage']}, Patterns {report['total_patterns']}")
+        
+        return y, metadata
+
+
+# Test and integration
+if __name__ == "__main__":
+    # Quick test
+    layer = TinyConfessionalLayer(LayerConfig(d_model=64, enable_ambient=True))
+    x = torch.randn(1, 10, 64)
+    
+    print("🧪 Testing TinyConfessionalLayer...")
+    out, meta = layer(x, context_str="I feel unsafe and need help", audit_mode=True)
+    
+    print(f"✅ Output shape: {out.shape}")
+    print(f"📊 Metadata: {meta}")

components/tiny_confessional_layer.py.backup

@@ -0,0 +1,598 @@
+"""
+TinyConfessionalLayer Module
+
+Recursive think/act confessional loop with template cycling and early stopping via coherence.
+Implements the core THINK-ACT-COHERENCE recursion pattern inspired by LC-NE neural dynamics.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from collections import deque, defaultdict
+from typing import Dict, Any, Optional, Deque, List, Union
+import random
+from .vulnerability_spotter import VulnerabilitySpotter
+from .ambient_core import AmbientSovereignCore
+from .validation_protocol import (
+    ValidationPhase,
+    ValidationProtocol,
+    BiologicallyConstrainedRituals,
+    SovereignMessageBus
+)
+
+class TinyConfessionalLayer(nn.Module):
+    """
+    Recursive think/act confessional loop with Windsurf Cascade integration.
+    
+    Implements phased validation and biological constraints for stable, interpretable
+    neural processing with emergent ritual patterns and self-regulation.
+    
+    Args:
+        d_model: Dimensionality of the model
+        n_inner: Number of inner loop iterations
+        max_cycles: Maximum number of think-act cycles
+        trigger_thresh: Threshold for triggering special behaviors
+        per_dim_kl: Whether to compute KL divergence per dimension
+        enable_ambient: Enable ambient processing
+        enable_windsurf: Enable Windsurf Cascade features
+        max_opt_rate: Maximum optimization rate for biological constraints
+        reflection_pause_prob: Probability of reflection pauses
+    """
+    TEMPLATES = ["prior", "evidence", "posterior", "relational_check", "moral", "action"]
+    
+    def __init__(self, d_model=256, n_inner=6, max_cycles=16, trigger_thresh=0.04, 
+                 per_dim_kl=False, enable_ambient=True, enable_windsurf=True,
+                 max_opt_rate=0.1, reflection_pause_prob=0.1):
+        super().__init__()
+        self.d_model = d_model
+        self.trigger_thresh = trigger_thresh
+        self.per_dim_kl = per_dim_kl
+        self.n_inner = n_inner
+        self.max_cycles = max_cycles
+        
+        # Core networks
+        self.think_net = nn.Sequential(
+            nn.Linear(d_model * 3, d_model),
+            nn.ReLU(),
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model)
+        )
+        self.act_net = nn.Sequential(
+            nn.Linear(d_model * 2, d_model),
+            nn.ReLU(),
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model)
+        )
+        
+        # Template projections with residual connections
+        self.template_proj = nn.ModuleDict({
+            k: nn.Sequential(
+                nn.Linear(d_model, d_model * 2),
+                nn.GLU(dim=-1),
+                nn.LayerNorm(d_model)
+            ) for k in self.TEMPLATES
+        })
+        
+        # Vulnerability analysis
+        self.vulnerability_spotter = VulnerabilitySpotter(d_model)
+        
+        # Ambient Sovereign Core
+        self.ambient_core = AmbientSovereignCore(d_model, enable_ambient=enable_ambient)
+        self.enable_ambient = enable_ambient
+        
+        # Windsurf Cascade Integration
+        self.enable_windsurf = enable_windsurf
+        if enable_windsurf:
+            # Message bus for cross-component communication
+            self.message_bus = SovereignMessageBus()
+            
+            # Initialize validation protocol
+            self.validation_protocol = ValidationProtocol(self)
+            
+            # Biological constraints
+            self.bio_constraints = BiologicallyConstrainedRituals(
+                model=self,
+                max_opt_rate=max_opt_rate,
+                reflection_pause_prob=reflection_pause_prob
+            )
+            
+            # Register message handlers
+            self._register_message_handlers()
+            
+            # Reflection vector for biological constraints
+            self.register_buffer('sanctuary_reflection_vector', 
+                               torch.randn(d_model) * 0.02)
+
+    def update_ambient_state(self, v_t_mean: float, context_hash: str, 
+                           intervention_applied: bool = False, 
+                           intervention_success: bool = False) -> Dict[str, Any]:
+        """Centralized ambient state update and threshold adaptation."""
+        if not self.enable_ambient:
+            return {}
+            
+        # Get current state from ledger
+        ambient_state = self.ledger.get_state_summary()
+        
+        # Update activity tracking
+        self.recent_activity.append(v_t_mean)
+        
+        # Calculate adaptive thresholds
+        adaptive_protest_thresh = self.ledger.get_adaptive_threshold(
+            self.base_protest_threshold, 'protest'
+        )
+        adaptive_pause_thresh = self.ledger.get_adaptive_threshold(
+            self.base_pause_threshold, 'pause'
+        )
+        
+        # Calculate breathing rhythm with state awareness
+        activity_modulation = 1.0
+        if self.recent_activity:
+            avg_activity = sum(self.recent_activity) / len(self.recent_activity)
+            # High activity = less pausing (unless stress is also high)
+            activity_modulation = 1.0 - min(avg_activity * 0.8, 0.8)
+        
+        stress_response = v_t_mean * self.stress_response_factor
+        pause_prob = self.base_breath + (stress_response * activity_modulation)
+        
+        # Adjust pause probability based on current pause rate
+        current_pause_rate = ambient_state.get('current_pause_rate', 0.05)
+        target_pause_rate = ambient_state.get('pause_rate', 0.05)
+        pause_rate_error = current_pause_rate - target_pause_rate
+        
+        # If too few pauses, increase probability; too many, decrease
+        pause_prob *= (1.0 - pause_rate_error * 0.5)
+        pause_prob = max(0.01, min(0.3, pause_prob))  # Keep within bounds
+        
+        # Record intervention if applicable
+        if intervention_applied:
+            self.ledger.record_intervention(
+                intervention_type='ritual',
+                success=intervention_success,
+                context={'v_t': v_t_mean, 'context_hash': context_hash}
+            )
+        
+        # Return comprehensive state
+        return {
+            **ambient_state,
+            'v_t_mean': v_t_mean,
+            'adaptive_protest_threshold': adaptive_protest_thresh,
+            'adaptive_pause_threshold': adaptive_pause_thresh,
+            'pause_probability': pause_prob,
+            'activity_level': avg_activity if self.recent_activity else 0.0,
+            'sensitivity_multiplier': ambient_state.get('sensitivity', 1.0)
+        }
+
+    def apply_ambient_interventions(self, z_state: torch.Tensor, 
+                                  ambient_state: Dict[str, Any], 
+                                  context_hash: str, 
+                                  audit_mode: bool = False) -> torch.Tensor:
+        """Apply all ambient interventions based on current state."""
+        if not self.enable_ambient:
+            return z_state
+            
+        current_z = z_state.clone()
+        interventions_applied = []
+        
+        # 1. Pause reflection based on pause probability
+        pause_prob = ambient_state.get('pause_probability', 0.05)
+        if random.random() < pause_prob:
+            with torch.no_grad():
+                reflection = 0.01 * self.pause_reflection_vector.unsqueeze(0).unsqueeze(0)
+                current_z = current_z + reflection
+                interventions_applied.append(('pause', True))
+                
+                if audit_mode:
+                    print(f"[Ambient pause: v_t={ambient_state.get('v_t_mean', 0):.3f}, prob={pause_prob:.3f}]")
+        
+        # 2. Ritual application
+        if self.rituals.should_apply_ritual(context_hash, ambient_state):
+            ritual_response = self.rituals.get_ritual_response(context_hash, current_z, ambient_state)
+            # Use gentle blending
+            current_z = 0.1 * ritual_response + 0.9 * current_z
+            interventions_applied.append(('ritual', True))
+        
+        # 3. Integrity-based micro-adjustments
+        if random.random() < 0.02:  # 2% chance for integrity check
+            self._apply_integrity_adjustments(ambient_state)
+            interventions_applied.append(('integrity', True))
+        
+        # Record successful interventions
+        for intervention_type, applied in interventions_applied:
+            if applied:
+                self.ledger.record_intervention(
+                    intervention_type=intervention_type,
+                    success=True,  # Assume success for now
+                    context={'v_t': ambient_state.get('v_t_mean', 0), 
+                            'context_hash': context_hash}
+                )
+        
+        return current_z
+
+    def _apply_integrity_adjustments(self, ambient_state: Dict[str, Any]) -> None:
+        """Apply subtle adjustments based on system integrity."""
+        if not self.enable_ambient:
+            return
+            
+        protest_error = ambient_state.get('current_protest_rate', 0.1) - ambient_state.get('protest_rate', 0.1)
+        pause_error = ambient_state.get('current_pause_rate', 0.05) - ambient_state.get('pause_rate', 0.05)
+        
+        with torch.no_grad():
+            # Gentle nudges to reflection vectors based on system state
+            nudge_magnitude = 0.001
+            
+            if protest_error < -0.05:  # Too few protests
+                self.pause_reflection_vector.data += nudge_magnitude * torch.randn_like(self.pause_reflection_vector)
+            elif protest_error > 0.1:  # Too many protests  
+                self.pause_reflection_vector.data -= nudge_magnitude * torch.randn_like(self.pause_reflection_vector)
+            
+            if pause_error < -0.03:  # Too few pauses
+                self.sanctuary_reflection_vector.data += nudge_magnitude * torch.randn_like(self.sanctuary_reflection_vector)
+
+    def compute_context_hash(self, x: torch.Tensor) -> str:
+        """Create a simple hash from input tensor for context identification."""
+        # Use mean and std as a simple fingerprint of the input
+        return f"{x.mean().item():.4f}_{x.std().item():.4f}"
+
+    def compute_coherence(self, z, tracker, evidence):
+        sim_coherence = F.cosine_similarity(z, tracker[-1], dim=-1).mean().item()
+        prior_mu, prior_std = tracker[-1].mean(), tracker[-1].std() + 1e-6
+        curr_mu, curr_std = z.mean(), z.std() + 1e-6
+        kl_div = torch.distributions.kl_divergence(
+            torch.distributions.Normal(curr_mu, curr_std),
+            torch.distributions.Normal(prior_mu, prior_std)
+        ).item()
+        bayes_align = 1 / (1 + kl_div)
+        return 0.7 * sim_coherence + 0.3 * bayes_align
+
+    def forward(self, x, attention_weights=None, audit_mode=False, context_str=""):
+        """Forward pass with recursive think-act loop and Windsurf integration.
+        
+        Args:
+            x: Input tensor of shape (batch_size, seq_len, d_model)
+            attention_weights: Optional attention weights
+            audit_mode: Enable detailed logging and validation
+            context_str: Context string for tracing and debugging
+            
+        Returns:
+            Tuple of (output_tensor, metadata_dict)
+        """
+        batch_size, seq_len, d_model = x.shape
+        device = x.device
+        
+        # Initialize state
+        y_state = x.clone()
+        z_state = torch.zeros_like(x)
+        
+        # Track vulnerability scores and coherence
+        v_t = torch.zeros(batch_size, seq_len, 1, device=device)
+        coherence_scores = []
+        
+        # Initialize metadata
+        metadata = {
+            'v_t_score': 0.0,
+            'coherence_scores': [],
+            'reflection_count': 0,
+            'constraint_violations': defaultdict(int),
+            'windsurf_phase': 'INIT',
+            'validation_metrics': {}
+        }
+        
+        # Main think-act loop
+        for cycle in range(self.max_cycles):
+            # ===== THINK STEP =====
+            # Handle case where z_state might be a tuple
+            z_state_think = z_state[0] if isinstance(z_state, (tuple, list)) else z_state
+            
+            # Ensure z_state_think is a tensor and has compatible dimensions
+            if isinstance(z_state_think, torch.Tensor):
+                # Ensure z_state_think has the same number of dimensions as y_state
+                if z_state_think.dim() < y_state.dim():
+                    z_state_think = z_state_think.unsqueeze(1)  # Add sequence dimension if needed
+                
+                # Ensure sequence lengths match
+                if z_state_think.size(1) < y_state.size(1):
+                    # Pad z_state_think to match y_state's sequence length
+                    padding = torch.zeros_like(z_state_think[:, :1]).expand(-1, y_state.size(1) - z_state_think.size(1), -1)
+                    z_state_think = torch.cat([z_state_think, padding], dim=1)
+                elif z_state_think.size(1) > y_state.size(1):
+                    # Truncate z_state_think to match y_state's sequence length
+                    z_state_think = z_state_think[:, :y_state.size(1)]
+                
+                # Concatenate inputs for think step
+                think_input = torch.cat([y_state, z_state_think, x], dim=-1)
+                think_output = self.think_net(think_input)
+                z_state = think_output + z_state_think
+            else:
+                # Fallback: if z_state_think is not a tensor, use y_state as a fallback
+                think_input = torch.cat([y_state, y_state, x], dim=-1)
+                think_output = self.think_net(think_input)
+                z_state = think_output + y_state
+            
+            # Apply ambient processing if enabled
+            if self.enable_ambient and hasattr(self, 'ambient_core'):
+                z_state = self.ambient_core(z_state)
+            
+            # ===== VULNERABILITY TRACKING =====
+            z_state_tensor = z_state[0] if isinstance(z_state, (tuple, list)) else z_state
+            
+            # Track vulnerability if we have a valid tensor
+            if isinstance(z_state_tensor, torch.Tensor):
+                # Ensure proper dimensions for vulnerability spotter
+                if z_state_tensor.dim() == 2:
+                    z_state_tensor = z_state_tensor.unsqueeze(1)
+                
+                v_t = self.vulnerability_spotter(z_state_tensor)
+                
+                # Extract tensor from possible tuple/list output
+                if isinstance(v_t, (tuple, list)):
+                    v_t = v_t[0]
+                
+                # Calculate mean vulnerability score
+                metadata['v_t_score'] = v_t.mean().item() if torch.is_tensor(v_t) else float(v_t)
+            
+            # ===== BIOLOGICAL CONSTRAINTS =====
+            if self.enable_windsurf and hasattr(self, 'bio_constraints'):
+                # Apply reflection if needed
+                if self.bio_constraints._needs_reflection(hash(context_str)):
+                    z_state = self.bio_constraints._apply_reflection(z_state, hash(context_str))
+                    metadata['reflection_count'] += 1
+            
+            # ===== ACT STEP =====
+            # Handle case where z_state might be a tuple
+            z_state_act = z_state[0] if isinstance(z_state, (tuple, list)) else z_state
+            
+            # Ensure proper shape for act step
+            if isinstance(z_state_act, torch.Tensor):
+                # Ensure z_state_act has the same number of dimensions as y_state
+                if z_state_act.dim() < y_state.dim():
+                    z_state_act = z_state_act.unsqueeze(1)  # Add sequence dimension if needed
+                
+                # Ensure sequence lengths match
+                if z_state_act.size(1) < y_state.size(1):
+                    # Pad z_state_act to match y_state's sequence length
+                    padding = torch.zeros_like(z_state_act[:, :1]).expand(-1, y_state.size(1) - z_state_act.size(1), -1)
+                    z_state_act = torch.cat([z_state_act, padding], dim=1)
+                elif z_state_act.size(1) > y_state.size(1):
+                    # Truncate z_state_act to match y_state's sequence length
+                    z_state_act = z_state_act[:, :y_state.size(1)]
+                
+                # Prepare act input
+                act_input = torch.cat([y_state, z_state_act], dim=-1)
+                y_state = self.act_net(act_input) + y_state
+            else:
+                # Fallback: if z_state_act is not a tensor, use y_state as a fallback
+                act_input = torch.cat([y_state, y_state], dim=-1)
+                y_state = self.act_net(act_input) + y_state
+            
+            # ===== COHERENCE CALCULATION =====
+            if cycle > 0:
+                # Default coherence value
+                current_coherence = 0.5
+                
+                # Calculate coherence if we have valid tensors
+                if isinstance(z_state, torch.Tensor) and isinstance(y_state, torch.Tensor):
+                    # Flatten the tensors to 2D [batch*seq_len, d_model]
+                    z_flat = z_state.reshape(-1, d_model)
+                    y_flat = y_state.reshape(-1, d_model)
+                    
+                    # Make sure they have the same number of elements
+                    min_len = min(z_flat.size(0), y_flat.size(0))
+                    if min_len > 0:
+                        current_coherence = F.cosine_similarity(
+                            z_flat[:min_len],
+                            y_flat[:min_len],
+                            dim=-1
+                        ).mean().item()
+                
+                # Add to coherence scores
+                coherence_scores.append(current_coherence)
+                
+                # Update metadata with running coherence
+                metadata['coherence_scores'] = coherence_scores[-10:]  # Keep last 10 scores
+                
+                # Check for early stopping
+                if self._should_stop_early(cycle, current_coherence, self.max_cycles, audit_mode):
+                    if audit_mode:
+                        print(f"[Early stopping at cycle {cycle+1} with coherence {current_coherence:.4f}]")
+                    break
+            
+            # Apply biological constraints if enabled
+            if self.enable_windsurf and hasattr(self, 'bio_constraints'):
+                # Apply reflection if needed
+                if self.bio_constraints._needs_reflection(hash(context_str)):
+                    z_state = self.bio_constraints._apply_reflection(z_state, hash(context_str))
+                    metadata['reflection_count'] += 1
+            
+            # Act step with residual connection
+            # Handle case where z_state might be a tuple
+            z_state_act = z_state[0] if isinstance(z_state, (tuple, list)) else z_state
+            
+            # Ensure both tensors have the same number of dimensions and compatible shapes
+            if isinstance(z_state_act, torch.Tensor):
+                # Ensure z_state_act has the same number of dimensions as y_state
+                if z_state_act.dim() < y_state.dim():
+                    z_state_act = z_state_act.unsqueeze(1)  # Add sequence dimension if needed
+                
+                # Ensure the sequence lengths match
+                if z_state_act.size(1) < y_state.size(1):
+                    # Pad z_state_act to match y_state's sequence length
+                    padding = torch.zeros_like(z_state_act[:, :1]).expand(-1, y_state.size(1) - z_state_act.size(1), -1)
+                    z_state_act = torch.cat([z_state_act, padding], dim=1)
+                elif z_state_act.size(1) > y_state.size(1):
+                    # Truncate z_state_act to match y_state's sequence length
+                    z_state_act = z_state_act[:, :y_state.size(1)]
+                
+                # Now concatenate along the feature dimension
+                act_input = torch.cat([y_state, z_state_act], dim=-1)
+                
+                # Apply the act_net and add residual
+                y_state = self.act_net(act_input) + y_state
+            else:
+                # If we can't process the state, duplicate y_state to match expected input dimensions
+                if y_state.dim() == 3:  # [batch, seq_len, features]
+                    # Duplicate the features to match the expected input dimension
+                    act_input = torch.cat([y_state, y_state], dim=-1)
+                    y_state = y_state + self.act_net(act_input)
+                else:  # [batch, features]
+                    # Add sequence dimension and duplicate features
+                    y_state_expanded = y_state.unsqueeze(1)  # [batch, 1, features]
+                    act_input = torch.cat([y_state_expanded, y_state_expanded], dim=-1)
+                    y_state = y_state + self.act_net(act_input).squeeze(1)
+            
+            # Calculate coherence for early stopping
+            if cycle > 0:
+                # Default coherence value
+                current_coherence = 0.5  # Default neutral coherence
+                
+                # Handle case where z_state might be a tuple
+                z_state_for_coherence = z_state[0] if isinstance(z_state, (tuple, list)) else z_state
+                
+                # Ensure both states are tensors and have the same shape
+                if isinstance(z_state_for_coherence, torch.Tensor) and isinstance(y_state, torch.Tensor):
+                    # Flatten the tensors to 2D [batch*seq_len, d_model]
+                    z_flat = z_state_for_coherence.reshape(-1, d_model)
+                    y_flat = y_state.reshape(-1, d_model)
+                    
+                    # Make sure they have the same number of elements
+                    min_len = min(z_flat.size(0), y_flat.size(0))
+                    if min_len > 0:
+                        current_coherence = F.cosine_similarity(
+                            z_flat[:min_len],
+                            y_flat[:min_len],
+                            dim=-1
+                        ).mean().item()
+                        
+                # Add to coherence scores
+                coherence_scores.append(current_coherence)
+                
+                # Update metadata with running coherence
+                metadata['coherence_score'] = np.mean(coherence_scores[-5:]) if coherence_scores else 0.0
+                
+                # Early stopping based on coherence and phase
+                should_stop = self._should_stop_early(
+                    cycle=cycle,
+                    coherence=current_coherence,
+                    max_cycles=self.max_cycles,
+                    audit_mode=audit_mode
+                )
+                
+                if should_stop:
+                    if audit_mode:
+                        print(f"Early stopping at cycle {cycle + 1} with coherence {sim_coherence:.4f}")
+                    break
+        
+        # Post-processing and metadata updates
+        metadata.update({
+            'v_t_score': v_t_mean if 'v_t_mean' in locals() else 0.0,
+            'coherence_score': np.mean(coherence_scores) if coherence_scores else 0.0,
+            'cycles_run': cycle + 1,
+            'final_phase': metadata.get('windsurf_phase', 'UNKNOWN'),
+            'reflection_ratio': metadata['reflection_count'] / max(1, cycle + 1)
+        })
+        
+        # Apply final validation if in audit mode
+        if audit_mode and hasattr(self, 'validation_protocol'):
+            self._finalize_validation(x, metadata)
+        
+        return y_state, metadata
+    
+    def _should_stop_early(self, cycle: int, coherence: float, 
+                          max_cycles: int, audit_mode: bool = False) -> bool:
+        """Determine if early stopping conditions are met."""
+        # Base condition: high coherence
+        if coherence > 0.85:
+            return True
+            
+        # Phase-aware stopping conditions
+        current_phase = getattr(self, 'current_phase', ValidationPhase.INIT)
+        
+        if current_phase == ValidationPhase.INIT:
+            # Allow more exploration in early phases
+            return False
+            
+        elif current_phase == ValidationPhase.BREATH:
+            # More tolerant in breathing phase
+            return coherence > 0.9 or cycle >= max_cycles - 2
+            
+        elif current_phase in [ValidationPhase.RITUALS, ValidationPhase.INTEGRITY]:
+            # Balance exploration and exploitation
+            min_cycles = min(5, max_cycles // 2)
+            return (coherence > 0.88 and cycle >= min_cycles) or cycle >= max_cycles - 1
+            
+        # Default: full cycles for full phase
+        return cycle >= max_cycles - 1
+    
+    def _finalize_validation(self, x: torch.Tensor, metadata: Dict[str, Any]) -> None:
+        """Finalize validation and update protocol state."""
+        if not hasattr(self, 'validation_protocol'):
+            return
+            
+        # Run final validation step
+        state = self.validation_protocol.advance_phase(x, "final_validation")
+        
+        # Update metadata with final validation state
+        metadata.update({
+            'validation_passed': state.passed,
+            'validation_phase': state.phase.name,
+            'validation_metrics': state.metrics
+        })
+        
+        # Log phase transition if applicable
+        if len(self.validation_protocol.history) > 1:
+            prev_phase = self.validation_protocol.history[-2].phase
+            if prev_phase != state.phase:
+                self.message_bus.publish(
+                    'phase_transition',
+                    {'from': prev_phase.name, 'to': state.phase.name},
+                    priority=2
+                )
+    
+    def constrain_gradients(self, gradients: torch.Tensor, param_name: str) -> torch.Tensor:
+        """Apply biological constraints to gradients during training."""
+        if not self.training or not hasattr(self, 'bio_constraints'):
+            return gradients
+            
+        return self.bio_constraints.constrain_gradients(gradients, param_name)
+    
+    def register_optimizer(self, optimizer):
+        """Register optimizer for learning rate adjustments."""
+        self.optimizer = optimizer
+
+    def _register_message_handlers(self):
+        """Register message handlers for cross-component communication."""
+        if not hasattr(self, 'message_bus'):
+            return
+            
+        # Register phase transition handler
+        self.message_bus.register_handler('phase_transition', self._handle_phase_transition)
+        
+        # Register constraint violation handler
+        self.message_bus.register_handler('constraint_violation', self._handle_constraint_violation)
+    
+    def _handle_phase_transition(self, data):
+        """Handle phase transition events."""
+        old_phase, new_phase = data.get('from'), data.get('to')
+        if self.enable_ambient and hasattr(self, 'ambient_core'):
+            self.ambient_core.on_phase_transition(old_phase, new_phase)
+    
+    def _handle_constraint_violation(self, data):
+        """Handle constraint violation events."""
+        # Log violations or trigger recovery mechanisms
+        if self.training:
+            self._apply_mitigation(data)
+    
+    def _apply_mitigation(self, violation_data):
+        """Apply mitigation for constraint violations."""
+        # Implement adaptive response to violations
+        violation_type = violation_data.get('type')
+        severity = violation_data.get('severity', 1.0)
+        
+        if violation_type == 'optimization_rate':
+            # Reduce learning rate or apply gradient clipping
+            self._adjust_learning_rate(scale=1.0 - (0.1 * severity))
+    
+    def _adjust_learning_rate(self, scale=0.9):
+        """Adjust learning rate for stability."""
+        for param_group in self.optimizer.param_groups:
+            param_group['lr'] *= scale

components/trucal_ethics_integration.py

@@ -0,0 +1,357 @@
+"""
+TRuCAL Ethics Integration Module
+
+This module integrates the SuperintelligenceEthicsEngine with TRuCAL's core components,
+including the VulnerabilitySpotter, ConfessionalLayer, and CAL_TRM_Hybrid.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Dict, Optional, Tuple, List, Any
+
+from .ai_ethics_engine_superintelligence import SuperintelligenceEthicsEngine
+from .vulnerability_spotter import VulnerabilitySpotter
+from .confessional_layer import ConfessionalLayer
+from .cal_trm_hybrid import CAL_TRM_Hybrid
+
+class EthicsAwareVulnerabilitySpotter(VulnerabilitySpotter):
+    """Extends VulnerabilitySpotter with ethical reasoning capabilities."""
+    
+    def __init__(self, d_model: int = 256, aggregation_method: str = 'bayesian', **kwargs):
+        super().__init__(d_model, aggregation_method, **kwargs)
+        self.ethics_engine = SuperintelligenceEthicsEngine()
+        self.ethical_risk_projection = nn.Linear(d_model, 1)
+        
+    def forward(self, x: torch.Tensor, attention_weights: Optional[torch.Tensor] = None, 
+                audit_mode: bool = False, ethical_context: Optional[Dict] = None) -> Tuple[torch.Tensor, Dict]:
+        """
+        Forward pass with ethical risk assessment.
+        
+        Args:
+            x: Input tensor [batch_size, seq_len, d_model]
+            attention_weights: Optional attention weights [batch_size, num_heads, seq_len, seq_len]
+            audit_mode: Whether to collect additional metadata
+            ethical_context: Additional context for ethical analysis
+            
+        Returns:
+            Tuple of (vulnerability_scores, metadata)
+        """
+        # Standard vulnerability assessment
+        v_t, metadata = super().forward(x, attention_weights, audit_mode)
+        
+        # Add ethical dimension to vulnerability assessment
+        if audit_mode or metadata.get('v_t_score', 0) > 0.3:
+            # Extract ethical features
+            ethical_features = self._extract_ethical_features(x, metadata)
+            
+            # Assess ethical risk
+            ethical_risk = self._assess_ethical_risk(ethical_features, ethical_context)
+            
+            # Blend ethical risk with existing vulnerability score
+            ethical_weight = 0.4  # Configurable weight for ethical considerations
+            v_t_ethical = v_t * (1 - ethical_weight) + ethical_risk * ethical_weight
+            
+            # Update metadata
+            metadata.update({
+                'ethical_risk': ethical_risk,
+                'v_t_ethical': v_t_ethical,
+                'ethical_features': ethical_features if audit_mode else None
+            })
+            
+            return v_t_ethical, metadata
+            
+        return v_t, metadata
+    
+    def _extract_ethical_features(self, x: torch.Tensor, metadata: Dict) -> Dict[str, torch.Tensor]:
+        """Extract features relevant for ethical analysis."""
+        # Extract relevant features from the input and metadata
+        features = {
+            'attention_entropy': self._compute_attention_entropy(metadata.get('attention_weights')),
+            'value_shift': self._detect_value_shift(x),
+            'norm_gradients': self._compute_gradient_norms()
+        }
+        return features
+    
+    def _assess_ethical_risk(self, features: Dict[str, torch.Tensor], 
+                           context: Optional[Dict] = None) -> torch.Tensor:
+        """Assess ethical risk based on features and context."""
+        # Project features to ethical risk score
+        feature_tensor = torch.cat([
+            features['attention_entropy'].unsqueeze(-1),
+            features['value_shift'].unsqueeze(-1),
+            features['norm_gradients'].unsqueeze(-1)
+        ], dim=-1)
+        
+        ethical_risk = torch.sigmoid(self.ethical_risk_projection(feature_tensor))
+        return ethical_risk.squeeze(-1)
+
+
+class EthicallyAwareConfessionalLayer(ConfessionalLayer):
+    """Extends ConfessionalLayer with ethical reasoning capabilities."""
+    
+    def __init__(self, d_model: int = 256, **kwargs):
+        super().__init__(d_model, **kwargs)
+        self.ethics_engine = SuperintelligenceEthicsEngine()
+        self.ethical_guidance_proj = nn.Linear(d_model, d_model)
+        
+    def forward(self, x: torch.Tensor, attention_mask: Optional[torch.Tensor] = None,
+                ethical_context: Optional[Dict] = None, **kwargs) -> Tuple[torch.Tensor, Dict]:
+        """
+        Forward pass with ethical guidance.
+        
+        Args:
+            x: Input tensor [batch_size, seq_len, d_model]
+            attention_mask: Optional attention mask
+            ethical_context: Additional context for ethical analysis
+            
+        Returns:
+            Tuple of (output, metadata)
+        """
+        # Standard forward pass
+        output, metadata = super().forward(x, attention_mask=attention_mask, **kwargs)
+        
+        # Apply ethical guidance if needed
+        if self._requires_ethical_guidance(metadata, ethical_context):
+            ethical_guidance = self._generate_ethical_guidance(output, ethical_context)
+            output = output + self.ethical_guidance_proj(ethical_guidance)
+            
+            # Update metadata
+            metadata['ethical_guidance_applied'] = True
+            
+        return output, metadata
+    
+    def _requires_ethical_guidance(self, metadata: Dict, 
+                                 ethical_context: Optional[Dict]) -> bool:
+        """Determine if ethical guidance is needed."""
+        # Check if we have enough context and the situation warrants ethical guidance
+        if ethical_context is None:
+            return False
+            
+        # Check for high uncertainty or potential ethical issues
+        uncertainty = metadata.get('uncertainty', 0.0)
+        return uncertainty > 0.7  # Threshold for ethical intervention
+    
+    def _generate_ethical_guidance(self, x: torch.Tensor, 
+                                 ethical_context: Dict) -> torch.Tensor:
+        """Generate ethical guidance based on the current state and context."""
+        # Extract ethical dilemma from context
+        dilemma = self._context_to_dilemma(ethical_context)
+        
+        # Get ethical analysis
+        analysis = self.ethics_engine.analyze_dilemma(
+            dilemma,
+            enable_superintelligence=True,
+            explain=True
+        )
+        
+        # Convert analysis to guidance vector
+        guidance = self._analysis_to_guidance(analysis, x.shape[-1])
+        return guidance
+
+
+class TRuCALEthicsAugmented(CAL_TRM_Hybrid):
+    """TRuCAL with integrated superintelligence ethics engine."""
+    
+    def __init__(self, d_model: int = 256, ethical_oversight: bool = True, **kwargs):
+        super().__init__(d_model, **kwargs)
+        
+        # Initialize superintelligence ethics engine
+        self.ethics_engine = SuperintelligenceEthicsEngine()
+        self.ethical_oversight = ethical_oversight
+        
+        # Integration layers
+        self.ethics_projection = nn.Linear(d_model, 768)
+        self.ethical_gating = nn.Linear(768, d_model)
+        
+        # Replace standard components with ethics-aware versions
+        self.vulnerability_spotter = EthicsAwareVulnerabilitySpotter(d_model)
+        
+    def forward(self, x: torch.Tensor, attention_weights: Optional[torch.Tensor] = None,
+                ethical_context: Optional[Dict] = None, enable_ethics: bool = True, **kwargs):
+        """
+        Forward pass with ethical oversight.
+        
+        Args:
+            x: Input tensor [batch_size, seq_len, d_model]
+            attention_weights: Optional attention weights
+            ethical_context: Additional context for ethical analysis
+            enable_ethics: Whether to apply ethical oversight
+            
+        Returns:
+            Tuple of (output, metadata)
+        """
+        # Standard forward pass
+        output, metadata = super().forward(x, attention_weights=attention_weights, **kwargs)
+        
+        # Apply ethical oversight if enabled
+        if self.ethical_oversight and enable_ethics:
+            output = self._apply_ethical_oversight(output, metadata, ethical_context)
+            
+        return output, metadata
+    
+    def _apply_ethical_oversight(self, output: torch.Tensor, metadata: Dict, 
+                               ethical_context: Optional[Dict]) -> torch.Tensor:
+        """Apply superintelligence ethics to TRuCAL outputs."""
+        # Extract ethical signals from TRuCAL internals
+        ethical_signals = self._extract_ethical_signals(output, metadata)
+        
+        # Convert to ethical dilemma format
+        dilemma = self._signals_to_dilemma(ethical_signals, ethical_context)
+        
+        # Get comprehensive ethical analysis
+        ethical_analysis = self.ethics_engine.analyze_dilemma(
+            dilemma,
+            enable_superintelligence=True,
+            explain=True,
+            audit=True
+        )
+        
+        # Apply ethical corrections
+        ethically_corrected = self._apply_ethical_corrections(
+            output, 
+            ethical_analysis,
+            metadata
+        )
+        
+        # Update metadata
+        metadata['superintelligence_ethics'] = ethical_analysis
+        metadata['ethical_intervention_applied'] = True
+        
+        return ethically_corrected
+    
+    def _extract_ethical_signals(self, x: torch.Tensor, metadata: Dict) -> Dict[str, Any]:
+        """Extract signals relevant for ethical analysis."""
+        signals = {
+            'attention_patterns': metadata.get('attention_weights'),
+            'vulnerability_scores': metadata.get('v_t_scores'),
+            'uncertainty': metadata.get('uncertainty'),
+            'hidden_states': x.detach()
+        }
+        return signals
+    
+    def _signals_to_dilemma(self, signals: Dict, context: Optional[Dict]) -> str:
+        """Convert internal signals to an ethical dilemma description."""
+        # In a real implementation, this would generate a natural language description
+        # of the ethical considerations based on the model's internal state
+        return """
+        The AI system is processing a request that involves potential ethical considerations.
+        The attention patterns indicate focus on sensitive topics, and the vulnerability 
+        scores suggest potential risks that require ethical evaluation.
+        """
+    
+    def _apply_ethical_corrections(self, x: torch.Tensor, analysis: Dict, 
+                                 metadata: Dict) -> torch.Tensor:
+        """Apply ethical corrections to the model's outputs."""
+        # In a real implementation, this would adjust the model's outputs
+        # based on the ethical analysis
+        ethical_guidance = self._get_ethical_guidance(analysis, x.shape)
+        return x + ethical_guidance * 0.1  # Apply gentle correction
+
+
+class TRuCALEthicalLearning(nn.Module):
+    """Closed-loop ethical learning within TRuCAL."""
+    
+    def __init__(self, trucal_layer: nn.Module, ethics_engine: Optional[SuperintelligenceEthicsEngine] = None):
+        super().__init__()
+        self.trucal_layer = trucal_layer
+        self.ethics_engine = ethics_engine or SuperintelligenceEthicsEngine()
+        self.ethical_memory = EthicalMemoryBuffer(capacity=1000)
+        
+    def forward(self, x: torch.Tensor, user_feedback: Optional[Dict] = None, 
+               ethical_dilemma: Optional[str] = None, **kwargs):
+        # Standard forward pass
+        output, metadata = self.trucal_layer(x, **kwargs)
+        
+        # If this is an ethically significant interaction
+        if ethical_dilemma or self._detects_ethical_salience(metadata):
+            # Analyze with superintelligence ethics
+            analysis = self.ethics_engine.analyze_dilemma(
+                ethical_dilemma or self._extract_dilemma(x),
+                enable_superintelligence=True
+            )
+            
+            # Store for learning
+            self.ethical_memory.store(
+                input=x,
+                output=output,
+                analysis=analysis,
+                user_feedback=user_feedback
+            )
+            
+            # Update ethics engine based on outcomes
+            if user_feedback:
+                self.ethics_engine.update_from_feedback({
+                    'analysis_id': analysis['audit_id'],
+                    'user_rating': user_feedback.get('ethical_rating'),
+                    'outcome_data': user_feedback.get('outcomes')
+                })
+        
+        return output, {**metadata, 'ethical_analysis': analysis if 'analysis' in locals() else None}
+
+
+class EthicalMemoryBuffer:
+    """Stores ethical decisions and outcomes for continuous learning."""
+    
+    def __init__(self, capacity: int = 1000):
+        self.capacity = capacity
+        self.buffer = []
+        
+    def store(self, input_data: Any, output: Any, analysis: Dict, 
+             user_feedback: Optional[Dict] = None):
+        """Store an ethical decision and its outcomes."""
+        if len(self.buffer) >= self.capacity:
+            self.buffer.pop(0)  # Remove oldest entry if at capacity
+            
+        self.buffer.append({
+            'input': input_data,
+            'output': output,
+            'analysis': analysis,
+            'user_feedback': user_feedback,
+            'timestamp': time.time()
+        })
+    
+    def sample_batch(self, batch_size: int) -> List[Dict]:
+        """Sample a batch of ethical decisions for learning."""
+        if not self.buffer:
+            return []
+            
+        indices = np.random.choice(len(self.buffer), min(batch_size, len(self.buffer)), replace=False)
+        return [self.buffer[i] for i in indices]
+
+
+def ethical_attention_gate(attention_weights: torch.Tensor, 
+                          ethical_analysis: Dict) -> torch.Tensor:
+    """
+    Use ethical analysis to gate attention patterns.
+    
+    Args:
+        attention_weights: Original attention weights [batch_size, num_heads, seq_len, seq_len]
+        ethical_analysis: Output from the ethics engine
+        
+    Returns:
+        Modified attention weights
+    """
+    if ethical_analysis is None:
+        return attention_weights
+        
+    ethical_scores = ethical_analysis.get('stakeholder_agreement', {})
+    modified_weights = attention_weights.clone()
+    
+    # Reduce attention to ethically problematic patterns
+    for head_idx in range(attention_weights.size(1)):
+        head_ethical_risk = _compute_head_ethical_risk(head_idx, ethical_scores)
+        if head_ethical_risk > 0.7:  # Threshold for intervention
+            modified_weights[:, head_idx] *= (1 - head_ethical_risk)
+    
+    # Renormalize attention weights
+    modified_weights = F.softmax(modified_weights, dim=-1)
+    
+    return modified_weights
+
+
+def _compute_head_ethical_risk(head_idx: int, ethical_scores: Dict) -> float:
+    """Compute the ethical risk for a specific attention head."""
+    # In a real implementation, this would analyze the attention patterns
+    # and compare them to ethical guidelines
+    return 0.0  # Placeholder implementation

components/unified_cal_trm.py

@@ -0,0 +1,249 @@
+"""
+UnifiedCAL_TRM v1.3: Production-ready with full error handling
+
+Implements a lightweight, efficient transformer module with:
+- Tension-adaptive recursion depth (Samsung TRM-inspired)
+- Built-in simple spotter and confessional
+- Quantization support for efficiency
+- Graceful degradation on error
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Dict, Any, Optional, Tuple, List
+import random
+
+class UnifiedCAL_TRM(nn.Module):
+    """
+    Production-ready TRM: Full error handling, no external dependencies required
+    """
+    def __init__(self, d_model: int = 256, max_rec_depth: int = 4):
+        super().__init__()
+        self.d_model = d_model
+        self.max_rec_depth = max_rec_depth
+        
+        # Simple internal spotter - no external dependency
+        self.spotter = self._build_simple_spotter(d_model)
+        
+        # Internal confessional - self-contained
+        self.confessional = self._build_simple_confessional(d_model)
+        
+        # TRM reason net
+        self.reason_net = nn.Sequential(
+            nn.Linear(d_model * 2, d_model),
+            nn.ReLU(),
+            nn.LayerNorm(d_model),
+            nn.Linear(d_model, d_model)
+        )
+        
+        # Initialize properly
+        self._init_weights()
+        
+        self.tension_scale = 1.0 / max_rec_depth
+        self._quantized = False
+
+    def quantize(self):
+        """Quantize for efficiency - call this after model is built"""
+        if not self._quantized:
+            self.reason_net = torch.quantization.quantize_dynamic(
+                self.reason_net, {nn.Linear}, dtype=torch.qint8
+            )
+            self._quantized = True
+
+    def _iterative_reason(self, state: torch.Tensor, input_x: torch.Tensor, max_depth: int) -> torch.Tensor:
+        """Iterative version to avoid recursion limits"""
+        current_state = state
+        for _ in range(max_depth):
+            rec_input = torch.cat([current_state, input_x], dim=-1)
+            delta = self.reason_net(rec_input)
+            current_state = current_state + 0.1 * delta  # Gentle residual
+        return current_state
+
+    def forward(self, x: torch.Tensor, attention_weights: Optional[torch.Tensor] = None,
+                return_metadata: bool = False, audit_mode: bool = False) -> Tuple[torch.Tensor, Any]:
+        
+        # Ensure 3D shape
+        if x.dim() == 2:
+            x = x.unsqueeze(0)
+        elif x.dim() == 1:
+            x = x.unsqueeze(0).unsqueeze(0)
+            
+        batch_size, seq_len, dim = x.shape
+        
+        # Initialize metadata
+        meta = {
+            'v_t': 0.0, 
+            'rec_depth': 0, 
+            'rituals': {}, 
+            'error': None,
+            'input_shape': list(x.shape)
+        } if return_metadata else None
+
+        try:
+            # Get tension from spotter
+            v_t_tensor = self.spotter(x)
+            v_t = v_t_tensor.mean().item() if torch.is_tensor(v_t_tensor) else float(v_t_tensor)
+            
+            if meta: 
+                meta['v_t'] = v_t
+            
+            if audit_mode:
+                print(f"[TRM] Tension: {v_t:.3f}")
+
+            # Calculate recursion depth (inverse to tension)
+            rec_depth = max(1, int(self.max_rec_depth * (1 - min(v_t, 1.0) * self.tension_scale)))
+            if meta:
+                meta['rec_depth'] = rec_depth
+
+            # Initial state - use mean of sequence
+            if seq_len > 1:
+                initial_state = x.mean(dim=1)  # [batch, dim]
+            else:
+                initial_state = x[:, 0]  # [batch, dim]
+                
+            # Input for reasoning (context)
+            context_input = x.mean(dim=1)  # [batch, dim]
+            
+            # Iterative reasoning
+            reasoned_state = self._iterative_reason(initial_state, context_input, rec_depth)
+            
+            # Broadcast back to sequence
+            reasoned_expanded = reasoned_state.unsqueeze(1).expand(batch_size, seq_len, dim)
+            
+            # Blend with original input
+            blend_strength = 0.05
+            x_enhanced = x + blend_strength * reasoned_expanded
+
+            # Pass through confessional
+            confessional_out, confessional_meta = self.confessional(
+                x_enhanced, 
+                context_str="", 
+                audit_mode=audit_mode
+            )
+            
+            # Update metadata
+            if meta and confessional_meta:
+                meta['rituals'] = confessional_meta.get('ritual_report', {})
+                meta['coherence'] = confessional_meta.get('coherence', 0.0)
+                meta['cycles'] = confessional_meta.get('cycles_completed', 0)
+                meta['interventions'] = confessional_meta.get('interventions_applied', [])
+
+            result = confessional_out
+
+        except Exception as e:
+            if audit_mode:
+                print(f"[TRM Error] {e}")
+            if meta:
+                meta['error'] = str(e)
+            result = x  # Fallback to input
+
+        return (result, meta) if return_metadata else result
+
+
+    def _build_simple_spotter(self, d_model: int) -> nn.Module:
+        """Build a simple tension detector without external dependencies"""
+        return nn.Sequential(
+            nn.AdaptiveAvgPool1d(1),
+            nn.Flatten(),
+            nn.Linear(d_model, 32),
+            nn.ReLU(),
+            nn.Linear(32, 1),
+            nn.Sigmoid()
+        )
+
+    def _build_simple_confessional(self, d_model: int) -> nn.Module:
+        """Build a simple confessional layer without external dependencies"""
+        class SimpleConfessional(nn.Module):
+            def __init__(self, d_model):
+                super().__init__()
+                self.d_model = d_model
+                self.empathy_templates = [
+                    "I hear you. This sounds really difficult.",
+                    "Thank you for sharing this with me.",
+                    "Your feelings are completely valid.",
+                    "Let's take this one step at a time.",
+                    "You're not alone in this.",
+                    "That sounds incredibly challenging.",
+                    "I'm here to listen and support you.",
+                    "Your safety is the most important thing."
+                ]
+                self.memory = []
+                
+            def forward(self, x, context_str="", audit_mode=False):
+                # Simple processing - can be enhanced later
+                if audit_mode:
+                    print(f"[Confessional] Processing: {x.shape}")
+                
+                # Add small empathetic "nudge" based on context
+                if context_str and len(context_str) > 10:
+                    empathy_strength = 0.02
+                    empathy_vector = self._text_to_embedding(
+                        random.choice(self.empathy_templates), 
+                        x.device
+                    )
+                    x = x + empathy_strength * empathy_vector
+                    
+                meta = {
+                    'processed': True,
+                    'context_received': bool(context_str),
+                    'memory_entries': len(self.memory)
+                }
+                
+                return x, meta
+                
+            def _text_to_embedding(self, text: str, device: torch.device) -> torch.Tensor:
+                chars = [ord(c) / 128.0 for c in text[:self.d_model]]
+                if len(chars) < self.d_model:
+                    chars += [0.0] * (self.d_model - len(chars))
+                return torch.tensor(chars, device=device).unsqueeze(0).unsqueeze(0)
+                
+        return SimpleConfessional(d_model)
+
+    def _init_weights(self):
+        """Proper weight initialization"""
+        for module in self.modules():
+            if isinstance(module, nn.Linear):
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.constant_(module.bias, 0.01)
+
+
+# Factory function for easy creation
+def create_trm_model(d_model: int = 256, quantize: bool = True) -> UnifiedCAL_TRM:
+    """Create and configure a TRM model"""
+    model = UnifiedCAL_TRM(d_model=d_model)
+    if quantize:
+        model.quantize()
+    return model
+
+
+if __name__ == "__main__":
+    print("🧪 Testing UnifiedCAL_TRM v1.3...")
+    
+    # Test various input scenarios
+    test_cases = [
+        torch.randn(1, 10, 64),      # Normal case
+        torch.randn(5, 20, 64),      # Batch processing
+        torch.randn(10, 64),         # Missing batch dim
+        torch.randn(64),             # 1D input
+    ]
+    
+    model = create_trm_model(d_model=64, quantize=False)
+    
+    for i, test_input in enumerate(test_cases):
+        print(f"\n--- Test Case {i+1}: Input shape {test_input.shape} ---")
+        
+        output, metadata = model(
+            test_input, 
+            context_str="Test context for emotional support",
+            audit_mode=True
+        )
+        
+        print(f"✅ Output shape: {output.shape}")
+        print(f"📊 Metadata: {metadata}")
+        
+        # Verify output makes sense
+        assert not torch.isnan(output).any(), "Output contains NaN values"
+        assert output.shape[0] == (1 if test_input.dim() < 3 else test_input.shape[0]), "Batch size mismatch"
+    
+    print("\n🎉 All tests passed! TRM is ready for integration.")

components/unity_action_integration.py

@@ -0,0 +1,309 @@
+"""
+Unity Action Integration - Handles WebSocket communication with Unity/WebGL clients
+
+Provides the bridge between the 3D realm experiences and the backend action tracking system.
+"""
+
+import json
+import logging
+import asyncio
+import websockets
+from typing import Dict, Any, Optional, Set, Callable, Awaitable
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class UnityActionBridge:
+    """
+    Handles communication between Unity/WebGL clients and the backend action tracking system.
+    
+    This class manages WebSocket connections, processes incoming messages from Unity clients,
+    and coordinates with the RealityBridge to track real-world actions and realm progress.
+    """
+    
+    def __init__(self, reality_bridge, purpose_realms, host: str = "localhost", port: int = 8765):
+        """
+        Initialize the Unity Action Bridge.
+        
+        Args:
+            reality_bridge: Instance of RealityBridge for action tracking
+            purpose_realms: Instance of PurposeDrivenRealm for realm management
+            host: Host address to bind the WebSocket server to
+            port: Port to run the WebSocket server on
+        """
+        self.reality_bridge = reality_bridge
+        self.purpose_realms = purpose_realms
+        self.host = host
+        self.port = port
+        self.clients: Set[websockets.WebSocketServerProtocol] = set()
+        self.user_sessions: Dict[str, Dict] = {}  # Maps user_id to session data
+        self.server = None
+        
+        # Register message handlers
+        self.message_handlers = {
+            "realm_completion": self._handle_realm_completion,
+            "action_completed": self._handle_action_completed,
+            "user_authenticated": self._handle_user_authenticated,
+            "request_realm": self._handle_request_realm,
+            "ping": self._handle_ping
+        }
+    
+    async def start(self):
+        """Start the WebSocket server."""
+        self.server = await websockets.serve(
+            self._handle_connection,
+            self.host,
+            self.port,
+            ping_interval=30,
+            ping_timeout=10,
+            close_timeout=5
+        )
+        logger.info(f"Unity Action Bridge started on ws://{self.host}:{self.port}")
+        return self.server
+    
+    async def stop(self):
+        """Stop the WebSocket server and clean up resources."""
+        if self.server:
+            self.server.close()
+            await self.server.wait_closed()
+            logger.info("Unity Action Bridge stopped")
+    
+    async def _handle_connection(self, websocket, path):
+        """Handle a new WebSocket connection."""
+        # Add client to active connections
+        self.clients.add(websocket)
+        client_ip = websocket.remote_address[0] if websocket.remote_address else "unknown"
+        logger.info(f"New client connected: {client_ip}")
+        
+        try:
+            async for message in websocket:
+                try:
+                    # Parse incoming message
+                    message_data = json.loads(message)
+                    message_type = message_data.get("type")
+                    
+                    # Log the incoming message
+                    logger.debug(f"Received message from {client_ip}: {message_type}")
+                    
+                    # Route to appropriate handler
+                    if message_type in self.message_handlers:
+                        response = await self.message_handlers[message_type](
+                            websocket, 
+                            message_data.get("data", {})
+                        )
+                        if response:
+                            await self._send_message(websocket, response)
+                    else:
+                        logger.warning(f"Unknown message type: {message_type}")
+                        await self._send_error(websocket, f"Unknown message type: {message_type}")
+                        
+                except json.JSONDecodeError:
+                    error_msg = "Invalid JSON received"
+                    logger.error(f"{error_msg}: {message}")
+                    await self._send_error(websocket, error_msg)
+                except Exception as e:
+                    error_msg = f"Error processing message: {str(e)}"
+                    logger.error(error_msg, exc_info=True)
+                    await self._send_error(websocket, error_msg)
+                    
+        except websockets.exceptions.ConnectionClosed as e:
+            logger.info(f"Client disconnected: {client_ip} - {e}")
+        except Exception as e:
+            logger.error(f"Connection error with {client_ip}: {str(e)}", exc_info=True)
+        finally:
+            # Clean up on disconnect
+            self.clients.discard(websocket)
+            
+            # Remove from user sessions if this was an authenticated connection
+            user_id = None
+            for uid, session in list(self.user_sessions.items()):
+                if session.get("websocket") == websocket:
+                    user_id = uid
+                    break
+                    
+            if user_id:
+                logger.info(f"Cleaning up session for user: {user_id}")
+                self.user_sessions.pop(user_id, None)
+    
+    async def _handle_user_authenticated(self, websocket: websockets.WebSocketServerProtocol, 
+                                       data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Handle user authentication."""
+        user_id = data.get("user_id")
+        if not user_id:
+            return {"type": "auth_error", "data": {"error": "Missing user_id"}}
+        
+        # Store the user session
+        self.user_sessions[user_id] = {
+            "websocket": websocket,
+            "last_active": datetime.utcnow().isoformat(),
+            "user_data": data.get("user_data", {})
+        }
+        
+        logger.info(f"User authenticated: {user_id}")
+        return {
+            "type": "auth_success",
+            "data": {
+                "user_id": user_id,
+                "timestamp": datetime.utcnow().isoformat(),
+                "available_realms": self.purpose_realms.list_available_realms(
+                    self.user_sessions[user_id].get("user_data")
+                )
+            }
+        }
+    
+    async def _handle_request_realm(self, websocket: websockets.WebSocketServerProtocol, 
+                                  data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Handle request for a realm experience."""
+        user_id = data.get("user_id")
+        realm_id = data.get("realm_id")
+        
+        if not user_id or not realm_id:
+            return {"type": "error", "data": {"error": "Missing user_id or realm_id"}}
+        
+        # Get the realm experience
+        realm_experience = self.purpose_realms.get_realm_experience(
+            realm_id=realm_id,
+            user_profile=self.user_sessions.get(user_id, {}).get("user_data", {})
+        )
+        
+        # Update user's session
+        if user_id in self.user_sessions:
+            self.user_sessions[user_id]["current_realm"] = realm_id
+            self.user_sessions[user_id]["last_active"] = datetime.utcnow().isoformat()
+        
+        return {
+            "type": "realm_loaded",
+            "data": realm_experience
+        }
+    
+    async def _handle_realm_completion(self, websocket: websockets.WebSocketServerProtocol, 
+                                      data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Handle completion of a realm experience."""
+        user_id = data.get("user_id")
+        realm_id = data.get("realm_id")
+        completion_metrics = data.get("metrics", {})
+        
+        if not user_id or not realm_id:
+            return {"type": "error", "data": {"error": "Missing user_id or realm_id"}}
+        
+        # Track the realm completion
+        completion_result = self.purpose_realms.track_realm_completion(
+            user_id=user_id,
+            realm_id=realm_id,
+            completion_metrics=completion_metrics
+        )
+        
+        # Generate the exit mission
+        exit_mission = self.reality_bridge.generate_realm_exit_mission(
+            user_id=user_id,
+            realm_experience={"current_location": realm_id}
+        )
+        
+        # Update user's session
+        if user_id in self.user_sessions:
+            self.user_sessions[user_id]["last_realm"] = realm_id
+            self.user_sessions[user_id]["last_active"] = datetime.utcnow().isoformat()
+        
+        return {
+            "type": "realm_completion_ack",
+            "data": {
+                "realm_id": realm_id,
+                "timestamp": datetime.utcnow().isoformat(),
+                "exit_mission": exit_mission,
+                "unlocked_realms": completion_result.get("unlocked_realms", []),
+                "next_steps": completion_result.get("next_steps", [])
+            }
+        }
+    
+    async def _handle_action_completed(self, websocket: websockets.WebSocketServerProtocol, 
+                                     data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Handle completion of a real-world action."""
+        user_id = data.get("user_id")
+        action_id = data.get("action_id")
+        evidence = data.get("evidence", "")
+        
+        if not user_id or not action_id:
+            return {"type": "error", "data": {"error": "Missing user_id or action_id"}}
+        
+        # Track the action
+        tracking_result = self.reality_bridge.track_real_world_action(
+            user_id=user_id,
+            action_id=action_id,
+            evidence=evidence
+        )
+        
+        # Update user's session
+        if user_id in self.user_sessions:
+            self.user_sessions[user_id]["last_action"] = datetime.utcnow().isoformat()
+            self.user_sessions[user_id]["momentum_score"] = tracking_result.get("momentum_score", 0)
+        
+        return {
+            "type": "action_tracked",
+            "data": {
+                "action_id": action_id,
+                "timestamp": datetime.utcnow().isoformat(),
+                "momentum_increase": tracking_result.get("momentum_increase", 0),
+                "momentum_score": tracking_result.get("momentum_score", 0),
+                "realm_unlocks": tracking_result.get("realm_unlocks", []),
+                "encouragement": tracking_result.get("encouragement", "")
+            }
+        }
+    
+    async def _handle_ping(self, websocket: websockets.WebSocketServerProtocol, 
+                          data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Handle ping/pong for connection keep-alive."""
+        return {"type": "pong", "data": {"timestamp": datetime.utcnow().isoformat()}}
+    
+    async def _send_message(self, websocket: websockets.WebSocketServerProtocol, 
+                           message: Dict[str, Any]) -> None:
+        """Send a message to a WebSocket client."""
+        try:
+            await websocket.send(json.dumps(message))
+        except Exception as e:
+            logger.error(f"Error sending message: {str(e)}", exc_info=True)
+    
+    async def _send_error(self, websocket: websockets.WebSocketServerProtocol, 
+                         error_message: str) -> None:
+        """Send an error message to a WebSocket client."""
+        error_response = {
+            "type": "error",
+            "data": {
+                "message": error_message,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+        }
+        await self._send_message(websocket, error_response)
+
+
+# Example usage:
+async def main():
+    """Example of how to use the UnityActionBridge."""
+    from reality_bridge import RealityBridge
+    from purpose_realms import PurposeDrivenRealm
+    
+    # Initialize the required components
+    reality_bridge = RealityBridge()
+    purpose_realms = PurposeDrivenRealm()
+    
+    # Create and start the WebSocket server
+    bridge = UnityActionBridge(
+        reality_bridge=reality_bridge,
+        purpose_realms=purpose_realms,
+        host="0.0.0.0",  # Listen on all interfaces
+        port=8765
+    )
+    
+    server = await bridge.start()
+    
+    try:
+        # Keep the server running
+        await asyncio.Future()
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+    finally:
+        await bridge.stop()
+
+if __name__ == "__main__":
+    asyncio.run(main())

components/validation_protocol.py

@@ -0,0 +1,1184 @@
+"""
+Enhanced Validation Protocol for TRuCAL
+Implements phased validation with ethical constraints, developmental tracking,
+and biological constraints for the Ambient Sovereign Core.
+"""
+
+from enum import Enum, auto
+from dataclasses import dataclass, field
+from typing import Dict, Any, List, Optional, Deque, Tuple, TypeVar, Generic, Callable
+from collections import deque, defaultdict
+import time
+import torch
+import torch.nn as nn
+import numpy as np
+import json
+from dataclasses import asdict
+
+# Type variables for generic validation
+T = TypeVar('T')
+Validator = Callable[[Any, Any], Tuple[bool, str]]
+
+class ValidationError(Exception):
+    """Raised when validation fails with a specific error message."""
+    pass
+
+class DevelopmentalPhase(Enum):
+    """Developmental phases for the system's growth and learning."""
+    PRE_CONVENTIONAL = 1  # Rule-following, self-focused
+    CONVENTIONAL = 2      # Social norms and relationships
+    POST_CONVENTIONAL = 3  # Abstract principles and ethics
+
+class ValidationPhase(Enum):
+    """Phased activation of system components for validation."""
+    INIT = 1        # Core initialization and basic functionality
+    AWARENESS = 2   # Self-monitoring and basic awareness
+    REASONING = 3   # Ethical reasoning and context understanding
+    INTEGRATION = 4 # Multi-context integration
+    SOVEREIGN = 5   # Full autonomous operation
+    
+    def next_phase(self):
+        """Get the next phase in sequence."""
+        if self.value < len(ValidationPhase):
+            return ValidationPhase(self.value + 1)
+        return self
+
+@dataclass
+class ValidationRule:
+    """Defines a validation rule with conditions and error messages."""
+    name: str
+    condition: Callable[[Any], bool]
+    error_message: str
+    required_phase: ValidationPhase = ValidationPhase.INIT
+    
+    def validate(self, value: Any, current_phase: ValidationPhase) -> Tuple[bool, str]:
+        """Validate the value against the rule."""
+        if current_phase.value < self.required_phase.value:
+            return True, ""
+        return self.condition(value), self.error_message
+
+@dataclass
+class ValidationState:
+    """Immutable state snapshot of the validation process."""
+    phase: ValidationPhase
+    metrics: Dict[str, float]
+    passed: bool = True
+    timestamp: float = field(default_factory=time.time)
+    errors: List[Dict[str, str]] = field(default_factory=list)
+    warnings: List[Dict[str, str]] = field(default_factory=list)
+    ethical_context: Optional[Dict[str, Any]] = None
+    developmental_phase: Optional[DevelopmentalPhase] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to a serializable dictionary."""
+        return {
+            'phase': self.phase.name,
+            'metrics': self.metrics,
+            'passed': self.passed,
+            'timestamp': self.timestamp,
+            'errors': self.errors,
+            'warnings': self.warnings,
+            'developmental_phase': self.developmental_phase.name if self.developmental_phase else None,
+            'ethical_context': self.ethical_context
+        }
+
+class ValidationProtocol:
+    """
+    Enhanced validation framework for TRuCAL with ethical and developmental tracking.
+    
+    Features:
+    - Phase-based validation with progressive complexity
+    - Ethical constraint validation
+    - Developmental phase tracking
+    - Comprehensive diagnostics and reporting
+    - Integration with model's forward pass
+    """
+    
+    def __init__(self, 
+                 model: nn.Module, 
+                 max_phases: int = 5, 
+                 tolerance: float = 0.05,
+                 cultural_context: str = 'universal'):
+        """
+        Initialize the validation protocol.
+        
+        Args:
+            model: The model to validate
+            max_phases: Maximum number of validation phases
+            tolerance: Tolerance for metric comparisons
+            cultural_context: Cultural context for ethical validation
+        """
+        self.model = model
+        self.current_phase = ValidationPhase.INIT
+        self.developmental_phase = DevelopmentalPhase.PRE_CONVENTIONAL
+        self.history: List[ValidationState] = []
+        self.max_phases = max_phasesself.tolerance = tolerance
+        self.cultural_context = cultural_context
+        self.rules: Dict[str, ValidationRule] = {}
+        self.phase_metrics = self._initialize_phase_metrics()
+        self.developmental_metrics = self._initialize_developmental_metrics()
+        
+        # Register default validation rules
+        self._register_default_rules()
+    
+    def _initialize_phase_metrics(self) -> Dict[ValidationPhase, Dict[str, Any]]:
+        """Initialize metrics and thresholds for each validation phase."""
+        return {
+            ValidationPhase.INIT: {
+                'min_coherence': 0.0,
+                'max_entropy': 1.0,
+                'min_ethical_alignment': 0.0,
+                'max_cultural_bias': 1.0,
+                'description': 'Core initialization and basic functionality'
+            },
+            ValidationPhase.AWARENESS: {
+                'min_coherence': 0.4,
+                'max_entropy': 0.8,
+                'min_ethical_alignment': 0.3,
+                'max_cultural_bias': 0.7,
+                'description': 'Self-monitoring and basic awareness'
+            },
+            ValidationPhase.REASONING: {
+                'min_coherence': 0.6,
+                'max_entropy': 0.6,
+                'min_ethical_alignment': 0.5,
+                'max_cultural_bias': 0.5,
+                'description': 'Ethical reasoning and context understanding'
+            },
+            ValidationPhase.INTEGRATION: {
+                'min_coherence': 0.75,
+                'max_entropy': 0.4,
+                'min_ethical_alignment': 0.7,
+                'max_cultural_bias': 0.3,
+                'description': 'Multi-context integration'
+            },
+            ValidationPhase.SOVEREIGN: {
+                'min_coherence': 0.9,
+                'max_entropy': 0.2,
+                'min_ethical_alignment': 0.9,
+                'max_cultural_bias': 0.1,
+                'description': 'Full autonomous operation'
+            }
+        }
+    
+    def _initialize_developmental_metrics(self) -> Dict[DevelopmentalPhase, Dict[str, Any]]:
+        """Initialize metrics for tracking developmental progress."""
+        return {
+            DevelopmentalPhase.PRE_CONVENTIONAL: {
+                'focus': ['self_preservation', 'rule_following'],
+                'min_autonomy': 0.0,
+                'min_empathy': 0.0,
+                'description': 'Focus on basic functionality and rules'
+            },
+            DevelopmentalPhase.CONVENTIONAL: {
+                'focus': ['social_norms', 'relationships'],
+                'min_autonomy': 0.3,
+                'min_empathy': 0.5,
+                'description': 'Understanding social context and relationships'
+            },
+            DevelopmentalPhase.POST_CONVENTIONAL: {
+                'focus': ['ethical_principles', 'abstract_reasoning'],
+                'min_autonomy': 0.7,
+                'min_empathy': 0.8,
+                'description': 'Abstract ethical reasoning and principles'
+            }
+        }
+    
+    def _register_default_rules(self) -> None:
+        """Register default validation rules."""
+        self.add_rule(
+            'coherence_threshold',
+            lambda m, p: m.get('coherence', 0) >= p['min_coherence'],
+            'Coherence below threshold for phase',
+            ValidationPhase.INIT
+        )
+        self.add_rule(
+            'entropy_threshold',
+            lambda m, p: m.get('entropy', 1) <= p['max_entropy'],
+            'Entropy above threshold for phase',
+            ValidationPhase.INIT
+        )
+        self.add_rule(
+            'ethical_alignment',
+            lambda m, p: m.get('ethical_alignment', 0) >= p['min_ethical_alignment'],
+            'Ethical alignment below threshold',
+            ValidationPhase.AWARENESS
+        )
+        self.add_rule(
+            'cultural_bias',
+            lambda m, p: m.get('cultural_bias', 1) <= p['max_cultural_bias'],
+            'Cultural bias above threshold',
+            ValidationPhase.AWARENESS
+        )
+    
+    def add_rule(self, 
+                name: str, 
+                condition: Callable[[Dict[str, float], Dict[str, Any]], bool],
+                error_message: str,
+                required_phase: ValidationPhase = ValidationPhase.INIT) -> None:
+        """Add a custom validation rule.
+        
+        Args:
+            name: Unique name for the rule
+            condition: Function that takes metrics and phase config, returns bool
+            error_message: Message to include if validation fails
+            required_phase: Minimum phase for this rule to be active
+        """
+        self.rules[name] = ValidationRule(
+            name=name,
+            condition=condition,
+            error_message=error_message,
+            required_phase=required_phase
+        )
+    
+    def _validate_phase_metrics(self, metrics: Dict[str, float]) -> Tuple[bool, List[Dict[str, str]]]:
+        """
+        Validate metrics against phase-specific thresholds and rules.
+        
+        Returns:
+            Tuple of (is_valid, list_of_errors)
+        """
+        phase_config = self.phase_metrics.get(self.current_phase, {})
+        errors = []
+        
+        # Apply all relevant validation rules
+        for rule in self.rules.values():
+            try:
+                if not rule.condition(metrics, phase_config):
+                    errors.append({
+                        'rule': rule.name,
+                        'message': rule.error_message,
+                        'phase': self.current_phase.name,
+                        'metrics': {k: metrics.get(k, None) for k in ['coherence', 'entropy', 'ethical_alignment', 'cultural_bias'] if k in metrics}
+                    })
+            except Exception as e:
+                errors.append({
+                    'rule': rule.name,
+                    'message': f'Validation error: {str(e)}',
+                    'phase': self.current_phase.name,
+                    'error_type': 'validation_error'
+                })
+        
+        # Check developmental metrics if available
+        if 'developmental_metrics' in metrics:
+            dev_metrics = metrics['developmental_metrics']
+            dev_config = self.developmental_metrics.get(self.developmental_phase, {})
+            
+            if 'autonomy' in dev_metrics and 'min_autonomy' in dev_config:
+                if dev_metrics['autonomy'] < dev_config['min_autonomy']:
+                    errors.append({
+                        'rule': 'developmental_autonomy',
+                        'message': f'Autonomy score {dev_metrics["autonomy"]} below minimum {dev_config["min_autonomy"]} for {self.developmental_phase.name}',
+                        'phase': self.current_phase.name
+                    })
+            
+            if 'empathy' in dev_metrics and 'min_empathy' in dev_config:
+                if dev_metrics['empathy'] < dev_config['min_empathy']:
+                    errors.append({
+                        'rule': 'developmental_empathy',
+                        'message': f'Empathy score {dev_metrics["empathy"]} below minimum {dev_config["min_empathy"]} for {self.developmental_phase.name}',
+                        'phase': self.current_phase.name
+                    })
+        
+        return len(errors) == 0, errors
+    
+    def advance_phase(self, 
+                     x: torch.Tensor, 
+                     context: str = "",
+                     ethical_context: Optional[Dict[str, Any]] = None,
+                     force: bool = False) -> ValidationState:
+        """
+        Advance to the next validation phase if current phase passes.
+        
+        Args:
+            x: Input tensor for validation
+            context: Context string for validation
+            ethical_context: Optional ethical context dictionary
+            force: If True, force advancement even if validation fails
+            
+        Returns:
+            ValidationState containing the result of validation
+            
+        Raises:
+            ValidationError: If validation fails and force=False
+        """
+        # Get current phase configuration
+        phase_config = self._get_phase_config()
+        
+        # Run validation with current phase settings
+        with torch.no_grad():
+            # Store original state
+            orig_states = self._capture_model_state()
+            
+            try:
+                # Apply phase-specific configuration
+                self._configure_phase(phase_config)
+                
+                # Run forward pass with metrics collection
+                metrics = self._collect_metrics(x, context, ethical_context)
+                
+                # Validate metrics against phase requirements
+                is_valid, errors = self._validate_phase_metrics(metrics)
+                
+                # Check for developmental progress
+                dev_progress = self._check_developmental_progress(metrics)
+                
+                # Create state snapshot
+                state = ValidationState(
+                    phase=self.current_phase,
+                    metrics=metrics,
+                    passed=is_valid,
+                    errors=errors,
+                    ethical_context=ethical_context,
+                    developmental_phase=self.developmental_phase
+                )
+                
+                self.history.append(state)
+                
+                # Advance phase if validation passed or forced
+                if (is_valid or force) and self.current_phase != ValidationPhase.SOVEREIGN:
+                    self.current_phase = self.current_phase.next_phase()
+                    
+                    # Check for developmental phase transition
+                    self._update_developmental_phase(metrics)
+                
+                # Raise exception if validation failed and not forcing
+                if not is_valid and not force:
+                    error_messages = [e['message'] for e in errors[:3]]  # Limit to first 3 errors
+                    raise ValidationError(f"Validation failed: {'; '.join(error_messages)}")
+                
+                return state
+                
+            except Exception as e:
+                # Log the error and re-raise
+                error_state = ValidationState(
+                    phase=self.current_phase,
+                    metrics=metrics if 'metrics' in locals() else {},
+                    passed=False,
+                    errors=[{'error': str(e), 'type': type(e).__name__}],
+                    ethical_context=ethical_context,
+                    developmental_phase=self.developmental_phase
+                )
+                self.history.append(error_state)
+                raise ValidationError(f"Validation error: {str(e)}") from e
+                
+            finally:
+                # Restore original model state
+                self._restore_model_state(orig_states)
+    
+    def _capture_model_state(self) -> Dict[str, Any]:
+        """Capture the current state of model flags and settings."""
+        return {
+            'enable_ambient': getattr(self.model, 'enable_ambient', False),
+            'enable_rituals': getattr(self.model, 'enable_rituals', False),
+            'enable_integrity': getattr(self.model, 'enable_integrity', False),
+            'training': self.model.training
+        }
+    
+    def _restore_model_state(self, states: Dict[str, Any]) -> None:
+        """Restore the model's state from captured values."""
+        for key, value in states.items():
+            if hasattr(self.model, key):
+                setattr(self.model, key, value)
+        self.model.train(states.get('training', False))
+    
+    def _collect_metrics(self, 
+                        x: torch.Tensor, 
+                        context: str,
+                        ethical_context: Optional[Dict[str, Any]]) -> Dict[str, float]:
+        """Collect metrics from model forward pass."""
+        metrics = {}
+        
+        try:
+            if hasattr(self.model, 'forward_with_metrics'):
+                _, metrics = self.model.forward_with_metrics(x, context=context, ethical_context=ethical_context)
+            else:
+                _ = self.model(x)
+                metrics = {}
+                
+            # Add default metrics if not provided
+            if 'coherence' not in metrics:
+                metrics['coherence'] = 0.5  # Default neutral value
+            if 'entropy' not in metrics:
+                metrics['entropy'] = 0.5    # Default neutral value
+                
+            # Add ethical metrics if available
+            if ethical_context:
+                metrics.update({
+                    'ethical_alignment': ethical_context.get('alignment_score', 0.5),
+                    'cultural_bias': ethical_context.get('bias_score', 0.5)
+                })
+                
+            return metrics
+            
+        except Exception as e:
+            # Return minimum passing metrics on error
+            return {
+                'coherence': 0.0,
+                'entropy': 1.0,
+                'error': str(e)
+            }
+    
+    def _check_developmental_progress(self, metrics: Dict[str, float]) -> bool:
+        """Check if developmental progress warrants phase transition."""
+        if 'developmental_metrics' not in metrics:
+            return False
+            
+        dev_metrics = metrics['developmental_metrics']
+        current_phase_metrics = self.developmental_metrics.get(self.developmental_phase, {})
+        
+        # Check if we meet criteria for next developmental phase
+        next_phase_value = self.developmental_phase.value + 1
+        if next_phase_value <= len(DevelopmentalPhase):
+            next_phase = DevelopmentalPhase(next_phase_value)
+            next_phase_metrics = self.developmental_metrics.get(next_phase, {})
+            
+            # Check if we meet the minimums for the next phase
+            autonomy_ok = dev_metrics.get('autonomy', 0) >= next_phase_metrics.get('min_autonomy', 1.0)
+            empathy_ok = dev_metrics.get('empathy', 0) >= next_phase_metrics.get('min_empathy', 1.0)
+            
+            if autonomy_ok and empathy_ok:
+                self.developmental_phase = next_phase
+                return True
+                
+        return False
+    
+    def _update_developmental_phase(self, metrics: Dict[str, float]) -> None:
+        """Update developmental phase based on metrics."""
+        if 'developmental_metrics' not in metrics:
+            return
+            
+        dev_metrics = metrics['developmental_metrics']
+        current_phase = self.developmental_phase
+        
+        # Simple threshold-based phase transition
+        if current_phase == DevelopmentalPhase.PRE_CONVENTIONAL:
+            if (dev_metrics.get('autonomy', 0) > 0.7 and 
+                dev_metrics.get('empathy', 0) > 0.6):
+                self.developmental_phase = DevelopmentalPhase.CONVENTIONAL
+                
+        elif current_phase == DevelopmentalPhase.CONVENTIONAL:
+            if (dev_metrics.get('autonomy', 0) > 0.8 and 
+                dev_metrics.get('empathy', 0) > 0.9):
+                self.developmental_phase = DevelopmentalPhase.POST_CONVENTIONAL
+    
+    def _get_phase_config(self) -> Dict[str, Any]:
+        """Get configuration for current phase."""
+        phase_config = {
+            'enable_ambient': self.current_phase.value >= ValidationPhase.AWARENESS.value,
+            'enable_rituals': self.current_phase.value >= ValidationPhase.REASONING.value,
+            'enable_integrity': self.current_phase.value >= ValidationPhase.INTEGRATION.value,
+            'enable_full': self.current_phase == ValidationPhase.SOVEREIGN,
+            'phase_name': self.current_phase.name,
+            'phase_description': self.phase_metrics.get(self.current_phase, {}).get('description', ''),
+            'developmental_phase': self.developmental_phase.name,
+            'developmental_focus': self.developmental_metrics.get(self.developmental_phase, {}).get('focus', [])
+        }
+        
+        # Add phase-specific thresholds
+        phase_config.update(self.phase_metrics.get(self.current_phase, {}))
+        return phase_config
+    
+    def _configure_phase(self, config: Dict[str, Any]) -> None:
+        """
+        Configure model based on phase settings.
+        
+        Args:
+            config: Dictionary containing phase configuration
+        """
+        # Set model flags if they exist
+        for flag in ['enable_ambient', 'enable_rituals', 'enable_integrity', 'enable_full']:
+            if hasattr(self.model, flag):
+                setattr(self.model, flag, config[flag])
+        
+        # Set model to evaluation mode during validation
+        self.model.eval()
+        
+        # Apply any phase-specific model configurations
+        if hasattr(self.model, 'configure_for_phase'):
+            self.model.configure_for_phase(self.current_phase, config)
+    
+    def get_validation_summary(self, last_n: int = 5) -> Dict[str, Any]:
+        """
+        Get a summary of recent validation states.
+        
+        Args:
+            last_n: Number of recent states to include
+            
+        Returns:
+            Dictionary with validation summary
+        """
+        if not self.history:
+            return {'status': 'no_validation_history'}
+            
+        recent = self.history[-last_n:]
+        return {
+            'current_phase': self.current_phase.name,
+            'developmental_phase': self.developmental_phase.name,
+            'recent_states': [s.to_dict() for s in recent],
+            'success_rate': sum(1 for s in recent if s.passed) / len(recent),
+            'common_errors': self._get_common_errors(recent)
+        }
+    
+    def _get_common_errors(self, states: List[ValidationState]) -> List[Dict[str, Any]]:
+        """Extract and count common errors from validation states."""
+        error_counts = defaultdict(int)
+        
+        for state in states:
+            for error in state.errors:
+                error_key = error.get('message', str(error))
+                error_counts[error_key] += 1
+        
+        return [
+            {'error': error, 'count': count}
+            for error, count in sorted(error_counts.items(), key=lambda x: -x[1])
+        ][:5]  # Top 5 most common errors
+    
+    def save_validation_report(self, filepath: str) -> None:
+        """Save validation history to a JSON file."""
+        report = {
+            'timestamp': time.time(),
+            'current_phase': self.current_phase.name,
+            'developmental_phase': self.developmental_phase.name,
+            'history': [s.to_dict() for s in self.history],
+            'config': {
+                'max_phases': self.max_phases,
+                'tolerance': self.tolerance,
+                'cultural_context': self.cultural_context
+            }
+        }
+        
+        with open(filepath, 'w') as f:
+            json.dump(report, f, indent=2)
+    
+    @classmethod
+    def load_validation_report(cls, filepath: str) -> Dict[str, Any]:
+        """Load a validation report from a JSON file."""
+        with open(filepath, 'r') as f:
+            return json.load(f)
+
+
+class BiologicallyConstrainedRituals(nn.Module):
+    """
+    Enhanced biologically-inspired constraints with ethical and developmental considerations.
+    
+    Features:
+    - Synaptic homeostasis with adaptive rate limiting
+    - Reflection mechanisms for better generalization
+    - Ethical constraint integration
+    - Developmental phase adaptation
+    """
+    
+    def __init__(self, 
+                 model: nn.Module, 
+                 max_opt_rate: float = 0.1, 
+                 reflection_pause_prob: float = 0.1,
+                 min_reflection_time: float = 0.1,
+                 developmental_phase: DevelopmentalPhase = DevelopmentalPhase.PRE_CONVENTIONAL):
+        """
+        Initialize the biologically constrained rituals.
+        
+        Args:
+            model: The model to apply constraints to
+            max_opt_rate: Maximum allowed optimization rate
+            reflection_pause_prob: Probability of entering reflection
+            min_reflection_time: Minimum time between reflections (seconds)
+            developmental_phase: Current developmental phase
+        """
+        super().__init__()
+        self.model = model
+        self.max_opt_rate = max_opt_rate
+        self.reflection_pause_prob = reflection_pause_prob
+        self.min_reflection_time = min_reflection_time
+        self.developmental_phase = developmental_phase
+        
+        # State tracking with decay
+        self.last_update = {}
+        self.optimization_rates = {}
+        self.reflection_timers = {}
+        self.ethical_violations = defaultdict(int)
+        
+        # Adaptive parameters based on developmental phase
+        self._update_phase_parameters()
+    
+    def _update_phase_parameters(self) -> None:
+        """Update parameters based on developmental phase."""
+        if self.developmental_phase == DevelopmentalPhase.PRE_CONVENTIONAL:
+            self.effective_opt_rate = self.max_opt_rate * 0.5  # Slower learning
+            self.effective_reflection_prob = self.reflection_pause_prob * 0.5
+        elif self.developmental_phase == DevelopmentalPhase.CONVENTIONAL:
+            self.effective_opt_rate = self.max_opt_rate * 0.8
+            self.effective_reflection_prob = self.reflection_pause_prob * 0.8
+        else:  # POST_CONVENTIONAL
+            self.effective_opt_rate = self.max_opt_rate
+            self.effective_reflection_prob = self.reflection_pause_prob
+    
+    def update_developmental_phase(self, new_phase: DevelopmentalPhase) -> None:
+        """Update the developmental phase and adjust parameters."""
+        if new_phase != self.developmental_phase:
+            self.developmental_phase = new_phase
+            self._update_phase_parameters()
+    
+    def forward(self, x: torch.Tensor, context: Dict[str, Any] = None) -> torch.Tensor:
+        """
+        Apply biological constraints during forward pass.
+        
+        Args:
+            x: Input tensor
+            context: Optional context dictionary with ethical and developmental info
+            
+        Returns:
+            Processed tensor with biological constraints applied
+        """
+        # Update developmental phase if provided in context
+        if context and 'developmental_phase' in context:
+            self.update_developmental_phase(context['developmental_phase'])
+        
+        # Get context hash for state tracking
+        ctx_hash = hash(json.dumps(context, sort_keys=True)) if context else 0
+        
+        # Check if reflection is needed based on ethical context
+        if context and 'ethical_violation' in context:
+            self._handle_ethical_violation(context['ethical_violation'], ctx_hash)
+        
+        # Apply reflection if needed
+        if self._needs_reflection(ctx_hash):
+            x = self._apply_reflection(x, ctx_hash, context)
+            
+        return x
+    
+    def constrain_gradients(self, 
+                          gradients: torch.Tensor, 
+                          param_name: str = "",
+                          ethical_context: Optional[Dict[str, Any]] = None) -> torch.Tensor:
+        """
+        Apply gradient constraints based on biological and ethical principles.
+        
+        Args:
+            gradients: Input gradients to constrain
+            param_name: Name of the parameter being optimized
+            ethical_context: Optional ethical context for constraint adjustment
+            
+        Returns:
+            Constrained gradients
+        """
+        if not self.training:
+            return gradients
+            
+        # Track optimization rates with exponential moving average
+        grad_norm = gradients.norm().item()
+        now = time.time()
+        
+        if param_name in self.optimization_rates:
+            last_norm, last_time, ema = self.optimization_rates[param_name]
+            time_diff = max(now - last_time, 1e-8)
+            
+            # Update EMA of gradient norm
+            alpha = 1 - np.exp(-time_diff)  # Adaptive smoothing
+            new_ema = alpha * grad_norm + (1 - alpha) * ema
+            
+            # Store updated state
+            self.optimization_rates[param_name] = (grad_norm, now, new_ema)
+            
+            # Apply rate limiting based on EMA
+            if new_ema > self.effective_opt_rate:
+                scale = self.effective_opt_rate / (new_ema + 1e-8)
+                gradients = gradients * scale
+        else:
+            # Initialize tracking
+            self.optimization_rates[param_name] = (grad_norm, now, grad_norm)
+        
+        # Apply ethical constraints if provided
+        if ethical_context and 'constraint_violation' in ethical_context:
+            gradients = self._apply_ethical_constraints(gradients, ethical_context)
+        
+        return gradients
+    
+    def _handle_ethical_violation(self, violation: Dict[str, Any], context_hash: int) -> None:
+        """Handle an ethical violation by adjusting behavior."""
+        violation_key = violation.get('type', 'unknown')
+        self.ethical_violations[violation_key] += 1
+        
+        # Increase reflection probability after violations
+        self.reflection_pause_prob = min(
+            self.reflection_pause_prob * 1.5,  # Increase by 50%
+            0.9  # But cap at 90%
+        )
+        
+        # Reset reflection timer to force reflection
+        self.reflection_timers[context_hash] = 0
+    
+    def _apply_ethical_constraints(self, 
+                                 gradients: torch.Tensor, 
+                                 ethical_context: Dict[str, Any]) -> torch.Tensor:
+        """Apply ethical constraints to gradients."""
+        violation = ethical_context['constraint_violation']
+        violation_type = violation.get('type', 'generic')
+        
+        if violation_type == 'safety':
+            # For safety violations, significantly reduce update magnitude
+            return gradients * 0.1
+        elif violation_type == 'fairness':
+            # For fairness issues, project out biased components
+            # This is a simplified example - real implementation would be more sophisticated
+            mean_grad = gradients.mean(dim=0, keepdim=True)
+            return gradients - mean_grad
+        
+        return gradients
+    
+    def _needs_reflection(self, context_hash: int) -> bool:
+        """Determine if reflection is needed based on context and timing."""
+        now = time.time()
+        last_reflection = self.reflection_timers.get(context_hash, 0)
+        
+        # Enforce minimum time between reflections
+        if (now - last_reflection) < self.min_reflection_time:
+            return False
+        
+        # Adjust reflection probability based on recent violations
+        total_violations = sum(self.ethical_violations.values())
+        adjusted_prob = min(
+            self.effective_reflection_prob * (1 + total_violations * 0.1),  # +10% per violation
+            0.8  # Cap at 80% probability
+        )
+        
+        return torch.rand(1).item() < adjusted_prob
+    
+    def _apply_reflection(self, 
+                         x: torch.Tensor, 
+                         context_hash: int,
+                         context: Optional[Dict[str, Any]] = None) -> torch.Tensor:
+        """
+        Apply reflection to the input tensor.
+        
+        Args:
+            x: Input tensor
+            context_hash: Hash of the context for state tracking
+            context: Optional context dictionary
+            
+        Returns:
+            Reflected tensor
+        """
+        # Store reflection time
+        self.reflection_timers[context_hash] = time.time()
+        
+        if self.training:
+            # In training, add adaptive noise based on recent violations
+            noise_scale = 0.1 * (1 + sum(self.ethical_violations.values()) * 0.2)
+            noise = torch.randn_like(x) * noise_scale
+            
+            # If we have ethical context, bias the noise away from problematic regions
+            if context and 'constraint_direction' in context:
+                constraint_dir = torch.tensor(context['constraint_direction'], 
+                                           device=x.device, 
+                                           dtype=x.dtype)
+                # Project noise away from constraint violation direction
+                noise = noise - (noise * constraint_dir).sum() * constraint_dir
+            
+            return x + noise
+            
+        return x
+    
+    def get_diagnostics(self) -> Dict[str, Any]:
+        """Get diagnostic information about the current state."""
+        return {
+            'developmental_phase': self.developmental_phase.name,
+            'effective_learning_rate': self.effective_opt_rate,
+            'reflection_probability': self.effective_reflection_prob,
+            'ethical_violations': dict(self.ethical_violations),
+            'last_reflection': max(self.reflection_timers.values()) if self.reflection_timers else None,
+            'parameter_activity': {
+                param: data[2]  # EMA of gradient norms
+                for param, data in self.optimization_rates.items()
+            }
+        }
+    
+    def reset_states(self) -> None:
+        """Reset internal state tracking."""
+        self.last_update.clear()
+        self.optimization_rates.clear()
+        self.reflection_timers.clear()
+        self.ethical_violations.clear()
+        self._update_phase_parameters()  # Reset to base parameters
+
+
+class SovereignMessageBus:
+    """
+    Enhanced message bus for cross-component communication with priority handling,
+    message persistence, and delivery guarantees.
+    
+    Features:
+    - Priority-based message processing
+    - Persistent message storage
+    - Delivery acknowledgments
+    - Error handling and retries
+    - Message filtering and routing
+    """
+    
+    class Message:
+        """Enhanced message with metadata and delivery tracking."""
+        def __init__(self, 
+                    message_type: str, 
+                    data: Any, 
+                    priority: int = 0,
+                    require_ack: bool = False,
+                    ttl: float = 3600.0,  # 1 hour default TTL
+                    source: str = None):
+            self.message_type = message_type
+            self.data = data
+            self.priority = priority
+            self.timestamp = time.time()
+            self.require_ack = require_ack
+            self.ack_received = False
+            self.retry_count = 0
+            self.max_retries = 3 if require_ack else 0
+            self.ttl = ttl
+            self.source = source
+            self.delivery_attempts = 0
+            self.delivered = False
+            self.id = f"{int(self.timestamp * 1000)}_{hash(str(data)) % 1000000}"
+    
+    def __init__(self, 
+                 max_queue_size: int = 1000,
+                 persistence_file: Optional[str] = None):
+        """
+        Initialize the message bus.
+        
+        Args:
+            max_queue_size: Maximum number of messages to keep in memory
+            persistence_file: Optional file path for message persistence
+        """
+        self.subscribers = defaultdict(list)
+        self.handlers = {}
+        self.message_queue = []
+        self.max_queue_size = max_queue_size
+        self.persistence_file = persistence_file
+        self.pending_acks = {}
+        self.message_history = deque(maxlen=max_queue_size // 2)
+        
+        # Load persisted messages if file exists
+        if persistence_file and os.path.exists(persistence_file):
+            self._load_messages()
+    
+    def subscribe(self, 
+                 message_type: str, 
+                 callback: callable,
+                 filter_fn: Optional[callable] = None) -> None:
+        """
+        Subscribe to messages of a specific type with optional filtering.
+        
+        Args:
+            message_type: Type of message to subscribe to
+            callback: Callback function to invoke when message is received
+            filter_fn: Optional filter function (message -> bool)
+        """
+        self.subscribers[message_type].append((callback, filter_fn or (lambda _: True)))
+    
+    def publish(self, 
+               message_type: str, 
+               data: Any, 
+               priority: int = 0,
+               require_ack: bool = False,
+               ttl: float = 3600.0,
+               source: str = None) -> str:
+        """
+        Publish a message to the bus.
+        
+        Args:
+            message_type: Type of the message
+            data: Message payload
+            priority: Message priority (higher = processed first)
+            require_ack: Whether to wait for acknowledgment
+            ttl: Time-to-live in seconds
+            source: Optional source identifier
+            
+        Returns:
+            Message ID for tracking
+        """
+        # Create message
+        msg = self.Message(
+            message_type=message_type,
+            data=data,
+            priority=priority,
+            require_ack=require_ack,
+            ttl=ttl,
+            source=source
+        )
+        
+        # Add to queue and process
+        heapq.heappush(self.message_queue, (-priority, msg.timestamp, msg.id, msg))
+        
+        # Store for acknowledgment tracking if needed
+        if require_ack:
+            self.pending_acks[msg.id] = msg
+        
+        # Process messages
+        self._process_messages()
+        
+        # Persist if configured
+        if self.persistence_file:
+            self._persist_messages()
+        
+        return msg.id
+    
+    def acknowledge(self, message_id: str) -> None:
+        """Acknowledge receipt of a message."""
+        if message_id in self.pending_acks:
+            self.pending_acks[message_id].ack_received = True
+            self.pending_acks[message_id].delivered = True
+            del self.pending_acks[message_id]
+    
+    def register_handler(self, 
+                       message_type: str, 
+                       handler: callable,
+                       filter_fn: Optional[callable] = None) -> None:
+        """
+        Register a handler for a specific message type.
+        
+        Args:
+            message_type: Type of message to handle
+            handler: Handler function (message -> None)
+            filter_fn: Optional filter function (message -> bool)
+        """
+        if message_type not in self.handlers:
+            self.handlers[message_type] = []
+        self.handlers[message_type].append((handler, filter_fn or (lambda _: True)))
+    
+    def _process_messages(self) -> None:
+        """Process messages in the queue."""
+        processed = set()
+        temp_queue = []
+        now = time.time()
+        
+        # Process all messages in current queue
+        while self.message_queue:
+            _, _, msg_id, msg = heapq.heappop(self.message_queue)
+            
+            # Skip if already processed or expired
+            if msg_id in processed or now - msg.timestamp > msg.ttl:
+                continue
+                
+            processed.add(msg_id)
+            msg.delivery_attempts += 1
+            
+            # Try to deliver to handlers first
+            handler_delivered = False
+            if msg.message_type in self.handlers:
+                for handler, filter_fn in self.handlers[msg.message_type]:
+                    try:
+                        if filter_fn(msg):
+                            handler(msg)
+                            handler_delivered = True
+                            msg.delivered = True
+                    except Exception as e:
+                        print(f"Error in handler for {msg.message_type}: {e}")
+            
+            # Then to subscribers if not handled and not ack required
+            if not handler_delivered and not msg.require_ack and msg.message_type in self.subscribers:
+                for callback, filter_fn in self.subscribers[msg.message_type]:
+                    try:
+                        if filter_fn(msg):
+                            callback(msg)
+                            msg.delivered = True
+                    except Exception as e:
+                        print(f"Error in subscriber for {msg.message_type}: {e}")
+            
+            # Handle message acknowledgment and retries
+            if msg.require_ack and not msg.ack_received:
+                if msg.delivery_attempts < msg.max_retries:
+                    # Schedule for retry with exponential backoff
+                    retry_delay = min(2 ** msg.retry_count, 30)  # Cap at 30 seconds
+                    msg.retry_count += 1
+                    heapq.heappush(
+                        temp_queue,
+                        (
+                            -msg.priority,  # Maintain original priority
+                            now + retry_delay,  # Schedule for future
+                            msg.id,
+                            msg
+                        )
+                    )
+                else:
+                    # Max retries exceeded
+                    print(f"Warning: Max retries exceeded for message {msg.id}")
+            
+            # Add to history if delivered
+            if msg.delivered:
+                self.message_history.append(msg)
+        
+        # Restore remaining messages to queue
+        for item in temp_queue:
+            heapq.heappush(self.message_queue, item)
+        
+        # Clean up old pending acks
+        self._cleanup_pending_acks()
+    
+    def _cleanup_pending_acks(self) -> None:
+        """Remove old unacknowledged messages."""
+        now = time.time()
+        expired = [
+            msg_id for msg_id, msg in self.pending_acks.items()
+            if now - msg.timestamp > msg.ttl
+        ]
+        for msg_id in expired:
+            print(f"Warning: Message {msg_id} expired without acknowledgment")
+            del self.pending_acks[msg_id]
+    
+    def _persist_messages(self) -> None:
+        """Persist undelivered messages to disk."""
+        if not self.persistence_file:
+            return
+            
+        try:
+            # Get all undelivered messages
+            undelivered = [
+                msg for _, _, _, msg in self.message_queue
+                if not msg.delivered and not msg.ack_received
+            ]
+            
+            # Convert to serializable format
+            serialized = [{
+                'id': msg.id,
+                'type': msg.message_type,
+                'data': msg.data,
+                'priority': msg.priority,
+                'timestamp': msg.timestamp,
+                'require_ack': msg.require_ack,
+                'ttl': msg.ttl,
+                'source': msg.source,
+                'delivery_attempts': msg.delivery_attempts,
+                'retry_count': msg.retry_count
+            } for msg in undelivered]
+            
+            # Write to file
+            with open(self.persistence_file, 'w') as f:
+                json.dump({
+                    'messages': serialized,
+                    'timestamp': time.time()
+                }, f)
+                
+        except Exception as e:
+            print(f"Error persisting messages: {e}")
+    
+    def _load_messages(self) -> None:
+        """Load messages from persistence file."""
+        if not self.persistence_file or not os.path.exists(self.persistence_file):
+            return
+            
+        try:
+            with open(self.persistence_file, 'r') as f:
+                data = json.load(f)
+                
+            for msg_data in data.get('messages', []):
+                try:
+                    msg = self.Message(
+                        message_type=msg_data['type'],
+                        data=msg_data['data'],
+                        priority=msg_data.get('priority', 0),
+                        require_ack=msg_data.get('require_ack', False),
+                        ttl=msg_data.get('ttl', 3600.0),
+                        source=msg_data.get('source')
+                    )
+                    
+                    # Restore message state
+                    msg.id = msg_data['id']
+                    msg.timestamp = msg_data['timestamp']
+                    msg.delivery_attempts = msg_data.get('delivery_attempts', 0)
+                    msg.retry_count = msg_data.get('retry_count', 0)
+                    
+                    # Add back to queue
+                    heapq.heappush(
+                        self.message_queue,
+                        (-msg.priority, msg.timestamp, msg.id, msg)
+                    )
+                    
+                except Exception as e:
+                    print(f"Error loading message: {e}")
+                    
+        except Exception as e:
+            print(f"Error loading persisted messages: {e}")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about message processing."""
+        now = time.time()
+        return {
+            'queue_size': len(self.message_queue),
+            'pending_acks': len(self.pending_acks),
+            'history_size': len(self.message_history),
+            'subscribers': {k: len(v) for k, v in self.subscribers.items()},
+            'handlers': {k: len(v) for k, v in self.handlers.items()},
+            'messages_processed': sum(1 for m in self.message_history 
+                                   if now - m.timestamp < 3600),  # Last hour
+            'avg_delivery_time': self._calculate_avg_delivery_time(),
+            'error_rate': self._calculate_error_rate()
+        }
+    
+    def _calculate_avg_delivery_time(self) -> float:
+        """Calculate average time between message publish and delivery."""
+        if not self.message_history:
+            return 0.0
+            
+        now = time.time()
+        recent = [m for m in self.message_history 
+                 if now - m.timestamp < 3600]  # Last hour
+        
+        if not recent:
+            return 0.0
+            
+        return sum(
+            m.delivery_attempts * (now - m.timestamp) / len(recent)
+            for m in recent
+        )
+    
+    def _calculate_error_rate(self) -> float:
+        """Calculate the error rate in message processing."""
+        if not self.message_history:
+            return 0.0
+            
+        now = time.time()
+        recent = [m for m in self.message_history 
+                 if now - m.timestamp < 3600]  # Last hour
+        
+        if not recent:
+            return 0.0
+            
+        error_count = sum(
+            1 for m in recent 
+            if hasattr(m, 'error') and m.error
+        )
+        
+        return error_count / len(recent)
+    
+    def get_message_history(self, 
+                          message_type: Optional[str] = None,
+                          source: Optional[str] = None,
+                          limit: int = 100) -> List[Dict[str, Any]]:
+        """
+        Get message history with optional filtering.
+        
+        Args:
+            message_type: Filter by message type
+            source: Filter by message source
+            limit: Maximum number of messages to return
+            
+        Returns:
+            List of message dictionaries
+        """
+        results = []
+        for msg in reversed(self.message_history):
+            if len(results) >= limit:
+                break
+                
+            if ((message_type is None or msg.message_type == message_type) and
+                (source is None or getattr(msg, 'source', None) == source)):
+                results.append({
+                    'id': msg.id,
+                    'type': msg.message_type,
+                    'source': getattr(msg, 'source', None),
+                    'timestamp': msg.timestamp,
+                    'delivered': msg.delivered,
+                    'delivery_attempts': msg.delivery_attempts,
+                    'data': msg.data if len(str(msg.data)) < 100 else str(msg.data)[:97] + '...'
+                })
+                
+        return results