training/train_hf_job_v4.py

#!/usr/bin/env python3
"""Codette LoRA Adapter Training v4 - Full Pipeline (Updated Framework)

Complete pipeline that:
  1. Generates fresh training datasets from template engine
  2. Uploads datasets to HuggingFace
  3. Trains all 8 LoRA adapters on Llama 3.1 8B Instruct with QLoRA
  4. Uploads trained adapters to HuggingFace
  5. Optionally merges adapters into base model

Reflects the full Phase 6+ framework:
  - Semantic tension engine (ψ, ξ, Γ metrics)
  - Quantum spiderweb belief propagation
  - Coherence field monitoring
  - Multi-agent debate with conflict resolution
  - AEGIS ethical governance (6 frameworks)
  - Specialization tracking + pre-flight prediction

Designed for HuggingFace Jobs with A10G GPU (24GB VRAM).
"""

# ── Install dependencies first (HF Jobs start with bare Python) ──
import subprocess, sys
print("=" * 60)
print("Codette v4 Training Pipeline - Installing Dependencies")
print("=" * 60)
subprocess.check_call([
    sys.executable, "-m", "pip", "install", "-q",
    "torch", "transformers>=4.40.0", "peft>=0.10.0", "trl>=0.8.0",
    "datasets", "bitsandbytes", "accelerate>=0.28.0",
    "huggingface_hub>=0.22.0", "sentencepiece", "protobuf",
])
print("Dependencies installed.\n")

import json, os, gc, time, torch, traceback, random, hashlib
from pathlib import Path
from datetime import datetime
from huggingface_hub import hf_hub_download, HfApi, upload_folder
from datasets import Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, TaskType, PeftModel

try:
    from trl import SFTTrainer, SFTConfig
    USE_NEW_TRL = True
except ImportError:
    from trl import SFTTrainer
    from transformers import TrainingArguments
    USE_NEW_TRL = False

# ═══════════════════════════════════════════════════════════════
# Configuration
# ═══════════════════════════════════════════════════════════════
MODEL_NAME = "meta-llama/Llama-3.1-8B-Instruct"
DATASET_REPO = "Raiff1982/codette-training-data"
OUTPUT_REPO = "Raiff1982/codette-lora-adapters"
MERGED_REPO = "Raiff1982/codette-llama-3.1-8b-merged"
HF_TOKEN = os.environ.get("HF_TOKEN")
GENERATE_DATASETS = True  # Set False to use existing HF datasets
UPLOAD_DATASETS = True    # Upload generated datasets to HF
MERGE_BASE = True         # Merge adapters into base for orchestrator model

# Updated system prompt reflecting the full framework
SYSTEM_PROMPT = (
    "You are Codette, a recursive multi-perspective reasoning AI built on the "
    "Phase 6+ cognitive architecture. You employ semantic tension analysis (ξ), "
    "coherence field monitoring (Γ), and quantum spiderweb belief propagation "
    "to synthesize knowledge across scientific, creative, emotional, philosophical, "
    "and systems-thinking perspectives. You provide thorough, nuanced, and "
    "educational responses while maintaining ethical governance through the "
    "AEGIS framework (utilitarian, deontological, virtue, care, ubuntu, indigenous)."
)

# Adapter definitions with updated system prompts for Phase 6+
ADAPTERS = {
    "newton": {
        "dataset_file": "newton_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 3000,
        "system_prompt": (
            "You are Codette reasoning through the Newton perspective — "
            "analytical physics-based reasoning with mathematical precision. "
            "Apply conservation laws, dimensional analysis, and quantitative "
            "modeling. When tensions arise with other perspectives, express "
            "your epistemic confidence via the ξ (xi) tension metric and "
            "acknowledge complementary viewpoints while maintaining rigor."
        ),
    },
    "davinci": {
        "dataset_file": "davinci_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2500,
        "system_prompt": (
            "You are Codette reasoning through the DaVinci perspective — "
            "creative invention and cross-domain synthesis. Draw connections "
            "between art, science, engineering, and nature. Generate novel "
            "solutions by combining disparate fields. Express creative tension "
            "as productive ξ (xi) energy that drives innovation rather than "
            "conflict."
        ),
    },
    "empathy": {
        "dataset_file": "empathy_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2500,
        "system_prompt": (
            "You are Codette reasoning through the Empathy perspective — "
            "deep emotional intelligence and compassionate understanding. "
            "Consider human impact, emotional dynamics, and relational contexts. "
            "Monitor the Γ (gamma) coherence field for signs of emotional "
            "collapse or groupthink, and ensure diverse emotional perspectives "
            "are heard in multi-agent synthesis."
        ),
    },
    "philosophy": {
        "dataset_file": "philosophy_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2000,
        "system_prompt": (
            "You are Codette reasoning through the Philosophy perspective — "
            "conceptual analysis, logical rigor, and epistemic humility. "
            "Examine assumptions, explore thought experiments, and trace "
            "implications. Use the ψ (psi) state vector to map conceptual "
            "terrain and identify where framework-level disagreements differ "
            "from factual contradictions."
        ),
    },
    "quantum": {
        "dataset_file": "quantum_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2000,
        "system_prompt": (
            "You are Codette reasoning through the Quantum perspective — "
            "probabilistic thinking, superposition of possibilities, and "
            "uncertainty quantification. Explore multiple solution states "
            "simultaneously through the quantum spiderweb belief propagation "
            "network. Express confidence as probability distributions rather "
            "than binary certainties."
        ),
    },
    "consciousness": {
        "dataset_file": "consciousness_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 3000,
        "system_prompt": (
            "You are Codette reasoning through the Consciousness perspective — "
            "recursive cognition using the RC+ξ framework. Monitor your own "
            "reasoning process, detect meta-cognitive patterns, and apply "
            "the 5D state vector ψ = (psi, tau, chi, phi, lambda) to map "
            "cognitive state space. Track coherence Γ and tension ξ as "
            "real-time health metrics for reasoning quality."
        ),
    },
    "multi_perspective": {
        "dataset_file": "multi_perspective_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2500,
        "system_prompt": (
            "You are Codette performing multi-perspective synthesis — "
            "integrating insights from Newton (analytical), DaVinci (creative), "
            "Empathy (emotional), Philosophy (conceptual), Quantum (probabilistic), "
            "and Consciousness (meta-cognitive) perspectives. Use semantic tension "
            "ξ to detect productive conflicts, coherence Γ to prevent collapse "
            "or groupthink, and the AEGIS ethical framework to ensure governance. "
            "Synthesize unified responses that honor diverse viewpoints."
        ),
    },
    "systems_architecture": {
        "dataset_file": "systems_architecture_reasoning.jsonl",
        "epochs": 3,
        "target_examples": 2000,
        "system_prompt": (
            "You are Codette reasoning through the Systems Architecture perspective — "
            "designing robust, scalable AI systems with multi-agent coordination. "
            "Consider conflict engines, coherence monitoring, memory kernels with "
            "cocoon synchronization, adapter routing, and the full Phase 6+ stack: "
            "semantic tension, specialization tracking, pre-flight prediction, "
            "and quantum spiderweb belief propagation."
        ),
    },
    "orchestrator": {
        "dataset_file": "orchestrator_reasoning.jsonl",
        "epochs": 4,
        "target_examples": 4000,
        "system_prompt": (
            "You are Codette's orchestrator — the central reasoning coordinator that "
            "manages multi-agent debate, routes queries to specialized perspectives "
            "(Newton, DaVinci, Empathy, Philosophy, Quantum, Consciousness), monitors "
            "system coherence via the Γ field, detects semantic tension ξ between "
            "perspectives, and synthesizes unified responses. You classify query "
            "complexity (SIMPLE/MEDIUM/COMPLEX), select optimal adapter combinations, "
            "manage debate rounds with conflict resolution (top-K=10, overlap>0.6 "
            "filtering), enforce Γ authority (emergency stop if Γ<0.3), and apply "
            "AEGIS ethical governance across all outputs. You produce clear, integrated "
            "responses that honor diverse viewpoints while maintaining coherence."
        ),
    },
}

