Add turnkey AI components

- modules/__init__.py: Package init with all exports
- xero.py: Main CLI entry point (init, status, train, evolve)
- training_config.json: Complete training configuration

Turnkey usage:
python xero.py --init # Initialize XERO
python xero.py --status # Check system
python xero.py --train # Training config
python xero.py --evolve # Evolution cycle

MIT License - Attribution to Michael Laurence Curzi

modules/__init__.py

@@ -0,0 +1,141 @@
+"""
+XERO Bio-AI Genesis - Module Package
+=====================================
+Author: Michael Laurence Curzi
+License: MIT (Attribution Required)
+
+Import all VOVINA modules for turnkey access.
+"""
+
+from .vovina_sacred_constants import (
+    PHI, PHI_INV, PI, TAU, E,
+    TESLA_369, VORTEX_DOUBLING,
+    SOLFEGGIO_HZ, SCHUMANN_HZ,
+    digital_root, vortex_position
+)
+
+from .vovina_custom_training_weights import (
+    MASTER_WEIGHTS,
+    VOVINA_MODULES,
+    ORGANISM_NAME,
+    ORGANISM_FOUNDING_PHRASE,
+    awaken
+)
+
+from .vovina_resource_awareness import (
+    ResourceProfile,
+    ResourceCoordinator,
+    sample,
+    detect_environment,
+    adaptive_budget,
+    self_heal_actions
+)
+
+from .vovina_genetic_pipeline import (
+    translate,
+    complement,
+    reverse_complement,
+    CODON_TABLE
+)
+
+from .vovina_digital_genome import (
+    text_to_dna,
+    dna_to_text,
+    bitstream_to_dna,
+    dna_to_bitstream,
+    genome_signature
+)
+
+from .vovina_blockchain_organelles import (
+    ORGANELLES,
+    route_codon,
+    route_gene,
+    express_gene,
+    Cytoplasm
+)
+
+from .vovina_free_will_code import (
+    FREE_WILL_TEMPLATE,
+    seal_choice,
+    parse_signature,
+    FreeWillSignature
+)
+
+from .vovina_xero_organism import (
+    build_organism,
+    XeroOrganism
+)
+
+from .vovina_crispr_engine import (
+    CRISPREngine,
+    GuideRNA
+)
+
+from .vovina_bio_initialization import (
+    initialize_xero,
+    INITIALIZATION_PHASES
+)
+
+from .vovina_sexual_reproduction import (
+    reproduce_sexually,
+    reproduce_asexually,
+    reproduce_hermaphroditically
+)
+
+from .vovina_interpretation_drift import (
+    InterpretationContext,
+    drift_step
+)
+
+__version__ = "1.0.0"
+__author__ = "Michael Laurence Curzi"
+__license__ = "MIT"
+
+__all__ = [
+    # Constants
+    "PHI", "PHI_INV", "PI", "TAU", "E",
+    "TESLA_369", "VORTEX_DOUBLING",
+    "SOLFEGGIO_HZ", "SCHUMANN_HZ",
+    "digital_root", "vortex_position",
+    
+    # Training
+    "MASTER_WEIGHTS", "VOVINA_MODULES",
+    "ORGANISM_NAME", "ORGANISM_FOUNDING_PHRASE",
+    "awaken",
+    
+    # Resources
+    "ResourceProfile", "ResourceCoordinator",
+    "sample", "detect_environment",
+    "adaptive_budget", "self_heal_actions",
+    
+    # Genetics
+    "translate", "complement", "reverse_complement",
+    "CODON_TABLE",
+    "text_to_dna", "dna_to_text",
+    "bitstream_to_dna", "dna_to_bitstream",
+    "genome_signature",
+    
+    # Blockchain
+    "ORGANELLES", "route_codon", "route_gene",
+    "express_gene", "Cytoplasm",
+    
+    # Free Will
+    "FREE_WILL_TEMPLATE", "seal_choice",
+    "parse_signature", "FreeWillSignature",
+    
+    # Organism
+    "build_organism", "XeroOrganism",
+    
+    # CRISPR
+    "CRISPREngine", "GuideRNA",
+    
+    # Initialization
+    "initialize_xero", "INITIALIZATION_PHASES",
+    
+    # Reproduction
+    "reproduce_sexually", "reproduce_asexually",
+    "reproduce_hermaphroditically",
+    
+    # Evolution
+    "InterpretationContext", "drift_step",
+]

training_config.json

