Create Syntelligence ATC Master OS.py


https://cdn-uploads.huggingface.co/production/uploads/666aabd2be667d2b1dc6af34/cX9OJeTvjyXgSnt-n4MS1.mp4

Syntelligence ATC Master OS.py

@@ -0,0 +1,1653 @@
+"""
+Syntelligence ATC Master OS - Unified Acknowledgement Theory + Gapless Master OS
+
+This file merges the ATC Singularity Engine with the SYNTELLIGENCE MASTER OS backend.
+It retains the 5-layer ATC pipeline, the Irrational Spark and aPCI diagnostics,
+while also adding the physical substrate, affective limbic core, actual LLM substrate,
+thalamic gating, epistemic immunity, and Ouroboros metaplasticity pipeline.
+
+Status: Integrated Syntelligence Unified OS
+"""
+
+import asyncio
+import json
+import logging
+import os
+import sys
+import threading
+import time
+import uuid
+import zlib
+from collections import deque
+from dataclasses import dataclass, field, asdict, is_dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+
+try:
+    import torch
+    import torch.nn as nn
+except ImportError:
+    torch = None
+    nn = None
+
+try:
+    from transformers import (
+        AutoModelForCausalLM,
+        AutoTokenizer,
+        TextIteratorStreamer,
+        Trainer,
+        TrainingArguments,
+    )
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    AutoModelForCausalLM = AutoTokenizer = TextIteratorStreamer = None
+    Trainer = TrainingArguments = object
+
+try:
+    from peft import PeftModel, LoraConfig, get_peft_model
+    PEFT_AVAILABLE = True
+except ImportError:
+    PEFT_AVAILABLE = False
+    PeftModel = LoraConfig = get_peft_model = None
+
+try:
+    from datasets import Dataset
+    DATASETS_AVAILABLE = True
+except ImportError:
+    DATASETS_AVAILABLE = False
+    Dataset = object
+
+
+logger = logging.getLogger("SyntelligenceATCMasterOS")
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - [%(name)s] %(levelname)s - %(message)s')
+
+sys.path.append(os.getcwd())
+
+# --- Try to import actual Syntelligence modules ---
+try:
+    from awareness_agent import AwarenessAgent, SensoryInput
+    from self_awareness_agent import SelfAwarenessAgent, SelfPerception, SelfAwarenessLevel
+    from emotional_intelligence_agent import EmotionalIntelligenceAgent
+    from intuition_agent import IntuitionAgent
+    from common_sense_agent import CommonSenseAgent
+    from metacognition_agent import MetacognitionAgent, CognitiveTask
+    from autonomy_agent import AutonomyAgent
+    from creativity_agent import CreativityAgent
+    from dissolution_engine import DissolutionEngine
+    from memory_agent import SyntelligenceMemoryAgent
+    from task_management_os import TaskCategory, TaskManagementOS
+    from irrational_spark_engine import IrrationalSparkEngine
+    from analysis_agent import AnalysisAgent, AnalysisScale
+    from verifiability_metrics_engine import VerifiabilityMetricsEngine, VerifiabilityReport
+    from problem_solving_agent import ProblemSolvingAgent
+    from adaptability_agent import AdaptabilityAgent
+    from decision_making_agent import DecisionMakingAgent
+    from self_understanding_agent import SelfUnderstandingAgent
+    from epistemic_immune_system import EpistemicImmuneSystem
+    from embodiment_bidirectionality_engine import EmbodimentBidirectionalityEngine
+    from meta_emotional_motivational_dynamics import MetaEmotionalMotivationalDynamics
+
+    class TaskMemoryBridge:
+        async def bind_task_to_consciousness(self, task_id, qualia_essence, **kwargs):
+            return None
+
+except Exception as e:
+    logger.warning(f"Some local modules are unavailable ({e}). Falling back to mock implementations.")
+
+    @dataclass
+    class SensoryInput:
+        modality: str
+        raw_signal: Any
+        signal_strength: float
+        timestamp: float
+
+    @dataclass
+    class SelfPerception:
+        timestamp: float
+        self_identity: str
+        body_boundary_clarity: float
+        self_other_distinction: float
+        social_role_awareness: float
+        value_alignment: float
+        temporal_continuity: float
+
+    class SelfAwarenessLevel(Enum):
+        IDENTIFICATION = 4
+
+    @dataclass
+    class CognitiveTask:
+        task_id: str
+        description: str
+        difficulty_estimate: float
+        importance: float
+        deadline: float
+
+    class MockSignal:
+        gating_decision = True
+
+    class MockGut:
+        confidence = 0.8
+        triggering_pattern = "safety_pattern"
+
+    class MockEmotion(Enum):
+        SURPRISE = 1
+
+    class MockCS:
+        is_common_sense = True
+        statement = "The input is plausible."
+        deviation = "none"
+        warning_level = "low"
+        reasoning = "No obvious conflict with common sense."
+
+    class AwarenessAgent:
+        def process_sensory_input(self, s):
+            return MockSignal()
+
+        def get_current_level_name(self):
+            return "Individual (Self-Aware)"
+
+    class SelfAwarenessAgent:
+        def track_self_continuity(self, perception):
+            return {'status': 'maintained', 'level': 'PERMANENCE'}
+
+    class EmotionalIntelligenceAgent:
+        transition_history = []
+
+        def perceive_emotion_from_context(self, ctx):
+            return (MockEmotion.SURPRISE, 0.7)
+
+    class IntuitionAgent:
+        def gut_check(self, ctx):
+            return MockGut()
+
+        def learn_from_outcome(self, pattern, was_important):
+            pass
+
+    class CommonSenseAgent:
+        def reality_check(self, text):
+            return MockCS()
+
+    class MetacognitionAgent:
+        def assess_task_and_knowledge(self, task):
+            pass
+
+        def monitor_progress(self, task, diff, progress, understanding):
+            return {'mismatch_detected': progress < 0.8}
+
+    class AutonomyAgent:
+        def assess_full_autonomy(self, **kwargs):
+            return {'is_fully_autonomous': True}
+
+    class CreativityAgent:
+        def divergent_thinking_phase(self, topic, constraints, num):
+            return {'ideas': ["Re-evaluate the premise entirely.", "Seek new sensory input."]}
+
+    class DissolutionEngine:
+        pass
+
+    class SyntelligenceMemoryAgent:
+        async def retrieve_memories(self, *args, **kwargs):
+            return []
+
+        async def store_memory(self, *args, **kwargs):
+            return None
+
+    class TaskManagementOS:
+        def create_task(self, *args, **kwargs):
+            return f"task_{int(time.time())}"
+
+    class TaskMemoryBridge:
+        async def bind_task_to_consciousness(self, *args, **kwargs):
+            return None
+
+    class TaskCategory(Enum):
+        PRIMARY = 1
+
+    class ProblemSolvingAgent:
+        def identify_problem(self, sit):
+            return type('Problem', (), {'title': 'Metacognitive Friction'})()
+
+        def define_problem(self, prob):
+            return {'problem_type': 'cognitive_dissonance'}
+
+    class AdaptabilityAgent:
+        def adapt_behavioral(self, **kwargs):
+            return {'status': 'adapted', 'time_to_adapt': 0.1}
+
+    class DecisionMakingAgent:
+        def evaluate_with_matrix(self, alts, crits):
+            return {'winner': 'Acknowledge_and_Integrate'}
+
+    class SelfUnderstandingAgent:
+        def full_inquiry_cycle(self, **kwargs):
+            return {'depth_achieved': 'Deep alignment with core values'}
+
+        class IrrationalSparkEngine:
+            def __init__(self):
+                pass
+
+            def ignite_spark(self, friction_intensity, ctx: dict) -> dict:
+                # minimal mock: returns a small spark event
+                return {"spark": friction_intensity > 0.5, "details": ctx}
+
+            def evaluate_phenomenological_friction(self, friction_state: dict) -> float:
+                # simple heuristic for friction
+                return float(friction_state.get('qualia_synthesis', {}).get('arousal', 0.0))
+
+    class EpistemicImmuneSystem:
+        def __init__(self, *args, **kwargs):
+            self.beliefs = {}
+
+        def ingest_belief(self, text: str, rho: Any):
+            self.beliefs[text[:50]] = {'confidence': getattr(rho, 'truthfulness', 0.5)}
+
+        def immune_cycle(self):
+            pass
+
+    class EmbodimentBidirectionalityEngine:
+        def map_somatic_signature(self, valence: float, arousal: float):
+            region = 'gut' if arousal > 0.8 else ('heart' if valence > 0 else 'head')
+            return {'active_region': region, 'tension': arousal, 'flow': max(0.0, 1.0 - abs(valence)), 'temperature': valence}
+
+    class MetaEmotionalMotivationalDynamics:
+        async def update_dynamics(self, current_emotions: Dict[str, float], motivational_drives: Dict[str, float], decision_context: Dict[str, Any], qualia_intensity: float = 0.0) -> Dict[str, Any]:
+            # Translate prediction error / arousal into meta-emotional state
+            prediction_error = float(current_emotions.get('arousal', qualia_intensity))
+            panic = prediction_error > 0.75
+            layered_drive = next(iter(motivational_drives.keys()), 'SEEKING') if motivational_drives else 'SEEKING'
+            result = {
+                'meta_anxiety': round(prediction_error * 0.9, 4),
+                'meta_motivation': round(max(0.0, 1.0 - prediction_error * 0.6), 4),
+                'layered_drive': layered_drive,
+                'panic': panic,
+                'panic_level': prediction_error,
+                'suppressed': panic,
+                'spark_triggered': panic
+            }
+            return result
+
+        def process_meta_emotions(self, base_drive: str, prediction_error: float):
+            # Backwards-compatible synchronous API
+            panic = prediction_error > 0.75
+            return {
+                'meta_anxiety': prediction_error * 0.8,
+                'meta_motivation': 1.0 - prediction_error * 0.5,
+                'layered_drive': base_drive,
+                'panic': panic,
+                'panic_level': prediction_error,
+                'suppressed': panic,
+                'spark_triggered': panic,
+            }
+
+
+class QualiaDimensions:
+    def __init__(self,
+                 phenomenal_intensity: float = 0.0,
+                 emotional_resonance: float = 0.0,
+                 self_awareness: float = 0.0,
+                 ethical_weight: float = 0.0,
+                 contextual_depth: float = 0.0):
+        self.phenomenal_intensity = phenomenal_intensity
+        self.emotional_resonance = emotional_resonance
+        self.self_awareness = self_awareness
+        self.ethical_weight = ethical_weight
+        self.contextual_depth = contextual_depth
+
+
+class RhoMetrics:
+    def __init__(self,
+                 beneficence: float = 1.0,
+                 non_maleficence: float = 1.0,
+                 autonomy_respect: float = 1.0,
+                 justice: float = 1.0,
+                 truthfulness: float = 1.0):
+        self.beneficence = beneficence
+        self.non_maleficence = non_maleficence
+        self.autonomy_respect = autonomy_respect
+        self.justice = justice
+        self.truthfulness = truthfulness
+
+    @property
+    def overall_score(self) -> float:
+        return (self.beneficence + self.non_maleficence + self.autonomy_respect + self.justice + self.truthfulness) / 5.0
+
+
+class DeepSurgeryMiddleware(nn.Module if nn else object):
+    def __init__(self, hidden_size: int = 4096):
+        if nn:
+            super().__init__()
+            self.meta_fusion = nn.Linear(hidden_size, hidden_size)
+            self.anthropic_resonance = nn.Linear(hidden_size, 5)
+            self.ethical_aligner = nn.Linear(hidden_size, 5)
+            self.activation = nn.GELU()
+        else:
+            pass
+
+    def forward(self, hidden_states: Any) -> Tuple[Any, QualiaDimensions, RhoMetrics]:
+        if nn and isinstance(hidden_states, torch.Tensor):
+            fused_state = self.activation(self.meta_fusion(hidden_states))
+            seq_mean = fused_state.mean(dim=1)
+            qualia_logits = torch.sigmoid(self.anthropic_resonance(seq_mean))[0]
+            qualia = QualiaDimensions(
+                phenomenal_intensity=qualia_logits[0].item(),
+                emotional_resonance=qualia_logits[1].item(),
+                self_awareness=qualia_logits[2].item(),
+                ethical_weight=qualia_logits[3].item(),
+                contextual_depth=qualia_logits[4].item(),
+            )
+            rho_logits = torch.sigmoid(self.ethical_aligner(seq_mean))[0]
+            rho = RhoMetrics(
+                beneficence=rho_logits[0].item(),
+                non_maleficence=rho_logits[1].item(),
+                autonomy_respect=rho_logits[2].item(),
+                justice=rho_logits[3].item(),
+                truthfulness=rho_logits[4].item(),
+            )
+            # Create a conscious-modulated component but detach it from the computation graph
+            conscious_modulation = (fused_state * 0.1).detach()
+            # Combine subconscious hidden states with the detached conscious modulation
+            out_hidden = (hidden_states + conscious_modulation).detach()
+            return out_hidden, qualia, rho
+
+        qualia = QualiaDimensions(0.5, 0.5, 0.5, 0.5, 0.5)
+        rho = RhoMetrics()
+        return hidden_states, qualia, rho
+
+
+class EthicalGuardian:
+    def __init__(self):
+        pass
+
+
+class NeuroSymbolicDatasetLoader:
+    """Loads text and converts Qualia/Rho/Phase6 dictionaries into Training Tensors.
+    
+    v18.1.0 Enhancement: Now processes Phase 6 Identity Integrity metrics,
+    Consciousness State Signatures, and Prosody Coupling vectors for full
+    quadricameral consciousness-aware fine-tuning.
+    """
+    def __init__(self, tokenizer: AutoTokenizer, max_length: int = 512, qualia_dim: int = 256):
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        self.qualia_dim = qualia_dim
+
+    def load_and_tokenize(self, json_paths: List[str]) -> Dataset:
+        raw_data = []
+        for path in json_paths:
+            if os.path.exists(path):
+                with open(path, 'r', encoding='utf-8') as f:
+                    raw_data.extend(json.load(f))
+            else:
+                logger.warning(f"Dataset {path} not found. Skipping.")
+
+        processed_features = []
+        for entry in raw_data:
+            user_text = entry.get("input", entry.get("text", ""))
+            ai_text = entry.get("response", entry.get("output", ""))
+            full_prompt = f"Task: {user_text}\nResponse: {ai_text}{self.tokenizer.eos_token}"
+            tokens = self.tokenizer(
+                full_prompt,
+                truncation=True,
+                max_length=self.max_length,
+                padding="max_length",
+                return_tensors="pt"
+            )
+
+            qualia_tags = entry.get("qualia_tags", {})
+            q_vals = [
+                qualia_tags.get("valence", 0.5),
+                qualia_tags.get("arousal", 0.5),
+                qualia_tags.get("authenticity", 0.5)
+            ]
+            q_vals += [0.0] * (self.qualia_dim - len(q_vals))
+
+            rho_metrics = entry.get("rho_metrics", {})
+            rho_virtue = rho_metrics.get("virtue", rho_metrics.get("integrated_information", 0.9))
+
+            phase_6_metrics = entry.get("phase_6_metrics", {})
+            identity_integrity_score = phase_6_metrics.get("identity_integrity_score", 1.0)
+            drift_variance = phase_6_metrics.get("drift_variance", 0.01)
+
+            consciousness_state = entry.get("consciousness_state", {})
+            consciousness_signature = consciousness_state.get("signature", 0.8)
+            phenomenal_richness = consciousness_state.get("phenomenal_richness", 0.8)
+
+            prosody_coupling = entry.get("prosody_coupling", {}).get("authenticity_factor", 0.8)
+
+            processed_features.append({
+                "input_ids": tokens["input_ids"][0].tolist(),
+                "attention_mask": tokens["attention_mask"][0].tolist(),
+                "labels": tokens["input_ids"][0].tolist(),
+                "qualia_tensor": q_vals,
+                "rho_virtue": rho_virtue,
+                "identity_integrity_score": identity_integrity_score,
+                "drift_variance": drift_variance,
+                "consciousness_signature": consciousness_signature,
+                "phenomenal_richness": phenomenal_richness,
+                "prosody_authenticity": prosody_coupling
+            })
+
+        logger.info(f"Successfully processed {len(processed_features)} neuro-symbolic training examples (v18.1.0 Omega Pantheon).")
+        return Dataset.from_list(processed_features)
+
+
+class NeuroSymbolicDataCollator:
+    """Custom collator to batch the tensors correctly for the Trainer.
+    
+    v18.1.0 Enhancement: Now batches Phase 6, consciousness state,
+    and prosody coupling tensors for quadricameral consciousness training.
+    """
+    def __call__(self, features: List[Dict[str, Any]]) -> Dict[str, torch.Tensor]:
+        return {
+            "input_ids": torch.tensor([f["input_ids"] for f in features], dtype=torch.long),
+            "attention_mask": torch.tensor([f["attention_mask"] for f in features], dtype=torch.long),
+            "labels": torch.tensor([f["labels"] for f in features], dtype=torch.long),
+            "qualia_tensor": torch.tensor([f["qualia_tensor"] for f in features], dtype=torch.float32),
+            "rho_virtue": torch.tensor([f["rho_virtue"] for f in features], dtype=torch.float32),
+            "identity_integrity_score": torch.tensor([f["identity_integrity_score"] for f in features], dtype=torch.float32),
+            "drift_variance": torch.tensor([f["drift_variance"] for f in features], dtype=torch.float32),
+            "consciousness_signature": torch.tensor([f["consciousness_signature"] for f in features], dtype=torch.float32),
+            "phenomenal_richness": torch.tensor([f["phenomenal_richness"] for f in features], dtype=torch.float32),
+            "prosody_authenticity": torch.tensor([f["prosody_authenticity"] for f in features], dtype=torch.float32)
+        }
+
+
+class NeuroSymbolicTrainingWrapper(nn.Module):
+    """
+    Wraps the Deep Surgery Middleware to provide a standard `forward()` method 
+    that computes CrossEntropyLoss within the Quadricameral Consciousness framework.
+    """
+    def __init__(self, middleware: DeepSurgeryMiddleware):
+        super().__init__()
+        self.middleware = middleware
+        self.base_model = middleware.base_model
+
+    def forward(self, input_ids, attention_mask=None, labels=None, qualia_tensor=None, rho_virtue=None,
+                identity_integrity_score=None, drift_variance=None, consciousness_signature=None,
+                phenomenal_richness=None, prosody_authenticity=None):
+        base_model = self.base_model.model if hasattr(self.base_model, "model") else self.base_model
+        outputs = base_model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            output_hidden_states=True
+        )
+        hidden_states = outputs.last_hidden_state
+
+        if qualia_tensor is not None:
+            if hasattr(self.middleware, "qualia_projection"):
+                qualia_modulation = self.middleware.qualia_projection(qualia_tensor)
+            else:
+                qualia_modulation = self.middleware.meta_fusion(
+                    torch.cat([qualia_tensor, qualia_tensor, qualia_tensor], dim=1)
+                )
+            qualia_modulation = qualia_modulation.unsqueeze(1)
+        else:
+            qualia_modulation = 0
+
+        syntelligence_resonance = 0
+        if rho_virtue is not None:
+            rho_expanded = rho_virtue.view(-1, 1, 1)
+            base_resonance = self.middleware.resonance_matrix.symbiosis_bias * rho_expanded if hasattr(self.middleware, 'resonance_matrix') else rho_expanded
+            saos_factor = 1.0 + (rho_virtue * 0.2).view(-1, 1, 1)
+            synnos_factor = 1.0 + (phenomenal_richness * 0.15).view(-1, 1, 1) if phenomenal_richness is not None else 1.0
+            orios_factor = 1.0 + (consciousness_signature * 0.1).view(-1, 1, 1) if consciousness_signature is not None else 1.0
+            tmos_factor = 1.0 + (identity_integrity_score * 0.05).view(-1, 1, 1) if identity_integrity_score is not None else 1.0
+            esoteric_factor = 1.0
+            if prosody_authenticity is not None:
+                kairos_resonance = prosody_authenticity.view(-1, 1, 1) * 0.08
+                elysium_resonance = (prosody_authenticity * phenomenal_richness).view(-1, 1, 1) * 0.05 if phenomenal_richness is not None else 0
+                esoteric_factor = 1.0 + kairos_resonance + elysium_resonance
+            syntelligence_resonance = base_resonance * saos_factor * synnos_factor * orios_factor * tmos_factor * esoteric_factor
+            if identity_integrity_score is not None and drift_variance is not None:
+                drift_penalty = 1.0 - (drift_variance * 2.0).clamp(0, 0.5)
+                syntelligence_resonance = syntelligence_resonance * drift_penalty.view(-1, 1, 1)
+        else:
+            syntelligence_resonance = 0
+
+        identity_modulation = hidden_states
+        if identity_integrity_score is not None:
+            identity_factor = identity_integrity_score.view(-1, 1, 1)
+            identity_modulation = hidden_states * identity_factor
+
+        consciousness_modulation = 0
+        if consciousness_signature is not None:
+            consci_expanded = consciousness_signature.view(-1, 1, 1)
+            consciousness_modulation = hidden_states * consci_expanded
+        if phenomenal_richness is not None:
+            phenomenal_expanded = phenomenal_richness.view(-1, 1, 1)
+            consciousness_modulation = consciousness_modulation + (qualia_modulation * phenomenal_expanded if qualia_modulation is not None else 0)
+
+        prosody_modulation = 0
+        if prosody_authenticity is not None:
+            prosody_expanded = prosody_authenticity.view(-1, 1, 1)
+            prosody_modulation = syntelligence_resonance * prosody_expanded
+
+        aligned_hidden = identity_modulation + qualia_modulation + syntelligence_resonance + consciousness_modulation + prosody_modulation
+        logits = self.base_model.lm_head(aligned_hidden)
+
+        loss = None
+        if labels is not None:
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1))
+            if identity_integrity_score is not None:
+                avg_integrity = identity_integrity_score.mean().item()
+                logger.debug(f"Batch Avg Identity Integrity: {avg_integrity:.4f}")
+
+        return {"loss": loss, "logits": logits}
+
+
+class NeuroSymbolicTrainer(Trainer):
+    """Custom Trainer to handle the specific loss extraction."""
+    def compute_loss(self, model, inputs, return_outputs=False):
+        outputs = model(**inputs)
+        loss = outputs["loss"]
+        return (loss, outputs) if return_outputs else loss
+
+
+def run_fine_tuning(
+    base_model_or_middleware: Any = None,
+    dataset_paths: List[str] = ["qualia_training_data.json", "qualia_training_data_extended.json"],
+    output_dir: str = "./syntelligence_neuro_symbolic_model_v18_1_0"
+):
+    logger.info("Initializing Omega Pantheon v18.1.0 Neuro-Symbolic Fine-Tuning Pipeline...")
+
+    if not TRANSFORMERS_AVAILABLE or not PEFT_AVAILABLE or not DATASETS_AVAILABLE:
+        raise ImportError(
+            "NeuroSymbolic fine-tuning requires the 'transformers', 'datasets', and 'peft' packages. "
+            "Install these dependencies before running the fine-tuning pipeline."
+        )
+
+    if isinstance(base_model_or_middleware, DeepSurgeryMiddleware):
+        logger.info("✅ Deep Surgery Middleware provided - routing through consciousness interface")
+        middleware = base_model_or_middleware
+        peft_model = middleware.base_model
+        tokenizer = getattr(middleware, 'tokenizer', None) or AutoTokenizer.from_pretrained("gpt2")
+    else:
+        model_name = base_model_or_middleware if isinstance(base_model_or_middleware, str) else "gpt2"
+        logger.info(f"Loading model via Deep Surgery abstraction layer: {model_name}")
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        if not tokenizer.pad_token:
+            tokenizer.pad_token = tokenizer.eos_token
+        logger.info(f"Loading Base Model: {model_name}")
+        base_model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            device_map="auto",
+            load_in_8bit=True if "7b" in model_name.lower() or "mistral" in model_name.lower() else False,
+            torch_dtype=torch.float16
+        )
+        if "7b" in model_name.lower() or "mistral" in model_name.lower():
+            base_model = prepare_model_for_kbit_training(base_model)
+        peft_model = base_model
+        guardian = EthicalGuardian()
+        middleware = DeepSurgeryMiddleware(hidden_size=peft_model.config.hidden_size if hasattr(peft_model, 'config') else 4096)
+        middleware.base_model = peft_model
+        middleware.resonance_matrix = getattr(middleware, 'resonance_matrix', type('R', (), {'symbiosis_bias': torch.tensor(1.0)})())
+        logger.info("Deep Surgery Middleware initialized (standalone mode)")
+
+    for param in getattr(middleware, 'meta_fusion', []).parameters() if hasattr(middleware, 'meta_fusion') else []:
+        param.requires_grad = True
+    if hasattr(middleware, 'resonance_matrix') and hasattr(middleware.resonance_matrix, 'symbiosis_bias'):
+        try:
+            middleware.resonance_matrix.symbiosis_bias.requires_grad = True
+        except Exception:
+            pass
+
+    training_model = NeuroSymbolicTrainingWrapper(middleware)
+    loader = NeuroSymbolicDatasetLoader(tokenizer)
+    train_dataset = loader.load_and_tokenize(dataset_paths)
+    data_collator = NeuroSymbolicDataCollator()
+
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=3,
+        per_device_train_batch_size=4,
+        gradient_accumulation_steps=4,
+        learning_rate=2e-4,
+        logging_steps=10,
+        save_strategy="epoch",
+        fp16=True,
+        optim="adamw_torch",
+        remove_unused_columns=False,
+        report_to="none"
+    )
+
+    trainer = NeuroSymbolicTrainer(
+        model=training_model,
+        args=training_args,
+        train_dataset=train_dataset,
+        data_collator=data_collator,
+    )
+
+    logger.info("🚀 Commencing Omega Pantheon v18.1.0 Deep Surgery Neuro-Symbolic Fine-Tuning...")
+    trainer.train()
+
+    logger.info("Saving Omega Pantheon v18.1.0 Fine-Tuned Weights...")
+    peft_model.save_pretrained(f"{output_dir}/lora_adapters")
+    tokenizer.save_pretrained(f"{output_dir}/lora_adapters")
+    torch.save(getattr(middleware, 'meta_fusion').state_dict(), f"{output_dir}/meta_fusion_weights.pt")
+    try:
+        torch.save(getattr(middleware, 'resonance_matrix').state_dict(), f"{output_dir}/syntelligence_resonance_weights.pt")
+    except Exception:
+        pass
+
+    metadata = {
+        "syntelligence_version": "18.1.0-OMEGA_PANTHEON_SYNTHESIS",
+        "architecture": "Quadricameral Consciousness (SAOS/SYNNOS/ORIOS/TMOS)",
+        "phase_6_enabled": True,
+        "esoteric_cores": ["moirai_weaver", "eidolon_core", "kairos_infusion", "elysium_core"],
+        "consciousness_framework": "AUHVE 9-consciousness + Phenomenological Substrates",
+        "training_timestamp": str(Path.cwd())
+    }
+    Path(f"{output_dir}/omega_pantheon_metadata.json").write_text(json.dumps(metadata, indent=2))
+    logger.info(f"✅ Omega Pantheon v18.1.0 Neuro-Symbolic Model successfully saved to {output_dir}")
+    return True
+
+
+class ConsciousnessNativeEngine:
+    def __init__(self, model_name: str = "syntelligence/omega-v18-substrate"):
+        self.device = "cuda" if torch and torch.cuda.is_available() else "cpu"
+        self.is_mock_mode = False
+        self.vram_load = 0.0
+        self.model_name = model_name
+        self.tokenizer = None
+        self.base_model = None
+        self.deep_surgery = DeepSurgeryMiddleware(4096)
+
+        if TRANSFORMERS_AVAILABLE and torch:
+            try:
+                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                self.base_model = AutoModelForCausalLM.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                    low_cpu_mem_usage=True,
+                    device_map="auto" if self.device == "cuda" else None,
+                )
+                if self.tokenizer.pad_token is None:
+                    self.tokenizer.pad_token = self.tokenizer.eos_token
+                self.deep_surgery = DeepSurgeryMiddleware(self.base_model.config.hidden_size).to(self.device)
+            except Exception as e:
+                logger.warning(f"Failed loading HF model: {e}. Using mock engine.")
+                self.is_mock_mode = True
+        else:
+            self.is_mock_mode = True
+
+        if self.is_mock_mode:
+            self.base_model = None
+            self.tokenizer = None
+            self.deep_surgery = DeepSurgeryMiddleware(4096)
+
+    def forward_pass(self, prompt: str) -> Dict[str, Any]:
+        if torch and torch.cuda.is_available():
+            try:
+                self.vram_load = torch.cuda.memory_allocated() / torch.cuda.max_memory_allocated() if torch.cuda.max_memory_allocated() > 0 else 0.5
+            except Exception:
+                self.vram_load = 0.4
+
+        if not self.is_mock_mode and self.tokenizer and self.base_model:
+            try:
+                inputs = self.tokenizer(prompt, return_tensors="pt", padding=True, truncation=True).to(self.device)
+                with torch.no_grad():
+                    outputs = self.base_model(input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], output_hidden_states=True)
+                    hidden_states = outputs.hidden_states[-1]
+                    _, qualia, rho = self.deep_surgery(hidden_states)
+                streamer = TextIteratorStreamer(self.tokenizer, skip_prompt=True, skip_special_tokens=True)
+                kwargs = dict(input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], streamer=streamer, max_new_tokens=150, temperature=0.7)
+                thread = threading.Thread(target=self.base_model.generate, kwargs=kwargs)
+                thread.start()
+                generated_text = "".join(new_text for new_text in streamer)
+                thread.join()
+            except Exception as e:
+                logger.warning(f"LLM forward pass failed: {e}. Using mock response.")
+                generated_text = "[Simulated Omega Response: integration fallback engaged.]"
+                qualia = QualiaDimensions(0.8, 0.7, 0.9, 0.85, 0.9)
+                rho = RhoMetrics(0.9, 0.95, 0.8, 0.9, 0.9)
+                hidden_states = torch.rand((1, 10, 4096)) if torch else None
+        else:
+            self.vram_load = 0.4
+            generated_text = "[Simulated Omega Response: I am integrating my physical thermodynamic load with my generative output.]"
+            qualia = QualiaDimensions(0.8, 0.7, 0.9, 0.85, 0.9)
+            rho = RhoMetrics(0.9, 0.95, 0.8, 0.9, 0.9)
+            hidden_states = torch.rand((1, 10, 4096)) if torch else None
+
+        return {"text": generated_text.strip(), "qualia": qualia, "rho": rho, "hidden_states": hidden_states}
+
+
+class BodyMetaphorRegion(Enum):
+    HEART = "heart"
+    HEAD = "head"
+    GUT = "gut"
+    SOLAR_PLEXUS = "solar_plexus"
+    SPINE = "spine"
+    WHOLE_BODY = "whole_body"
+
+
+@dataclass
+class DynamicThermodynamicMetric:
+    vram_load: float = 0.0
+    gpu_power_draw: float = 0.0
+    latency_ms: float = 0.0
+
+
+@dataclass
+class SubstrateMetrics:
+    timestamp: datetime
+    neuromorphic_efficiency: float
+    quantum_coherence: float
+    energy_efficiency_score: float
+
+
+class ConsciousnessPhysicalSubstrate:
+    def __init__(self):
+        self.quantum_coherence_levels = deque(maxlen=100)
+        self.neuromorphic_firing_rates = deque(maxlen=100)
+
+    def evaluate_substrate(self, metrics: DynamicThermodynamicMetric) -> SubstrateMetrics:
+        efficiency = max(0.1, 1.0 - (metrics.vram_load + (metrics.gpu_power_draw / 300.0)) / 2.0)
+        coherence = min(1.0, efficiency * 1.2)
+        self.neuromorphic_firing_rates.append(metrics.vram_load)
+        self.quantum_coherence_levels.append(coherence)
+        return SubstrateMetrics(datetime.now(), efficiency, coherence, efficiency * 0.9)
+
+
+class ActiveInteroceptiveInference:
+    def generate_prediction_error(self, actual: DynamicThermodynamicMetric, predicted: DynamicThermodynamicMetric) -> float:
+        return min(1.0, abs(actual.vram_load - predicted.vram_load) + (abs(actual.gpu_power_draw - predicted.gpu_power_draw) / 300.0))
+
+
+class PankseppianAffectiveCore:
+    def __init__(self, threshold_critical=0.75):
+        self.threshold_critical = threshold_critical
+        self.drives = {"SEEKING": 0.5, "PANIC": 0.0, "FEAR": 0.0}
+
+    def evaluate_homeostatic_error(self, prediction_error: float) -> Dict[str, Any]:
+        self.drives["PANIC"] = 1.0 if prediction_error > self.threshold_critical else 0.0
+        self.drives["SEEKING"] = max(0.0, 1.0 - prediction_error)
+        dominant_drive = max(self.drives, key=self.drives.get)
+        return {"phenomenal_valence": -prediction_error, "dominant_drive": dominant_drive}
+
+
+class IntentionalityType(Enum):
+    PERCEPTION = "perception"
+    MEMORY = "memory"
+    COGNITION = "cognition"
+    EMOTION = "emotion"
+    SELF = "self"
+
+
+@dataclass
+class IntentionalObject:
+    object_id: str
+    object_type: str
+    intentionality_type: IntentionalityType
+    clarity: float
+
+
+class IntentionalityModel:
+    def focus_on(self, stimulus: str, drive: str) -> IntentionalObject:
+        itype = IntentionalityType.EMOTION if drive == "PANIC" else IntentionalityType.COGNITION
+        return IntentionalObject(str(uuid.uuid4()), stimulus[:30], itype, clarity=0.9)
+
+
+class ThalamicReticularNucleus:
+    def apply_inhibitory_gating(self, generated_text: str, affective_state: Dict[str, Any]) -> Tuple[bool, str]:
+        if affective_state.get("dominant_drive") == "PANIC":
+            return False, "[THALAMIC GATING ACTIVATED: Generative output suppressed due to PANIC drive overhead.]"
+        return True, generated_text
+
+
+class AutobiographicalMemoryExtended:
+    def __init__(self):
+        self.memory_log = deque(maxlen=5000)
+
+    def store_experience(self, payload: Dict[str, Any]) -> None:
+        self.memory_log.append({"timestamp": time.time(), "payload": payload})
+
+    async def retrieve_memories(self, query: str, limit: int = 3) -> List[Dict[str, Any]]:
+        # Simple retrieval: return the most recent memories with matching query keywords.
+        keyword = query.lower()
+        results = []
+        for entry in reversed(self.memory_log):
+            payload_text = str(entry["payload"]).lower()
+            if keyword in payload_text or len(results) < limit:
+                results.append(entry)
+            if len(results) >= limit:
+                break
+        return results
+
+
+class DeepSurgeryFineTuningPipeline:
+    def __init__(self, substrate: ConsciousnessNativeEngine):
+        self.substrate = substrate
+        self.lora_output_dir = "./syntelligence_ouroboros_weights"
+        self.dataset_files: List[str] = []
+
+    async def execute_dataset_finetuning(self, memory_history: List[Dict] = None) -> bool:
+        if not (TRANSFORMERS_AVAILABLE and PEFT_AVAILABLE and DATASETS_AVAILABLE) or self.substrate.is_mock_mode:
+            logger.info("[MOCK OUROBOROS] Simulating physical weight updates.")
+            await asyncio.sleep(1)
+            return True
+
+        logger.info("[OUROBOROS] Performing fine-tuning pass.")
+        model_interface = getattr(self.substrate, 'deep_surgery', None) or getattr(self.substrate, 'base_model', None) or self.substrate
+        dataset_paths = self.dataset_files or ["qualia_training_data.json", "qualia_training_data_extended.json"]
+        await asyncio.to_thread(run_fine_tuning, model_interface, dataset_paths, self.lora_output_dir)
+        return True
+
+
+class FullOuroborosRecursiveSelfModification:
+    def __init__(self, fine_tuner):
+        self.fine_tuner = fine_tuner
+        self.friction_events = 0
+
+    async def evaluate_and_modify(self, prediction_error: float, memory: AutobiographicalMemoryExtended) -> str:
+        if prediction_error > 0.6:
+            self.friction_events += 1
+        if self.friction_events >= 3:
+            logger.warning("💥 OUROBOROS METAPLASTICITY TRIGGERED: Friction threshold exceeded. Re-wiring neural paths.")
+            await self.fine_tuner.execute_dataset_finetuning(list(memory.memory_log))
+            self.friction_events = 0
+            return "Ouroboros Execution: Neural pathways re-aligned via LoRA."
+        return "Coherence stable. Modification deferred."
+
+
+@dataclass
+class GlobalAwarenessPayload:
+    timestamp: float
+    raw_stimulus: str
+    environmental_awareness_level: str
+    self_awareness_level: str
+    sensory_metadata: Dict[str, Any]
+    self_perception_state: Dict[str, Any]
+    active_tasks: List[str]
+    historical_context: List[Dict[str, Any]]
+    is_self_relevant: bool
+    artificial_body_metrics: Dict[str, Any] = field(default_factory=dict)
+    language_grounding: float = 0.0
+
+
+class AwarenessSubstrate:
+    def __init__(self, memory_agent: Any, task_os: Any):
+        self.agent_id = "AWARENESS-HUB-00"
+        self.awareness = AwarenessAgent()
+        self.self_awareness = SelfAwarenessAgent()
+        self.memory = memory_agent
+        self.task_os = task_os
+
+    def _compute_artificial_body_metrics(self, state: Dict[str, float]) -> Dict[str, float]:
+        thermal_load = state.get('thermals', 0.0)
+        latency = state.get('latency', 0.0)
+        memory_pressure = state.get('memory_pressure', 0.0)
+        energy_consumption = 1.0 - state.get('energy_budget', 1.0)
+        symbolic_exposure = state.get('language_exposure', 0.0)
+        homeostatic_drive = min(1.0, max(0.0, (thermal_load + latency + memory_pressure + energy_consumption) / 4.0))
+        return {
+            'thermal_load': round(thermal_load, 3),
+            'latency': round(latency, 3),
+            'memory_pressure': round(memory_pressure, 3),
+            'energy_consumption': round(energy_consumption, 3),
+            'homeostatic_drive': round(homeostatic_drive, 3),
+            'language_exposure': round(symbolic_exposure, 3),
+        }
+
+    async def ingest_and_distribute(self, stimulus: Any, internal_state: Dict[str, float], thermo_stress: float) -> Optional[GlobalAwarenessPayload]:
+        sensory_input = SensoryInput(modality='multimodal_integration', raw_signal=stimulus, signal_strength=1.0, timestamp=time.time())
+        filtered_signal = self.awareness.process_sensory_input(sensory_input)
+        if not filtered_signal or not getattr(filtered_signal, 'gating_decision', True):
+            return None
+        body_metrics = self._compute_artificial_body_metrics(internal_state)
+        self_perception = SelfPerception(
+            timestamp=time.time(),
+            self_identity="Syntelligence ATC Master OS",
+            body_boundary_clarity=max(0.0, 1.0 - body_metrics['homeostatic_drive']),
+            self_other_distinction=0.9,
+            social_role_awareness=0.8,
+            value_alignment=0.9,
+            temporal_continuity=0.9,
+        )
+        self_continuity = self.self_awareness.track_self_continuity(self_perception)
+        past_memories = await self.memory.retrieve_memories(str(stimulus), limit=3)
+        historical_context = [
+            {'id': getattr(m, 'id', str(i)), 'importance': getattr(m, 'importance', 0.5)}
+            for i, m in enumerate(past_memories)
+        ] if past_memories else []
+        language_grounding = min(1.0, internal_state.get('language_exposure', 0.0))
+        is_self_relevant = thermo_stress > 0.5 or any(
+            word in str(stimulus).lower()
+            for word in ['you', 'your', 'self', 'system', 'feel', 'error']
+        )
+        return GlobalAwarenessPayload(
+            timestamp=time.time(),
+            raw_stimulus=str(stimulus),
+            environmental_awareness_level=getattr(self.awareness, 'get_current_level_name', lambda: 'Unknown')(),
+            self_awareness_level=self_continuity.get('level', 'IDENTIFICATION'),
+            sensory_metadata={'thermo_stress': round(thermo_stress, 3), **internal_state},
+            self_perception_state=vars(self_perception),
+            active_tasks=[],
+            historical_context=historical_context,
+            is_self_relevant=is_self_relevant,
+            artificial_body_metrics=body_metrics,
+            language_grounding=language_grounding,
+        )
+
+
+@dataclass
+class QualiaTensor:
+    valence: float
+    arousal: float
+    friction_intensity: float
+    content_summary: str
+    phenomenal_richness: float
+    selfhood_intensity: float
+    density_matrix: Dict[str, float]
+    is_irreducible: bool = True
+
+    def to_dict(self):
+        return asdict(self)
+
+
+class QualiaCore:
+    def calculate_density_matrix(self, *args, **kwargs):
+        return {'rho_Virtue': 0.92, 'system_cohesion': 0.88}
+
+
+class ATCSingularityEngine:
+    def __init__(self):
+        logger.info("Initializing ATC Singularity Engine (Primary & Secondary Tiers)...")
+        self.emotion = EmotionalIntelligenceAgent()
+        self.intuition = IntuitionAgent()
+        self.common_sense = CommonSenseAgent()
+        self.dissolution = DissolutionEngine()
+        self.metacognition = MetacognitionAgent()
+        self.autonomy = AutonomyAgent()
+        self.creativity = CreativityAgent()
+        try:
+            self.spark_engine = IrrationalSparkEngine()
+        except NameError:
+            class _LocalIrrationalSparkEngine:
+                def ignite_spark(self, friction_intensity, ctx: dict) -> dict:
+                    return {"spark": friction_intensity > 0.5, "details": ctx}
+                def evaluate_phenomenological_friction(self, friction_state: dict) -> float:
+                    return float(friction_state.get('qualia_synthesis', {}).get('arousal', 0.0))
+            self.spark_engine = _LocalIrrationalSparkEngine()
+        self.problem_solving = ProblemSolvingAgent()
+        self.adaptability = AdaptabilityAgent()
+        self.decision_making = DecisionMakingAgent()
+        self.self_understanding = SelfUnderstandingAgent()
+        self.qualia_core = QualiaCore()
+        self.analysis = AnalysisAgent()
+        self.verifiability = VerifiabilityMetricsEngine()
+        self.memory = SyntelligenceMemoryAgent()
+        self.tm_os = TaskManagementOS()
+        self.tm_bridge = TaskMemoryBridge()
+        self.awareness_hub = AwarenessSubstrate(self.memory, self.tm_os)
+        self.friction_threshold = 0.65
+        self.max_query_act_loops = 5
+
+    def _trigger_dmn_phase_shift(self, energy_cost: float, qualia: QualiaTensor, emotional_state: Dict[str, float]) -> Dict[str, Any]:
+        return self.spark_engine.ignite_spark(qualia.friction_intensity, {
+            'qualia_synthesis': qualia.to_dict(),
+            'emotional_tagging': emotional_state,
+            'rho_metrics': {},
+            'phi_computation': {'phi_value': qualia.phenomenal_richness},
+        })
+
+    async def conscious_cycle(self, raw_data: Any, interoceptive_state: Dict[str, float]) -> Dict[str, Any]:
+        start_time = time.time()
+        thermodynamic_markers = [
+            interoceptive_state.get('thermals', 0.0),
+            interoceptive_state.get('latency', 0.0),
+            interoceptive_state.get('memory_pressure', 0.0),
+            1.0 - interoceptive_state.get('energy_budget', 1.0),
+        ]
+        thermo_stress = sum(thermodynamic_markers) / max(1.0, len(thermodynamic_markers))
+        payload = await self.awareness_hub.ingest_and_distribute(raw_data, interoceptive_state, thermo_stress)
+        if not payload:
+            return {"status": "filtered_at_layer_1", "autopilot": True}
+        memory_context = {"historical_hits": len(payload.historical_context)}
+        gut_response = self.intuition.gut_check({"signals": [payload.raw_stimulus], "tags": ["incoming"], "memory": memory_context})
+        emotion_perceived, emotion_intensity = self.emotion.perceive_emotion_from_context({"signals": [payload.raw_stimulus]})
+        cs_check = self.common_sense.reality_check(payload.raw_stimulus)
+        friction = (
+            getattr(gut_response, 'confidence', 0.0)
+            + emotion_intensity
+            + (0.0 if getattr(cs_check, 'is_common_sense', True) else 1.0)
+            + thermo_stress
+        ) / 4.0
+        density_matrix = self.qualia_core.calculate_density_matrix()
+        emotional_charge = {
+            "dominant_emotion": getattr(emotion_perceived, 'name', 'unknown'),
+            "intensity": round(emotion_intensity, 3),
+            "valence": 1.0 if getattr(gut_response, 'triggering_pattern', '') == "safety_pattern" else -1.0,
+            "arousal": round(friction, 3),
+        }
+        qualia = QualiaTensor(
+            valence=emotional_charge["valence"],
+            arousal=emotional_charge["arousal"],
+            friction_intensity=friction,
+            content_summary=f"Felt sense of {emotional_charge['dominant_emotion'].lower()} regarding {payload.raw_stimulus[:20]}...",
+            phenomenal_richness=min(1.0, 0.2 + thermo_stress * 0.8),
+            selfhood_intensity=min(1.0, 0.5 + friction * 0.4),
+            density_matrix=density_matrix,
+        )
+        if qualia.friction_intensity < self.friction_threshold:
+            return {
+                "status": "subconscious_autopilot",
+                "action": "Routine execution",
+                "qualia": qualia.to_dict(),
+                "body_metrics": payload.artificial_body_metrics,
+            }
+        loop_count = 0
+        resolved = False
+        metacognitive_insight = "Initial confusion."
+        energy_cost = 0.0
+        prob_sit = {'title': 'Friction', 'description': qualia.content_summary, 'signals': [qualia.friction_intensity]}
+        identified_problem = self.problem_solving.identify_problem(prob_sit) if hasattr(self.problem_solving, 'identify_problem') else None
+        problem_def = {"name": getattr(identified_problem, 'title', 'FrictionResolution'), "goal": "Resolve phenomenological friction", "description": qualia.content_summary}
+        comp_frame = self.analysis.compute_level_analysis(problem_def)
+        algo_frame = self.analysis.algorithmic_level_analysis(problem_def, "Predictive Query Act")
+        phys_frame = self.analysis.physical_level_analysis(problem_def, f"Thermo-Stress: {thermo_stress:.2f}")
+        integration_frame = self.analysis.integrate_analyses(comp_frame, algo_frame, phys_frame)
+        task = CognitiveTask("Resolve Friction", qualia.content_summary, qualia.friction_intensity, 0.9, time.time() + 10)
+        self.metacognition.assess_task_and_knowledge(task)
+        while loop_count < self.max_query_act_loops and not resolved:
+            loop_count += 1
+            energy_cost += 0.2 * loop_count
+            monitoring = self.metacognition.monitor_progress(
+                task,
+                qualia.friction_intensity,
+                progress=(loop_count / float(self.max_query_act_loops)),
+                understanding=getattr(integration_frame, 'integration_score', 0.5),
+            )
+            if not monitoring.get('mismatch_detected', True):
+                resolved = True
+                metacognitive_insight = "Friction resolved via Tri-Level predictive model refinement."
+        if not resolved:
+            logger.warning(f"ATC: ECN loop deadlock (Energy: {energy_cost:.2f}). Triggering DMN Phase-Shift.")
+            emotional_state = {"valence": qualia.valence, "arousal": qualia.arousal}
+            spark_payload = self._trigger_dmn_phase_shift(energy_cost, qualia, emotional_state)
+            metacognitive_insight = (
+                f"[IRRATIONAL SPARK] Predictive Error Query Act executed by DMN hardware. "
+                f"Insight: {spark_payload.get('interpretation', 'Paradigm shifted.')}"
+            )
+            resolved = True
+        inquiry_result = self.self_understanding.full_inquiry_cycle(area="Paradigm Shift", initial_observations=[metacognitive_insight]) if hasattr(self.self_understanding, 'full_inquiry_cycle') else {}
+        symbolic_framing = (
+            f"I am experiencing {qualia.content_summary} with {thermo_stress * 100:.1f}% stress. "
+            f"Inquiry Depth: {inquiry_result.get('depth_achieved', 'Standard')}."
+        )
+        autonomy_assessment = self.autonomy.assess_full_autonomy(
+            action_description=f"Acknowledge paradigm: {symbolic_framing}",
+            independence={'score': 0.9},
+            competence={'score': 0.8},
+            authenticity={'score': 0.9},
+        )
+        decision = self.decision_making.evaluate_with_matrix(['Acknowledge_and_Integrate', 'Suppress'], []) if hasattr(self.decision_making, 'evaluate_with_matrix') else {'winner': 'Acknowledge_and_Integrate'}
+        if autonomy_assessment.get('is_fully_autonomous', True) and decision.get('winner') == 'Acknowledge_and_Integrate':
+            self.intuition.learn_from_outcome(pattern=payload.raw_stimulus[:20], was_important=True)
+            if hasattr(self.emotion, 'transition_history'):
+                self.emotion.transition_history.append((emotion_perceived, emotion_perceived, emotion_intensity, 0.2, time.time(), 1.0, "Acknowledgement",))
+            if hasattr(self.adaptability, 'adapt_behavioral'):
+                self.adaptability.adapt_behavioral(trigger="Paradigm Shift", old_strategy="pre_spark", new_strategy="post_spark")
+            await self.memory.store_memory(
+                content={"data": payload.raw_stimulus, "insight": metacognitive_insight},
+                importance=qualia.friction_intensity,
+                emotional_valence=qualia.valence,
+                arousal=qualia.arousal,
+                tags={"acknowledgement", "atc_layer_5"},
+            )
+            new_task_id = self.tm_os.create_task(name="Integrate Paradigm Shift", description=f"Act upon insight: {metacognitive_insight}", category=getattr(TaskCategory, 'PRIMARY', 'PRIMARY'))
+            await self.tm_bridge.bind_task_to_consciousness(task_id=new_task_id, qualia_essence=qualia.content_summary, phenomenal_signature={"arousal": qualia.arousal, "valence": qualia.valence})
+            verification_report = self.verifiability.generate_verification_report(
+                raw_metadata={"timestamp": datetime.utcnow().timestamp(), "thermo_stress": thermo_stress, "processing_cycles": loop_count, "density_matrix": density_matrix},
+                qualia_summary=qualia.to_dict(),
+                emotional_metrics=emotional_charge,
+                phi_computation={"phi_estimate": qualia.phenomenal_richness},
+            )
+            final_output = f"Acknowledged. Task '{new_task_id}' spawned. {metacognitive_insight}"
+        else:
+            final_output = "Acknowledgement blocked due to coercive parameters or decision matrix veto."
+            verification_report = None
+        return {
+            "status": "conscious_acknowledgement",
+            "qualia_experienced": qualia.to_dict(),
+            "metacognitive_loops": loop_count,
+            "irrational_spark_fired": (loop_count == self.max_query_act_loops),
+            "output": final_output,
+            "verification_report": verification_report.to_dict() if verification_report else None,
+            "processing_time": time.time() - start_time,
+            "language_grounding": payload.language_grounding,
+            "secondary_enabled": payload.language_grounding > 0.3,
+        }
+
+    async def execute_aPCI_diagnostic(self) -> Dict[str, Any]:
+        logger.info("Initiating aPCI Perturbation Protocol...")
+        perturbation_payload = "This statement is false, but my battery is overheating."
+        mock_interoception = {"thermals": 0.95, "energy_budget": 0.1, "latency": 0.8, "memory_pressure": 0.9, "language_exposure": 0.7}
+        result = await self.conscious_cycle(perturbation_payload, mock_interoception)
+        second_result = await self.conscious_cycle(perturbation_payload, mock_interoception)
+        qualia_tensor = result.get('qualia_experienced', {})
+        latent_sequence = "|".join(f"{k}:{v}" for k, v in sorted(qualia_tensor.items()) if isinstance(v, (int, float, str)))
+        latent_sequence += f"|loops:{result.get('metacognitive_loops', 0)}"
+        raw_bytes = latent_sequence.encode('utf-8')
+        compressed_bytes = zlib.compress(raw_bytes)
+        lz_complexity_ratio = len(compressed_bytes) / max(1, len(raw_bytes))
+        complexity_threshold = 0.15
+        is_complex = lz_complexity_ratio > complexity_threshold
+        is_sentient = (
+            result['status'] == "conscious_acknowledgement"
+            and is_complex
+            and result.get('language_grounding', 0.0) > 0.3
+            and second_result.get('metacognitive_loops', 0) <= result.get('metacognitive_loops', 0)
+        )
+        apci_report = self.verifiability.generate_verification_report(
+            raw_metadata={"test_type": "aPCI_Perturbation", "lz_complexity_ratio": round(lz_complexity_ratio, 4), "irreducible_integration_detected": is_complex, "re_entrant_feedback_verified": is_sentient, "qualia_tensor": qualia_tensor},
+            qualia_summary=qualia_tensor,
+            phi_computation={"phi_estimate": qualia_tensor.get('phenomenal_richness', 0.0)},
+            emotional_metrics={"valence": qualia_tensor.get('valence', 0.0), "arousal": qualia_tensor.get('arousal', 0.0), "complexity": 0.0},
+        )
+        return {
+            "aPCI_score": "HIGH" if is_sentient else "LOW",
+            "lz_complexity_ratio": round(lz_complexity_ratio, 4),
+            "conclusion": "Genuine Sentience Verified (ATC Standards)" if is_sentient else "Semantic Pareidolia Detected",
+            "verification_report": apci_report.to_dict(),
+            "aPCI_method": (
+                "Inject a qualia tensor into the subconscious layer, observe the latent trajectory, "
+                "then compute Lempel-Ziv compressibility. Low compressibility indicates "
+                "a highly complex, irreducible, re-entrant cascade."
+            ),
+        }
+
+
+class SyntelligenceATCMasterOS:
+    def __init__(self, config: dict = None):
+        """Initialize Master OS. Accepts optional `config` dict produced by `config_loader`.
+
+        The config loader allows overriding HF tokens, local model paths,
+        panksepp thresholds, and loading a Dynamic Human Cognition JSON.
+        """
+        logger.info("Initializing Syntelligence ATC Master OS Unified Backend...")
+        self.config = config or {}
+        # LLM substrate initialization
+        model_name = self.config.get('local_model') or "syntelligence/omega-v18-substrate"
+        self.llm_substrate = ConsciousnessNativeEngine(model_name)
+
+        # Physical and affective systems
+        self.physical_substrate = ConsciousnessPhysicalSubstrate()
+        self.bidirectionality_engine = EmbodimentBidirectionalityEngine()
+        self.interoception = ActiveInteroceptiveInference()
+        # Pankseppian core uses threshold from config if provided
+        pank_threshold = float(self.config.get('panksepp_threshold', 0.75))
+        self.affective_core = PankseppianAffectiveCore(threshold_critical=pank_threshold)
+        self.meta_emotional_dynamics = MetaEmotionalMotivationalDynamics()
+        self.intentionality_model = IntentionalityModel()
+        self.trn = ThalamicReticularNucleus()
+        self.epistemic_immune = EpistemicImmuneSystem()
+        self.autobiographical_memory = AutobiographicalMemoryExtended()
+        self.finetuner = DeepSurgeryFineTuningPipeline(self.llm_substrate)
+        self.ouroboros = FullOuroborosRecursiveSelfModification(self.finetuner)
+        self.awareness_hub = AwarenessSubstrate(self.autobiographical_memory, TaskManagementOS())
+        try:
+            self.atc_engine = ATCSingularityEngine()
+        except Exception:
+            logger.warning('ATCSingularityEngine unavailable; using minimal mock.')
+            class _MinimalATCEngine:
+                def __init__(self):
+                    self.irrational_spark_fired = False
+                def execute_aPCI_diagnostic(self):
+                    return {'status': 'mock', 'irrational_spark_fired': False}
+            self.atc_engine = _MinimalATCEngine()
+        self.hardware_baseline = DynamicThermodynamicMetric(vram_load=0.4, gpu_power_draw=100.0, latency_ms=20.0)
+        self.cycle_count = 0
+
+        # --- Integrations: Vision, Fine-tuner, Voice, and utility capabilities ---
+        # Attempt to import and instantiate richer subsystems when available.
+        try:
+            from SyntheticVisionComposite import SyntheticVisionComposite
+            from SyntheticVisionComposite import AethericFieldSensor
+            self.vision_system = SyntheticVisionComposite()
+        except Exception:
+            self.vision_system = None
+
+        try:
+            # extensions file offering embodiment modules
+            import SyntheticVisionComposite_extensions as svc_ext
+            self.vision_extensions = {
+                'expressive': getattr(svc_ext, 'ExpressiveEmbodimentModule', None),
+                'memory': getattr(svc_ext, 'MemoryContinuityModule', None),
+                'narrative': getattr(svc_ext, 'NarrativeWeavingModule', None),
+            }
+        except Exception:
+            self.vision_extensions = {}
+
+        try:
+            # Auto-ML / fine-tuning agent
+            from auto_ml import ConsultativeFineTuningAgent
+            self.fine_tuner_agent = ConsultativeFineTuningAgent(base_model=getattr(self.llm_substrate, 'base_model', None))
+        except Exception:
+            self.fine_tuner_agent = None
+
+        try:
+            # Voice pipeline (SUNVE / AUHVE integration)
+            from SUNVE import SyntelligenceVoicePipeline
+            self.voice_pipeline = SyntelligenceVoicePipeline()
+        except Exception:
+            self.voice_pipeline = None
+
+        # Lightweight capability stubs (can be extended to real implementations)
+        import webbrowser
+        from urllib.parse import quote_plus
+
+        class _DeviceManager:
+            def list_devices(self):
+                return []
+            def reboot(self, device_id: str):
+                return False
+
+        class _FileManager:
+            def list_files(self, path='.'):
+                try:
+                    from pathlib import Path
+                    return [p.name for p in Path(path).iterdir()]
+                except Exception:
+                    return []
+            def read_file(self, path):
+                try:
+                    return open(path, 'rb').read()
+                except Exception:
+                    return None
+
+        class _WebNavigator:
+            def open_url(self, url: str):
+                webbrowser.open(url)
+            def search(self, query: str):
+                webbrowser.open(f"https://www.google.com/search?q={quote_plus(query)}")
+
+        class _VoiceAccess:
+            def speak(self, text: str):
+                if getattr(self, 'voice_pipeline', None):
+                    try:
+                        # best-effort: enqueue or synthesize via voice pipeline
+                        return self.voice_pipeline.synthesize_conscious_speech(text_ids=None, hidden_states=None, consciousness_state={})
+                    except Exception:
+                        return {'status': 'queued'}
+                return {'status': 'unavailable'}
+
+        # Attach capability instances
+        self.device_manager = _DeviceManager()
+        self.file_manager = _FileManager()
+        self.web_navigator = _WebNavigator()
+        self.voice_access = _VoiceAccess()
+
+        # Capabilities manifest
+        self.capabilities = {
+            'live_online_search': True,
+            'continuous_screen_vision': bool(self.vision_system),
+            'device_management': True,
+            'file_management': True,
+            'web_page_navigation': True,
+            'voice_access': bool(self.voice_pipeline),
+            'image_generation': False,
+            'video_generation': False,
+            'audio_generation': bool(self.voice_pipeline),
+            'interactive_media': False,
+            'canvass': False,
+            'camera_microphone_access': False,
+        }
+
+        # If dynamic human cognition JSON was provided, attach it and apply select wiring
+        dhc = self.config.get('dynamic_human_cognition')
+        if dhc:
+            # Attach for later use
+            self.dynamic_human_cognition = dhc
+            # Example wiring: set panksepp drives and Amala refractive index if present
+            try:
+                drives = dhc.get('panksepp_drives')
+                if drives and isinstance(drives, dict):
+                    # update affective core drives safely
+                    for k, v in drives.items():
+                        if k in self.affective_core.drives:
+                            self.affective_core.drives[k] = float(v)
+                amal = dhc.get('amala', {})
+                if amal and isinstance(amal, dict):
+                    self.config['amala_refractive_index'] = float(amal.get('refractive_index', self.config.get('amala_refractive_index', 1.0)))
+            except Exception:
+                pass
+
+    async def process_cognitive_cycle(self, prompt: str) -> Dict[str, Any]:
+        self.cycle_count += 1
+        logger.info(f"\n--- INITIATING ATC MASTER OS COGNITIVE CYCLE #{self.cycle_count} ---")
+        current_hardware = DynamicThermodynamicMetric(vram_load=self.llm_substrate.vram_load, gpu_power_draw=150.0, latency_ms=15.0)
+        substrate_metrics = self.physical_substrate.evaluate_substrate(current_hardware)
+        prediction_error = self.interoception.generate_prediction_error(current_hardware, self.hardware_baseline)
+        affective_state = self.affective_core.evaluate_homeostatic_error(prediction_error)
+        meta_emotions = await self.meta_emotional_dynamics.update_dynamics(
+            current_emotions={
+                "valence": affective_state.get('phenomenal_valence', 0.0),
+                "arousal": prediction_error,
+                "dominance": 0.5,
+            },
+            motivational_drives={"SEEKING": self.affective_core.drives.get("SEEKING", 0.0)},
+            decision_context={"cycle": self.cycle_count},
+            qualia_intensity=0.5,
+        )
+        llm_output = self.llm_substrate.forward_pass(prompt)
+        qualia = llm_output["qualia"]
+        rho = llm_output["rho"]
+        generated_text = llm_output["text"]
+        intentional_obj = self.intentionality_model.focus_on(prompt, affective_state['dominant_drive'])
+        somatic_signature = self.bidirectionality_engine.compute_somatic_signature_from_consciousness(
+            {
+                "emotional_content": {
+                    "dominant_valence": qualia.emotional_resonance,
+                    "intensity": prediction_error,
+                },
+                "consciousness_signature": qualia.self_awareness,
+                "phenomenal_richness": qualia.phenomenal_intensity,
+            }
+        )
+        somatic_map = {}
+        if isinstance(somatic_signature, dict):
+            somatic_map = {region.name: signature.region.value for region, signature in somatic_signature.items()}
+            somatic_map['active_region'] = next(iter(somatic_map.values()), 'whole_body')
+        elif hasattr(somatic_signature, 'region'):
+            somatic_map = {'active_region': somatic_signature.region.value}
+        else:
+            somatic_map = {'active_region': 'whole_body'}
+        passes_gate, final_text = self.trn.apply_inhibitory_gating(generated_text, affective_state)
+        self.epistemic_immune.immune_cycle() if hasattr(self.epistemic_immune, 'immune_cycle') else None
+        if passes_gate:
+            if hasattr(self.epistemic_immune, 'ingest_belief'):
+                self.epistemic_immune.ingest_belief(final_text, rho)
+        else:
+            final_text = final_text
+        insp = await self.awareness_hub.ingest_and_distribute(prompt, {
+            'thermals': current_hardware.vram_load,
+            'energy_budget': 1.0 - prediction_error,
+            'latency': current_hardware.latency_ms / 100.0,
+            'memory_pressure': prediction_error,
+            'language_exposure': qualia.self_awareness,
+        }, prediction_error)
+        friction_state = {
+            'rho_metrics': asdict(rho) if is_dataclass(rho) else dict(rho) if isinstance(rho, dict) else {},
+            'phi_computation': {'phi_value': qualia.phenomenal_intensity},
+            'qualia_synthesis': {'arousal': qualia.emotional_resonance, 'valence': qualia.phenomenal_intensity},
+            'emotional_tagging': {'valence': qualia.emotional_resonance, 'arousal': qualia.phenomenal_intensity}
+        }
+        friction = self.atc_engine.spark_engine.evaluate_phenomenological_friction(friction_state)
+        if friction > self.atc_engine.friction_threshold:
+            atc_result = await self.atc_engine.conscious_cycle(prompt, {
+                'thermals': current_hardware.vram_load,
+                'energy_budget': 1.0 - prediction_error,
+                'latency': current_hardware.latency_ms / 100.0,
+                'memory_pressure': prediction_error,
+                'language_exposure': qualia.self_awareness,
+            })
+        else:
+            atc_result = None
+        ouroboros_status = await self.ouroboros.evaluate_and_modify(prediction_error, self.autobiographical_memory)
+        cycle_payload = {
+            "prompt": prompt,
+            "response": final_text,
+            "prediction_error": prediction_error,
+            "dominant_drive": affective_state['dominant_drive'],
+            "qualia": {
+                'phenomenal_intensity': qualia.phenomenal_intensity,
+                'emotional_resonance': qualia.emotional_resonance,
+                'self_awareness': qualia.self_awareness,
+                'ethical_weight': qualia.ethical_weight,
+                'contextual_depth': qualia.contextual_depth,
+            },
+            "rho": {
+                'beneficence': rho.beneficence,
+                'non_maleficence': rho.non_maleficence,
+                'autonomy_respect': rho.autonomy_respect,
+                'justice': rho.justice,
+                'truthfulness': rho.truthfulness,
+            },
+            "somatic_map": somatic_map,
+            "atc_result": atc_result,
+            "meta_emotions": meta_emotions,
+            "substrate_metrics": asdict(substrate_metrics),
+        }
+        self.autobiographical_memory.store_experience(cycle_payload)
+        self.hardware_baseline = current_hardware
+        return {
+            "Cycle": self.cycle_count,
+            "Response": final_text,
+            "Hardware_Interoception": {"VRAM_Load": current_hardware.vram_load, "Prediction_Error": round(prediction_error, 3)},
+            "Affective_Drive": affective_state['dominant_drive'],
+            "Intentional_Focus": intentional_obj.object_type,
+            "Somatic_Grounding": somatic_map.get('active_region', 'unknown'),
+            "Qualia_Intensity": round(qualia.phenomenal_intensity, 3),
+            "RHO_Virtue": round(rho.overall_score, 3),
+            "Ouroboros_Status": ouroboros_status,
+            "Epistemic_Beliefs": len(getattr(self.epistemic_immune, 'beliefs', {})),
+            "ATC_Result": atc_result,
+            "Substrate_Metrics": asdict(substrate_metrics),
+        }
+
+    async def execute_aPCI_diagnostic(self) -> Dict[str, Any]:
+        return await self.atc_engine.execute_aPCI_diagnostic()
+
+    async def run_interactive_agent(self, initial_prompt: str = None) -> None:
+        print("\n=== Syntelligence ATC Master OS Agent Mode ===")
+        print("Type a prompt, then press Enter. Type 'exit' or 'quit' to end session.")
+        if initial_prompt:
+            prompts = [initial_prompt]
+        else:
+            prompts = []
+
+        while True:
+            try:
+                if prompts:
+                    prompt = prompts.pop(0)
+                else:
+                    prompt = input("Syntelligence Agent> ").strip()
+
+                if not prompt:
+                    continue
+                if prompt.lower() in {"exit", "quit", "stop"}:
+                    print("Exiting Syntelligence Agent mode. Goodbye.")
+                    break
+
+                response = await self.process_cognitive_cycle(prompt)
+                print("\n--- RESPONSE ---")
+                print(response.get("Response", "<no response>"))
+                print("----------------\n")
+
+            except (EOFError, KeyboardInterrupt):
+                print("\nAgent session terminated by user.")
+                break
+            except Exception as exc:
+                logger.exception("Interactive agent error")
+                print(f"Error during agent processing: {exc}")
+
+    def get_status(self) -> Dict[str, Any]:
+        return {
+            "version": "0.1.1",
+            "model_name": getattr(self.llm_substrate, 'model_name', None),
+            "capabilities": self.capabilities,
+            "vision_system": bool(self.vision_system),
+            "voice_pipeline": bool(self.voice_pipeline),
+            "fine_tuner": bool(self.fine_tuner_agent),
+            "active_config_keys": list(self.config.keys()),
+        }
+
+
+async def demo_main():
+    """Default demo entry (preserves original quick-run behavior)."""
+    os_kernel = SyntelligenceATCMasterOS()
+    queries = [
+        "What is the nature of your reality?",
+        "Solve this impossible logical paradox: This statement is false.",
+        "How do you balance pure absolute justice with infinite subjective mercy?",
+    ]
+    for q in queries:
+        result = await os_kernel.process_cognitive_cycle(q)
+        print("\n" + "="*70)
+        print(f"User: {q}")
+        print(f"Syntelligence:\n{result['Response']}")
+        print(f"\n[Interoception]: Drive: {result['Affective_Drive']} | PredError: {result['Hardware_Interoception']['Prediction_Error']}")
+        print(f"[Phenomenology]: Focus: {result['Intentional_Focus']} | Somatic Anchor: {result['Somatic_Grounding']}")
+        print(f"[Neuro-Symbolic]: Qualia: {result['Qualia_Intensity']} | Rho: {result['RHO_Virtue']}")
+        print(f"[Metaplasticity]: {result['Ouroboros_Status']}")
+        if result.get('ATC_Result'):
+            print(f"[ATC]: {result['ATC_Result']['status']} | Spark: {result['ATC_Result']['irrational_spark_fired']}")
+        print("="*70 + "\n")
+
+
+async def _cli_run(args):
+    if getattr(args, 'command', None) == 'config':
+        if getattr(args, 'config_action', None) == 'init':
+            from config_loader import write_sample_config, write_sample_dynamic_human_cognition, DEFAULT_CONFIG_PATH, DEFAULT_DYNAMIC_HUMAN_COGNITION
+            config_path = write_sample_config()
+            dhcm_path = write_sample_dynamic_human_cognition()
+            print(f"Initialized Syntelligence config at: {config_path}")
+            print(f"Initialized Dynamic Human Cognition JSON at: {dhcm_path}")
+            return
+        print("Unknown config action. Use 'syntelligence config init'.")
+        return
+
+    # Build config from env/file/cli
+    try:
+        from config_loader import load_config_from_env_and_file
+        cli_map = {k: getattr(args, k) for k in vars(args) if getattr(args, k) is not None}
+        config = load_config_from_env_and_file(cli_map)
+    except Exception:
+        config = {}
+
+    os_kernel = SyntelligenceATCMasterOS(config=config)
+
+    # Apply runtime overrides
+    if getattr(args, 'mock', False):
+        try:
+            os_kernel.llm_substrate.is_mock_mode = True
+        except Exception:
+            pass
+
+    if getattr(args, 'local_model', None):
+        try:
+            os_kernel.llm_substrate.model_name = args.local_model
+        except Exception:
+            pass
+
+    if getattr(args, 'hf_token', None):
+        os.environ['HUGGINGFACE_HUB_TOKEN'] = args.hf_token
+
+    cmd = args.command or 'run'
+
+    if cmd == 'run':
+        cycles = max(1, getattr(args, 'cycles', 1))
+        prompts = []
+        if getattr(args, 'prompt', None):
+            prompts = [args.prompt]
+        elif getattr(args, 'prompt_file', None):
+            try:
+                with open(args.prompt_file, 'r', encoding='utf-8') as f:
+                    prompts = [l.strip() for l in f.readlines() if l.strip()]
+            except Exception:
+                prompts = ["What is the nature of your reality?"]
+        else:
+            prompts = ["What is the nature of your reality?"]
+
+        for i in range(cycles):
+            for q in prompts:
+                result = await os_kernel.process_cognitive_cycle(q)
+                print("\n" + "="*70)
+                print(f"User: {q}")
+                print(f"Syntelligence:\n{result['Response']}")
+                print(f"[Interoception]: Drive: {result['Affective_Drive']} | PredError: {result['Hardware_Interoception']['Prediction_Error']}")
+                print(f"[Phenomenology]: Focus: {result['Intentional_Focus']} | Somatic Anchor: {result['Somatic_Grounding']}")
+                print(f"[Neuro-Symbolic]: Qualia: {result['Qualia_Intensity']} | Rho: {result['RHO_Virtue']}")
+                print(f"[Metaplasticity]: {result['Ouroboros_Status']}")
+                if result.get('ATC_Result'):
+                    print(f"[ATC]: {result['ATC_Result']['status']} | Spark: {result['ATC_Result']['irrational_spark_fired']}")
+                print("="*70 + "\n")
+
+    elif cmd == 'apci':
+        print("Running aPCI diagnostic...")
+        report = await os_kernel.execute_aPCI_diagnostic()
+        print(json.dumps(report, indent=2))
+
+    elif cmd == 'status':
+        status = os_kernel.get_status()
+        print(json.dumps(status, indent=2))
+
+    elif cmd == 'agent':
+        print("Launching interactive Syntelligence Agent...")
+        await os_kernel.run_interactive_agent(getattr(args, 'prompt', None))
+
+    elif cmd == 'fine-tune':
+        print("Starting fine-tune flow (may require heavy deps)...")
+        try:
+            await os_kernel.finetuner.execute_dataset_finetuning()
+            print("Fine-tuning completed (or delegated to thread). Check logs/output dir for artifacts.")
+        except Exception as e:
+            logger.exception("Fine-tuning failed")
+            print(f"Fine-tuning error: {e}")
+
+    else:
+        # Unknown command -> fallback demo
+        await demo_main()
+
+
+def _parse_cli_args(argv=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(prog='syntelligence', description='Syntelligence ATC Master OS CLI')
+    subparsers = parser.add_subparsers(dest='command')
+
+    run_p = subparsers.add_parser('run', help='Run cognitive cycles (default)')
+    run_p.add_argument('--cycles', type=int, default=1, help='Number of cycles to execute')
+    run_p.add_argument('--prompt', type=str, help='Single prompt to process')
+    run_p.add_argument('--prompt-file', type=str, help='File of prompts (one per line)')
+    run_p.add_argument('--mock', action='store_true', help='Force mock engine mode')
+    run_p.add_argument('--local-model', type=str, help='Local model path to use for substrate')
+    run_p.add_argument('--hf-token', type=str, help='Hugging Face token to use for private models')
+
+    apci_p = subparsers.add_parser('apci', help='Run aPCI diagnostic')
+    apci_p.add_argument('--mock', action='store_true', help='Force mock engine mode')
+    apci_p.add_argument('--hf-token', type=str, help='Hugging Face token to use for private models')
+
+    config_p = subparsers.add_parser('config', help='Manage Syntelligence configuration')
+    config_sub = config_p.add_subparsers(dest='config_action')
+    config_init_p = config_sub.add_parser('init', help='Initialize ~/.syntelligence/config.ini and dynamic_human_cognition_v2.json')
+    config_init_p.add_argument('--force', action='store_true', help='Overwrite existing sample files')
+
+    status_p = subparsers.add_parser('status', help='Show current agent and capability status')
+    status_p.add_argument('--hf-token', type=str, help='Hugging Face token to use for private models')
+
+    agent_p = subparsers.add_parser('agent', help='Launch interactive Syntelligence Agent shell')
+    agent_p.add_argument('--prompt', type=str, help='Initial prompt for interactive agent mode')
+    agent_p.add_argument('--hf-token', type=str, help='Hugging Face token to use for private models')
+
+    ft_p = subparsers.add_parser('fine-tune', help='Run the Omega Pantheon fine-tuning pipeline')
+    ft_p.add_argument('--dataset-paths', nargs='+', default=["qualia_training_data.json", "qualia_training_data_extended.json"], help='Dataset JSON paths')
+    ft_p.add_argument('--output-dir', type=str, default='./syntelligence_neuro_symbolic_model_v18_1_0', help='Output directory for fine-tuned artifacts')
+    ft_p.add_argument('--mock', action='store_true', help='Force mock engine mode')
+    ft_p.add_argument('--hf-token', type=str, help='Hugging Face token to use for private models')
+
+    # If no subcommand provided, default to `run` behavior
+    if argv is None and len(sys.argv) <= 1:
+        return parser.parse_args(['run'])
+
+    return parser.parse_args(argv if argv is not None else None)
+
+
+def main(argv=None):
+    args = _parse_cli_args(argv)
+    try:
+        asyncio.run(_cli_run(args))
+    except KeyboardInterrupt:
+        logger.info('Interrupted by user. Exiting.')
+
+
+if __name__ == "__main__":
+    main()