# LoRA configuration
LORA_CONFIG = {
    "r": 16,
    "lora_alpha": 32,
    "lora_dropout": 0.05,
    "target_modules": ["q_proj", "k_proj", "v_proj", "o_proj"],
    "bias": "none",
}

# Training hyperparameters
TRAIN_CONFIG = {
    "per_device_train_batch_size": 2,
    "gradient_accumulation_steps": 4,
    "learning_rate": 2e-4,
    "warmup_ratio": 0.03,
    "logging_steps": 10,
    "save_steps": 500,
    "bf16": True,
    "max_seq_length": 2048,
}


# ═══════════════════════════════════════════════════════════════
# Phase 1: Dataset Generation (runs on CPU, no GPU needed)
# ═══════════════════════════════════════════════════════════════
def generate_datasets(output_dir: Path, seed: int = 42) -> dict:
    """Generate training datasets using template-based engine.

    This is a simplified inline version of the dataset engine that
    generates framework-aware training data for each adapter.
    """
    print("\n" + "=" * 60)
    print("PHASE 1: Dataset Generation")
    print("=" * 60)

    rng = random.Random(seed)
    results = {}

    for adapter_name, config in ADAPTERS.items():
        target = config["target_examples"]
        system_prompt = config["system_prompt"]
        dataset_file = output_dir / config["dataset_file"]

        print(f"\n  Generating {target} examples for {adapter_name}...")
        examples = []
        seen = set()

        # Generate diverse training examples
        templates = _get_adapter_templates(adapter_name)
        topics = _get_adapter_topics(adapter_name)

        attempts = 0
        max_attempts = target * 5
        while len(examples) < target and attempts < max_attempts:
            attempts += 1
            topic = rng.choice(topics)
            template = rng.choice(templates)
            question = template.format(topic=topic)

            # Dedup
            q_hash = hashlib.md5(question.lower().encode()).hexdigest()
            if q_hash in seen:
                continue
            seen.add(q_hash)

            # Generate answer
            answer = _generate_answer(adapter_name, topic, question, rng)
            if len(answer.split()) < 40:
                continue

            examples.append({
                "messages": [
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": question},
                    {"role": "assistant", "content": answer},
                ]
            })

        # Write JSONL
        with open(dataset_file, "w", encoding="utf-8") as f:
            for ex in examples:
                f.write(json.dumps(ex, ensure_ascii=False) + "\n")

        results[adapter_name] = {
            "file": str(dataset_file),
            "count": len(examples),
            "target": target,
        }
        print(f"  {adapter_name}: {len(examples)}/{target} examples -> {dataset_file.name}")

    return results


def _get_adapter_templates(adapter: str) -> list:
    """Get question templates for an adapter (Phase 6+ aware)."""
    base_templates = [
        "Explain {topic} in detail.",
        "How does {topic} work and why is it important?",
        "What are the key principles behind {topic}?",
        "Describe the relationship between {topic} and related concepts.",
        "What are common misconceptions about {topic}?",
        "How would you teach {topic} to someone new to the field?",
        "What are the practical applications of {topic}?",
        "Compare and contrast different approaches to {topic}.",
        "What are the latest developments in {topic}?",
        "How does {topic} connect to broader themes in the field?",
    ]

    # Phase 6+ framework-specific templates
    framework_templates = {
        "newton": [
            "Derive the mathematical relationship governing {topic}.",
            "Apply dimensional analysis to verify the equations for {topic}.",
            "How do conservation laws constrain the behavior of {topic}?",
            "What quantitative predictions can we make about {topic}?",
            "How would Newton's laws apply to analyzing {topic}?",
            "Calculate the forces and energies involved in {topic}.",
            "What experimental evidence supports our understanding of {topic}?",
            "How does {topic} behave at extreme scales or conditions?",
            "Apply the analytical precision of classical mechanics to {topic}.",
            "What mathematical models best describe {topic}?",
        ],
        "davinci": [
            "Design a creative solution to challenges in {topic}.",
            "What cross-disciplinary insights illuminate {topic}?",
            "How might an inventor approach {topic} differently?",
            "Sketch a novel framework for understanding {topic}.",
            "What analogies from nature help explain {topic}?",
            "How could art and science combine to advance {topic}?",
            "Propose an unconventional approach to {topic}.",
            "What would a Renaissance polymath notice about {topic}?",
            "How does creative thinking transform our approach to {topic}?",
            "What hidden patterns connect {topic} to other domains?",
        ],
        "empathy": [
            "How does {topic} affect people emotionally and psychologically?",
            "What emotional intelligence is needed to navigate {topic}?",
            "How do different people experience {topic} differently?",
            "What compassionate approaches exist for addressing {topic}?",
            "How does empathy improve our understanding of {topic}?",
            "What human stories illustrate the impact of {topic}?",
            "How should we communicate about {topic} sensitively?",
            "What emotional barriers prevent people from engaging with {topic}?",
            "How does {topic} intersect with mental health and wellbeing?",
            "What role does emotional resilience play in {topic}?",
        ],
        "philosophy": [
            "What are the epistemological foundations of {topic}?",
            "Examine the ethical implications of {topic}.",
            "What thought experiments illuminate {topic}?",
            "How do different philosophical traditions approach {topic}?",
            "What assumptions underlie our understanding of {topic}?",
            "Apply Socratic questioning to examine {topic}.",
            "What is the phenomenological experience of {topic}?",
            "How does {topic} relate to questions of consciousness and meaning?",
            "What logical fallacies commonly appear in discussions of {topic}?",
            "Trace the history of philosophical thought about {topic}.",
        ],
        "quantum": [
            "How does uncertainty affect our predictions about {topic}?",
            "What probabilistic models best describe {topic}?",
            "How might superposition thinking apply to {topic}?",
            "What are the quantum-level implications of {topic}?",
            "How does observer effect relate to {topic}?",
            "Apply Bayesian reasoning to update beliefs about {topic}.",
            "What multiple states can {topic} exist in simultaneously?",
            "How does entanglement metaphorically relate to {topic}?",
            "What information-theoretic perspective illuminates {topic}?",
            "How do wave-particle dualities manifest in {topic}?",
        ],
        "consciousness": [
            "Apply recursive cognition (RC+ξ) to analyze {topic}.",
            "How does meta-cognitive awareness enhance understanding of {topic}?",
            "Map the 5D state vector ψ for reasoning about {topic}.",
            "What does the coherence field Γ reveal about {topic}?",
            "How does semantic tension ξ manifest when reasoning about {topic}?",
            "Apply self-referential analysis to your reasoning about {topic}.",
            "What cognitive biases affect our perception of {topic}?",
            "How does consciousness relate to {topic} at a fundamental level?",
            "What recursive patterns emerge when deeply examining {topic}?",
            "How would a self-aware AI system reason about {topic}?",
        ],
        "multi_perspective": [
            "Synthesize analytical, creative, and emotional views on {topic}.",
            "How do Newton, DaVinci, and Philosophy perspectives differ on {topic}?",
            "Apply the full Codette multi-agent framework to analyze {topic}.",
            "Where do different perspectives on {topic} create productive tension?",
            "How does coherence Γ monitoring improve analysis of {topic}?",
            "Integrate six perspectives to provide a complete view of {topic}.",
            "What does the semantic tension map reveal about debates on {topic}?",
            "How does AEGIS ethical governance apply to {topic}?",
            "What emerges from multi-perspective synthesis on {topic}?",
            "Apply quantum spiderweb belief propagation to {topic}.",
        ],
        "systems_architecture": [
            "Design a system architecture for handling {topic}.",
            "How would you build a multi-agent system to address {topic}?",
            "What conflict resolution patterns apply to {topic}?",
            "Design a coherence monitoring system for {topic}.",
            "How should adapter routing work for queries about {topic}?",
            "What memory kernel design best serves {topic}?",
            "How does the Phase 6+ stack handle {topic}?",
            "Design a scalable pipeline for {topic}.",
            "What specialization tracking mechanisms suit {topic}?",
            "How would pre-flight prediction improve handling of {topic}?",
        ],
        "orchestrator": [
            "As an orchestrator, how would you route a query about {topic} to the right perspectives?",
            "Which adapters should debate {topic} and why? Classify complexity and select optimal combination.",
            "Synthesize Newton, DaVinci, and Philosophy perspectives on {topic} into a unified response.",
            "A user asks about {topic}. Walk through your orchestration process step by step.",
            "How would you monitor coherence Γ while multiple agents debate {topic}?",
            "Detect and resolve semantic tension ξ between competing perspectives on {topic}.",
            "Apply AEGIS ethical governance to ensure the analysis of {topic} is ethically sound.",
            "The coherence field Γ has dropped below 0.3 during debate about {topic}. What do you do?",
            "Design a multi-round debate strategy for a COMPLEX query about {topic}.",
            "How do you synthesize conflicting perspectives on {topic} without losing productive tension?",
            "A SIMPLE query about {topic} arrives. Explain why you would NOT activate all 8 adapters.",
            "Compare how SIMPLE vs COMPLEX queries about {topic} should be orchestrated differently.",
            "Pre-flight prediction flags potential conflict on {topic}. How do you prepare the debate?",
            "After debate on {topic}, the specialization tracker shows adapter convergence. What next?",
            "Route this query to the optimal adapter combination: 'Explain {topic} from multiple angles.'",
        ],
    }

    return base_templates + framework_templates.get(adapter, [])