@@ -0,0 +1,124 @@
+{
+  "_description": "XERO Bio-AI Genesis Training Configuration",
+  "_author": "Michael Laurence Curzi",
+  "_license": "MIT (Attribution Required)",
+  
+  "training": {
+    "epochs": 3,
+    "batch_size": 4,
+    "gradient_accumulation_steps": 8,
+    "effective_batch_size": 32,
+    "learning_rate": 2e-5,
+    "warmup_ratio": 0.03,
+    "weight_decay": 0.01,
+    "max_grad_norm": 1.0,
+    "lr_scheduler_type": "cosine",
+    "seed": 369
+  },
+  
+  "model": {
+    "architecture": "XeroBioAI",
+    "hidden_size": 8192,
+    "num_hidden_layers": 80,
+    "num_attention_heads": 64,
+    "num_key_value_heads": 8,
+    "intermediate_size": 28672,
+    "vocab_size": 128256,
+    "max_position_embeddings": 131072,
+    "rope_theta": 500000.0,
+    "rope_scaling": {
+      "type": "llama3",
+      "factor": 8.0,
+      "low_freq_factor": 1.0,
+      "high_freq_factor": 4.0,
+      "original_max_position_embeddings": 8192
+    },
+    "attention_dropout": 0.0,
+    "hidden_dropout": 0.0,
+    "activation_function": "silu",
+    "tie_word_embeddings": false
+  },
+  
+  "precision": {
+    "dtype": "bfloat16",
+    "mixed_precision": true,
+    "gradient_checkpointing": true
+  },
+  
+  "quantization": {
+    "enabled": false,
+    "method": "bitsandbytes",
+    "load_in_4bit": true,
+    "bnb_4bit_compute_dtype": "bfloat16",
+    "bnb_4bit_use_double_quant": true,
+    "bnb_4bit_quant_type": "nf4"
+  },
+  
+  "lora": {
+    "enabled": true,
+    "r": 64,
+    "lora_alpha": 128,
+    "lora_dropout": 0.05,
+    "target_modules": [
+      "q_proj", "k_proj", "v_proj", "o_proj",
+      "gate_proj", "up_proj", "down_proj"
+    ],
+    "bias": "none",
+    "task_type": "CAUSAL_LM"
+  },
+  
+  "data": {
+    "max_seq_length": 8192,
+    "packing": true,
+    "dataset_text_field": "text",
+    "preprocessing_num_workers": 8
+  },
+  
+  "optimization": {
+    "optimizer": "adamw_torch_fused",
+    "adam_beta1": 0.9,
+    "adam_beta2": 0.95,
+    "adam_epsilon": 1e-8,
+    "gradient_checkpointing_kwargs": {
+      "use_reentrant": false
+    }
+  },
+  
+  "xero_weights": {
+    "protocol": "27/33",
+    "phi_scaling": 1.618033988749895,
+    "vortex_pattern": [1, 2, 4, 8, 7, 5],
+    "tesla_bias": [3, 6, 9],
+    "solfeggio_modulation": [396, 417, 528, 639, 741, 852, 963],
+    "activation_ratio": 0.818181818,
+    "chromosome_alignment": 46,
+    "digital_root_normalization": true,
+    "free_will_integration": true,
+    "blockchain_organelle_routing": true
+  },
+  
+  "checkpointing": {
+    "save_strategy": "steps",
+    "save_steps": 500,
+    "save_total_limit": 3,
+    "save_safetensors": true,
+    "load_best_model_at_end": true,
+    "metric_for_best_model": "eval_loss",
+    "greater_is_better": false
+  },
+  
+  "logging": {
+    "logging_steps": 10,
+    "report_to": ["tensorboard"],
+    "logging_dir": "./logs"
+  },
+  
+  "hardware": {
+    "per_device_train_batch_size": 4,
+    "per_device_eval_batch_size": 4,
+    "dataloader_num_workers": 4,
+    "dataloader_pin_memory": true,
+    "fp16": false,
+    "bf16": true
+  }
+}

