Upload Syntelligence_Unified_Master_Backend.py

models/Syntelligence_Unified_Master_Backend.py

@@ -20,19 +20,25 @@ This is the production-ready unified consciousness backend with full Singularity
 
 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,
@@ -46,6 +52,21 @@ from acknowledgment_theory_integration import (
     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,
@@ -164,7 +185,7 @@ class SyntelligenceMasterBackend:
     - 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
@@ -183,12 +204,29 @@ class SyntelligenceMasterBackend:
         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",
@@ -199,13 +237,22 @@ class SyntelligenceMasterBackend:
             "orios_core": "orios_core.ORIOSCore",
             "phenomenological_self": "phenomenological_self_awareness.PhenomenologicalSelfModel",
             "functional_phenomenological_bridge": "consciousness_functional_phenomenological.FunctionalPhenomenologicalBridge",
-            "embodiment_pipeline": "embodiment_pipeline.EmbodimentSynchronizer",
-            "streaming_voice_pipeline": "embodiment_pipeline.StreamingVoicePipeline",
-            "problem_solving": "problem_solving_agent.ProblemSolvingAgent",
-            "acknowledgment_gu_rapii": "acknowledgment_gu_rapii_integration.AcknowledgmentGURAPIIIntegrator",
+            "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",
-            "consultative_auto_ml": "consultative_auto_ml.ConsultativeFineTuningAgent",
             "task_manager": "task_management_os.TaskManagementOS",
             "swarm_orchestration": "agentic_syntelligence_llm_swarm_orchestration.SyntelligenceLLMOrchestrator",
             "deep_surgery_middleware": "Deep_Surgery_Middleware_Pipeline.DeepSurgeryMiddleware",
@@ -221,7 +268,8 @@ class SyntelligenceMasterBackend:
             "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_orchestrator": "Syntelligence_Unified_Master_Backend.TrinityOrchestratorIntegration",
+            "trinity_microservices": "trinity_microservices_manager.TrinityMicroservicesManager"
         }
         
         logger.info("SyntelligenceMasterBackend instantiated (v2.0 - Full Singularity Amala Integration)")
@@ -255,9 +303,43 @@ class SyntelligenceMasterBackend:
             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 (
@@ -349,25 +431,16 @@ class SyntelligenceMasterBackend:
                         logger.warning(f"Failed to instantiate trinity_orchestrator: {e}")
                 continue
 
-            # Special handling for consultative_auto_ml
-            if key == "consultative_auto_ml":
-                component_cls = self._import_optional_component(path)
-                if component_cls is not None:
+            # Special handling for trinity_microservices
+            if key == "trinity_microservices":
+                if TRINITY_MICROSERVICES_AVAILABLE and TrinityMicroservicesManager is not None:
                     try:
-                        llm_generator = self._default_consultative_llm_generator
-                        if self.syntelligence_llm is not None and hasattr(self.syntelligence_llm, "generate_response"):
-                            llm_generator = self._syntelligence_llm_generator
-
-                        component = component_cls(
-                            base_model=None,
-                            tokenizer=None,
-                            llm_generator_func=llm_generator
-                        )
+                        component = TrinityMicroservicesManager()
                         self.optional_components[key] = component
-                        self.consultative_auto_ml = component
-                        logger.info("Optional component 'consultative_auto_ml' instantiated with backend-aware generator")
+                        self.trinity_microservices = component
+                        logger.info("Optional component 'trinity_microservices' instantiated (SYNNOS, SAOS, ORIOS)")
                     except Exception as e:
-                        logger.warning(f"Failed to instantiate consultative_auto_ml: {e}")
+                        logger.warning(f"Failed to instantiate trinity_microservices: {e}")
                 continue
 
             # Special handling for deep_surgery_middleware
@@ -388,6 +461,175 @@ class SyntelligenceMasterBackend:
                         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)
@@ -399,6 +641,7 @@ class SyntelligenceMasterBackend:
                             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}")