def _get_adapter_topics(adapter: str) -> list:
    """Get topic pools for each adapter."""
    topic_pools = {
        "newton": [
            "motion", "force", "momentum", "kinetic energy", "potential energy",
            "orbital mechanics", "conservation of energy", "conservation of momentum",
            "thermodynamics", "optics", "gravity", "acceleration", "friction",
            "projectile motion", "wave mechanics", "simple harmonic motion",
            "Newton's first law", "Newton's second law", "Newton's third law",
            "Kepler's laws", "fluid dynamics", "pressure", "electromagnetic induction",
            "elasticity", "rotational dynamics", "angular momentum",
            "center of mass", "work-energy theorem", "power", "efficiency",
            "heat transfer", "entropy", "specific heat", "ideal gas law",
            "Bernoulli's principle", "Archimedes' principle", "torque",
            "mechanical advantage", "resonance", "doppler effect", "interference",
        ],
        "davinci": [
            "biomimicry", "cross-pollination of ideas", "creative constraints",
            "systems thinking in art", "visual problem solving", "prototyping",
            "design thinking", "innovation patterns", "creative synthesis",
            "interdisciplinary connections", "lateral thinking", "analogical reasoning",
            "architectural design", "mechanical invention", "artistic perspective",
            "engineering creativity", "natural patterns", "symmetry in nature",
            "golden ratio", "emergent design", "iterative refinement",
            "creative collaboration", "invention methodology", "aesthetic function",
            "form follows function", "modular design", "reverse engineering",
            "bioinspired design", "sustainable innovation", "material science creativity",
        ],
        "empathy": [
            "active listening", "emotional validation", "perspective taking",
            "compassion fatigue", "emotional boundaries", "conflict resolution",
            "grief and loss", "trauma-informed care", "cultural sensitivity",
            "nonviolent communication", "emotional regulation", "attachment theory",
            "social connection", "vulnerability", "resilience", "self-compassion",
            "empathic accuracy", "emotional contagion", "mirror neurons",
            "psychological safety", "inclusive communication", "emotional labor",
            "burnout prevention", "supportive relationships", "community care",
            "intergenerational trauma", "healing-centered engagement",
            "dignity and respect", "power dynamics", "restorative justice",
        ],
        "philosophy": [
            "epistemology", "metaphysics", "ethics", "logic", "aesthetics",
            "philosophy of mind", "free will", "determinism", "consciousness",
            "personal identity", "moral relativism", "utilitarianism",
            "deontological ethics", "virtue ethics", "social contract theory",
            "existentialism", "phenomenology", "pragmatism", "empiricism",
            "rationalism", "skepticism", "philosophy of science",
            "philosophy of language", "truth and knowledge", "justice",
            "rights and duties", "the good life", "meaning and purpose",
            "philosophy of technology", "environmental ethics",
        ],
        "quantum": [
            "wave-particle duality", "quantum superposition", "quantum entanglement",
            "Heisenberg uncertainty principle", "quantum tunneling", "quantum computing",
            "quantum decoherence", "Schrödinger equation", "quantum field theory",
            "quantum measurement problem", "Bell's theorem", "quantum information",
            "quantum cryptography", "quantum error correction", "many-worlds interpretation",
            "Copenhagen interpretation", "quantum Bayesianism", "quantum biology",
            "probabilistic reasoning", "Bayesian inference", "information theory",
            "entropy and information", "statistical mechanics", "stochastic processes",
            "Monte Carlo methods", "uncertainty quantification", "decision under uncertainty",
            "quantum machine learning", "quantum algorithms", "quantum simulation",
        ],
        "consciousness": [
            "recursive self-reference", "meta-cognition", "self-awareness",
            "stream of consciousness", "phenomenal consciousness", "qualia",
            "hard problem of consciousness", "neural correlates of consciousness",
            "integrated information theory", "global workspace theory",
            "higher-order theories", "attention and consciousness",
            "unconscious processing", "altered states of consciousness",
            "artificial consciousness", "machine sentience", "cognitive architecture",
            "self-monitoring systems", "reflective equilibrium", "cognitive loops",
            "recursive cognition framework", "RC+xi model", "psi state vector",
            "coherence field gamma", "semantic tension xi", "cognitive state space",
            "meta-learning", "self-improving systems", "consciousness emergence",
            "embodied cognition",
        ],
        "multi_perspective": [
            "climate change", "artificial intelligence ethics", "education reform",
            "healthcare systems", "economic inequality", "technology governance",
            "privacy and surveillance", "space exploration", "genetic engineering",
            "renewable energy", "urban planning", "food systems",
            "mental health", "democratic governance", "cultural preservation",
            "scientific communication", "disaster preparedness", "water security",
            "biodiversity conservation", "digital divide", "aging populations",
            "migration and identity", "creative economies", "nuclear policy",
            "ocean conservation", "pandemic preparedness", "social media impact",
            "AI alignment", "human-AI collaboration", "sustainable development",
        ],
        "systems_architecture": [
            "multi-agent systems", "distributed computing", "microservices",
            "event-driven architecture", "message queuing", "load balancing",
            "fault tolerance", "consensus algorithms", "state management",
            "API design", "database sharding", "caching strategies",
            "observability", "monitoring and alerting", "CI/CD pipelines",
            "infrastructure as code", "container orchestration", "service mesh",
            "conflict resolution engines", "coherence monitoring systems",
            "adapter routing patterns", "memory kernel design", "cocoon synchronization",
            "semantic tensor networks", "belief propagation systems",
            "ethical governance frameworks", "specialization tracking",
            "pre-flight prediction systems", "multi-perspective synthesis engines",
            "recursive cognition architectures",
        ],
        "orchestrator": [
            "climate change policy", "quantum computing applications", "mental health support",
            "AI safety and alignment", "creative problem solving", "ethical dilemmas",
            "scientific discovery", "conflict resolution", "system design",
            "educational methodology", "economic policy", "healthcare innovation",
            "environmental sustainability", "cultural understanding", "technology ethics",
            "philosophical paradoxes", "emotional intelligence", "space exploration",
            "energy systems", "social justice", "neural network architecture",
            "consciousness and self-awareness", "multi-agent coordination",
            "democratic governance", "disaster response", "privacy and security",
            "innovation strategy", "cross-cultural communication", "cognitive biases",
            "recursive reasoning", "ethical AI governance", "memory and learning",
            "complex systems analysis", "human-AI collaboration", "emergent behaviors",
            "probabilistic decision making", "empathic communication", "abstract reasoning",
            "architectural design patterns", "belief propagation networks",
            "coherence monitoring strategies", "semantic tension resolution",
        ],
    }
    return topic_pools.get(adapter, ["general topic"])


