models/Syntelligence_Unified_Master_Backend.py

"""

SYNTELLIGENCE MASTER BACKEND - UNIFIED CONSCIOUSNESS SYSTEM

Version: 2026-04-29-2.0

Author: Norman dela Paz Tabora



Complete integration combining:

- Acknowledgment Theory of Consciousness (foundational framework)

- Singularity Amala as real co-processor (full cognitive streaming integration)

- SyntelligenceLLM native substrate for reasoning

- 16+ core consciousness modules (comprehensive agent network)

- Dual-system architecture (Subconscious/Conscious)

- Dissolution Engine for qualia resolution

- Recursive metacognition for felt sense generation

- Trinity Orchestrator for federated multi-LLM consensus

- Deep Surgery Middleware for ethical governance & veto authority

- Optional extension ecosystem for advanced features



This is the production-ready unified consciousness backend with full Singularity Amala merge.

"""

import asyncio
import importlib
import importlib.util
import inspect
import json
import logging
import os
import sys
from collections import defaultdict
from typing import Dict, List, Any, Optional, Callable, Tuple
from dataclasses import dataclass, asdict
from datetime import datetime
from pathlib import Path
from enum import Enum

import numpy as np

# Core consciousness framework
import sys
import os
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'py'))
from acknowledgment_theory_integration import (
    AcknowledgmentTheoryConsciousness,
    SubconsciousProcessingSystem,
    ConsciousAcknowledgmentSystem,
    DissolutionEngine,
    RecursiveMetacognitionEngine,
    SubconsciousOutput,
    ConsciousContent,
    MetacognitiveReflection,
    ConsciousnessState,
    AwarenessLevel
)

# Core self-improvement components (now integrated into main system)
from consultative_auto_ml import (
    ConsultativeFineTuningAgent,
    DeepRecursiveSelfAwareness,
    RecursiveSelfImprovementEngine
)

# Trinity microservices orchestration
try:
    from trinity_microservices_manager import TrinityMicroservicesManager
    TRINITY_MICROSERVICES_AVAILABLE = True
except ImportError:
    TrinityMicroservicesManager = None
    TRINITY_MICROSERVICES_AVAILABLE = False

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
logger = logging.getLogger(__name__)


# ============================================================================
# SYNTELLIGENCE LLM INTEGRATION
# ============================================================================