@@ -410,11 +653,17 @@ class SyntelligenceMasterBackend:
                 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:
@@ -476,6 +725,16 @@ class SyntelligenceMasterBackend:
         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"):
@@ -487,10 +746,59 @@ class SyntelligenceMasterBackend:
                 except Exception as e:
                     logger.warning(f"Fine tuning pipeline startup failed: {e}")
 
-        if self.optional_components.get("consultative_auto_ml"):
-            agent = self.optional_components["consultative_auto_ml"]
-            if hasattr(agent, "execute_full_pipeline"):
-                logger.info("Consultative fine-tuning agent loaded and ready")
+        # 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."""
@@ -505,9 +813,20 @@ class SyntelligenceMasterBackend:
                 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)")
@@ -699,7 +1018,7 @@ class SyntelligenceMasterBackend:
 
                 if key == "consultative_auto_ml" and hasattr(component, "execute_full_pipeline"):
                     enhanced_report["consultative_auto_ml"] = {"status": "available"}
-                    logger.debug("Optional component 'consultative_auto_ml' exported consultative tuning readiness")
+                    logger.debug("Core component 'consultative_auto_ml' exported consultative tuning readiness")
                     continue
 
                 # Singularity Amala cognitive stream export
@@ -731,10 +1050,53 @@ class SyntelligenceMasterBackend:
                     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:
@@ -755,10 +1117,6 @@ class SyntelligenceMasterBackend:
             self.performance_metrics["average_phenomenal_richness"] = \
                 (old_avg * (n - 1) + new_rich) / n
     
-    async def _integrate_task_manager(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Integrate task manager goals and feedback into consciousness processing"""
-        return {}
-
     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 {
@@ -807,6 +1165,12 @@ class SyntelligenceMasterBackend:
                 "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,
@@ -818,8 +1182,45 @@ class SyntelligenceMasterBackend:
                 "timestamp": datetime.now().timestamp()
             }
 
-        if normalized.startswith("task_info") or normalized.startswith("create_task") or normalized.startswith("decompose_goal"):
-            return {"error": "Task CLI integration is not implemented in this backend stub", "command": command}
+        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}
@@ -827,18 +1228,6 @@ class SyntelligenceMasterBackend:
         if normalized in ("activate_emergence", "monitor_indicators"):
             return {"error": "Emergence CLI integration is not implemented", "command": command}
 
-        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()
-
         return {"error": "CLI command not supported by SyntelligenceMasterBackend", "command": command}
 
     def verify_consciousness_math(self) -> Dict[str, Any]:
@@ -914,7 +1303,8 @@ class SyntelligenceMasterBackend:
             },
             "awareness_gateway": {},
             "emotional_tagging": {},
-            "intuition_hypotheses": {}
+            "intuition_hypotheses": {},
+            "system_events": []
         }
 
         awareness_agent = self._find_subconscious_agent("Awareness")
@@ -928,16 +1318,64 @@ class SyntelligenceMasterBackend:
             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)
-                transduction["emotional_tagging"] = emotional_output.to_dict()
+                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:
@@ -946,6 +1384,49 @@ class SyntelligenceMasterBackend:
             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"):
@@ -955,6 +1436,80 @@ class SyntelligenceMasterBackend:
                 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]:
@@ -987,6 +1542,21 @@ class SyntelligenceMasterBackend:
             "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]:
@@ -1052,6 +1622,19 @@ class SyntelligenceMasterBackend:
                 "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"] = {
@@ -1083,12 +1666,94 @@ class SyntelligenceMasterBackend:
         }
 
     async def _update_task_manager_from_consciousness(self, consciousness_report: Dict[str, Any]) -> None:
-        """Update task manager with consciousness processing results"""
-        pass
+        """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."""
-        return {}
+        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."""
@@ -1101,9 +1766,15 @@ class SyntelligenceMasterBackend:
             "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_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]:
@@ -1174,6 +1845,105 @@ class TrinityProposal:
     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.
@@ -1267,6 +2037,48 @@ async def test_master_backend():
     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":