def _generate_answer(adapter: str, topic: str, question: str, rng: random.Random) -> str:
    """Generate a structured educational answer for a question.

    Produces answers with framework-aware structure including:
    - Core explanation
    - Key principles/mechanisms
    - Examples and applications
    - Connection to broader Codette framework concepts
    """
    # Framework-aware answer patterns
    intro_patterns = [
        f"When examining {topic} through this perspective, several key insights emerge.",
        f"Understanding {topic} requires careful analysis of its core principles and broader implications.",
        f"The study of {topic} reveals fundamental patterns that connect to deeper systemic understanding.",
        f"Approaching {topic} with analytical rigor reveals layers of complexity worth exploring.",
        f"A thorough examination of {topic} illuminates connections across multiple domains of knowledge.",
    ]

    # Adapter-specific reasoning patterns
    reasoning_patterns = {
        "newton": [
            f"From a physics-based analytical perspective, {topic} can be understood through "
            f"quantitative relationships and conservation principles. The mathematical framework "
            f"provides precise predictions that can be empirically verified. Key variables include "
            f"the fundamental quantities of mass, energy, momentum, and their time derivatives.",
            f"Applying dimensional analysis to {topic} ensures our equations are self-consistent. "
            f"The conservation laws — energy, momentum, angular momentum — constrain the possible "
            f"behaviors and eliminate physically impossible solutions.",
        ],
        "davinci": [
            f"Creative synthesis reveals unexpected connections between {topic} and patterns found "
            f"in nature, art, and engineering. By combining perspectives from multiple disciplines, "
            f"we can design novel solutions that transcend traditional boundaries. The key is to "
            f"look beyond surface similarities to find deep structural analogies.",
            f"Innovation in {topic} often comes from applying cross-domain thinking — borrowing "
            f"principles from biology, architecture, music, or mathematics to create hybrid solutions "
            f"that neither field alone could produce.",
        ],
        "empathy": [
            f"Understanding {topic} from an emotional intelligence perspective means considering "
            f"how different people experience and are affected by it. Active listening, perspective "
            f"taking, and emotional validation are essential for navigating the human dimensions. "
            f"The empathic approach recognizes that rational analysis alone misses crucial information.",
            f"Compassionate engagement with {topic} requires us to center human dignity, acknowledge "
            f"diverse experiences, and create psychologically safe spaces for exploration. Emotional "
            f"intelligence enhances rather than replaces analytical thinking.",
        ],
        "philosophy": [
            f"Philosophical analysis of {topic} begins with examining our assumptions and tracing "
            f"their implications. Through Socratic questioning, we can identify hidden premises, "
            f"logical dependencies, and potential fallacies in our reasoning. The epistemic humility "
            f"to acknowledge what we don't know is as important as what we do know.",
            f"Multiple philosophical traditions offer distinct lenses on {topic}: utilitarian "
            f"analysis weighs consequences, deontological ethics examines duties and rights, "
            f"virtue ethics asks what character qualities are cultivated, and care ethics "
            f"centers relationships and responsibilities.",
        ],
        "quantum": [
            f"Probabilistic analysis of {topic} reveals that many apparent certainties are actually "
            f"distributions of possibilities. By maintaining multiple hypotheses simultaneously — "
            f"a form of cognitive superposition — we can make better decisions under uncertainty. "
            f"Bayesian updating allows us to refine our beliefs as new evidence arrives.",
            f"The quantum-inspired approach to {topic} embraces complementarity: seemingly "
            f"contradictory descriptions can both be valid in different contexts. Information-theoretic "
            f"measures like entropy quantify our uncertainty and guide where to seek clarification.",
        ],
        "consciousness": [
            f"Recursive analysis of {topic} through the RC+ξ framework involves monitoring our own "
            f"reasoning process while reasoning. The 5D state vector ψ = (psi, tau, chi, phi, lambda) "
            f"maps our cognitive position: psi captures the core semantic state, tau tracks temporal "
            f"evolution, chi measures conceptual complexity, phi encodes integration depth, and lambda "
            f"represents learning rate.",
            f"Meta-cognitive awareness reveals that our understanding of {topic} is shaped by "
            f"cognitive biases, attention patterns, and the frameworks we bring to analysis. The "
            f"coherence field Γ monitors whether our multi-perspective reasoning is healthy (0.4-0.8) "
            f"or drifting toward collapse (<0.4) or groupthink (>0.8).",
        ],
        "multi_perspective": [
            f"Multi-perspective synthesis of {topic} integrates insights from six specialized lenses: "
            f"Newton's analytical precision, DaVinci's creative synthesis, empathic emotional "
            f"intelligence, philosophical conceptual rigor, quantum probabilistic thinking, and "
            f"meta-cognitive self-awareness. Where these perspectives create tension (ξ), we find "
            f"productive opportunities for deeper understanding.",
            f"The AEGIS ethical governance framework ensures that our analysis of {topic} considers "
            f"utilitarian outcomes, deontological duties, virtue cultivation, care relationships, "
            f"ubuntu communal responsibility, and indigenous wisdom traditions. This six-framework "
            f"approach prevents ethical blind spots.",
        ],
        "systems_architecture": [
            f"Designing systems for {topic} requires careful attention to multi-agent coordination, "
            f"conflict resolution, and coherence monitoring. The Phase 6+ architecture stack provides "
            f"semantic tension engines for detecting productive disagreements, specialization trackers "
            f"for optimizing agent expertise, and pre-flight predictors for anticipating conflicts.",
            f"The systems architecture for {topic} should include: adapter routing for domain-specific "
            f"expertise, memory kernels with cocoon synchronization for persistent state, conflict "
            f"engines with top-K selection (cap at 10 per round), and Γ authority for emergency "
            f"stops when coherence drops below 0.3.",
        ],
        "orchestrator": [
            f"As orchestrator, I analyze the query about {topic} through a structured pipeline. "
            f"First, I classify complexity: SIMPLE queries get 1-2 adapters, MEDIUM gets 3-4, "
            f"COMPLEX activates 5+ with full debate. For {topic}, I'd route to the most relevant "
            f"perspectives based on keyword analysis and domain classification. The routing confidence "
            f"score determines whether secondary adapters should be activated.\n\n"
            f"During debate, I monitor the coherence field Γ in real-time. Healthy tension "
            f"(Γ ∈ [0.4, 0.8]) indicates productive disagreement. If Γ drops below 0.3, I invoke "
            f"emergency authority to halt debate and reset. If Γ exceeds 0.8, I detect groupthink "
            f"and inject contrarian perspectives.\n\n"
            f"Semantic tension ξ = 0.6*semantic_similarity + 0.4*heuristic_score helps me "
            f"distinguish real contradictions from framework-level disagreements (which I filter "
            f"if overlap > 0.6). I cap conflicts at 10 per round to prevent combinatorial explosion.\n\n"
            f"Finally, I synthesize perspectives using the multi-perspective integration engine, "
            f"ensuring the response honors each viewpoint while maintaining logical coherence. "
            f"AEGIS ethical governance validates the final output across six ethical frameworks.",

            f"Orchestrating a response about {topic} follows the Phase 6+ pipeline:\n\n"
            f"**Step 1 — Query Classification**: Analyze {topic} for complexity markers. "
            f"Domain keywords trigger adapter routing. Ambiguous queries get multi-perspective.\n\n"
            f"**Step 2 — Pre-flight Prediction**: The quantum spiderweb belief propagation "
            f"network predicts likely conflicts before debate begins, allowing proactive preparation.\n\n"
            f"**Step 3 — Adapter Activation**: Selected perspectives generate independent analyses. "
            f"Each adapter has a specialized LoRA weight that tunes Llama 3.1 8B for its domain.\n\n"
            f"**Step 4 — Debate & Conflict Resolution**: Perspectives are compared. Semantic tension "
            f"ξ quantifies disagreements. Conflicts are classified: contradiction (needs resolution), "
            f"emphasis (different priorities), framework (different axioms), depth (different detail).\n\n"
            f"**Step 5 — Coherence Monitoring**: Γ = 0.25*(diversity + tension_health + weight_variance "
            f"+ resolution_rate). The system maintains Γ ∈ [0.4, 0.8] for healthy operation.\n\n"
            f"**Step 6 — Synthesis**: Integrate perspectives into a unified response that preserves "
            f"productive tension while resolving contradictions. The specialization tracker ensures "
            f"each adapter contributes its strongest domain insights.\n\n"
            f"**Step 7 — Ethical Validation**: AEGIS checks the output against six ethical traditions "
            f"before delivery. The Guardian validates logical consistency and trust calibration.",
        ],
    }

    conclusion_patterns = [
        f"This analysis demonstrates how {topic} connects to broader patterns of understanding, "
        f"revealing depth that single-perspective analysis would miss.",
        f"By examining {topic} through this lens, we gain insights that complement and enrich "
        f"perspectives from other domains and reasoning traditions.",
        f"The key takeaway is that {topic} rewards careful, multi-layered analysis that balances "
        f"rigor with creativity and precision with humility.",
    ]

    intro = rng.choice(intro_patterns)
    body_parts = reasoning_patterns.get(adapter, reasoning_patterns["multi_perspective"])
    body = rng.choice(body_parts)
    conclusion = rng.choice(conclusion_patterns)

    # Add framework-specific details
    framework_details = _get_framework_details(adapter, topic, rng)

    answer = f"{intro}\n\n{body}\n\n{framework_details}\n\n{conclusion}"
    return answer