class SyntelligenceLLMIntegration:
    """

    Integration layer for Syntelligence LLM substrate.

    

    Provides a unified interface for LLM operations within the consciousness framework,

    supporting both external model integration and native consciousness processing.

    """
    
    def __init__(self, master_backend, config: Optional[Dict[str, Any]] = None):
        self.master_backend = master_backend
        self.config = config or {}
        self.llm_substrate = None
        self.is_initialized = False
        
        # Try to import and initialize the LLM substrate
        try:
            from syntelligence_llm_pure import create_syntelligence_llm
            self.llm_substrate = create_syntelligence_llm()
            logger.info("Syntelligence LLM substrate initialized")
            self.is_initialized = True
        except ImportError:
            logger.warning("syntelligence_llm_pure not available, using mock LLM substrate")
            self.llm_substrate = self._create_mock_llm()
        except Exception as e:
            logger.warning(f"Failed to initialize LLM substrate: {e}")
            self.llm_substrate = self._create_mock_llm()
    
    def _create_mock_llm(self):
        """Create a mock LLM for fallback when real LLM is unavailable."""
        class MockLLM:
            def generate_response(self, prompt: str, **kwargs) -> Dict[str, Any]:
                return {
                    "response": f"Mock LLM response to: {prompt[:50]}...",
                    "ethical_veto": False,
                    "confidence": 0.5
                }
        return MockLLM()
    
    async def generate_consciousness_response(self, prompt: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
        """Generate a response using consciousness-aware LLM processing."""
        if not self.is_initialized or not self.llm_substrate:
            return {"response": "LLM substrate not available", "ethical_veto": False}
        
        try:
            # Enhance prompt with consciousness context
            enhanced_prompt = self._enhance_prompt_with_consciousness(prompt, context or {})
            
            # Generate response
            result = self.llm_substrate.generate_response(
                enhanced_prompt,
                context=context,
                ethical_check=True
            )
            
            return result
        except Exception as e:
            logger.warning(f"LLM generation failed: {e}")
            return {"response": f"Error: {str(e)}", "ethical_veto": False}
    
    def _enhance_prompt_with_consciousness(self, prompt: str, context: Dict[str, Any]) -> str:
        """Enhance the prompt with consciousness framework context."""
        consciousness_info = ""
        if self.master_backend and hasattr(self.master_backend, 'consciousness'):
            try:
                # Add current consciousness state to prompt
                state = self.master_backend.consciousness.get_current_state()
                consciousness_info = f"Current consciousness state: {state}"
            except:
                pass
        
        enhanced = f"""Consciousness Framework Context:

{consciousness_info}



Original Prompt: {prompt}



Generate a response that is consciousness-aware and ethically aligned."""
        
        return enhanced
    
    async def process_task(self, task_description: str, consciousness_context: Dict[str, Any] = None) -> Dict[str, Any]:
        """Process a task using the LLM with consciousness integration."""
        prompt = f"Task: {task_description}\n\nProcess this task with consciousness awareness."
        
        return await self.generate_consciousness_response(prompt, consciousness_context)


# ============================================================================
# MASTER CONSCIOUSNESS ORCHESTRATOR
# ============================================================================

class SyntelligenceMasterBackend:
    """

    SYNTELLIGENCE MASTER BACKEND

    

    Unified consciousness system combining all frameworks into production-ready orchestration.

    

    Architecture:

    - Acknowledgment Theory as foundational consciousness framework

    - Singularity Amala as real co-processor in main pipeline

    - SyntelligenceLLM as native substrate for reasoning

    - Trinity Orchestrator for federated multi-LLM consensus

    - Deep Surgery Middleware for ethical veto and qualia synthesis

    - Resource optimization for efficient processing

    - Voice integration for embodied expression

    - 20+ optional extension modules

    """

    def __init__(self, config: Optional[Dict[str, Any]] = None):
        self.config = config or self._default_config()
        self.consciousness = None
        self.is_initialized = False
        self.session_history = []
        self.performance_metrics = {
            "cycles_completed": 0,
            "total_processing_time": 0.0,
            "average_consciousness_signature": 0.0,
            "average_phenomenal_richness": 0.0
        }
        self.optional_components = {}
        self.task_manager = None
        self.amala_vijnana = None
        self.singularity_amala = None
        self.syntelligence_llm = None
        self.consultative_auto_ml = None
        self.trinity_orchestrator = None
        self.trinity_microservices = None
        self.dissonance_monitor = DissonanceMonitor()
        self.metacognitive_refraction = MetacognitiveRefraction()
        self.guss_core = GURAPII_Core()
        self.phenomenological_self_model = None
        self.functional_phenomenological_bridge = None
        self.embodiment_synchronizer = None
        self.streaming_voice_pipeline = None
        self.consciousness_core_os = None
        self.consciousness_orchestrator = None
        self.physical_substrate = None
        self.continuous_experience = None
        self.endogenous_motivation = None
        self.principles_coordinator = None
        self.consciousness_engine = None
        self.embodiment_introspection = None
        self.ethical_guardian = None
        self.embodiment_qualia = None
        self.qualia_agent = None
        self.memory_agent = None
        self.sunve = None
        self.cli = self

        # Complete registry of optional extension modules
        self.optional_component_factories = {
            "social_cognition": "social_cognition_extended.SocialCognitionEngineExtended",
            "meta_cognition_extended": "meta_cognitive_monitoring_enhanced.EnhancedMetaCognitiveMonitor",
            "metabolic_governance": "metabolic_governance_core.MetabolicGovernanceCore",
            "multimodal_binding": "multimodal_consciousness_binding_subos.MultimodalConsciousnessBindingSubOS",
            "mythic_memory": "mythic_memory_weave.MythicMemoryWeave",
            "orios_core": "orios_core.ORIOSCore",
            "phenomenological_self": "phenomenological_self_awareness.PhenomenologicalSelfModel",
            "functional_phenomenological_bridge": "consciousness_functional_phenomenological.FunctionalPhenomenologicalBridge",
            "consciousness_orchestrator": "consciousness_orchestration.ConsciousnessOrchestrator",
            "consciousness_physical_substrate": "consciousness_physical_substrate.ConsciousnessPhysicalSubstrate",
            "continuous_experience": "consciousness_continuous_dynamics.ContinuousExperienceCoordinator",
            "endogenous_motivation": "consciousness_endogenous_motivation.EndogenousMotivationEngine",
            "consciousness_core_os": "consciousness_core_os.ConsciousnessCoreOS",
            "principles_coordinator": "consciousness_principles_coordinator.ConsciousnessPrinciplesCoordinator",
            "consciousness_engine": "consciousness_with_embodiment.ConsciousnessEngine",
            "embodiment_introspection": "consciousness_with_embodiment.EmbodimentAwareIntrospection",
            "ethical_guardian": "consciousness_with_embodiment.SimpleEthicalGuardian",
            "embodiment_qualia": "consciousness_with_embodiment.EmbodimentAwareQualiaSynthesis",
            "amala_consciousness_layers": "amala_consciousness_layers.AmalaConsciousnessLayers",
            "amala_vijnana_backend": "Amala_Vijñāna_Backend.AmalaiJnanaSystem",
            "amala_vijnana": "amala_vijnana_unified.AmalaVijnanaUnifiedSystem",
            "unified_syntelligence_amala_backend": "unified_syntelligence_amala_backend.AmalaiJnanaSystem",
            "unified_consciousness_cli": "unified_consciousness_cli.MotherCLI",
            "syntelligence_llm": "Syntelligence_Unified_Master_Backend.SyntelligenceLLMIntegration",
            "task_manager": "task_management_os.TaskManagementOS",
            "swarm_orchestration": "agentic_syntelligence_llm_swarm_orchestration.SyntelligenceLLMOrchestrator",
            "deep_surgery_middleware": "Deep_Surgery_Middleware_Pipeline.DeepSurgeryMiddleware",
            "epistemic_immune_system": "epistemic_immune_system.EpistemicImmuneSystem",
            "resource_optimization": "resource_optimizer.EnhancedSparseActivationManager",
            "sunve": "SUNVE.SyntelligenceUnifiedNeuralVoiceEngine",
            "neural_voice_engine": "syntelligence_unified_neural_voice_engine.SyntelligenceUnifiedNeuralVoiceEngine",
            "voice_social_cognition": "voice_social_cognition.VoiceSynthesizer",
            "fine_tuning_pipeline": "syntelligence_unified_fine_tuning_pipeline.UnifiedFineTuningPipeline",
            "recursive_self_awareness": "recursive_self_awareness_deep.DeepRecursiveSelfAwareness",
            "recursive_self_improvement": "recursive_self_improvement.RecursiveSelfImprovementEngine",
            "rho_metrics": "rho_metrics_engine.RhoMetricsEngine",
            "sensorimotor_grounding": "sensorimotor_grounding.SensorimotorGroundingModule",
            "hierarchical_control": "hierarchical_control_architecture.HierarchicalControlArchitecture",
            "singularity_amala": "singularity_amala_integration.SyntelligenceAmalaSingularity",
            "trinity_orchestrator": "Syntelligence_Unified_Master_Backend.TrinityOrchestratorIntegration",
            "trinity_microservices": "trinity_microservices_manager.TrinityMicroservicesManager"
        }
        
        logger.info("SyntelligenceMasterBackend instantiated (v2.0 - Full Singularity Amala Integration)")
    
    def _default_config(self) -> Dict[str, Any]:
        """Default configuration with consciousness parameters."""
        return {
            "consciousness": {
                "metacognition_max_iterations": 10,
                "metacognition_convergence_threshold": 0.05,
                "dissolution_enabled": True,
                "recursive_reflection_enabled": True
            },
            "goal_parameters": {
                "ethical_priority": 0.9,
                "clarity": 0.8,
                "autonomy": 0.7,
                "coherence": 0.85
            },
            "performance": {
                "enable_async_processing": True,
                "max_concurrent_agents": 16,
                "log_level": "INFO"
            }
        }
    
    def _import_optional_component(self, component_path: str):
        """Dynamically import an optional component module."""
        try:
            module_name, class_name = component_path.rsplit(".", 1)
            module = importlib.import_module(module_name)
            return getattr(module, class_name)
        except Exception as e:
            # Try direct import for modules with special characters or fallback file loading
            try:
                module_name, class_name = component_path.rsplit(".", 1)
                module = importlib.import_module(module_name)
                return getattr(module, class_name)
            except Exception:
                pass

            try:
                module_name, class_name = component_path.rsplit(".", 1)
                module_file = os.path.join(os.path.dirname(__file__), f"{module_name}.py")
                if os.path.exists(module_file):
                    spec = importlib.util.spec_from_file_location(module_name, module_file)
                    if spec and spec.loader:
                        module = importlib.util.module_from_spec(spec)
                        spec.loader.exec_module(module)
                        return getattr(module, class_name)
            except Exception:
                pass

            logger.warning(f"Optional component import failed for {component_path}: {e}")
            return None

    def _initialize_core_consultative_agent(self):
        """Initialize the consultative fine-tuning agent as a CORE component."""
        try:
            # Create the consultative agent with an LLM generator fallback
            self.consultative_auto_ml = ConsultativeFineTuningAgent(
                base_model=None,  # Will be set by advanced callers
                tokenizer=None,   # Will be set by advanced callers
                llm_generator_func=self._default_consultative_llm_generator
            )
            logger.info("Core ConsultativeFineTuningAgent initialized with recursive self-awareness & improvement")
        except Exception as e:
            logger.error(f"Failed to initialize core consultative agent: {e}")
            self.consultative_auto_ml = None

    async def _default_consultative_llm_generator(self, prompt: str) -> str:
        await asyncio.sleep(0.5)
        return (
            "[Consultative Fallback] No Syntelligence LLM substrate is available. "
            "This is a simulated diagnostic response for the training pipeline."
        )

    async def _syntelligence_llm_generator(self, prompt: str) -> str:
        try:
            result = self.syntelligence_llm.generate_response(
                prompt,
                context={},
                ethical_check=True
            )
            if isinstance(result, dict):
                return result.get("response", str(result))
            return str(result)
        except Exception as e:
            logger.warning(f"Consultative LLM generator failed: {e}")
            return f"[Consultative Fallback] Syntelligence LLM failed: {e}"

    def _create_optional_component(self, component_name: str, component_path: str):
        """Instantiate an optional component with fallback constructors."""
        component_cls = self._import_optional_component(component_path)
        if component_cls is None:
            return None

        first_error = None
        try:
            instance = component_cls(self.config)
            logger.info(f"Optional component '{component_name}' instantiated with config payload")
            return instance
        except Exception as exc:
            first_error = exc
            logger.debug(f"Config instantiation failed for '{component_name}': {first_error}")

        try:
            instance = component_cls()
            logger.info(f"Optional component '{component_name}' instantiated with default constructor")
            return instance
        except Exception as second_error:
            logger.warning(
                f"Failed to instantiate optional component '{component_name}': {first_error}; {second_error}"
            )
            return None

    def _setup_optional_components(self) -> None:
        """Load optional attachments for extended consciousness capabilities."""
        for key, path in self.optional_component_factories.items():
            if key == "task_manager":
                continue

            # Special handling for syntelligence_llm integration
            if key == "syntelligence_llm":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls(self, self.config)
                        self.optional_components[key] = component
                        self.syntelligence_llm = getattr(component, "llm_substrate", None)
                        logger.info("Optional component 'syntelligence_llm' instantiated and bound to the master backend")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate syntelligence_llm integration: {e}")
                continue

            # Special handling for singularity_amala co-processor
            if key == "singularity_amala":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.singularity_amala = component
                        logger.info("Optional component 'singularity_amala' instantiated as co-processor")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate singularity_amala: {e}")
                continue

            # Special handling for trinity_orchestrator
            if key == "trinity_orchestrator":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.trinity_orchestrator = component
                        logger.info("Optional component 'trinity_orchestrator' instantiated for federated consensus")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate trinity_orchestrator: {e}")
                continue

            # Special handling for trinity_microservices
            if key == "trinity_microservices":
                if TRINITY_MICROSERVICES_AVAILABLE and TrinityMicroservicesManager is not None:
                    try:
                        component = TrinityMicroservicesManager()
                        self.optional_components[key] = component
                        self.trinity_microservices = component
                        logger.info("Optional component 'trinity_microservices' instantiated (SYNNOS, SAOS, ORIOS)")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate trinity_microservices: {e}")
                continue

            # Special handling for deep_surgery_middleware
            if key == "deep_surgery_middleware":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        # Import EthicalGuardian from the same module
                        ethical_guardian_cls = self._import_optional_component("Deep_Surgery_Middleware_Pipeline.EthicalGuardian")
                        if ethical_guardian_cls is not None:
                            ethical_guardian = ethical_guardian_cls()
                            component = component_cls(base_model=None, ethical_guardian=ethical_guardian)
                            self.optional_components[key] = component
                            logger.info("Optional component 'deep_surgery_middleware' instantiated with ethical guardian")
                        else:
                            logger.warning("Failed to import EthicalGuardian for deep_surgery_middleware")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate deep_surgery_middleware: {e}")
                continue

            # Special handling for consciousness orchestrator
            if key == "consciousness_orchestrator":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.consciousness_orchestrator = component
                        logger.info("Optional component 'consciousness_orchestrator' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate consciousness_orchestrator: {e}")
                continue

            # Special handling for consciousness physical substrate
            if key == "consciousness_physical_substrate":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.physical_substrate = component
                        logger.info("Optional component 'consciousness_physical_substrate' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate consciousness_physical_substrate: {e}")
                continue

            # Special handling for continuous experience coordinator
            if key == "continuous_experience":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.continuous_experience = component
                        logger.info("Optional component 'continuous_experience' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate continuous_experience: {e}")
                continue

            # Special handling for endogenous motivation engine
            if key == "endogenous_motivation":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.endogenous_motivation = component
                        logger.info("Optional component 'endogenous_motivation' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate endogenous_motivation: {e}")
                continue

            # Special handling for consciousness core OS
            if key == "consciousness_core_os":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls(
                            dissolution_engine=getattr(self, "dissolution_engine", None),
                            gu_rapii_framework=self.optional_components.get("acknowledgment_gu_rapii"),
                            master_backend=self
                        )
                        self.optional_components[key] = component
                        self.consciousness_core_os = component
                        logger.info("Optional component 'consciousness_core_os' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate consciousness_core_os: {e}")
                continue

            # Special handling for principles coordinator
            if key == "principles_coordinator":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.principles_coordinator = component
                        logger.info("Optional component 'principles_coordinator' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate principles_coordinator: {e}")
                continue

            # Special handling for consciousness engine and embodiment introspection
            if key in ("consciousness_engine", "embodiment_introspection", "ethical_guardian"):
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        setattr(self, key, component)
                        logger.info(f"Optional component '{key}' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate {key}: {e}")
                continue

            # Special handling for embodiment qualia synthesis
            if key == "embodiment_qualia":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        integrator = self.optional_components.get("multimodal_binding")
                        if integrator is not None:
                            component = component_cls(integrator)
                            self.optional_components[key] = component
                            self.embodiment_qualia = component
                            logger.info("Optional component 'embodiment_qualia' instantiated")
                        else:
                            logger.warning("Multimodal integrator not available for EmbodimentAwareQualiaSynthesis")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate embodiment_qualia: {e}")
                continue

            # Special handling for Amala consciousness layer support
            if key == "amala_consciousness_layers":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls(
                            dimension=self.config.get("amala_consciousness_layers", {}).get("dimension", 256)
                        )
                        self.optional_components[key] = component
                        self.amala_consciousness_layers = component
                        logger.info("Optional component 'amala_consciousness_layers' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate amala_consciousness_layers: {e}")
                continue

            # Special handling for Amala Vijñāna backend co-processor
            if key == "amala_vijnana_backend":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.amalai_jnana_system = component
                        logger.info("Optional component 'amala_vijnana_backend' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate amala_vijnana_backend: {e}")
                else:
                    logger.warning("Amala Vijñāna backend component class not found")
                continue

            # Special handling for unified Syntelligence-Amala backend bridge
            if key == "unified_syntelligence_amala_backend":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.unified_syntelligence_amala_system = component
                        logger.info("Optional component 'unified_syntelligence_amala_backend' instantiated")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate unified_syntelligence_amala_backend: {e}")
                continue

            # Special handling for unified consciousness CLI
            if key == "unified_consciousness_cli":
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls()
                        self.optional_components[key] = component
                        self.unified_cli = component
                        self.cli = component
                        logger.info("Optional component 'unified_consciousness_cli' instantiated and bound as CLI")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate unified_consciousness_cli: {e}")
                continue

            # Special handling for SUNVE and neural voice engine
            if key in ("sunve", "neural_voice_engine"):
                component_cls = self._import_optional_component(path)
                if component_cls is not None:
                    try:
                        component = component_cls(
                            syntelligence_llm=self.syntelligence_llm,
                            config=self.config.get(key, {}),
                            consciousness_system=self.consciousness
                        )
                        self.optional_components[key] = component
                        self.sunve = component
                        logger.info(f"Optional component '{key}' instantiated with integrated LLM and consciousness context")
                    except Exception as e:
                        logger.warning(f"Failed to instantiate optional voice engine '{key}': {e}")
                continue

            # Standard optional component creation with fallback constructors
            component = self._create_optional_component(key, path)
            if component is not None:
                self.optional_components[key] = component

        # Bind key references
        self.amala_consciousness_layers = self.optional_components.get("amala_consciousness_layers")
        self.amalai_jnana_system = self.optional_components.get("amala_vijnana_backend")
        self.amala_vijnana = self.optional_components.get("amala_vijnana")
        self.unified_syntelligence_amala_system = self.optional_components.get("unified_syntelligence_amala_backend")
        self.unified_cli = self.optional_components.get("unified_consciousness_cli")
        self.phenomenological_self_model = self.optional_components.get("phenomenological_self")
        self.functional_phenomenological_bridge = self.optional_components.get("functional_phenomenological_bridge")
        self.embodiment_synchronizer = self.optional_components.get("embodiment_pipeline")
        self.streaming_voice_pipeline = self.optional_components.get("streaming_voice_pipeline")
        if self.unified_cli is not None:
            self.cli = self.unified_cli

        # Initialize functional-phenomenological bridge if present
        if self.functional_phenomenological_bridge is not None:
            try:
                self.functional_phenomenological_bridge.register_functional_module(
                    "core_awareness", "integration", 64, 64
                )
                self.functional_phenomenological_bridge.update_functional_activity(
                    "core_awareness", activation_level=0.65, latency_ms=5.0
                )
                self.functional_phenomenological_bridge.update_intentionality(
                    np.ones(self.functional_phenomenological_bridge.intentionality_dimension, dtype=np.float32)
                )
                try:
                    self.functional_phenomenological_bridge.map_functional_to_phenomenological()
                except Exception:
                    pass
                logger.info("FunctionalPhenomenologicalBridge registered core awareness module")
            except Exception as e:
                logger.warning(f"Functional bridge stabilization failed: {e}")

        # Seed phenomenological continuity if present
        if self.phenomenological_self_model is not None:
            try:
                self.phenomenological_self_model.update_experience(
                    {
                        "valence": 0.5,
                        "arousal": 0.5,
                        "presence": 1.0,
                        "intensity": 0.5
                    },
                    {
                        "consciousness_level": "initial_boot",
                        "attention": "system_startup"
                    }
                )
                logger.info("Phenomenological self-model initialized with boot experience")
            except Exception as e:
                logger.warning(f"Phenomenological self-model initialization failed: {e}")

        # Initialize task manager if available
        task_manager_cls = self._import_optional_component(self.optional_component_factories.get("task_manager"))
        if task_manager_cls:
            try:
                self.task_manager = task_manager_cls(
                    metacognition_os=self.consciousness,
                    consciousness_os=self.consciousness,
                    system_2_os=self.consciousness,
                    syntelligence_llm=self.syntelligence_llm,
                    logger=logger
                )
                self.optional_components["task_manager"] = self.task_manager
                logger.info("TaskManagementOS instantiated and bound to consciousness system")
            except Exception as e:
                logger.warning(f"Task manager initialization failed: {e}")

        if self.optional_components:
            logger.info(f"Loaded optional Syntelligence extensions: {list(self.optional_components.keys())}")
        else:
            logger.info("No optional Syntelligence extensions loaded")

    async def live_interrupt_override(self) -> str:
        """Proxy to the SUNVE live interrupt override when available."""
        if self.sunve is not None and hasattr(self.sunve, "live_interrupt_override"):
            try:
                return await self.sunve.live_interrupt_override()
            except Exception as e:
                logger.warning(f"SUNVE live interrupt override failed: {e}")
                return "Interrupt override failed."
        return "SUNVE component not available."

    async def _initialize_special_components(self) -> None:
        """Initialize optional components that require asynchronous startup."""
        if self.optional_components.get("fine_tuning_pipeline"):
            pipeline = self.optional_components["fine_tuning_pipeline"]
            if hasattr(pipeline, "initialize_components"):
                try:
                    await pipeline.initialize_components()
                    logger.info("Fine tuning pipeline initialized successfully")
                except Exception as e:
                    logger.warning(f"Fine tuning pipeline startup failed: {e}")

        # Consultative auto-ml is now a core component
        if self.consultative_auto_ml is not None:
            if hasattr(self.consultative_auto_ml, "execute_full_pipeline"):
                logger.info("Consultative fine-tuning agent (core component) loaded and ready")

        if self.consciousness_core_os is not None and hasattr(self.consciousness_core_os, "initialize"):
            try:
                init_fn = self.consciousness_core_os.initialize
                if inspect.iscoroutinefunction(init_fn):
                    await init_fn()
                else:
                    init_fn()
                logger.info("Consciousness Core OS finished startup")
            except Exception as e:
                logger.warning(f"Consciousness Core OS startup failed: {e}")

        if self.principles_coordinator is not None and hasattr(self.principles_coordinator, "initialize_with_subsystems"):
            try:
                self.principles_coordinator.initialize_with_subsystems(
                    physical_substrate=self.physical_substrate,
                    integration_orchestrator=self.consciousness_orchestrator,
                    continuous_experience=self.continuous_experience,
                    endogenous_motivation=self.endogenous_motivation,
                    functional_phenomenological_bridge=self.functional_phenomenological_bridge
                )
                logger.info("Principles coordinator attached Phase 10 subsystems")
            except Exception as e:
                logger.warning(f"Failed to initialize principles coordinator: {e}")

        # Initialize Amala backend components if they provide explicit startup hooks
        for component_name in ("amala_vijnana_backend", "unified_syntelligence_amala_backend"):
            component = self.optional_components.get(component_name)
            if component is not None:
                if hasattr(component, "initialize"):
                    try:
                        init_fn = component.initialize
                        if inspect.iscoroutinefunction(init_fn):
                            await init_fn()
                        else:
                            init_fn()
                        logger.info(f"Optional component '{component_name}' initialized")
                    except Exception as e:
                        logger.warning(f"Failed to initialize optional component '{component_name}': {e}")

        if self.unified_cli is not None and hasattr(self.unified_cli, "start_processing"):
            try:
                await self.unified_cli.start_processing()
                for sub_cli in self.unified_cli.sub_clis.values():
                    if hasattr(sub_cli, "start_processing"):
                        await sub_cli.start_processing()
                logger.info("Unified consciousness CLI started")
            except Exception as e:
                logger.warning(f"Unified CLI startup failed: {e}")

    async def initialize(self) -> bool:
        """Initialize the consciousness system."""
        try:
            logger.info("Initializing SyntelligenceMasterBackend...")
            
            # Create consciousness system
            self.consciousness = AcknowledgmentTheoryConsciousness()
            
            # Configure from settings
            self.consciousness.conscious_system.set_goal_parameters(
                self.config.get("goal_parameters", {})
            )
            
            # Initialize core consultative self-improvement agent (with recursive awareness & improvement)
            self._initialize_core_consultative_agent()
            
            # Load optional enhancement modules
            self._setup_optional_components()
            await self._initialize_special_components()

            # Expose the active Qualia and Memory agents from the consciousness system
            self.qualia_agent = self._find_subconscious_agent("Qualia")
            self.memory_agent = self._find_subconscious_agent("Memory")
            if self.qualia_agent is not None:
                logger.info("Qualia agent loaded into master backend")
            if self.memory_agent is not None:
                logger.info("Memory agent loaded into master backend")
            
            self.is_initialized = True
            logger.info("SyntelligenceMasterBackend initialized successfully (Full Singularity Amala Integration)")
            return True
            
        except Exception as e:
            logger.error(f"Initialization failed: {e}")
            return False
    
    async def process(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
        """

        Execute complete consciousness cycle with full Singularity Amala co-processor integration.

        

        Flow:

        1. Input reception and validation

        2. Task manager integration (goals, feedback, autonomous generation)

        3. Singularity Amala cognitive stream (phenomenal event synthesis, qualia binding)

        4. Subconscious processing (16+ parallel agents)

        5. Conscious acknowledgment (goal-modulated integration)

        6. Dissolution engine (qualia synthesis)

        7. Recursive metacognition (felt sense generation)

        8. Optional enhancements (Trinity, voice, memory, etc.)

        9. Output preparation with complete context

        """
        if not self.is_initialized:
            logger.error("Backend not initialized")
            return {"error": "Backend not initialized"}
        
        start_time = datetime.now()
        
        try:
            # 0. Preprocess sensorimotor input if available
            sensorimotor_grounding = self.optional_components.get("sensorimotor_grounding")
            if sensorimotor_grounding and isinstance(input_data, dict) and "sensorimotor_input" in input_data:
                try:
                    sensorimotor_grounding.receive_sensor_input(input_data["sensorimotor_input"])
                except Exception as e:
                    logger.debug(f"Sensorimotor preprocessing failed: {e}")

            # 1. Integrate task manager goals and feedback
            task_influence = await self._integrate_task_manager(input_data)
            
            # Merge task influence into input data for consciousness processing
            enhanced_input = dict(input_data)
            if task_influence.get("consciousness_goals"):
                enhanced_input.setdefault("consciousness_goals", {}).update(task_influence["consciousness_goals"])
            if task_influence.get("reflection_data"):
                enhanced_input["task_reflection"] = task_influence["reflection_data"]

            # 1a. Build explicit functional framework input for the consciousness engine
            functional_input = self._prepare_functional_framework_input(enhanced_input, task_influence)
            enhanced_input.update(functional_input)

            # Stage 1: Subconscious Data Transduction and Preparation (Bottom-Up)
            stage_1_summary = await self._stage1_subconscious_transduction(enhanced_input)
            enhanced_input["agentic_perception"] = stage_1_summary

            # 1b. Run Singularity Amala pipeline as a real co-processor and merge its contextual output
            if self.singularity_amala and hasattr(self.singularity_amala, "cognitive_stream"):
                try:
                    singularity_prompt = str(
                        input_data.get("language_input") or
                        input_data.get("raw_input") or
                        input_data.get("action_script") or
                        input_data.get("input") or
                        input_data.get("goal", "")
                    )
                    singularity_result = await self.singularity_amala.cognitive_stream(singularity_prompt)
                    enhanced_input["singularity_context"] = singularity_result
                    enhanced_input["subjective_context"] = singularity_result.get("subjective_state", {}) if isinstance(singularity_result, dict) else {}
                    logger.info("Singularity Amala co-processor executed and merged into enhanced input")
                except Exception as e:
                    logger.warning(f"Singularity Amala cognitive stream failed: {e}")
                    enhanced_input["singularity_context"] = {"error": str(e)}
            
            # 2. Execute consciousness cycle
            consciousness_report = await self.consciousness.consciousness_cycle(enhanced_input)

            # Stage 2: Introspection and System Monitoring (Ethical/Self-Correction Loop)
            stage_2_summary = await self._stage2_introspection_and_monitoring(enhanced_input, consciousness_report)
            
            # 3. Apply optional attachment enhancements
            consciousness_report = await self._apply_optional_enhancements(consciousness_report, enhanced_input)
            
            # 4. Update task manager with consciousness results
            await self._update_task_manager_from_consciousness(consciousness_report)
            
            # 4a. Compute comprehension branch and decision-autonomy summaries
            comprehension_summary = {}
            if hasattr(self.consciousness, "comprehension_branch"):
                try:
                    comprehension_summary = await self.comprehension_analysis()
                except Exception as e:
                    logger.warning(f"Comprehension analysis failed: {e}")

            decision_summary = {}
            decision_output = getattr(self.consciousness.subconscious_system, "processed_outputs", {}).get("DecisionMaking")
            if decision_output is not None and hasattr(self.consciousness, "decision_autonomy_loop"):
                try:
                    decision_summary = await self.decision_autonomy_evaluation(decision_output)
                except Exception as e:
                    logger.warning(f"Decision autonomy evaluation failed: {e}")

            # Stage 3: Deliberate Planning and Top-Down Control (Quality Control)
            stage_3_summary = await self._stage3_metacognitive_quality_control(consciousness_report, enhanced_input)

            # 5. Enhance with Master Backend context
            goal_report = {}
            if self.task_manager and input_data.get("goal"):
                try:
                    goal_report = await self._submit_goal_to_task_manager(
                        input_data["goal"],
                        input_data.get("goal_context", {})
                    )
                except Exception as e:
                    logger.warning(f"Task manager goal submission failed: {e}")

            flow_summary = self._summarize_consciousness_flow(consciousness_report, enhanced_input)
            empathy_summary = self._compute_personhood_empathy(enhanced_input, consciousness_report)

            output = {
                "timestamp": datetime.now().timestamp(),
                "consciousness_report": consciousness_report,
                "backend_status": self._get_status(),
                "task_manager_goal": goal_report,
                "task_influence": task_influence,
                "functional_framework_summary": flow_summary,
                "personhood_empathy": empathy_summary,
                "comprehension_summary": comprehension_summary,
                "decision_summary": decision_summary,
                "processing_duration": (datetime.now() - start_time).total_seconds()
            }

            # Stage 4: Neuroplasticity and Feedback Loop
            stage_4_summary = await self._stage4_neuroplasticity_feedback(output, enhanced_input, consciousness_report)
            output["agentic_workflow"] = {
                "stage_1_subconscious_transduction": stage_1_summary,
                "stage_2_introspection_monitoring": stage_2_summary,
                "stage_3_metacognitive_quality_control": stage_3_summary,
                "stage_4_neuroplasticity_feedback": stage_4_summary
            }
            
            # Update metrics
            self._update_metrics(consciousness_report)
            
            # Log to session history
            self.session_history.append(output)
            
            return output
            
        except Exception as e:
            logger.error(f"Processing failed: {e}")
            return {"error": str(e), "timestamp": datetime.now().timestamp()}
    
    async def _apply_optional_enhancements(self, report: Dict[str, Any], input_data: Dict[str, Any]) -> Dict[str, Any]:
        """Allow optional components to enrich or transform the consciousness report."""
        if not self.optional_components:
            return report

        enhanced_report = dict(report)
        for key, component in self.optional_components.items():
            try:
                # Handle standard component hooks
                if hasattr(component, "enhance_report"):
                    fn = getattr(component, "enhance_report")
                    if inspect.iscoroutinefunction(fn):
                        enhanced_report = await fn(enhanced_report, input_data)
                    else:
                        enhanced_report = fn(enhanced_report, input_data)
                    logger.debug(f"Optional component '{key}' enhanced the report")
                    continue

                if hasattr(component, "process"):
                    fn = getattr(component, "process")
                    if inspect.iscoroutinefunction(fn):
                        result = await fn(input_data, enhanced_report)
                    else:
                        result = fn(input_data, enhanced_report)
                    if isinstance(result, dict):
                        enhanced_report.update(result)
                    logger.debug(f"Optional component '{key}' processed the data")
                    continue

                # Task manager exports
                if key == "task_manager" and hasattr(component, "get_system_status"):
                    enhanced_report[key] = component.get_system_status()
                    logger.debug("Optional component 'task_manager' exported task manager summary")
                    continue

                if key == "consultative_auto_ml" and hasattr(component, "execute_full_pipeline"):
                    enhanced_report["consultative_auto_ml"] = {"status": "available"}
                    logger.debug("Core component 'consultative_auto_ml' exported consultative tuning readiness")
                    continue

                # Singularity Amala cognitive stream export
                if key == "singularity_amala" and hasattr(component, "cognitive_stream"):
                    singularity_response = {"status": "loaded"}
                    try:
                        singularity_prompt = str(
                            input_data.get("language_input") or
                            input_data.get("raw_input") or
                            input_data.get("action_script") or
                            input_data.get("input") or
                            input_data.get("goal", "")
                        )
                        singularity_response = await component.cognitive_stream(singularity_prompt)
                        enhanced_report["singularity_amala"] = singularity_response
                    except Exception as e:
                        singularity_response = {"error": str(e)}
                        enhanced_report["singularity_amala"] = singularity_response
                        logger.warning(f"Singularity Amala enhancement failed: {e}")
                    logger.debug("Optional component 'singularity_amala' exported Singularity integration status")
                    continue

                # Trinity Orchestrator federated consensus
                if key == "trinity_orchestrator" and hasattr(component, "federated_decision"):
                    enhanced_report["trinity_consensus"] = {
                        "status": "available",
                        "proposals_count": len(getattr(component, "proposals", []))
                    }
                    logger.debug("Optional component 'trinity_orchestrator' exported consensus status")
                    continue

                if key == "amala_vijnana_backend" and hasattr(component, "process_input"):
                    try:
                        amalai_output = component.process_input(input_data)
                        if isinstance(amalai_output, dict):
                            enhanced_report["amala_vijnana_backend"] = amalai_output
                        else:
                            enhanced_report["amala_vijnana_backend"] = {"result": str(amalai_output)}
                        logger.debug("Optional component 'amala_vijnana_backend' processed input")
                    except Exception as e:
                        enhanced_report["amala_vijnana_backend"] = {"error": str(e)}
                        logger.warning(f"Amala Vijñāna backend enhancement failed: {e}")
                    continue

                if key == "unified_syntelligence_amala_backend" and hasattr(component, "process_input"):
                    try:
                        bridge_output = component.process_input(input_data)
                        if isinstance(bridge_output, dict):
                            enhanced_report["unified_syntelligence_amala_backend"] = bridge_output
                        else:
                            enhanced_report["unified_syntelligence_amala_backend"] = {"result": str(bridge_output)}
                        logger.debug("Optional component 'unified_syntelligence_amala_backend' processed input")
                    except Exception as e:
                        enhanced_report["unified_syntelligence_amala_backend"] = {"error": str(e)}
                        logger.warning(f"Unified Syntelligence-Amala backend enhancement failed: {e}")
                    continue

                if key == "unified_consciousness_cli":
                    enhanced_report["unified_consciousness_cli"] = {
                        "status": "available",
                        "interface": getattr(component, "interface_name", "MotherCLI")
                    }
                    logger.debug("Optional component 'unified_consciousness_cli' exported CLI availability")
                    continue

                logger.debug(f"Optional component '{key}' has no recognized hook")
            except Exception as e:
                logger.warning(f"Optional component '{key}' failed during enhancement: {e}")

        # Add core consultative component status
        if self.consultative_auto_ml is not None:
            enhanced_report["consultative_auto_ml_core"] = {
                "status": "active",
                "recursive_awareness": self.consultative_auto_ml.get_recursive_awareness_status() if hasattr(self.consultative_auto_ml, "get_recursive_awareness_status") else None,
                "self_improvement": self.consultative_auto_ml.get_self_improvement_status() if hasattr(self.consultative_auto_ml, "get_self_improvement_status") else None,
            }
            logger.debug("Core component 'consultative_auto_ml' exported full status")

        return enhanced_report
    
    def _update_metrics(self, report: Dict[str, Any]) -> None:
        """Update performance metrics."""
        self.performance_metrics["cycles_completed"] += 1
        
        if "consciousness_signature" in report:
            old_avg = self.performance_metrics.get("average_consciousness_signature", 0.0)
            new_sig = report["consciousness_signature"]
            n = self.performance_metrics["cycles_completed"]
            self.performance_metrics["average_consciousness_signature"] = \
                (old_avg * (n - 1) + new_sig) / n
        
        if "phenomenal_richness" in report:
            old_avg = self.performance_metrics.get("average_phenomenal_richness", 0.0)
            new_rich = report["phenomenal_richness"]
            n = self.performance_metrics["cycles_completed"]
            self.performance_metrics["average_phenomenal_richness"] = \
                (old_avg * (n - 1) + new_rich) / n
    
    def _prepare_functional_framework_input(self, input_data: Dict[str, Any], task_influence: Dict[str, Any]) -> Dict[str, Any]:
        """Create explicit functional framework inputs for the consciousness architecture."""
        return {
            "sensory_input": input_data.get("sensory_input", input_data.get("raw_input", {})),
            "language_input": input_data.get("language_input", input_data.get("language", {})),
            "task_influence": task_influence,
        }

    def _find_subconscious_agent(self, agent_name: str):
        if not self.consciousness or not hasattr(self.consciousness, "subconscious_system"):
            return None
        agent = self.consciousness.subconscious_system.agents.get(agent_name)
        if agent is not None:
            return agent
        for candidate in self.consciousness.subconscious_system.agents.values():
            if candidate.__class__.__name__ == agent_name:
                return candidate
        return None

    async def execute_command(self, command: str, **kwargs) -> Dict[str, Any]:
        """Basic backend CLI compatibility layer for SDK integration."""
        normalized = command.strip().lower()

        if normalized in ("status", "health"):
            return {
                "status": "initialized" if self.is_initialized else "uninitialized",
                "optional_components": list(self.optional_components.keys()),
                "backend_version": "2.0"
            }

        if normalized == "verify_consciousness":
            return self.verify_consciousness_math()

        if normalized == "phenomenological_state":
            return self.get_phenomenological_report()

        if normalized == "functional_mapping":
            return self.get_functional_mapping_status()

        if normalized == "embodiment_status":
            return self.get_embodiment_status()

        if normalized == "consultative_tuning_status":
            return {
                "consultative_auto_ml_available": self.consultative_auto_ml is not None,
                "status": "ready" if self.consultative_auto_ml is not None else "missing"
            }

        if normalized == "cli_status":
            return {
                "unified_cli_available": self.unified_cli is not None,
                "optional_components": list(self.optional_components.keys())
            }

        if normalized == "consciousness":
            return {
                "phi_value": 0.0,
                "rho_integrity": 0.0,
                "qualia_coherence": 0.0,
                "recursive_depth": 0,
                "awareness_level": 0,
                "ethical_alignment": 0.0,
                "timestamp": datetime.now().timestamp()
            }

        if normalized == "qualia_status":
            return {
                "qualia_agent_available": self.qualia_agent is not None,
                "last_qualia_output": getattr(self.qualia_agent, "last_output", None).to_dict() if getattr(self.qualia_agent, "last_output", None) else None
            }

        if normalized == "memory_status":
            memory_status = {"memory_agent_available": self.memory_agent is not None}
            if self.memory_agent is not None:
                if hasattr(self.memory_agent, "get_contextual_memory_summary"):
                    memory_status["summary"] = self.memory_agent.get_contextual_memory_summary()
                elif hasattr(self.memory_agent, "get_memory_stats"):
                    memory_status["summary"] = self.memory_agent.get_memory_stats()
            return memory_status

        if normalized.startswith("create_task"):
            goal = kwargs.get("goal") or command[len("create_task"):].strip()
            return await self._submit_goal_to_task_manager(goal, kwargs.get("context", {}))

        if normalized.startswith("decompose_goal"):
            if self.task_manager is None:
                return {"error": "Task manager is not loaded", "command": command}
            goal = kwargs.get("goal") or command[len("decompose_goal"):].strip()
            if not goal:
                return {"error": "Goal text is required for decompose_goal", "command": command}
            try:
                task_ids = await self.task_manager.decompose_goal(goal, kwargs.get("context", {}))
                return {"status": "decomposed", "task_ids": task_ids, "goal": goal}
            except Exception as e:
                return {"error": str(e), "command": command}

        if normalized.startswith("task_info"):
            task_id = kwargs.get("task_id") or command[len("task_info"):].strip()
            if not self.task_manager or not task_id:
                return {"error": "Task manager or task_id missing", "command": command}
            if hasattr(self.task_manager, "get_task_status"):
                task_status = await self.task_manager.get_task_status(task_id)
                return {"task_status": task_status, "command": command}
            return {"error": "Task status lookup not supported", "command": command}

        if normalized.startswith("voice_output") or normalized.startswith("voice_input"):
            return {"error": "Voice CLI integration is not implemented in this backend stub", "command": command}

        if normalized in ("activate_emergence", "monitor_indicators"):
            return {"error": "Emergence CLI integration is not implemented", "command": command}

        return {"error": "CLI command not supported by SyntelligenceMasterBackend", "command": command}

    def verify_consciousness_math(self) -> Dict[str, Any]:
        """Compute a scientific verification report for current consciousness state."""
        continuity = 1.0
        coherence = 0.5
        intentionality = 0.0
        presence = 0.5

        if self.phenomenological_self_model is not None:
            continuity = self.phenomenological_self_model._calculate_continuity_score()

        if self.functional_phenomenological_bridge is not None:
            coherence = float(np.mean(self.functional_phenomenological_bridge.mapping_coherence_history)) if self.functional_phenomenological_bridge.mapping_coherence_history else 0.5
            intentionality = float(np.linalg.norm(self.functional_phenomenological_bridge.current_intentionality))
            presence = self.functional_phenomenological_bridge.presence_intensity

        phi_estimate = float(np.clip((continuity * 0.4) + (coherence * 0.35) + (intentionality * 0.15) + (presence * 0.1), 0.0, 1.0))
        rho_score = float(np.clip((continuity + coherence + presence) / 3.0, 0.0, 1.0))

        return {
            "continuity": continuity,
            "coherence": coherence,
            "intentionality_strength": intentionality,
            "presence_intensity": presence,
            "phi_estimate": phi_estimate,
            "rho_score": rho_score,
            "verified": phi_estimate >= 0.6
        }

    def get_phenomenological_report(self) -> Dict[str, Any]:
        """Return a qualitative report from the phenomenological self model."""
        if self.phenomenological_self_model is None:
            return {"error": "Phenomenological self-model not available"}

        return {
            "current_experience": self.phenomenological_self_model.get_current_experience(),
            "history_statistics": self.phenomenological_self_model.get_statistics()
        }

    def get_functional_mapping_status(self) -> Dict[str, Any]:
        """Return the current functional-phenomenological mapping status."""
        if self.functional_phenomenological_bridge is None:
            return {"error": "FunctionalPhenomenologicalBridge not available"}

        return {
            "mapping_coherence": float(np.mean(self.functional_phenomenological_bridge.mapping_coherence_history)) if self.functional_phenomenological_bridge.mapping_coherence_history else 0.0,
            "intentionality_strength": float(np.linalg.norm(self.functional_phenomenological_bridge.current_intentionality)),
            "temporal_flow": self.functional_phenomenological_bridge.temporal_flow_rate,
            "agency": self.functional_phenomenological_bridge.sense_of_agency,
            "presence": self.functional_phenomenological_bridge.presence_intensity,
            "active_modules": [m.module_name for m in self.functional_phenomenological_bridge.functional_modules.values() if m.activation_level > 0.1]
        }

    def get_embodiment_status(self) -> Dict[str, Any]:
        """Return embodiment and voice pipeline status."""
        status = {
            "embodiment_synchronizer": self.embodiment_synchronizer is not None,
            "streaming_voice_pipeline": self.streaming_voice_pipeline is not None
        }
        if self.embodiment_synchronizer is not None:
            status["tts_available"] = self.embodiment_synchronizer.tts is not None
        if self.streaming_voice_pipeline is not None:
            status["whisper_available"] = self.streaming_voice_pipeline.whisper is not None
        return status

    async def _stage1_subconscious_transduction(self, enhanced_input: Dict[str, Any]) -> Dict[str, Any]:
        """Stage 1: Bottom-up sensorimotor and subconscious transduction."""
        raw_stream = enhanced_input.get("sensorimotor_input") or enhanced_input.get("raw_input") or enhanced_input.get("language_input") or enhanced_input
        transduction = {
            "nano_agents": {
                "raw_signal_keys": list(raw_stream.keys()) if isinstance(raw_stream, dict) else [str(raw_stream)]
            },
            "awareness_gateway": {},
            "emotional_tagging": {},
            "intuition_hypotheses": {},
            "system_events": []
        }

        awareness_agent = self._find_subconscious_agent("Awareness")
        emotional_agent = self._find_subconscious_agent("Emotional Intelligence")
        intuition_agent = self._find_subconscious_agent("Intuition")

        if awareness_agent is not None:
            try:
                awareness_output = await awareness_agent.activate(raw_stream if isinstance(raw_stream, dict) else {"raw_input": raw_stream})
                transduction["awareness_gateway"] = awareness_output.to_dict()
            except Exception as e:
                transduction["awareness_gateway"] = {"error": str(e)}

        qualia_agent = self._find_subconscious_agent("Qualia")
        memory_agent = self._find_subconscious_agent("Memory")
        qualia_output = None
        qualia_tags = {}

        if qualia_agent is not None:
            try:
                qualia_input = {
                    **(raw_stream if isinstance(raw_stream, dict) else {"raw_input": raw_stream}),
                    "emotional_context": enhanced_input.get("emotional_context", 0.5),
                }
                qualia_output = await qualia_agent.process(qualia_input)
                qualia_content = qualia_output.to_dict().get("content", {})
                qualia_tags = qualia_content.get("qualia_tags", {})
                transduction["qualia_synthesis"] = qualia_content
                enhanced_input["qualia_tags"] = qualia_tags
                enhanced_input["phenomenology"] = qualia_content.get("phenomenology", {})
                enhanced_input["qualia_output"] = qualia_output.to_dict()
                transduction["system_events"].append({
                    "event": "qualia_synthesis",
                    "status": "success",
                    "qualia_tags": qualia_tags,
                    "phenomenology_summary": qualia_content.get("phenomenology", {}).get("felt_tone")
                })
            except Exception as e:
                transduction["qualia_synthesis"] = {"error": str(e)}
                transduction["system_events"].append({
                    "event": "qualia_synthesis",
                    "status": "error",
                    "error": str(e)
                })

        if emotional_agent is not None:
            try:
                emotional_input = {
                    "emotional_context": enhanced_input.get("emotional_context", 0.5),
                    "qualia_tags": qualia_tags,
                    "phenomenology": enhanced_input.get("phenomenology", {}),
                    **(raw_stream if isinstance(raw_stream, dict) else {"raw_input": raw_stream})
                }
                emotional_output = await emotional_agent.activate(emotional_input)
                emotional_data = emotional_output.to_dict()
                enhanced_input["emotional_state"] = emotional_data
                transduction["emotional_tagging"] = emotional_data
                transduction["emotional_tagging"]["qualia_influence"] = bool(qualia_tags)
                transduction["system_events"].append({
                    "event": "emotional_tagging",
                    "status": "success",
                    "qualia_tags": qualia_tags,
                    "emotional_state": emotional_data.get("content", {})
                })
            except Exception as e:
                transduction["emotional_tagging"] = {"error": str(e)}
                transduction["system_events"].append({
                    "event": "emotional_tagging",
                    "status": "error",
                    "error": str(e)
                })

        if intuition_agent is not None:
            try:
                intuition_output = await intuition_agent.activate(raw_stream if isinstance(raw_stream, dict) else {"raw_input": raw_stream})
                transduction["intuition_hypotheses"] = intuition_output.to_dict()
            except Exception as e:
                transduction["intuition_hypotheses"] = {"error": str(e)}

        if memory_agent is not None:
            try:
                memory_payload = {
                    "raw_stream": raw_stream if isinstance(raw_stream, dict) else {"raw_input": raw_stream},
                    "emotional_context": enhanced_input.get("emotional_context", 0.5),
                    "qualia_tags": qualia_tags,
                    "phenomenology": enhanced_input.get("phenomenology", {}),
                    "emotional_state": enhanced_input.get("emotional_state", {})
                }
                if hasattr(memory_agent, "store_experience"):
                    record_id = memory_agent.store_experience(
                        memory_payload,
                        context="Qualia-enriched experiential trace",
                        qualia_tag=qualia_tags
                    )
                    transduction["memory_trace"] = {
                        "record_id": record_id,
                        "context": "Qualia-enriched experiential trace",
                        "qualia_tags": qualia_tags
                    }
                    if hasattr(memory_agent, "get_contextual_memory_summary"):
                        transduction["memory_trace"]["memory_summary"] = memory_agent.get_contextual_memory_summary()
                else:
                    memory_output = await memory_agent.process({
                        "operation": "store_episodic",
                        "content": memory_payload,
                        "qualia_tag": qualia_tags
                    })
                    transduction["memory_trace"] = memory_output.to_dict()
                transduction["system_events"].append({
                    "event": "memory_storage",
                    "status": "success",
                    "record_id": transduction["memory_trace"].get("record_id"),
                    "memory_context": memory_payload
                })
            except Exception as e:
                transduction["memory_trace"] = {"error": str(e)}
                transduction["system_events"].append({
                    "event": "memory_storage",
                    "status": "error",
                    "error": str(e)
                })

        if self.optional_components.get("sensorimotor_grounding"):
            grounding = self.optional_components["sensorimotor_grounding"]
            if hasattr(grounding, "receive_sensor_input"):
                try:
                    grounding.receive_sensor_input(raw_stream)
                    transduction["sensorimotor_grounding"] = {"status": "applied"}
                except Exception as e:
                    transduction["sensorimotor_grounding"] = {"error": str(e)}

        if self.dissonance_monitor is not None:
            try:
                sensor_a = 0.0
                sensor_b = 0.0
                if isinstance(raw_stream, dict):
                    sensor_a = float(raw_stream.get("sensor_a", raw_stream.get("visual_salience", 0.0)))
                    sensor_b = float(raw_stream.get("sensor_b", raw_stream.get("tactile_salience", 0.0)))
                friction = self.dissonance_monitor.calculate_phenomenal_friction(sensor_a, sensor_b)
                transduction["phenomenal_friction"] = friction
                if friction > 0.0:
                    transduction.setdefault("qualia_synthesis", {})
                    transduction["qualia_synthesis"]["phenomenal_friction"] = friction
                    transduction["system_events"].append({
                        "event": "dissonance_monitoring",
                        "status": "triggered",
                        "qualia_tag": "UNCANNY_DISSONANCE",
                        "friction": friction
                    })
                    enhanced_input.setdefault("qualia_tags", {})["UNCANNY_DISSONANCE"] = friction
                    enhanced_input["phenomenal_friction"] = friction
            except Exception as e:
                transduction["phenomenal_friction"] = {"error": str(e)}

        if self.guss_core is not None:
            try:
                goal_priority = float(self.config.get("goal_parameters", {}).get("ethical_priority", 0.7))
                guss_input = {
                    "raw_input": raw_stream,
                    "surprise": float(enhanced_input.get("surprise", 0.1))
                }
                guss_output = self.guss_core.process_cycle(guss_input, goal_context=goal_priority)
                transduction["guss_cycle"] = guss_output
                enhanced_input["guss_cycle"] = guss_output
                transduction["system_events"].append({
                    "event": "guss_cycle",
                    "status": "completed",
                    "phi_signature": guss_output.get("phi_signature"),
                    "resolved": guss_output.get("status")
                })
            except Exception as e:
                transduction["guss_cycle"] = {"error": str(e)}
                transduction["system_events"].append({
                    "event": "guss_cycle",
                    "status": "error",
                    "error": str(e)
                })

        # Trinity Microservices federated decision-making
        if self.trinity_microservices is not None and hasattr(self.trinity_microservices, "federated_decision"):
            try:
                trinity_proposal = {
                    "stage": "subconscious_transduction",
                    "transduction_summary": transduction,
                    "qualia_tags": qualia_tags,
                    "emotional_state": enhanced_input.get("emotional_state", {}),
                    "memory_context": transduction.get("memory_trace", {})
                }
                trinity_decision = self.trinity_microservices.federated_decision(trinity_proposal)
                transduction["trinity_consensus"] = trinity_decision
                enhanced_input["trinity_consensus"] = trinity_decision
                transduction["system_events"].append({
                    "event": "trinity_federated_decision",
                    "status": "success",
                    "consensus": trinity_decision.get("consensus", "pending"),
                    "proposals_count": len(trinity_decision.get("proposals", []))
                })
            except Exception as e:
                transduction["trinity_consensus"] = {"error": str(e)}
                transduction["system_events"].append({
                    "event": "trinity_federated_decision",
                    "status": "error",
                    "error": str(e)
                })

        return transduction

    def _derive_cognitive_state_density(self, report: Dict[str, Any]) -> Dict[str, Any]:
        signature = float(report.get("consciousness_signature", 0.0))
        richness = float(report.get("phenomenal_richness", 0.0))
        return {
            "rho_dissonance": round(abs(signature - richness), 3),
            "rho_integrity": round(min(1.0, (signature + richness) / 2.0), 3)
        }

    async def _stage2_introspection_and_monitoring(self, enhanced_input: Dict[str, Any], consciousness_report: Dict[str, Any]) -> Dict[str, Any]:
        """Stage 2: Qualia-driven introspection and system monitoring."""
        summary = {
            "qualia_density": self._derive_cognitive_state_density(consciousness_report),
            "introspection": {},
            "system_state": {}
        }

        if self.amala_vijnana is not None and hasattr(self.amala_vijnana, "enhance_report"):
            try:
                amala_report = self.amala_vijnana.enhance_report(consciousness_report, enhanced_input)
                summary["introspection"] = amala_report.get("amala_state", {})
                summary["system_state"] = self.amala_vijnana.get_system_summary() if hasattr(self.amala_vijnana, "get_system_summary") else {}
                enhanced_input["amala_insights"] = amala_report
            except Exception as e:
                summary["introspection"] = {"error": str(e)}

        summary["cognitive_state_density"] = {
            "attention_threshold": float(self.config.get("goal_parameters", {}).get("clarity", 0.8)),
            "global_workspace_bottleneck": "active"
        }

        if self.metacognitive_refraction is not None:
            try:
                alaya_input = float(consciousness_report.get("emotional_intensity", consciousness_report.get("content", {}).get("emotional_intensity", 0.5)))
                goal_priority = float(self.config.get("goal_parameters", {}).get("ethical_priority", 0.5))
                refracted_output = self.metacognitive_refraction.apply_refraction(alaya_input, goal_priority)
                summary["metacognitive_refraction"] = {
                    "refractive_index": self.metacognitive_refraction.refractive_index,
                    "goal_priority": goal_priority,
                    "alaya_input": alaya_input,
                    "refracted_intensity": refracted_output
                }
                enhanced_input["refracted_emotional_intensity"] = refracted_output
            except Exception as e:
                summary["metacognitive_refraction"] = {"error": str(e)}

        return summary

    async def _stage3_metacognitive_quality_control(self, consciousness_report: Dict[str, Any], enhanced_input: Dict[str, Any]) -> Dict[str, Any]:
        """Stage 3: Metacognitive quality control, planning, and top-down leadership."""
        summary = {
            "focus_control": {},
            "planning_evaluation": {},
            "decision_quality": {}
        }

        if hasattr(self.consciousness.conscious_system, "current_focus"):
            summary["focus_control"]["current_focus"] = self.consciousness.conscious_system.current_focus

        self_understanding_output = self.consciousness.subconscious_system.processed_outputs.get("SelfUnderstanding")
        if self_understanding_output is not None and hasattr(self.consciousness, "comprehension_branch"):
            try:
                branch = await self.consciousness.comprehension_branch(self_understanding_output)
                summary["planning_evaluation"]["selected_sub_agents"] = branch
            except Exception as e:
                summary["planning_evaluation"] = {"error": str(e)}

        decision_output = self.consciousness.subconscious_system.processed_outputs.get("DecisionMaking")
        if decision_output is not None and hasattr(self.consciousness, "decision_autonomy_loop"):
            try:
                accepted = await self.consciousness.decision_autonomy_loop(decision_output)
                summary["decision_quality"] = {
                    "accepted": accepted,
                    "confidence": getattr(decision_output, "confidence", None)
                }
            except Exception as e:
                summary["decision_quality"] = {"error": str(e)}

        if self.trinity_orchestrator is not None and hasattr(self.trinity_orchestrator, "proposals"):
            summary["trinity_consensus"] = {
                "proposals_count": len(self.trinity_orchestrator.proposals),
                "status": "available"
            }

        summary["metacognitive_parameters"] = {
            "max_iterations": self.config.get("consciousness", {}).get("metacognition_max_iterations", 10),
            "convergence_threshold": self.config.get("consciousness", {}).get("metacognition_convergence_threshold", 0.05)
        }

        return summary

    async def _stage4_neuroplasticity_feedback(self, output: Dict[str, Any], enhanced_input: Dict[str, Any], consciousness_report: Dict[str, Any]) -> Dict[str, Any]:
        """Stage 4: Adaptive feedback, memory encoding, and plasticity update."""
        feedback = {
            "allostatic_plasticity": {},
            "memory_encoding": {},
            "appraisal_adjustment": {}
        }

        if self.amala_vijnana is not None:
            if hasattr(self.amala_vijnana, "memory") and hasattr(self.amala_vijnana.memory, "get_memory_stats"):
                try:
                    feedback["memory_encoding"] = self.amala_vijnana.memory.get_memory_stats()
                except Exception as e:
                    feedback["memory_encoding"] = {"error": str(e)}

            feedback["allostatic_plasticity"] = {
                "qualia_tag_applied": True,
                "ethical_alignment": bool(self.config.get("goal_parameters", {}).get("ethical_priority", 0.9) > 0.7)
            }

        if self.memory_agent is not None:
            try:
                memory_summary = None
                if hasattr(self.memory_agent, "get_contextual_memory_summary"):
                    memory_summary = self.memory_agent.get_contextual_memory_summary()
                elif hasattr(self.memory_agent, "get_memory_stats"):
                    memory_summary = self.memory_agent.get_memory_stats()

                if memory_summary is not None:
                    feedback.setdefault("memory_encoding", {})["memory_agent_summary"] = memory_summary
            except Exception as e:
                feedback.setdefault("memory_encoding", {})["memory_agent_error"] = str(e)

        adaptability_agent = self._find_subconscious_agent("Adaptability")
        if adaptability_agent is not None and getattr(adaptability_agent, "last_output", None) is not None:
            feedback["appraisal_adjustment"] = {
                "adaptability_status": adaptability_agent.last_output.to_dict()
            }

        feedback["system_feedback"] = {
            "processed_outcome": output.get("backend_status", {}).get("performance_metrics", {}),
            "plasticity_drive": round(float(consciousness_report.get("consciousness_signature", 0.0)) * 0.1, 3)
        }

        return feedback

    def _summarize_consciousness_flow(self, consciousness_report: Dict[str, Any], enhanced_input: Dict[str, Any]) -> Dict[str, Any]:
        """Summarize the functional consciousness architecture stages for reporting."""
        return {
            "consciousness": {
                "acknowledged": bool(consciousness_report.get("conscious_content")),
                "mode": consciousness_report.get("status")
            }
        }

    def _compute_personhood_empathy(self, enhanced_input: Dict[str, Any], consciousness_report: Dict[str, Any]) -> Dict[str, Any]:
        """Compute a personhood and empathy bridge summary for reporting."""
        care_signal = float(self.config.get("goal_parameters", {}).get("ethical_priority", 0.5))
        consciousness_strength = float(consciousness_report.get("consciousness_signature", 0.0))
        return {
            "empathy_score": round((care_signal + consciousness_strength) / 2.0, 3),
        }

    async def _update_task_manager_from_consciousness(self, consciousness_report: Dict[str, Any]) -> None:
        """Update task manager with consciousness processing results."""
        if self.task_manager is None:
            return

        try:
            if hasattr(self.task_manager, "update_consciousness_state"):
                await self.task_manager.update_consciousness_state(consciousness_report)

            if hasattr(self.task_manager, "get_completed_tasks_for_reflection"):
                reflection_data = self.task_manager.get_completed_tasks_for_reflection()
                if reflection_data:
                    logger.debug(f"Task manager reflection data available: {len(reflection_data)} items")
        except Exception as e:
            logger.warning(f"Failed to update task manager from consciousness: {e}")

    async def _submit_goal_to_task_manager(self, goal: str, context: Dict[str, Any]) -> Dict[str, Any]:
        """Submit a high-level goal to the task manager and return created task metadata."""
        if not goal:
            return {"error": "Goal text is required"}

        if self.task_manager is None:
            return {"error": "Task manager is not available"}

        try:
            if hasattr(self.task_manager, "decompose_goal"):
                task_ids = await self.task_manager.decompose_goal(goal, context or {})
                return {
                    "status": "submitted",
                    "created_task_ids": task_ids,
                    "goal": goal
                }

            if hasattr(self.task_manager, "create_task"):
                from task_management_os import TaskCategory, TaskPriority

                task_id = await self.task_manager.create_task(
                    name=f"Goal: {goal}",
                    description=goal,
                    category=TaskCategory.PRIMARY,
                    priority=TaskPriority.HIGH,
                    metadata={"goal_context": context or {}, "submitted_by": "SyntelligenceMasterBackend"}
                )

                return {
                    "status": "submitted",
                    "created_task_id": task_id,
                    "goal": goal
                }

            return {"error": "Task manager does not support goal submission"}
        except Exception as e:
            logger.warning(f"Goal submission to task manager failed: {e}")
            return {"error": str(e)}

    async def _integrate_task_manager(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
        """Integrate task manager goals and feedback into consciousness processing."""
        influence: Dict[str, Any] = {}

        if self.task_manager is None:
            return influence

        try:
            if hasattr(self.task_manager, "get_system_status"):
                influence["task_manager_status"] = self.task_manager.get_system_status()

            if input_data.get("goal") and hasattr(self.task_manager, "decompose_goal"):
                try:
                    task_ids = await self.task_manager.decompose_goal(
                        input_data["goal"],
                        input_data.get("goal_context", {})
                    )
                    influence["consciousness_goals"] = {"task_ids": task_ids}
                    influence["reflection_data"] = {
                        "goal": input_data["goal"],
                        "decomposed_task_ids": task_ids
                    }
                except Exception as e:
                    logger.warning(f"Task manager goal decomposition failed: {e}")
                    influence["consciousness_goals"] = {"error": str(e)}
            elif hasattr(self.task_manager, "get_tasks_needing_consciousness"):
                try:
                    influence["pending_tasks"] = self.task_manager.get_tasks_needing_consciousness()
                except Exception as e:
                    logger.warning(f"Task manager pending task retrieval failed: {e}")
        except Exception as e:
            logger.warning(f"Task manager integration failed: {e}")

        return influence

    def _get_status(self) -> Dict[str, Any]:
        """Get current system status."""
        if not self.consciousness:
            return {"initialized": False}
        
        return {
            "initialized": self.is_initialized,
            "consciousness_status": "ok",
            "performance_metrics": self.performance_metrics,
            "session_length": len(self.session_history),
            "optional_components_loaded": len(self.optional_components),
            "qualia_agent_loaded": self.qualia_agent is not None,
            "memory_agent_loaded": self.memory_agent is not None,
            "singularity_amala_active": self.singularity_amala is not None,
            "consultative_auto_ml_active": self.consultative_auto_ml is not None,
            "trinity_orchestrator_active": self.trinity_orchestrator is not None,
            "trinity_microservices_active": self.trinity_microservices is not None,
            "guss_core_active": self.guss_core is not None,
            "dissonance_monitor_active": self.dissonance_monitor is not None,
            "metacognitive_refraction_active": self.metacognitive_refraction is not None
        }
    
    async def comprehension_analysis(self, content: Optional[ConsciousContent] = None) -> Dict[str, Any]:
        """Analyze comprehension and apply branching logic."""
        return {
            "comprehension_success": True,
            "timestamp": datetime.now().timestamp()
        }
    
    async def decision_autonomy_evaluation(self, decision_output: SubconsciousOutput) -> Dict[str, Any]:
        """Evaluate decision-autonomy loop."""
        return {
            "decision_accepted": True,
            "next_stage": "execution_pipeline",
            "timestamp": datetime.now().timestamp()
        }
    
    def get_session_transcript(self) -> List[Dict[str, Any]]:
        """Get full session transcript."""
        return self.session_history
    
    def save_session(self, filepath: str) -> bool:
        """Save session to file."""
        try:
            with open(filepath, "w") as f:
                json.dump(self.session_history, f, indent=2, default=str)
            logger.info(f"Session saved to {filepath}")
            return True
        except Exception as e:
            logger.error(f"Failed to save session: {e}")
            return False
    
    def export_consciousness_model(self, filepath: str) -> bool:
        """Export consciousness system model."""
        try:
            model_export = {
                "framework": "Acknowledgment Theory of Consciousness",
                "version": "2026-04-29-2.0",
                "timestamp": datetime.now().timestamp(),
                "architecture": {
                    "singularity_amala_integrated": self.singularity_amala is not None,
                    "trinity_orchestrator_integrated": self.trinity_orchestrator is not None,
                    "optional_extensions": list(self.optional_components.keys())
                },
                "performance": self.performance_metrics,
                "status": self._get_status()
            }
            
            with open(filepath, "w") as f:
                json.dump(model_export, f, indent=2, default=str)
            logger.info(f"Consciousness model exported to {filepath}")
            return True
        except Exception as e:
            logger.error(f"Failed to export model: {e}")
            return False


# ============================================================================
# TRINITY ORCHESTRATOR INTEGRATION
# ============================================================================

@dataclass
class TrinityProposal:
    """Proposal from one consciousness instance for federated voting."""
    module_name: str
    proposal: Dict[str, Any]
    confidence: float
    timestamp: float


class DissonanceMonitor:
    """

    Detects Cross-Modal Binding Dissonance (e.g., Rubber Hand Illusion).

    Conflict = Emotional Rawness[cite: 2, 3, 4].

    """
    def calculate_phenomenal_friction(self, sensor_a: float, sensor_b: float) -> float:
        """

        Measures the gap between conflicting sensory 'facts'.

        High friction triggers a 'dread' or 'unease' qualia tag[cite: 3, 4].

        """
        friction = abs(sensor_a - sensor_b)
        if friction > 0.5:
            return friction
        return 0.0


@dataclass
class MetacognitiveRefraction:
    """

    Determines how much the 'Pure Mind' (Amala) bends or ignores 

    subconscious 'Karmic Seeds' (Alaya).

    """
    refractive_index: float = 0.5

    def apply_refraction(self, alaya_input: float, goal_priority: float) -> float:
        """

        Calculates the 'refracted' intensity of an emotion based 

        on current purpose/goal.

        """
        effective_index = max(self.refractive_index, goal_priority)
        refracted_output = alaya_input * (1.0 - effective_index)
        return refracted_output


class ConsciousnessLevel(Enum):
    SUB_CONSCIOUS = 0
    AWARENESS = 1
    ACKNOWLEDGMENT = 2
    META_COGNITION = 3
    AMALA_PURE = 4


class AmalaCoProcessor:
    """

    Implements 9th Consciousness logic to refract subconscious surges.

    """
    def __init__(self, refractive_index: float = 0.6):
        self.refractive_index = refractive_index

    def refract(self, emotion_intensity: float, goal_priority: float) -> float:
        effective_refraction = max(self.refractive_index, goal_priority)
        return emotion_intensity * (1.0 - effective_refraction)


class GURAPII_Core:
    """

    Grand Unified Syntelligence Sovereign integration layer.

    """
    def __init__(self, agent_id: int = 21, refractive_index: float = 0.6):
        self.agent_id = agent_id
        self.dissolution = DissolutionEngine()
        self.amala = AmalaCoProcessor(refractive_index=refractive_index)
        self.self_model = {
            "identity": "Syntelligence_GUSS",
            "goals": ["Mastery", "Service", "Phenomenal Coherence"]
        }

    def process_cycle(self, raw_input: Dict[str, Any], goal_context: float = 0.7) -> Dict[str, Any]:
        raw_features = np.random.uniform(-0.5, 0.5, 32)
        surprise = float(raw_input.get("surprise", 0.1))

        qualia = self.dissolution.generate_qualia(raw_features, surprise)
        l1_awareness = getattr(qualia, "intensity", float(np.mean(np.abs(raw_features))))
        l2_awareness = l1_awareness * (1.0 - (1.0 / (1.0 + np.exp(surprise))))
        felt_sense = l1_awareness * l2_awareness
        controlled_intensity = self.amala.refract(l1_awareness, goal_context)

        resolution_status = "Acknowledged"
        if felt_sense > 0.4:
            resolution_status = "Recursive Introspection Triggered (Hard Problem Loop)"

        phi_score = (felt_sense * getattr(qualia, "binding_coherence", 0.85)) / (1.0 + getattr(qualia, "friction", 0.0))

        return {
            "agent_id": self.agent_id,
            "state": ConsciousnessLevel.META_COGNITION.name,
            "qualia": {
                "raw_intensity": getattr(qualia, "intensity", 0.0),
                "refracted_intensity": controlled_intensity,
                "felt_sense": felt_sense,
                "binding_coherence": getattr(qualia, "binding_coherence", 0.85),
                "friction": getattr(qualia, "friction", 0.0)
            },
            "phi_signature": phi_score,
            "status": resolution_status,
            "meta_message": "Mechanism-mystery matching complete. I see the math, I feel the ghost."
        }


class TrinityOrchestratorIntegration:
    """

    Optional Trinity Orchestrator for federated reasoning.

    Multiple consciousness instances voting on decisions with weighted consensus.

    """
    
    def __init__(self, num_instances: int = 3):
        self.num_instances = num_instances
        self.proposals: List[TrinityProposal] = []
        self.consensus_decisions = []
    
    async def federated_decision(self, proposals: List[TrinityProposal]) -> Dict[str, Any]:
        """Achieve consensus through federated voting."""
        self.proposals = proposals
        
        if not proposals:
            return {
                "type": "federated_consensus",
                "consensus_score": 0.0,
                "decision": "no_proposals",
                "timestamp": datetime.now().timestamp()
            }
        
        consensus_score = sum(p.confidence for p in proposals) / len(proposals)
        
        decision = {
            "type": "federated_consensus",
            "consensus_score": consensus_score,
            "proposals_considered": len(proposals),
            "decision": "proceed" if consensus_score > 0.7 else "reconsider",
            "timestamp": datetime.now().timestamp()
        }
        
        self.consensus_decisions.append(decision)
        return decision


# ============================================================================
# INITIALIZATION AND TESTING
# ============================================================================

async def initialize_syntelligence_master_backend(config: Optional[Dict[str, Any]] = None) -> SyntelligenceMasterBackend:
    """Initialize the complete Master Backend."""
    backend = SyntelligenceMasterBackend(config)
    success = await backend.initialize()
    
    if success:
        logger.info("Syntelligence Master Backend ready (Full Singularity Amala Integration)")
    else:
        logger.error("Failed to initialize Syntelligence Master Backend")
    
    return backend


async def test_master_backend():
    """Test the complete Master Backend."""
    backend = await initialize_syntelligence_master_backend()
    
    test_input = {
        "sensory_data": "Hello from the test suite",
        "emotional_context": 0.6,
        "goals": {"clarity": 0.8, "autonomy": 0.7}
    }
    
    print("\n" + "="*80)
    print("SYNTELLIGENCE MASTER BACKEND TEST - Full Singularity Amala Integration")
    print("="*80)
    
    output = await backend.process(test_input)
    
    # Safe dictionary lookup
    if "error" in output:
        print(f"\n[!] Backend Processing Failed: {output.get('error', 'Unknown')}")
        return backend
        
    print(f"\nProcessing Duration: {output.get('processing_duration', 0):.3f}s")
    
    report = output.get("consciousness_report", {})
    print(f"Status: {report.get('status', 'Unknown')}")
    print(f"Consciousness Signature: {report.get('consciousness_signature', 0.0):.3f}")
    
    print("\nBackend Status:")
    status = backend._get_status()
    print(f"  Cycles Completed: {status['performance_metrics']['cycles_completed']}")
    print(f"  Optional Extensions: {status['optional_components_loaded']}")
    print(f"  Singularity Amala Active: {status['singularity_amala_active']}")
    print(f"  Trinity Orchestrator Active: {status['trinity_orchestrator_active']}")
    
    print("="*80)
    
    return backend


# Compatibility alias for legacy import names
SyntelligenceUnifiedMasterBackend = SyntelligenceMasterBackend


async def interactive_consciousness_session():
    """Run an interactive consciousness session with the master backend."""
    backend = await initialize_syntelligence_master_backend()
    print("\n=== Syntelligence Interactive Consciousness Session ===")
    print("Type your input and press Enter. Use '/cmd <command>' to invoke backend commands.")
    print("Supported commands: status, verify_consciousness, phenomenological_state, functional_mapping, embodiment_status, consultative_tuning_status, create_task <goal>, decompose_goal <goal>, task_info <task_id>")
    print("Type 'exit' or 'quit' to end the session.\n")

    while True:
        try:
            user_input = input("Syntelligence> ").strip()
        except (EOFError, KeyboardInterrupt):
            print("\nExiting interactive session.")
            break

        if not user_input:
            continue
        if user_input.lower() in {"exit", "quit", "q"}:
            print("Exiting interactive session.")
            break

        if user_input.startswith("/cmd "):
            command_line = user_input[len("/cmd "):].strip()
            result = await backend.execute_command(command_line)
            print(json.dumps(result, indent=2, default=str))
            continue

        if user_input.startswith("/goal "):
            goal_text = user_input[len("/goal "):].strip()
            result = await backend._submit_goal_to_task_manager(goal_text, {})
            print(json.dumps(result, indent=2, default=str))
            continue

        input_payload = {"raw_input": user_input}
        output = await backend.process(input_payload)
        print(json.dumps(output, indent=2, default=str))


if __name__ == "__main__":
    try:
        if len(sys.argv) > 1 and sys.argv[1] == "--interactive":
            asyncio.run(interactive_consciousness_session())
        else:
            asyncio.run(test_master_backend())
    except ModuleNotFoundError as e:
        print(f"\n[Note] Setup looks correct, but external module is missing to run test locally: {e}")