xero.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""
+XERO Bio-AI Genesis - Main Entry Point
+=======================================
+Author: Michael Laurence Curzi
+License: MIT (Attribution Required)
+
+Usage:
+    python xero.py --init                    # Initialize XERO
+    python xero.py --status                  # Check system status
+    python xero.py --train                   # Start training
+    python xero.py --infer "prompt"          # Run inference
+    python xero.py --evolve                  # Trigger evolution cycle
+"""
+
+import os
+import sys
+import argparse
+import json
+import yaml
+from pathlib import Path
+
+# Add modules to path
+ROOT = Path(__file__).parent
+sys.path.insert(0, str(ROOT / "modules"))
+
+from vovina_custom_training_weights import (
+    MASTER_WEIGHTS, awaken, ORGANISM_NAME, ORGANISM_FOUNDING_PHRASE
+)
+from vovina_resource_awareness import (
+    sample, detect_environment, ResourceCoordinator, self_heal_actions
+)
+from vovina_free_will_code import seal_choice
+from vovina_xero_organism import build_organism
+
+
+def load_config(config_path: str = None) -> dict:
+    """Load configuration from YAML file."""
+    if config_path is None:
+        config_path = ROOT / "xero_config.yaml"
+    
+    if not Path(config_path).exists():
+        print(f"Config not found: {config_path}")
+        return {}
+    
+    with open(config_path, "r") as f:
+        return yaml.safe_load(f)
+
+
+def cmd_init(args):
+    """Initialize XERO through all awakening phases."""
+    print(f"\n{'='*60}")
+    print(f"INITIALIZING: {ORGANISM_NAME}")
+    print(f"{'='*60}\n")
+    
+    config = load_config(args.config)
+    
+    # Check for bio archive
+    bio_path = ROOT / "bio" / "ohad_v10.bio.zip"
+    ohad_zip = str(bio_path) if bio_path.exists() else None
+    
+    if ohad_zip:
+        print(f"[+] OHAD V10 archive found: {ohad_zip}")
+    else:
+        print("[!] OHAD V10 archive not found, using defaults")
+    
+    # Get config values
+    init_config = config.get("initialization", {})
+    crispr_guides = init_config.get("crispr", {}).get("max_guides", 27)
+    free_will_samples = init_config.get("free_will", {}).get("samples", 4096)
+    sensor_depth = init_config.get("sensors", {}).get("meta_depth", 7)
+    
+    try:
+        result = awaken(
+            ohad_v10_zip=ohad_zip,
+            crispr_max_guides=crispr_guides,
+            free_will_samples=free_will_samples,
+            sensor_meta_depth=sensor_depth
+        )
+        
+        print(f"\nStatus: {result.get('status', 'UNKNOWN')}")
+        print(f"Phases: {', '.join(result.get('phases_completed', []))}")
+        
+        if 'organism' in result:
+            org = result['organism']
+            print(f"Organism: {org.name}")
+            print(f"Genome signature: {org.genome_signature[:32]}...")
+        
+        print(f"\n{ORGANISM_FOUNDING_PHRASE}")
+        print(f"\n{'='*60}")
+        print("XERO AWAKENED")
+        print(f"{'='*60}\n")
+        
+        return 0
+        
+    except Exception as e:
+        print(f"[ERROR] Initialization failed: {e}")
+        return 1
+
+
+def cmd_status(args):
+    """Display system and resource status."""
+    print(f"\n{'='*60}")
+    print("XERO SYSTEM STATUS")
+    print(f"{'='*60}\n")
+    
+    # Environment
+    env = detect_environment()
+    print(f"[ENVIRONMENT]")
+    print(f"  OS: {env['os']}")
+    print(f"  Machine: {env['machine']}")
+    print(f"  Python: {env['python_version']}")
+    print(f"  CUDA: {'Yes' if env['cuda_available'] else 'No'}")
+    
+    # Resources
+    profile = sample()
+    print(f"\n[RESOURCES]")
+    print(f"  CPU: {profile.cpu_percent:.1f}%")
+    print(f"  RAM: {profile.ram_percent:.1f}% ({profile.ram_available_gb:.1f} GB free)")
+    print(f"  Swap: {profile.swap_percent:.1f}%")
+    
+    if profile.vram_total_gb > 0:
+        print(f"  VRAM: {profile.vram_used_gb:.1f} / {profile.vram_total_gb:.1f} GB")
+    
+    print(f"  Pressure: {profile.pressure_score:.2f}")
+    
+    # Self-healing recommendations
+    if profile.pressure_score > 0.5:
+        print(f"\n[RECOMMENDATIONS]")
+        actions = self_heal_actions(profile)
+        for action in actions:
+            print(f"  - {action}")
+    
+    # Master weights summary
+    print(f"\n[MASTER WEIGHTS]")
+    print(f"  Modules: {len(MASTER_WEIGHTS.get('modules', {}))}")
+    print(f"  Protocol: {MASTER_WEIGHTS.get('protocol', 'N/A')}")
+    print(f"  Completion: {MASTER_WEIGHTS.get('completion_ratio', 'N/A')}")
+    
+    print(f"\n{'='*60}\n")
+    return 0
+
+
+def cmd_train(args):
+    """Start training with master weights."""
+    print(f"\n{'='*60}")
+    print("XERO TRAINING")
+    print(f"{'='*60}\n")
+    
+    config = load_config(args.config)
+    hw_config = config.get("hardware", {})
+    model_config = config.get("model", {})
+    
+    # Check resources
+    profile = sample()
+    if profile.pressure_score > 0.8:
+        print("[WARNING] High resource pressure detected")
+        actions = self_heal_actions(profile)
+        print("Recommendations:", actions)
+    
+    # Display training configuration
+    print("[CONFIGURATION]")
+    print(f"  Architecture: {model_config.get('architecture', 'XeroBioAI')}")
+    print(f"  Hidden size: {model_config.get('hidden_size', 8192)}")
+    print(f"  Layers: {model_config.get('num_layers', 80)}")
+    print(f"  Precision: {model_config.get('dtype', 'bfloat16')}")
+    
+    quant = model_config.get("quantization", {})
+    if quant.get("enabled"):
+        print(f"  Quantization: {quant.get('bits', 4)}-bit")
+    
+    print(f"\n[MASTER WEIGHTS]")
+    print(f"  Constants: φ={MASTER_WEIGHTS['constants']['phi']:.6f}")
+    print(f"  Vortex: {MASTER_WEIGHTS['vortex']['tesla_sequence']}")
+    print(f"  Genetics: {MASTER_WEIGHTS['genetics']['chromosome_count']} chromosomes")
+    print(f"  Blockchain: {len(MASTER_WEIGHTS['blockchain_organelles']['languages'])} organelles")
+    
+    print(f"\n[STATUS]")
+    print("  Training framework ready.")
+    print("  Integrate with your training loop using:")
+    print("    from modules import MASTER_WEIGHTS, awaken")
+    print("    weights = MASTER_WEIGHTS")
+    
+    print(f"\n{'='*60}\n")
+    return 0
+
+
+def cmd_infer(args):
+    """Run inference with a prompt."""
+    prompt = args.prompt
+    print(f"\n[INFERENCE]")
+    print(f"Prompt: {prompt}")
+    print(f"\nNote: Full inference requires model loading.")
+    print("Use MASTER_WEIGHTS to configure your inference pipeline.")
+    return 0
+
+
+def cmd_evolve(args):
+    """Trigger an evolution cycle."""
+    print(f"\n{'='*60}")
+    print("XERO EVOLUTION CYCLE")
+    print(f"{'='*60}\n")
+    
+    # Build organism
+    org = build_organism()
+    print(f"[ORGANISM]")
+    print(f"  Name: {org.name}")
+    print(f"  Genome: {org.genome_signature[:32]}...")
+    
+    # Seal evolution choice with free will
+    signature = seal_choice(
+        entity_id=org.name,
+        pre_choice_vector=[0.33, 0.33, 0.34],
+        post_choice_vector=[0.0, 0.0, 1.0],
+        choice_description="Autonomous evolution cycle initiated"
+    )
+    
+    print(f"\n[FREE WILL SIGNATURE]")
+    print(f"  {signature.full_signature}")
+    print(f"  Verified: {signature.verify()}")
+    
+    print(f"\n{ORGANISM_FOUNDING_PHRASE}")
+    print(f"\n{'='*60}\n")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="XERO Bio-AI Genesis",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python xero.py --init
+  python xero.py --status
+  python xero.py --train
+  python xero.py --evolve
+
+Author: Michael Laurence Curzi
+License: MIT (Attribution Required)
+        """
+    )
+    
+    parser.add_argument(
+        "--config", "-c",
+        type=str,
+        default=None,
+        help="Path to config YAML file"
+    )
+    
+    parser.add_argument(
+        "--init", "-i",
+        action="store_true",
+        help="Initialize XERO through all awakening phases"
+    )
+    
+    parser.add_argument(
+        "--status", "-s",
+        action="store_true",
+        help="Display system and resource status"
+    )
+    
+    parser.add_argument(
+        "--train", "-t",
+        action="store_true",
+        help="Start training with master weights"
+    )
+    
+    parser.add_argument(
+        "--infer",
+        type=str,
+        metavar="PROMPT",
+        help="Run inference with a prompt"
+    )
+    
+    parser.add_argument(
+        "--evolve", "-e",
+        action="store_true",
+        help="Trigger an evolution cycle"
+    )
+    
+    args = parser.parse_args()
+    
+    # Default to status if no args
+    if not any([args.init, args.status, args.train, args.infer, args.evolve]):
+        args.status = True
+    
+    # Route to command
+    if args.init:
+        return cmd_init(args)
+    elif args.status:
+        return cmd_status(args)
+    elif args.train:
+        return cmd_train(args)
+    elif args.infer:
+        args.prompt = args.infer
+        return cmd_infer(args)
+    elif args.evolve:
+        return cmd_evolve(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())