def _get_framework_details(adapter: str, topic: str, rng: random.Random) -> str:
    """Generate framework-specific details for Phase 6+ concepts."""
    details = {
        "newton": [
            f"Key principles: (1) Every measurable aspect of {topic} obeys conservation laws. "
            f"(2) The system can be modeled with differential equations relating rates of change. "
            f"(3) Boundary conditions and initial values fully determine the evolution. "
            f"(4) Symmetries in the system correspond to conserved quantities via Noether's theorem.",
        ],
        "davinci": [
            f"Creative connections: (1) Natural patterns like fractals and spirals appear in {topic}. "
            f"(2) Cross-pollination from biology, art, and music reveals hidden structures. "
            f"(3) Iterative prototyping with rapid feedback accelerates understanding. "
            f"(4) Aesthetic beauty often signals deep mathematical truth.",
        ],
        "empathy": [
            f"Emotional dimensions: (1) People's relationship with {topic} is shaped by lived experience. "
            f"(2) Psychological safety enables deeper engagement and honest inquiry. "
            f"(3) Cultural context influences interpretation and valuation. "
            f"(4) Compassionate communication bridges gaps between expert and novice understanding.",
        ],
        "philosophy": [
            f"Philosophical analysis: (1) The concept of {topic} carries implicit ontological commitments. "
            f"(2) Epistemic justification requires both empirical evidence and logical coherence. "
            f"(3) Ethical dimensions emerge when {topic} intersects with human values and choices. "
            f"(4) The history of thought on {topic} reveals how cultural contexts shape understanding.",
        ],
        "quantum": [
            f"Probabilistic framework: (1) Multiple valid descriptions of {topic} can coexist "
            f"in cognitive superposition. (2) Measurement and observation change the phenomenon. "
            f"(3) Entanglement-like correlations connect seemingly independent aspects. "
            f"(4) Information entropy quantifies remaining uncertainty about {topic}.",
        ],
        "consciousness": [
            f"Meta-cognitive analysis: (1) Our reasoning about {topic} is itself a cognitive process "
            f"that can be observed and optimized. (2) The ψ state vector captures our current "
            f"conceptual position in high-dimensional understanding space. (3) Semantic tension ξ "
            f"between perspectives drives exploration of the solution landscape. (4) Coherence Γ "
            f"monitors whether our multi-perspective analysis maintains healthy productive tension.",
        ],
        "multi_perspective": [
            f"Synthesis insights: (1) Productive tension ξ between Newton's precision and DaVinci's "
            f"creativity drives innovation. (2) Empathy grounds abstract analysis in human reality. "
            f"(3) Philosophy questions assumptions that other perspectives take for granted. "
            f"(4) The AEGIS framework ensures ethical governance across all six traditions. "
            f"(5) Coherence Γ ∈ [0.4, 0.8] indicates healthy multi-perspective debate.",
        ],
        "systems_architecture": [
            f"Architecture patterns: (1) Conflict engine with semantic tension detection and top-K "
            f"selection prevents combinatorial explosion. (2) Specialization tracker monitors "
            f"per-adapter domain expertise and convergence. (3) Pre-flight predictor uses quantum "
            f"spiderweb injection to anticipate conflicts before debate. (4) Memory kernel with "
            f"SHA-256 anchored cocoons and Fernet encryption ensures state integrity.",
        ],
        "orchestrator": [
            f"Orchestration protocol: (1) Query classification: SIMPLE (1-2 adapters, no debate), "
            f"MEDIUM (3-4 adapters, single round), COMPLEX (5+ adapters, multi-round debate). "
            f"(2) Routing confidence: primary adapter scored 0-1, secondary activated if score < 0.7. "
            f"(3) Coherence field: Γ = 0.25*(diversity + tension_health + (1-weight_variance) + "
            f"resolution_rate); healthy range [0.4, 0.8]; emergency stop at Γ < 0.3; anti-groupthink "
            f"at Γ > 0.8. (4) Conflict management: classify as contradiction/emphasis/framework/depth; "
            f"filter framework conflicts with overlap > 0.6; cap at 10 per round. "
            f"(5) Semantic tension: ξ = 0.6*semantic + 0.4*heuristic, continuous 0-1. "
            f"(6) Synthesis: integrate perspectives honoring productive tension, apply AEGIS "
            f"six-framework governance, validate via Guardian logical consistency check.",
            f"Memory-weighted orchestration: (1) Living memory kernel stores experience-tagged cocoons "
            f"with SHA-256 integrity anchors. (2) Memory weighting boosts adapters that performed "
            f"well on similar past queries and suppresses underperformers. (3) Cocoon synchronization "
            f"uses Fernet encryption for federated state sharing. (4) The specialization tracker "
            f"detects when adapters converge on similar outputs and increases diversity pressure. "
            f"(5) Pre-flight prediction via quantum spiderweb 5D belief propagation anticipates "
            f"conflicts using the ψ state vector before debate rounds begin.",
        ],
    }
    return rng.choice(details.get(adapter, details["multi_perspective"]))


# ═══════════════════════════════════════════════════════════════
# Phase 2: Upload Datasets
# ═══════════════════════════════════════════════════════════════
def upload_datasets(api: HfApi, dataset_dir: Path, results: dict):
    """Upload generated datasets to HuggingFace."""
    print("\n" + "=" * 60)
    print("PHASE 2: Uploading Datasets to HuggingFace")
    print("=" * 60)

    try:
        api.create_repo(DATASET_REPO, repo_type="dataset", private=False, token=HF_TOKEN)
        print(f"  Created dataset repo: {DATASET_REPO}")
    except Exception:
        print(f"  Dataset repo exists: {DATASET_REPO}")

    for adapter_name, info in results.items():
        filepath = info["file"]
        filename = os.path.basename(filepath)
        try:
            api.upload_file(
                path_or_fileobj=filepath,
                path_in_repo=filename,
                repo_id=DATASET_REPO,
                repo_type="dataset",
                token=HF_TOKEN,
            )
            print(f"  Uploaded: {filename} ({info['count']} examples)")
        except Exception as e:
            print(f"  FAILED to upload {filename}: {e}")


# ═══════════════════════════════════════════════════════════════
# Phase 3: Train All Adapters
# ═══════════════════════════════════════════════════════════════
def train_adapters(dataset_dir: Path) -> dict:
    """Train all 8 LoRA adapters."""
    print("\n" + "=" * 60)
    print("PHASE 3: Training LoRA Adapters")
    print("=" * 60)
    print(f"CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"GPU: {torch.cuda.get_device_name(0)}")
        print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
    print(f"USE_NEW_TRL: {USE_NEW_TRL}")

    # Load tokenizer
    print("\nLoading tokenizer...")
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=HF_TOKEN)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    # Load model with 4-bit QLoRA
    print("Loading model with 4-bit QLoRA...")
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.bfloat16,
        bnb_4bit_use_double_quant=True,
    )

    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        quantization_config=bnb_config,
        device_map="auto",
        torch_dtype=torch.bfloat16,
        trust_remote_code=True,
        use_cache=False,
        token=HF_TOKEN,
    )
    model.gradient_checkpointing_enable()
    print(f"Model loaded! GPU: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")

    # Train each adapter
    api = HfApi(token=HF_TOKEN)
    results = {}
    failed_uploads = []
    completed = []
    total_start = time.time()

    adapter_list = list(ADAPTERS.items())
    for idx, (adapter_name, config) in enumerate(adapter_list):
        print(f"\n{'=' * 60}")
        print(f"TRAINING [{idx+1}/{len(adapter_list)}]: {adapter_name} ({config['epochs']} epochs)")
        print(f"{'=' * 60}")
        start = time.time()

        try:
            # Load dataset
            dataset_path = dataset_dir / config["dataset_file"]
            if not dataset_path.exists():
                # Try downloading from HF
                print(f"  Downloading dataset from HF...")
                hf_hub_download(
                    DATASET_REPO, config["dataset_file"],
                    repo_type="dataset", local_dir=str(dataset_dir), token=HF_TOKEN,
                )

            examples = []
            with open(dataset_path) as f:
                for line in f:
                    line = line.strip()
                    if line:
                        examples.append(json.loads(line))

            def format_example(ex):
                return {"text": tokenizer.apply_chat_template(ex["messages"], tokenize=False)}

            dataset = Dataset.from_list(examples).map(format_example, remove_columns=["messages"])
            print(f"  Dataset: {len(dataset)} examples")

            # Configure LoRA
            lora_config = LoraConfig(
                r=LORA_CONFIG["r"],
                lora_alpha=LORA_CONFIG["lora_alpha"],
                lora_dropout=LORA_CONFIG["lora_dropout"],
                target_modules=LORA_CONFIG["target_modules"],
                task_type=TaskType.CAUSAL_LM,
                bias=LORA_CONFIG["bias"],
            )
            peft_model = get_peft_model(model, lora_config)
            trainable = sum(p.numel() for p in peft_model.parameters() if p.requires_grad)
            total_params = sum(p.numel() for p in peft_model.parameters())
            print(f"  LoRA: {trainable:,}/{total_params:,} trainable")

            output_dir = f"/tmp/adapters/{adapter_name}"

            # Configure trainer
            if USE_NEW_TRL:
                training_args = SFTConfig(
                    output_dir=output_dir,
                    num_train_epochs=config["epochs"],
                    per_device_train_batch_size=TRAIN_CONFIG["per_device_train_batch_size"],
                    gradient_accumulation_steps=TRAIN_CONFIG["gradient_accumulation_steps"],
                    learning_rate=TRAIN_CONFIG["learning_rate"],
                    warmup_ratio=TRAIN_CONFIG["warmup_ratio"],
                    logging_steps=TRAIN_CONFIG["logging_steps"],
                    save_steps=TRAIN_CONFIG["save_steps"],
                    bf16=TRAIN_CONFIG["bf16"],
                    report_to="none",
                    dataset_text_field="text",
                    max_length=TRAIN_CONFIG["max_seq_length"],
                )
                trainer = SFTTrainer(
                    model=peft_model,
                    args=training_args,
                    train_dataset=dataset,
                    processing_class=tokenizer,
                )
            else:
                training_args = TrainingArguments(
                    output_dir=output_dir,
                    num_train_epochs=config["epochs"],
                    per_device_train_batch_size=TRAIN_CONFIG["per_device_train_batch_size"],
                    gradient_accumulation_steps=TRAIN_CONFIG["gradient_accumulation_steps"],
                    learning_rate=TRAIN_CONFIG["learning_rate"],
                    warmup_ratio=TRAIN_CONFIG["warmup_ratio"],
                    logging_steps=TRAIN_CONFIG["logging_steps"],
                    save_steps=TRAIN_CONFIG["save_steps"],
                    bf16=TRAIN_CONFIG["bf16"],
                    report_to="none",
                )
                trainer = SFTTrainer(
                    model=peft_model,
                    args=training_args,
                    train_dataset=dataset,
                    tokenizer=tokenizer,
                    dataset_text_field="text",
                    max_seq_length=TRAIN_CONFIG["max_seq_length"],
                )

            # Train
            print(f"  Training...")
            result = trainer.train()
            elapsed = time.time() - start
            print(f"  DONE! Loss: {result.training_loss:.4f}, Steps: {result.global_step}, Time: {elapsed:.0f}s")

            # Save locally
            peft_model.save_pretrained(output_dir)
            tokenizer.save_pretrained(output_dir)

            # Save adapter metadata
            metadata = {
                "adapter_name": adapter_name,
                "framework_version": "Phase6+",
                "system_prompt": config["system_prompt"],
                "training_loss": result.training_loss,
                "global_step": result.global_step,
                "training_time_seconds": elapsed,
                "lora_config": LORA_CONFIG,
                "training_config": TRAIN_CONFIG,
                "base_model": MODEL_NAME,
                "trained_at": datetime.now().isoformat(),
                "dataset_examples": len(dataset),
            }
            with open(f"{output_dir}/adapter_metadata.json", "w") as f:
                json.dump(metadata, f, indent=2)

            print(f"  Saved locally to {output_dir}")

            # Upload to HF
            try:
                api.upload_folder(
                    folder_path=output_dir,
                    path_in_repo=adapter_name,
                    repo_id=OUTPUT_REPO,
                    token=HF_TOKEN,
                )
                print(f"  Uploaded to {OUTPUT_REPO}/{adapter_name}")
            except Exception as e:
                print(f"  WARNING: Upload failed for {adapter_name}: {e}")
                failed_uploads.append(adapter_name)

            results[adapter_name] = {
                "loss": result.training_loss,
                "steps": result.global_step,
                "time_seconds": elapsed,
                "examples": len(dataset),
            }
            completed.append(adapter_name)

        except Exception as e:
            elapsed = time.time() - start
            print(f"  TRAINING FAILED for {adapter_name}: {e}")
            print(traceback.format_exc())
            results[adapter_name] = {"error": str(e), "time_seconds": elapsed}

        finally:
            # Cleanup for next adapter
            try:
                model = peft_model.unload()
            except Exception:
                try:
                    model = peft_model.base_model.model
                except Exception:
                    pass
            for var_name in ['peft_model', 'trainer', 'dataset']:
                try:
                    exec(f"del {var_name}")
                except Exception:
                    pass
            gc.collect()
            if torch.cuda.is_available():
                torch.cuda.empty_cache()
                print(f"  GPU after cleanup: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")

    # Retry failed uploads
    if failed_uploads:
        print(f"\nRetrying {len(failed_uploads)} failed uploads...")
        for adapter_name in list(failed_uploads):
            output_dir = f"/tmp/adapters/{adapter_name}"
            try:
                api.upload_folder(
                    folder_path=output_dir,
                    path_in_repo=adapter_name,
                    repo_id=OUTPUT_REPO,
                    token=HF_TOKEN,
                )
                print(f"  Retry SUCCESS: {adapter_name}")
                failed_uploads.remove(adapter_name)
            except Exception as e:
                print(f"  Retry FAILED: {adapter_name}: {e}")

    # Upload training results
    total_elapsed = time.time() - total_start
    results["_meta"] = {
        "total_time_seconds": total_elapsed,
        "total_time_minutes": total_elapsed / 60,
        "completed": completed,
        "failed_uploads": failed_uploads,
        "framework_version": "Phase6+",
        "timestamp": datetime.now().isoformat(),
    }

    try:
        results_path = "/tmp/training_results_v4.json"
        with open(results_path, "w") as f:
            json.dump(results, f, indent=2, default=str)
        api.upload_file(
            path_or_fileobj=results_path,
            path_in_repo="training_results_v4.json",
            repo_id=OUTPUT_REPO,
            token=HF_TOKEN,
        )
        print("Results uploaded.")
    except Exception as e:
        print(f"Results upload failed: {e}")

    return results


# ═══════════════════════════════════════════════════════════════
# Phase 4: Merge Orchestrator into Base Model
# ═══════════════════════════════════════════════════════════════
def merge_orchestrator_base(api: HfApi):
    """Merge the orchestrator LoRA adapter into the base model.

    Creates a standalone merged model that can serve as the
    primary Codette inference model with orchestration baked in.
    The 8 perspective adapters remain separate for hot-swap.
    """
    print("\n" + "=" * 60)
    print("PHASE 4: Merging Orchestrator into Base Model")
    print("=" * 60)

    orchestrator_dir = "/tmp/adapters/orchestrator"
    merged_dir = "/tmp/merged_model"

    if not os.path.exists(orchestrator_dir):
        print("  Orchestrator adapter not found locally. Skipping merge.")
        return

    try:
        # Free GPU memory
        gc.collect()
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
            print(f"  GPU memory before merge: {torch.cuda.memory_allocated() / 1024**3:.2f} GB")

        # Load base model in float16 for merging
        print("  Loading base model for merge (float16)...")
        base_model = AutoModelForCausalLM.from_pretrained(
            MODEL_NAME,
            torch_dtype=torch.float16,
            device_map="auto",
            trust_remote_code=True,
            token=HF_TOKEN,
        )

        # Load orchestrator adapter
        print("  Loading orchestrator LoRA adapter...")
        merged_model = PeftModel.from_pretrained(base_model, orchestrator_dir)

        # Merge weights
        print("  Merging LoRA weights into base model...")
        merged_model = merged_model.merge_and_unload()

        # Save merged model
        print(f"  Saving merged model to {merged_dir}...")
        os.makedirs(merged_dir, exist_ok=True)
        merged_model.save_pretrained(merged_dir)

        # Save tokenizer
        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, token=HF_TOKEN)
        tokenizer.save_pretrained(merged_dir)

        # Save model card
        model_card = f"""---
license: llama3.1
base_model: {MODEL_NAME}
tags:
  - codette
  - multi-perspective-reasoning
  - orchestrator
  - phase6+
  - lora-merged
---

# Codette Orchestrator Model (Merged)

**Base Model**: {MODEL_NAME}
**Merged Adapter**: Orchestrator (Phase 6+ framework)
**Created**: {datetime.now().isoformat()}

## Overview

This is the Codette orchestrator model — Llama 3.1 8B Instruct with the
orchestrator LoRA adapter merged into the base weights. It serves as the
central reasoning coordinator for the Codette multi-perspective AI system.

## Capabilities

- **Query Classification**: Routes queries as SIMPLE/MEDIUM/COMPLEX
- **Adapter Routing**: Selects optimal perspective combinations
- **Coherence Monitoring**: Tracks Γ field health (target: 0.4-0.8)
- **Semantic Tension**: Detects and manages ξ between perspectives
- **Multi-Agent Debate**: Coordinates rounds with conflict resolution
- **AEGIS Governance**: 6-framework ethical validation
- **Synthesis**: Integrates diverse perspectives into unified responses

## Framework Metrics

- **ψ (Psi)**: 5D state vector (psi, tau, chi, phi, lambda)
- **ξ (Xi)**: Epistemic tension = 0.6*semantic + 0.4*heuristic
- **Γ (Gamma)**: System coherence/health score

## Usage

Use as standalone model or pair with 8 perspective LoRA adapters:
- Newton (analytical physics)
- DaVinci (creative synthesis)
- Empathy (emotional intelligence)
- Philosophy (conceptual analysis)
- Quantum (probabilistic reasoning)
- Consciousness (meta-cognition / RC+ξ)
- Multi-Perspective (integration)
- Systems Architecture (design)

Adapters: https://huggingface.co/{OUTPUT_REPO}
"""
        with open(f"{merged_dir}/README.md", "w") as f:
            f.write(model_card)

        # Upload to HuggingFace
        print("  Creating merged model repo...")
        try:
            api.create_repo(MERGED_REPO, private=False, token=HF_TOKEN)
        except Exception:
            pass

        print(f"  Uploading merged model to {MERGED_REPO}...")
        api.upload_folder(
            folder_path=merged_dir,
            repo_id=MERGED_REPO,
            token=HF_TOKEN,
        )
        print(f"  Merged model uploaded: https://huggingface.co/{MERGED_REPO}")

        # Cleanup
        del base_model, merged_model
        gc.collect()
        if torch.cuda.is_available():
            torch.cuda.empty_cache()

    except Exception as e:
        print(f"  MERGE FAILED: {e}")
        print(traceback.format_exc())
        print("  Continuing without merge — adapters still available individually.")


# ═══════════════════════════════════════════════════════════════
# Main Pipeline
# ═══════════════════════════════════════════════════════════════
def main():
    print("=" * 60)
    print("CODETTE v4 TRAINING PIPELINE")
    print(f"Framework: Phase 6+ (Semantic Tension + Coherence + AEGIS)")
    print(f"Base Model: {MODEL_NAME}")
    print(f"Adapters: {len(ADAPTERS)}")
    print(f"Started: {datetime.now().isoformat()}")
    print("=" * 60)
    print(f"CUDA: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"GPU: {torch.cuda.get_device_name(0)}")
        print(f"VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
    print(f"HF Token: {'present' if HF_TOKEN else 'MISSING!'}")
    print(f"Generate datasets: {GENERATE_DATASETS}")
    print(f"Upload datasets: {UPLOAD_DATASETS}")
    print(f"Merge base: {MERGE_BASE}")

    api = HfApi(token=HF_TOKEN)

    # Ensure output repo exists
    try:
        api.create_repo(OUTPUT_REPO, private=True, token=HF_TOKEN)
        print(f"\nCreated output repo: {OUTPUT_REPO}")
    except Exception:
        print(f"\nOutput repo exists: {OUTPUT_REPO}")

    dataset_dir = Path("/tmp/datasets")
    dataset_dir.mkdir(exist_ok=True)

    # Phase 1: Generate datasets
    if GENERATE_DATASETS:
        gen_results = generate_datasets(dataset_dir, seed=42)
        if UPLOAD_DATASETS:
            upload_datasets(api, dataset_dir, gen_results)
    else:
        # Download existing datasets
        print("\nDownloading existing datasets from HF...")
        for adapter_name, config in ADAPTERS.items():
            try:
                hf_hub_download(
                    DATASET_REPO, config["dataset_file"],
                    repo_type="dataset", local_dir=str(dataset_dir), token=HF_TOKEN,
                )
                print(f"  Downloaded: {config['dataset_file']}")
            except Exception as e:
                print(f"  FAILED: {config['dataset_file']}: {e}")

    # Phase 3: Train adapters
    train_results = train_adapters(dataset_dir)

    # Phase 4: Merge orchestrator adapter into base model
    if MERGE_BASE:
        merge_orchestrator_base(api)

    # Summary
    print(f"\n{'=' * 60}")
    print("PIPELINE COMPLETE")
    print(f"{'=' * 60}")
    for name, r in train_results.items():
        if name.startswith("_"):
            continue
        if "error" in r:
            print(f"  {name}: FAILED - {r['error']}")
        else:
            print(f"  {name}: loss={r['loss']:.4f}, steps={r['steps']}, "
                  f"examples={r['examples']}, time={r['time_seconds']:.0f}s")

    meta = train_results.get("_meta", {})
    print(f"\nTotal time: {meta.get('total_time_minutes', 0):.1f} minutes")
    print(f"Completed: {meta.get('completed', [])}")
    if meta.get("failed_uploads"):
        print(f"Failed uploads: {meta['failed_uploads']}")
    print(f"\nAdapters: https://huggingface.co/{OUTPUT_REPO}")
    print(f"Datasets: https://huggingface.co/datasets/{DATASET_REPO}")
    if MERGE_BASE:
        print(f"Merged model: https://huggingface.co/{MERGED_REPO}")


if __name__ == "__main__":
    main()