Initial MANIFOLD upload - CS2 cheat detection training

README.md

@@ -1,12 +1,21 @@
 ---
-title: Manifold Cs2 Training
-emoji: 📚
+title: MANIFOLD CS2 Cheat Detection
+emoji: 🎯
 colorFrom: purple
-colorTo: pink
+colorTo: blue
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+hardware: h200
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MANIFOLD - CS2 Cheat Detection Training
+
+Train the MANIFOLD (Motor-Aware Neural Inference for Faithfulness Of Latent Dynamics) model for CS2 cheat detection.
+
+## Features
+- Synthetic data generation with realistic player behavior
+- 4-stage curriculum learning
+- Evidential deep learning with uncertainty quantification
+- Physics-constrained motor dynamics modeling

app.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""MANIFOLD Training Interface for Hugging Face Spaces."""
+
+import gradio as gr
+import torch
+import numpy as np
+import json
+import time
+from pathlib import Path
+from threading import Thread
+import queue
+
+# Add src to path for manifold imports
+import sys
+sys.path.insert(0, str(Path(__file__).parent / "src"))
+
+from manifold import MANIFOLDLite
+from manifold.config import ModelConfig, TrainingConfig
+from manifold.data.generator import SyntheticDataGenerator
+from manifold.data.dataset import MANIFOLDDataset, create_dataloader
+from manifold.training.trainer import MANIFOLDTrainer
+from manifold.training.callbacks import Callback, ProgressCallback
+from manifold.training.curriculum import CurriculumScheduler
+
+# Global state
+training_log = queue.Queue()
+is_training = False
+current_model = None
+
+
+class GradioCallback(Callback):
+    """Callback that logs to Gradio interface."""
+    
+    def on_epoch_end(self, trainer, epoch_info):
+        epoch = epoch_info["epoch"]
+        stage = epoch_info.get("stage", {}).get("stage_name", "")
+        train_loss = epoch_info.get("train", {}).get("loss", 0)
+        val_loss = epoch_info.get("val", {}).get("loss", 0)
+        val_acc = epoch_info.get("val", {}).get("accuracy", 0)
+        lr = epoch_info.get("lr", 0)
+        
+        log_entry = {
+            "epoch": epoch + 1,
+            "stage": stage,
+            "train_loss": f"{train_loss:.4f}",
+            "val_loss": f"{val_loss:.4f}",
+            "val_acc": f"{val_acc:.4f}",
+            "lr": f"{lr:.2e}",
+        }
+        training_log.put(log_entry)
+
+
+def get_device_info():
+    """Get GPU information."""
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        gpu_mem = torch.cuda.get_device_properties(0).total_memory / 1e9
+        return f"GPU: {gpu_name} ({gpu_mem:.1f} GB)"
+    return "CPU only (no GPU detected)"
+
+
+def generate_data(num_legit, num_cheaters, seed, progress=gr.Progress()):
+    """Generate synthetic training data."""
+    progress(0, desc="Initializing generator...")
+    
+    generator = SyntheticDataGenerator(seed=seed, engagements_per_session=200)
+    
+    all_features = []
+    all_labels = []
+    total = num_legit + num_cheaters
+    
+    # Generate legit players
+    for i in progress.tqdm(range(num_legit), desc="Generating legit players"):
+        session = generator.generate_player(is_cheater=False)
+        all_features.append(session.to_tensor())
+        all_labels.append(0)
+    
+    # Generate cheaters
+    for i in progress.tqdm(range(num_cheaters), desc="Generating cheaters"):
+        session = generator.generate_player(is_cheater=True)
+        all_features.append(session.to_tensor())
+        all_labels.append(2)
+    
+    # Convert and shuffle
+    features = np.array(all_features)
+    labels = np.array(all_labels)
+    
+    rng = np.random.default_rng(seed)
+    indices = rng.permutation(total)
+    features = features[indices]
+    labels = labels[indices]
+    
+    # Split 90/10
+    split_idx = int(total * 0.9)
+    
+    # Save to temp location
+    data_dir = Path("/tmp/manifold_data")
+    data_dir.mkdir(exist_ok=True)
+    
+    np.save(data_dir / "train_features.npy", features[:split_idx])
+    np.save(data_dir / "train_labels.npy", labels[:split_idx])
+    np.save(data_dir / "val_features.npy", features[split_idx:])
+    np.save(data_dir / "val_labels.npy", labels[split_idx:])
+    
+    return f"Generated {total} samples:\n- Train: {split_idx}\n- Val: {total - split_idx}\n- Features shape: {features.shape}"
+
+
+def train_model(batch_size, learning_rate, max_epochs, progress=gr.Progress()):
+    """Train the MANIFOLD model."""
+    global is_training, current_model
+    
+    if is_training:
+        return "Training already in progress!"
+    
+    is_training = True
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    
+    try:
+        # Load data
+        data_dir = Path("/tmp/manifold_data")
+        if not (data_dir / "train_features.npy").exists():
+            is_training = False
+            return "No data found! Generate data first."
+        
+        progress(0.1, desc="Loading data...")
+        train_features = np.load(data_dir / "train_features.npy")
+        train_labels = np.load(data_dir / "train_labels.npy")
+        val_features = np.load(data_dir / "val_features.npy")
+        val_labels = np.load(data_dir / "val_labels.npy")
+        
+        train_dataset = MANIFOLDDataset(data=train_features, labels=train_labels)
+        val_dataset = MANIFOLDDataset(data=val_features, labels=val_labels)
+        
+        train_loader = create_dataloader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=0)
+        val_loader = create_dataloader(val_dataset, batch_size=batch_size, shuffle=False, num_workers=0)
+        
+        progress(0.2, desc="Creating model...")
+        model_config = ModelConfig()
+        model = MANIFOLDLite.from_config(model_config)
+        
+        train_config = TrainingConfig(
+            batch_size=batch_size,
+            learning_rate=learning_rate,
+            max_epochs=max_epochs,
+        )
+        
+        callbacks = [GradioCallback()]
+        
+        trainer = MANIFOLDTrainer(
+            model=model,
+            config=train_config,
+            train_dataloader=train_loader,
+            val_dataloader=val_loader,
+            callbacks=callbacks,
+        )
+        
+        progress(0.3, desc="Training...")
+        
+        # Run training
+        history = trainer.train()
+        
+        # Save model
+        save_path = Path("/tmp/manifold_model.pt")
+        trainer.save_checkpoint(save_path)
+        current_model = model
+        
+        is_training = False
+        return f"Training complete!\nFinal val accuracy: {history['val'][-1].get('accuracy', 'N/A')}\nModel saved to {save_path}"
+        
+    except Exception as e:
+        is_training = False
+        return f"Training failed: {str(e)}"
+
+
+def get_training_logs():
+    """Get accumulated training logs."""
+    logs = []
+    while not training_log.empty():
+        try:
+            logs.append(training_log.get_nowait())
+        except:
+            break
+    
+    if not logs:
+        return "No logs yet. Start training to see progress."
+    
+    # Format as table
+    header = "| Epoch | Stage | Train Loss | Val Loss | Val Acc | LR |\n|-------|-------|------------|----------|---------|----|\n"
+    rows = "\n".join([
+        f"| {l['epoch']} | {l['stage'][:20]} | {l['train_loss']} | {l['val_loss']} | {l['val_acc']} | {l['lr']} |"
+        for l in logs
+    ])
+    return header + rows
+
+
+def test_inference(num_samples):
+    """Test model inference."""
+    global current_model
+    
+    if current_model is None:
+        # Try to load saved model
+        model_path = Path("/tmp/manifold_model.pt")
+        if model_path.exists():
+            current_model = MANIFOLDLite.from_config(ModelConfig())
+            ckpt = torch.load(model_path, map_location="cpu")
+            current_model.load_state_dict(ckpt["model_state_dict"])
+        else:
+            return "No model available! Train a model first."
+    
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    current_model.to(device)
+    current_model.eval()
+    
+    # Generate test samples
+    generator = SyntheticDataGenerator(seed=12345)
+    
+    results = []
+    for i in range(num_samples):
+        is_cheater = i % 2 == 1  # Alternate
+        session = generator.generate_player(is_cheater=is_cheater)
+        features = torch.tensor(session.to_tensor(), dtype=torch.float32).unsqueeze(0).to(device)
+        
+        with torch.no_grad():
+            outputs = current_model(features)
+        
+        pred_class = outputs["predicted_class"].item()
+        uncertainty = outputs["uncertainty"].item()
+        probs = outputs["verdict_probs"][0].cpu().numpy()
+        
+        class_names = ["Clean", "Suspicious", "Cheating"]
+        results.append({
+            "Sample": i + 1,
+            "Actual": "Cheater" if is_cheater else "Legit",
+            "Predicted": class_names[pred_class],
+            "Confidence": f"{probs.max():.2%}",
+            "Uncertainty": f"{uncertainty:.4f}",
+            "Correct": "✓" if (pred_class > 0) == is_cheater else "✗",
+        })
+    
+    # Format as markdown table
+    header = "| # | Actual | Predicted | Confidence | Uncertainty | Correct |\n|---|--------|-----------|------------|-------------|---------|"
+    rows = "\n".join([
+        f"| {r['Sample']} | {r['Actual']} | {r['Predicted']} | {r['Confidence']} | {r['Uncertainty']} | {r['Correct']} |"
+        for r in results
+    ])
+    
+    correct = sum(1 for r in results if r["Correct"] == "✓")
+    summary = f"\n\n**Accuracy: {correct}/{num_samples} ({100*correct/num_samples:.1f}%)**"
+    
+    return header + "\n" + rows + summary
+
+
+# Build Gradio interface
+with gr.Blocks(title="MANIFOLD Training") as demo:
+    gr.Markdown("# 🎯 MANIFOLD - CS2 Cheat Detection Training")
+    gr.Markdown(f"**Device:** {get_device_info()}")
+    
+    with gr.Tabs():
+        with gr.TabItem("1. Generate Data"):
+            gr.Markdown("Generate synthetic CS2 player behavior data for training.")
+            with gr.Row():
+                num_legit = gr.Slider(100, 10000, value=1000, step=100, label="Legit Players")
+                num_cheaters = gr.Slider(100, 5000, value=500, step=100, label="Cheaters")
+                seed = gr.Number(value=42, label="Random Seed")
+            gen_btn = gr.Button("Generate Data", variant="primary")
+            gen_output = gr.Textbox(label="Generation Status", lines=5)
+            gen_btn.click(generate_data, [num_legit, num_cheaters, seed], gen_output)
+        
+        with gr.TabItem("2. Train Model"):
+            gr.Markdown("Train the MANIFOLD model with curriculum learning.")
+            with gr.Row():
+                batch_size = gr.Slider(8, 128, value=32, step=8, label="Batch Size")
+                learning_rate = gr.Number(value=3e-4, label="Learning Rate")
+                max_epochs = gr.Slider(5, 100, value=20, step=5, label="Max Epochs")
+            train_btn = gr.Button("Start Training", variant="primary")
+            train_output = gr.Textbox(label="Training Status", lines=5)
+            train_btn.click(train_model, [batch_size, learning_rate, max_epochs], train_output)
+            
+            gr.Markdown("### Training Logs")
+            logs_output = gr.Markdown("No logs yet.")
+            refresh_btn = gr.Button("Refresh Logs")
+            refresh_btn.click(get_training_logs, [], logs_output)
+        
+        with gr.TabItem("3. Test Model"):
+            gr.Markdown("Test the trained model on synthetic samples.")
+            num_test = gr.Slider(5, 50, value=10, step=5, label="Number of Test Samples")
+            test_btn = gr.Button("Run Inference", variant="primary")
+            test_output = gr.Markdown("Click 'Run Inference' to test the model.")
+            test_btn.click(test_inference, [num_test], test_output)
+    
+    gr.Markdown("---")
+    gr.Markdown("**MANIFOLD** - Motor-Aware Neural Inference for Faithfulness Of Latent Dynamics")
+
+
+if __name__ == "__main__":
+    demo.launch()

configs/data/generator.yaml

@@ -0,0 +1,20 @@
+generator:
+  num_legit_players: 70000
+  num_cheaters: 30000
+  engagements_per_session: 200
+  seed: null
+  
+  cheater_distribution:
+    blatant_rage: 0.10
+    obvious: 0.15
+    closet_moderate: 0.30
+    closet_subtle: 0.30
+    wallhack_only: 0.15
+  
+  rank_distribution:
+    silver: 0.20
+    gold_nova: 0.25
+    master_guardian: 0.25
+    legendary_eagle: 0.15
+    supreme_global: 0.10
+    pro: 0.05

configs/default.yaml

@@ -0,0 +1,42 @@
+model:
+  input_dim: 64
+  embed_dim: 256
+  sequence_length: 128
+  
+  ihe:
+    num_layers: 4
+    num_heads: 8
+    ff_dim: 1024
+    dropout: 0.1
+  
+  mdm:
+    hidden_dim: 512
+    num_steps: 4
+  
+  mpl:
+    latent_dim: 64
+    hidden_dim: 256
+    kl_weight: 0.001
+  
+  cca:
+    num_cf_probes: 16
+    num_heads: 8
+  
+  hse:
+    manifold_dim: 32
+    num_skill_levels: 7
+  
+  tiv:
+    num_domains: 4
+    adversarial_lambda: 0.1
+  
+  verdict:
+    num_classes: 3
+    evidence_scale: 10.0
+
+training:
+  batch_size: 32
+  effective_batch_size: 128
+  learning_rate: 3e-4
+  max_epochs: 50
+  use_amp: true

requirements.txt

@@ -0,0 +1,9 @@
+torch>=2.1.0
+numpy>=1.24.0
+scipy>=1.11.0
+pandas>=2.0.0
+pydantic>=2.0.0
+tqdm>=4.66.0
+einops>=0.7.0
+scikit-learn>=1.3.0
+gradio>=4.0.0

src/manifold.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: manifold
+Version: 0.1.0
+Summary: MANIFOLD: Novel Deep Learning Architecture for CS2 Cheat Detection
+Requires-Python: >=3.11
+Requires-Dist: torch>=2.1.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.11.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: hydra-core>=1.3.0
+Requires-Dist: omegaconf>=2.3.0
+Requires-Dist: wandb>=0.16.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: einops>=0.7.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: matplotlib>=3.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: hypothesis>=6.90.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.7.0; extra == "dev"

src/manifold.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/manifold/__init__.py
+src/manifold/config.py
+src/manifold.egg-info/PKG-INFO
+src/manifold.egg-info/SOURCES.txt
+src/manifold.egg-info/dependency_links.txt
+src/manifold.egg-info/requires.txt
+src/manifold.egg-info/top_level.txt
+src/manifold/data/__init__.py
+src/manifold/evaluation/__init__.py
+src/manifold/models/__init__.py
+src/manifold/models/components/__init__.py
+src/manifold/models/layers/__init__.py
+src/manifold/training/__init__.py

src/manifold.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

src/manifold.egg-info/requires.txt

@@ -0,0 +1,20 @@
+torch>=2.1.0
+numpy>=1.24.0
+scipy>=1.11.0
+pandas>=2.0.0
+pyarrow>=14.0.0
+pydantic>=2.0.0
+hydra-core>=1.3.0
+omegaconf>=2.3.0
+wandb>=0.16.0
+tqdm>=4.66.0
+rich>=13.0.0
+einops>=0.7.0
+scikit-learn>=1.3.0
+matplotlib>=3.8.0
+
+[dev]
+pytest>=7.4.0
+hypothesis>=6.90.0
+ruff>=0.1.0
+mypy>=1.7.0

src/manifold.egg-info/top_level.txt

@@ -0,0 +1 @@
+manifold

src/manifold/__init__.py

@@ -0,0 +1,13 @@
+"""MANIFOLD: Novel Deep Learning Architecture for CS2 Cheat Detection"""
+
+__version__ = "0.1.0"
+
+from manifold.config import ModelConfig, TrainingConfig, DataConfig
+from manifold.models.manifold_lite import MANIFOLDLite
+
+__all__ = [
+    "ModelConfig",
+    "TrainingConfig", 
+    "DataConfig",
+    "MANIFOLDLite",
+]

src/manifold/config.py

@@ -0,0 +1,94 @@
+"""MANIFOLD configuration models using Pydantic v2."""
+
+from pydantic import BaseModel
+from typing import Literal, Optional
+
+
+class ModelConfig(BaseModel):
+    """MANIFOLD-Lite model configuration"""
+    input_dim: int = 64
+    embed_dim: int = 256
+    sequence_length: int = 128
+    
+    # IHE
+    ihe_layers: int = 4
+    ihe_heads: int = 8
+    ihe_ff_dim: int = 1024
+    ihe_dropout: float = 0.1
+    
+    # MDM
+    mdm_hidden: int = 512
+    mdm_steps: int = 4
+    
+    # MPL
+    latent_dim: int = 64
+    mpl_hidden: int = 256
+    kl_weight: float = 0.001
+    
+    # CCA
+    num_cf_probes: int = 16
+    cca_heads: int = 8
+    
+    # HSE
+    manifold_dim: int = 32
+    num_skill_levels: int = 7
+    
+    # TIV
+    num_domains: int = 4
+    adversarial_lambda: float = 0.1
+    
+    # Verdict
+    num_classes: int = 3
+    evidence_scale: float = 10.0
+    dropout: float = 0.1
+
+
+class TrainingConfig(BaseModel):
+    """Training configuration"""
+    batch_size: int = 32
+    effective_batch_size: int = 128
+    learning_rate: float = 3e-4
+    min_learning_rate: float = 1e-6
+    weight_decay: float = 0.01
+    warmup_ratio: float = 0.1
+    max_epochs: int = 50
+    gradient_clip: float = 1.0
+    use_amp: bool = True
+    amp_dtype: Literal["float16", "bfloat16"] = "float16"
+    gradient_checkpointing: bool = True
+    save_every_n_epochs: int = 5
+    
+    loss_weights: dict = {
+        "classification": 1.0,
+        "reconstruction": 0.1,
+        "kl_divergence": 0.001,
+        "physics_violation": 0.5,
+        "invariance": 0.1,
+    }
+
+
+class DataConfig(BaseModel):
+    """Data generation configuration"""
+    num_legit_players: int = 70000
+    num_cheaters: int = 30000
+    engagements_per_session: int = 200
+    num_features: int = 64
+    trajectory_length: int = 128
+    seed: Optional[int] = None
+    
+    cheater_distribution: dict = {
+        "blatant_rage": 0.10,
+        "obvious": 0.15,
+        "closet_moderate": 0.30,
+        "closet_subtle": 0.30,
+        "wallhack_only": 0.15,
+    }
+    
+    rank_distribution: dict = {
+        "silver": 0.20,
+        "gold_nova": 0.25,
+        "master_guardian": 0.25,
+        "legendary_eagle": 0.15,
+        "supreme_global": 0.10,
+        "pro": 0.05,
+    }

src/manifold/data/__init__.py

@@ -0,0 +1,77 @@
+from manifold.data.profiles import (
+    SkillVector,
+    PlayerProfile,
+    Rank,
+    SKILL_CORRELATION_MATRIX,
+    RANK_STATISTICS,
+    generate_correlated_skills,
+)
+from manifold.data.cheats import (
+    CheatType,
+    TogglePattern,
+    CheatConfig,
+    CheatBehavior,
+    HumanizationConfig,
+    CHEAT_PROFILES,
+)
+from manifold.data.trajectories import (
+    minimum_jerk,
+    signal_dependent_noise,
+    generate_micro_corrections,
+    generate_human_trajectory,
+    generate_aimbot_trajectory,
+    fitts_law_time,
+    extract_trajectory_features,
+)
+from manifold.data.temporal import (
+    SessionState,
+    SessionSimulator,
+    simulate_round_sequence,
+    generate_session_trace,
+)
+from manifold.data.generator import (
+    SyntheticDataGenerator,
+    PlayerSession,
+    EngagementData,
+    TRAJECTORY_FEATURE_NAMES,
+    extract_extended_trajectory_features,
+)
+from manifold.data.dataset import (
+    MANIFOLDDataset,
+    create_dataloader,
+    collate_fn,
+)
+
+__all__ = [
+    "SkillVector",
+    "PlayerProfile", 
+    "Rank",
+    "SKILL_CORRELATION_MATRIX",
+    "RANK_STATISTICS",
+    "generate_correlated_skills",
+    "CheatType",
+    "TogglePattern",
+    "CheatConfig",
+    "CheatBehavior",
+    "HumanizationConfig",
+    "CHEAT_PROFILES",
+    "minimum_jerk",
+    "signal_dependent_noise",
+    "generate_micro_corrections",
+    "generate_human_trajectory",
+    "generate_aimbot_trajectory",
+    "fitts_law_time",
+    "extract_trajectory_features",
+    "SessionState",
+    "SessionSimulator",
+    "simulate_round_sequence",
+    "generate_session_trace",
+    "SyntheticDataGenerator",
+    "PlayerSession",
+    "EngagementData",
+    "TRAJECTORY_FEATURE_NAMES",
+    "extract_extended_trajectory_features",
+    "MANIFOLDDataset",
+    "create_dataloader",
+    "collate_fn",
+]

src/manifold/data/cheats.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, Set, Tuple
+from enum import Enum
+
+
+class CheatType(Enum):
+    AIMBOT = "aimbot"
+    WALLHACK = "wallhack"
+    TRIGGERBOT = "triggerbot"
+
+
+class TogglePattern(Enum):
+    ALWAYS = "always"
+    CLUTCH_ONLY = "clutch_only"
+    LOSING_ONLY = "losing_only"
+    RANDOM = "random"
+
+
+@dataclass
+class HumanizationConfig:
+    """Cheater's attempt to appear legit - but leaves artifacts."""
+    reaction_delay_ms: Tuple[float, float] = (0.0, 20.0)
+    aim_smoothing: Tuple[float, float] = (0.0, 0.2)
+    random_miss_rate: Tuple[float, float] = (0.0, 0.05)
+    fov_degrees: Tuple[float, float] = (90.0, 180.0)
+    noise_amplitude: Tuple[float, float] = (0.0, 0.0)
+    prefire_suppression: float = 0.0
+    check_delay_ms: Tuple[float, float] = (0.0, 0.0)
+    
+    def sample(self, rng: np.random.Generator) -> Dict[str, float]:
+        """Sample concrete values from ranges."""
+        return {
+            "reaction_delay_ms": rng.uniform(*self.reaction_delay_ms),
+            "aim_smoothing": rng.uniform(*self.aim_smoothing),
+            "random_miss_rate": rng.uniform(*self.random_miss_rate),
+            "fov_degrees": rng.uniform(*self.fov_degrees),
+            "noise_amplitude": rng.uniform(*self.noise_amplitude),
+            "prefire_suppression": self.prefire_suppression,
+            "check_delay_ms": rng.uniform(*self.check_delay_ms) if self.check_delay_ms[1] > 0 else 0.0,
+        }
+
+
+CHEAT_PROFILES: Dict[str, Dict[str, Any]] = {
+    "blatant_rage": {
+        "intensity": (0.8, 1.0),
+        "toggle_pattern": TogglePattern.ALWAYS,
+        "cheat_types": {CheatType.AIMBOT, CheatType.WALLHACK, CheatType.TRIGGERBOT},
+        "humanization": HumanizationConfig(
+            reaction_delay_ms=(0.0, 20.0),
+            aim_smoothing=(0.0, 0.2),
+            random_miss_rate=(0.0, 0.05),
+            fov_degrees=(90.0, 180.0),
+        ),
+        "base_skill_multiplier": (0.3, 0.5),
+    },
+    "obvious": {
+        "intensity": (0.5, 0.8),
+        "toggle_pattern": TogglePattern.ALWAYS,
+        "cheat_types": {CheatType.AIMBOT, CheatType.TRIGGERBOT},
+        "humanization": HumanizationConfig(
+            reaction_delay_ms=(30.0, 80.0),
+            aim_smoothing=(0.2, 0.5),
+            random_miss_rate=(0.05, 0.10),
+            fov_degrees=(30.0, 60.0),
+        ),
+        "base_skill_multiplier": (0.4, 0.6),
+    },
+    "closet_moderate": {
+        "intensity": (0.3, 0.5),
+        "toggle_pattern": TogglePattern.CLUTCH_ONLY,
+        "cheat_types": {CheatType.AIMBOT},
+        "humanization": HumanizationConfig(
+            reaction_delay_ms=(80.0, 150.0),
+            aim_smoothing=(0.5, 0.8),
+            random_miss_rate=(0.10, 0.18),
+            fov_degrees=(10.0, 25.0),
+        ),
+        "base_skill_multiplier": (0.5, 0.7),
+    },
+    "closet_subtle": {
+        "intensity": (0.15, 0.35),
+        "toggle_pattern": TogglePattern.LOSING_ONLY,
+        "cheat_types": {CheatType.AIMBOT, CheatType.TRIGGERBOT},
+        "humanization": HumanizationConfig(
+            reaction_delay_ms=(150.0, 250.0),
+            aim_smoothing=(0.8, 0.95),
+            random_miss_rate=(0.15, 0.25),
+            fov_degrees=(3.0, 10.0),
+            noise_amplitude=(0.5, 1.5),
+        ),
+        "base_skill_multiplier": (0.6, 0.8),
+    },
+    "wallhack_only": {
+        "intensity": (0.4, 0.7),
+        "toggle_pattern": TogglePattern.ALWAYS,
+        "cheat_types": {CheatType.WALLHACK},
+        "humanization": HumanizationConfig(
+            prefire_suppression=0.7,
+            check_delay_ms=(500.0, 1500.0),
+        ),
+        "base_skill_multiplier": (0.7, 0.9),
+    },
+}
+
+
+@dataclass
+class CheatConfig:
+    """Configuration for a specific cheater."""
+    profile_name: str
+    cheat_types: Set[CheatType]
+    intensity: float
+    toggle_pattern: TogglePattern
+    humanization: Dict[str, float]
+    base_skill_multiplier: float
+    
+    @classmethod
+    def from_profile(
+        cls,
+        profile_name: str,
+        seed: Optional[int] = None,
+    ) -> CheatConfig:
+        """Create config from predefined profile."""
+        if profile_name not in CHEAT_PROFILES:
+            raise ValueError(f"Unknown profile: {profile_name}. Valid: {list(CHEAT_PROFILES.keys())}")
+        
+        rng = np.random.default_rng(seed)
+        profile = CHEAT_PROFILES[profile_name]
+        
+        intensity = rng.uniform(*profile["intensity"])
+        base_skill_mult = rng.uniform(*profile["base_skill_multiplier"])
+        humanization = profile["humanization"].sample(rng)
+        
+        return cls(
+            profile_name=profile_name,
+            cheat_types=profile["cheat_types"].copy(),
+            intensity=intensity,
+            toggle_pattern=profile["toggle_pattern"],
+            humanization=humanization,
+            base_skill_multiplier=base_skill_mult,
+        )
+
+
+@dataclass
+class CheatBehavior:
+    """Runtime cheat behavior with toggle logic."""
+    config: CheatConfig
+    is_active: bool = True
+    rounds_since_toggle: int = 0
+    
+    @classmethod
+    def from_profile(cls, profile_name: str, seed: Optional[int] = None) -> CheatBehavior:
+        config = CheatConfig.from_profile(profile_name, seed)
+        return cls(config=config)
+    
+    @property
+    def toggle_pattern(self) -> TogglePattern:
+        return self.config.toggle_pattern
+    
+    def should_activate(
+        self,
+        is_clutch: bool = False,
+        is_losing: bool = False,
+        round_number: int = 0,
+        rng: Optional[np.random.Generator] = None,
+    ) -> bool:
+        """Determine if cheat should be active this round."""
+        pattern = self.config.toggle_pattern
+        
+        if pattern == TogglePattern.ALWAYS:
+            return True
+        elif pattern == TogglePattern.CLUTCH_ONLY:
+            return is_clutch
+        elif pattern == TogglePattern.LOSING_ONLY:
+            return is_losing
+        elif pattern == TogglePattern.RANDOM:
+            if rng is None:
+                rng = np.random.default_rng()
+            return rng.random() < 0.5
+        
+        return True
+    
+    def get_aim_modification(self, target_angle: float, current_angle: float) -> float:
+        """Calculate aim correction from cheat."""
+        if CheatType.AIMBOT not in self.config.cheat_types:
+            return 0.0
+        if not self.is_active:
+            return 0.0
+        
+        angle_diff = target_angle - current_angle
+        fov_limit = self.config.humanization["fov_degrees"]
+        
+        if abs(angle_diff) > fov_limit:
+            return 0.0
+        
+        smoothing = self.config.humanization["aim_smoothing"]
+        intensity = self.config.intensity
+        
+        # Smoothed correction
+        correction = angle_diff * (1.0 - smoothing) * intensity
+        
+        # Add humanization noise
+        noise_amp = self.config.humanization.get("noise_amplitude", 0.0)
+        if noise_amp > 0:
+            correction += np.random.normal(0, noise_amp)
+        
+        return correction
+    
+    def get_reaction_delay(self) -> float:
+        """Get reaction delay in ms."""
+        return self.config.humanization["reaction_delay_ms"]
+    
+    def should_miss_intentionally(self, rng: Optional[np.random.Generator] = None) -> bool:
+        """Check if should intentionally miss (humanization)."""
+        if rng is None:
+            rng = np.random.default_rng()
+        miss_rate = self.config.humanization["random_miss_rate"]
+        return rng.random() < miss_rate

src/manifold/data/dataset.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+import torch
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Union
+import pyarrow.parquet as pq
+
+from manifold.data.generator import SyntheticDataGenerator, PlayerSession
+
+
+class MANIFOLDDataset(Dataset):
+    """
+    PyTorch Dataset for MANIFOLD training data.
+    
+    Supports loading from Parquet files and on-the-fly generation.
+    Handles sequence padding/truncation for consistent tensor shapes.
+    """
+    
+    def __init__(
+        self,
+        data: Optional[np.ndarray] = None,
+        labels: Optional[np.ndarray] = None,
+        sequence_length: int = 128,
+        pad_value: float = 0.0,
+    ):
+        self.data = data
+        self.labels = labels
+        self.sequence_length = sequence_length
+        self.pad_value = pad_value
+        
+    def __len__(self) -> int:
+        return len(self.data) if self.data is not None else 0
+        
+    def __getitem__(self, idx: int) -> Dict[str, torch.Tensor]:
+        features = self.data[idx]
+        label = self.labels[idx]
+        
+        seq_len = features.shape[0]
+        if seq_len < self.sequence_length:
+            padding = np.full(
+                (self.sequence_length - seq_len, features.shape[1]),
+                self.pad_value
+            )
+            features = np.concatenate([features, padding], axis=0)
+            mask = np.concatenate([
+                np.ones(seq_len),
+                np.zeros(self.sequence_length - seq_len)
+            ])
+        else:
+            features = features[:self.sequence_length]
+            mask = np.ones(self.sequence_length)
+            
+        return {
+            "features": torch.tensor(features, dtype=torch.float32),
+            "labels": torch.tensor(label, dtype=torch.long),
+            "mask": torch.tensor(mask, dtype=torch.float32),
+        }
+    
+    @classmethod
+    def from_parquet(cls, path: Union[str, Path], **kwargs) -> "MANIFOLDDataset":
+        table = pq.read_table(path)
+        df = table.to_pandas()
+        data = np.array(df["features"].tolist())
+        labels = np.array(df["label"].tolist())
+        return cls(data=data, labels=labels, **kwargs)
+    
+    @classmethod
+    def from_generator(
+        cls,
+        num_samples: int,
+        cheater_ratio: float = 0.3,
+        seed: Optional[int] = None,
+        **kwargs
+    ) -> "MANIFOLDDataset":
+        gen = SyntheticDataGenerator(seed=seed)
+        num_cheaters = int(num_samples * cheater_ratio)
+        num_legit = num_samples - num_cheaters
+        
+        sessions = gen.generate_batch(num_legit, num_cheaters)
+        
+        data = np.array([s.to_tensor() for s in sessions])
+        labels = np.array([2 if s.is_cheater else 0 for s in sessions])
+        
+        return cls(data=data, labels=labels, **kwargs)
+
+
+def create_dataloader(
+    dataset: MANIFOLDDataset,
+    batch_size: int = 32,
+    shuffle: bool = True,
+    num_workers: int = 4,
+    pin_memory: bool = True,
+) -> DataLoader:
+    return DataLoader(
+        dataset,
+        batch_size=batch_size,
+        shuffle=shuffle,
+        num_workers=num_workers,
+        pin_memory=pin_memory,
+        drop_last=True,
+    )
+
+
+def collate_fn(batch: List[Dict[str, torch.Tensor]]) -> Dict[str, torch.Tensor]:
+    return {
+        "features": torch.stack([b["features"] for b in batch]),
+        "labels": torch.stack([b["labels"] for b in batch]),
+        "mask": torch.stack([b["mask"] for b in batch]),
+    }

src/manifold/data/generator.py

@@ -0,0 +1,749 @@
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, List, Iterator
+import random
+
+from manifold.data.profiles import PlayerProfile, SkillVector, RANK_STATISTICS, generate_correlated_skills, Rank
+from manifold.data.cheats import CheatBehavior, CHEAT_PROFILES, CheatType
+from manifold.data.trajectories import (
+    generate_human_trajectory,
+    generate_aimbot_trajectory,
+    fitts_law_time,
+    extract_trajectory_features,
+)
+from manifold.data.temporal import SessionSimulator, SessionState
+
+
+# Extended trajectory feature names for 25 features
+TRAJECTORY_FEATURE_NAMES = [
+    "max_jerk", "mean_jerk", "jerk_variance", "jerk_skewness", "jerk_kurtosis",
+    "path_efficiency", "velocity_peak_timing", "max_velocity", "mean_velocity", "velocity_variance",
+    "max_acceleration", "mean_acceleration", "acceleration_variance",
+    "total_distance", "direct_distance", "x_displacement", "y_displacement",
+    "direction_changes", "smoothness_index", "curvature_mean", "curvature_variance",
+    "overshoot_magnitude", "correction_count", "final_error", "movement_duration_ratio",
+]
+
+
+def extract_extended_trajectory_features(trajectory: np.ndarray) -> Dict[str, float]:
+    """
+    Extract 25 features from trajectory for cheat detection.
+    
+    Extends the base extract_trajectory_features with additional metrics.
+    
+    Args:
+        trajectory: Delta trajectory [n_ticks, 2]
+        
+    Returns:
+        Dict of 25 extracted features
+    """
+    # Start with base features
+    base_features = extract_trajectory_features(trajectory)
+    
+    if len(trajectory) < 3:
+        # Return zeros for all features
+        return {name: 0.0 for name in TRAJECTORY_FEATURE_NAMES}
+    
+    # Compute velocity, acceleration, jerk
+    velocity = np.linalg.norm(trajectory, axis=1)
+    acceleration = np.diff(velocity) if len(velocity) > 1 else np.array([0.0])
+    jerk = np.diff(acceleration) if len(acceleration) > 1 else np.array([0.0])
+    
+    # Jerk statistics (extended)
+    jerk_skewness = float(_safe_skewness(jerk)) if len(jerk) > 2 else 0.0
+    jerk_kurtosis = float(_safe_kurtosis(jerk)) if len(jerk) > 3 else 0.0
+    
+    # Velocity statistics
+    max_velocity = float(np.max(velocity)) if len(velocity) > 0 else 0.0
+    mean_velocity = float(np.mean(velocity)) if len(velocity) > 0 else 0.0
+    velocity_variance = float(np.var(velocity)) if len(velocity) > 0 else 0.0
+    
+    # Acceleration statistics
+    max_acceleration = float(np.max(np.abs(acceleration))) if len(acceleration) > 0 else 0.0
+    mean_acceleration = float(np.mean(np.abs(acceleration))) if len(acceleration) > 0 else 0.0
+    acceleration_variance = float(np.var(acceleration)) if len(acceleration) > 0 else 0.0
+    
+    # Distance metrics
+    total_distance = float(np.sum(velocity))
+    cumulative_displacement = np.cumsum(trajectory, axis=0)
+    direct_distance = float(np.linalg.norm(cumulative_displacement[-1])) if len(cumulative_displacement) > 0 else 0.0
+    x_displacement = float(cumulative_displacement[-1, 0]) if len(cumulative_displacement) > 0 else 0.0
+    y_displacement = float(cumulative_displacement[-1, 1]) if len(cumulative_displacement) > 0 else 0.0
+    
+    # Direction changes
+    if len(trajectory) > 1:
+        angles = np.arctan2(trajectory[:, 1], trajectory[:, 0])
+        angle_diffs = np.abs(np.diff(angles))
+        direction_changes = float(np.sum(angle_diffs > np.pi / 4))  # Count significant direction changes
+    else:
+        direction_changes = 0.0
+    
+    # Smoothness index (inverse of total squared jerk)
+    smoothness_index = 1.0 / (1.0 + np.sum(jerk**2)) if len(jerk) > 0 else 1.0
+    
+    # Curvature statistics
+    if len(trajectory) > 2:
+        # Approximate curvature as angle change per unit distance
+        curvatures = []
+        for i in range(1, len(trajectory) - 1):
+            v1 = trajectory[i]
+            v2 = trajectory[i + 1]
+            cross = v1[0] * v2[1] - v1[1] * v2[0]
+            norm_product = (np.linalg.norm(v1) * np.linalg.norm(v2)) + 1e-8
+            curvatures.append(abs(cross / norm_product))
+        curvature_mean = float(np.mean(curvatures)) if curvatures else 0.0
+        curvature_variance = float(np.var(curvatures)) if curvatures else 0.0
+    else:
+        curvature_mean = 0.0
+        curvature_variance = 0.0
+    
+    # Overshoot detection (when trajectory goes past target then comes back)
+    positions = np.cumsum(trajectory, axis=0)
+    if len(positions) > 1:
+        final_pos = positions[-1]
+        distances_to_final = np.linalg.norm(positions - final_pos, axis=1)
+        # Overshoot = minimum distance was achieved before the end
+        min_dist_idx = np.argmin(distances_to_final[:-1]) if len(distances_to_final) > 1 else 0
+        overshoot_magnitude = float(np.max(distances_to_final[min_dist_idx:])) if min_dist_idx < len(distances_to_final) - 1 else 0.0
+    else:
+        overshoot_magnitude = 0.0
+    
+    # Correction count (velocity sign changes)
+    if len(velocity) > 1:
+        vel_diff = np.diff(velocity)
+        correction_count = float(np.sum(np.abs(np.diff(np.sign(vel_diff))) > 0)) if len(vel_diff) > 1 else 0.0
+    else:
+        correction_count = 0.0
+    
+    # Final error (assuming target is at cumulative endpoint - would need target info)
+    # For now, use variance of final positions as proxy
+    final_error = float(np.linalg.norm(trajectory[-1])) if len(trajectory) > 0 else 0.0
+    
+    # Movement duration ratio (proportion of time with significant movement)
+    movement_threshold = 0.01 * max_velocity if max_velocity > 0 else 0.01
+    movement_duration_ratio = float(np.mean(velocity > movement_threshold)) if len(velocity) > 0 else 0.0
+    
+    return {
+        "max_jerk": base_features["max_jerk"],
+        "mean_jerk": base_features["mean_jerk"],
+        "jerk_variance": base_features["jerk_variance"],
+        "jerk_skewness": jerk_skewness,
+        "jerk_kurtosis": jerk_kurtosis,
+        "path_efficiency": base_features["path_efficiency"],
+        "velocity_peak_timing": base_features["velocity_peak_timing"],
+        "max_velocity": max_velocity,
+        "mean_velocity": mean_velocity,
+        "velocity_variance": velocity_variance,
+        "max_acceleration": max_acceleration,
+        "mean_acceleration": mean_acceleration,
+        "acceleration_variance": acceleration_variance,
+        "total_distance": total_distance,
+        "direct_distance": direct_distance,
+        "x_displacement": x_displacement,
+        "y_displacement": y_displacement,
+        "direction_changes": direction_changes,
+        "smoothness_index": smoothness_index,
+        "curvature_mean": curvature_mean,
+        "curvature_variance": curvature_variance,
+        "overshoot_magnitude": overshoot_magnitude,
+        "correction_count": correction_count,
+        "final_error": final_error,
+        "movement_duration_ratio": movement_duration_ratio,
+    }
+
+
+def _safe_skewness(arr: np.ndarray) -> float:
+    """Compute skewness safely."""
+    if len(arr) < 3:
+        return 0.0
+    mean = np.mean(arr)
+    std = np.std(arr)
+    if std < 1e-8:
+        return 0.0
+    return float(np.mean(((arr - mean) / std) ** 3))
+
+
+def _safe_kurtosis(arr: np.ndarray) -> float:
+    """Compute kurtosis safely."""
+    if len(arr) < 4:
+        return 0.0
+    mean = np.mean(arr)
+    std = np.std(arr)
+    if std < 1e-8:
+        return 0.0
+    return float(np.mean(((arr - mean) / std) ** 4) - 3.0)
+
+
+@dataclass
+class EngagementData:
+    """Single engagement - the atomic training unit with 64 features."""
+    # Context features [12]
+    enemy_distance: float
+    enemy_velocity: float
+    player_velocity: float
+    player_health: float
+    enemy_health: float
+    weapon_type: int
+    is_scoped: bool
+    is_crouched: bool
+    round_time_remaining: float
+    score_differential: float
+    is_clutch: bool
+    enemies_alive: int
+    
+    # Pre-engagement features [8]
+    crosshair_angle_to_hidden_enemy: float
+    time_tracking_hidden_ms: float
+    prefire_indicator: bool
+    check_pattern_efficiency: float
+    rotation_timing_vs_enemy: float
+    flank_awareness_score: float
+    info_advantage_score: float
+    position_optimality: float
+    
+    # Trajectory features [25] - from extract_trajectory_features
+    trajectory_features: Dict[str, float] = field(default_factory=dict)
+    
+    # Timing features [10]
+    reaction_time_ms: float = 0.0
+    time_to_first_shot_ms: float = 0.0
+    time_to_damage_ms: float = 0.0
+    time_to_kill_ms: float = 0.0
+    shot_timing_variance: float = 0.0
+    inter_shot_interval_mean: float = 0.0
+    inter_shot_interval_cv: float = 0.0
+    crosshair_on_enemy_to_shot_ms: float = 0.0
+    anticipatory_shot_rate: float = 0.0
+    perfect_timing_rate: float = 0.0
+    
+    # Accuracy features [9]
+    shots_fired: int = 0
+    shots_hit: int = 0
+    headshots: int = 0
+    damage_dealt: float = 0.0
+    spray_accuracy: float = 0.0
+    first_bullet_accuracy: float = 0.0
+    headshot_rate: float = 0.0
+    damage_efficiency: float = 0.0
+    kill_secured: bool = False
+    
+    # Labels
+    is_cheater: bool = False
+    cheat_type: str = "none"
+    cheat_intensity: float = 0.0
+    cheat_active_this_engagement: bool = False
+    
+    def to_tensor(self) -> np.ndarray:
+        """Convert to 64-dim feature vector."""
+        # Context features [12]
+        context = [
+            self.enemy_distance,
+            self.enemy_velocity,
+            self.player_velocity,
+            self.player_health,
+            self.enemy_health,
+            float(self.weapon_type),
+            float(self.is_scoped),
+            float(self.is_crouched),
+            self.round_time_remaining,
+            self.score_differential,
+            float(self.is_clutch),
+            float(self.enemies_alive),
+        ]
+        
+        # Pre-engagement features [8]
+        pre_engagement = [
+            self.crosshair_angle_to_hidden_enemy,
+            self.time_tracking_hidden_ms,
+            float(self.prefire_indicator),
+            self.check_pattern_efficiency,
+            self.rotation_timing_vs_enemy,
+            self.flank_awareness_score,
+            self.info_advantage_score,
+            self.position_optimality,
+        ]
+        
+        # Trajectory features [25]
+        trajectory = [
+            self.trajectory_features.get(name, 0.0)
+            for name in TRAJECTORY_FEATURE_NAMES
+        ]
+        
+        # Timing features [10]
+        timing = [
+            self.reaction_time_ms,
+            self.time_to_first_shot_ms,
+            self.time_to_damage_ms,
+            self.time_to_kill_ms,
+            self.shot_timing_variance,
+            self.inter_shot_interval_mean,
+            self.inter_shot_interval_cv,
+            self.crosshair_on_enemy_to_shot_ms,
+            self.anticipatory_shot_rate,
+            self.perfect_timing_rate,
+        ]
+        
+        # Accuracy features [9]
+        accuracy = [
+            float(self.shots_fired),
+            float(self.shots_hit),
+            float(self.headshots),
+            self.damage_dealt,
+            self.spray_accuracy,
+            self.first_bullet_accuracy,
+            self.headshot_rate,
+            self.damage_efficiency,
+            float(self.kill_secured),
+        ]
+        
+        # Concatenate all: 12 + 8 + 25 + 10 + 9 = 64
+        features = context + pre_engagement + trajectory + timing + accuracy
+        return np.array(features, dtype=np.float32)
+
+
+@dataclass
+class PlayerSession:
+    """Complete player session with multiple engagements."""
+    player_id: str
+    profile: PlayerProfile
+    engagements: List[EngagementData]
+    is_cheater: bool
+    cheat_profile: Optional[str] = None
+    rank: str = "gold_nova"
+    
+    def to_tensor(self) -> np.ndarray:
+        """Convert to tensor [num_engagements, 64]."""
+        return np.stack([e.to_tensor() for e in self.engagements])
+
+
+# Weapon type mapping
+WEAPON_TYPES = {
+    "rifle": 0,
+    "smg": 1,
+    "pistol": 2,
+    "awp": 3,
+    "shotgun": 4,
+    "machine_gun": 5,
+}
+
+
+class SyntheticDataGenerator:
+    """
+    Generate synthetic CS2 player behavior data.
+    
+    Orchestrates all data modules to create realistic player sessions
+    with proper skill modeling, cheat injection, and temporal dynamics.
+    """
+    
+    def __init__(
+        self,
+        seed: Optional[int] = None,
+        engagements_per_session: int = 200,
+    ):
+        self.rng = np.random.default_rng(seed)
+        self.engagements_per_session = engagements_per_session
+        self._seed = seed
+        
+    def generate_player(
+        self,
+        is_cheater: bool = False,
+        rank: Optional[str] = None,
+        cheat_profile: Optional[str] = None,
+    ) -> PlayerSession:
+        """Generate a single player session."""
+        # 1. Create player profile with correlated skills
+        if rank is None:
+            rank = self.rng.choice(["silver", "gold_nova", "master_guardian", "legendary_eagle", "supreme_global"])
+        
+        profile = PlayerProfile.generate(
+            rank=rank,
+            seed=int(self.rng.integers(0, 2**31)),
+        )
+        profile.is_cheater = is_cheater
+        
+        # 2. Initialize session simulator for temporal dynamics
+        session = SessionSimulator.from_skill(
+            mental_resilience=profile.skill_vector.mental_resilience,
+            seed=int(self.rng.integers(0, 2**31)),
+        )
+        
+        # 3. Setup cheat behavior if cheater
+        cheat_behavior: Optional[CheatBehavior] = None
+        if is_cheater:
+            if cheat_profile is None:
+                cheat_profile = self.rng.choice(list(CHEAT_PROFILES.keys()))
+            cheat_behavior = CheatBehavior.from_profile(
+                cheat_profile,
+                seed=int(self.rng.integers(0, 2**31)),
+            )
+        
+        # 4. Generate engagements
+        engagements: List[EngagementData] = []
+        
+        rounds_per_match = 24
+        base_engagements_per_round = self.engagements_per_session // rounds_per_match
+        extra_engagements = self.engagements_per_session % rounds_per_match
+        
+        score_differential = 0
+        for round_num in range(rounds_per_match):
+            engagements_this_round = base_engagements_per_round + (1 if round_num < extra_engagements else 0)
+            # Determine round context
+            is_losing = score_differential < -3
+            round_won = self.rng.random() < 0.5
+            
+            for eng_num in range(engagements_this_round):
+                is_clutch = (eng_num == engagements_this_round - 1) and self.rng.random() < 0.2
+                
+                # Update session state
+                event = "idle"
+                if eng_num == 0:
+                    event = "round_win" if round_won else "round_loss"
+                elif self.rng.random() < 0.3:
+                    event = "kill" if self.rng.random() < 0.5 else "death"
+                
+                if is_clutch:
+                    session.update("clutch_situation", 1000.0)
+                else:
+                    session.update(event, 3000.0)
+                
+                # Generate game context
+                game_context = {
+                    "round_time_remaining": 115.0 - (eng_num * 10.0) + self.rng.uniform(-5, 5),
+                    "score_differential": score_differential,
+                    "is_clutch": is_clutch,
+                    "enemies_alive": max(1, 5 - eng_num // 2),
+                    "is_losing": is_losing,
+                }
+                
+                # Determine if cheat is active this engagement
+                cheat_active = False
+                if cheat_behavior is not None:
+                    cheat_active = cheat_behavior.should_activate(
+                        is_clutch=is_clutch,
+                        is_losing=is_losing,
+                        round_number=round_num,
+                        rng=self.rng,
+                    )
+                    cheat_behavior.is_active = cheat_active
+                
+                engagement = self.generate_engagement(
+                    profile=profile,
+                    session=session,
+                    cheat_behavior=cheat_behavior if cheat_active else None,
+                    game_context=game_context,
+                )
+                
+                # Set labels
+                engagement.is_cheater = is_cheater
+                engagement.cheat_type = cheat_profile if is_cheater else "none"
+                engagement.cheat_intensity = cheat_behavior.config.intensity if cheat_behavior else 0.0
+                engagement.cheat_active_this_engagement = cheat_active
+                
+                engagements.append(engagement)
+            
+            # Update score
+            if round_won:
+                score_differential += 1
+            else:
+                score_differential -= 1
+        
+        return PlayerSession(
+            player_id=profile.profile_id,
+            profile=profile,
+            engagements=engagements,
+            is_cheater=is_cheater,
+            cheat_profile=cheat_profile,
+            rank=rank,
+        )
+        
+    def generate_engagement(
+        self,
+        profile: PlayerProfile,
+        session: SessionSimulator,
+        cheat_behavior: Optional[CheatBehavior] = None,
+        game_context: Optional[Dict[str, Any]] = None,
+    ) -> EngagementData:
+        """Generate a single engagement."""
+        if game_context is None:
+            game_context = {}
+        
+        skills = profile.skill_vector
+        rank_stats = RANK_STATISTICS[profile.rank]
+        
+        # Get session modifiers
+        modifiers = session.get_modifiers()
+        
+        # 1. Generate context features
+        enemy_distance = self.rng.uniform(5.0, 50.0)  # meters
+        enemy_velocity = self.rng.uniform(0.0, 250.0)  # units/s
+        player_velocity = self.rng.uniform(0.0, 250.0)
+        player_health = self.rng.uniform(20.0, 100.0)
+        enemy_health = self.rng.uniform(20.0, 100.0)
+        weapon_type = int(self.rng.integers(0, len(WEAPON_TYPES)))
+        is_scoped = weapon_type == WEAPON_TYPES["awp"] and self.rng.random() < 0.7
+        is_crouched = self.rng.random() < 0.3
+        round_time_remaining = game_context.get("round_time_remaining", 90.0)
+        score_differential = game_context.get("score_differential", 0)
+        is_clutch = game_context.get("is_clutch", False)
+        enemies_alive = game_context.get("enemies_alive", 3)
+        
+        # 2. Generate pre-engagement features
+        # These are affected by game sense and wallhack cheats
+        has_wallhack = (
+            cheat_behavior is not None and 
+            CheatType.WALLHACK in cheat_behavior.config.cheat_types
+        )
+        
+        game_sense_effective = skills.game_sense * modifiers.get("game_sense_mult", 1.0)
+        
+        # Crosshair angle to hidden enemy (wallhackers track better)
+        if has_wallhack:
+            crosshair_angle_to_hidden = self.rng.uniform(0.0, 15.0)  # Suspiciously good
+            time_tracking_hidden = self.rng.uniform(500.0, 2000.0)  # Long tracking time
+            prefire_indicator = self.rng.random() < (0.3 * (1.0 - cheat_behavior.config.humanization.get("prefire_suppression", 0.0)))
+        else:
+            crosshair_angle_to_hidden = self.rng.uniform(20.0, 90.0) * (1.0 - game_sense_effective / 150.0)
+            time_tracking_hidden = self.rng.exponential(200.0)
+            prefire_indicator = self.rng.random() < (0.05 * game_sense_effective / 100.0)
+        
+        check_pattern_efficiency = (game_sense_effective / 100.0) * self.rng.uniform(0.7, 1.0)
+        rotation_timing_vs_enemy = self.rng.uniform(0.3, 1.0) * (0.5 + game_sense_effective / 200.0)
+        flank_awareness_score = self.rng.uniform(0.2, 1.0) * (0.5 + game_sense_effective / 200.0)
+        info_advantage_score = self.rng.uniform(0.0, 1.0)
+        position_optimality = self.rng.uniform(0.3, 1.0) * (0.5 + game_sense_effective / 200.0)
+        
+        if has_wallhack:
+            check_pattern_efficiency = min(1.0, check_pattern_efficiency * 1.3)
+            rotation_timing_vs_enemy = min(1.0, rotation_timing_vs_enemy * 1.2)
+            flank_awareness_score = min(1.0, flank_awareness_score * 1.4)
+        
+        # 3. Generate trajectory
+        # Start and target angles
+        start_angle = np.array([
+            self.rng.uniform(-30.0, 30.0),
+            self.rng.uniform(-20.0, 20.0),
+        ])
+        target_angle = np.array([
+            self.rng.uniform(-5.0, 5.0),
+            self.rng.uniform(-3.0, 3.0),
+        ])
+        
+        # Movement time based on Fitts' law and skill
+        target_width = 3.0 if weapon_type == WEAPON_TYPES["awp"] else 8.0  # Hitbox size in degrees
+        distance = np.linalg.norm(target_angle - start_angle)
+        
+        base_movement_time = fitts_law_time(distance, target_width, a=0.1, b=0.15)
+        skill_factor = (100.0 - skills.raw_aim) / 100.0  # Lower skill = longer time
+        movement_time_s = base_movement_time * (1.0 + skill_factor * 0.5) * modifiers.get("reaction_time_mult", 1.0)
+        movement_time_ms = movement_time_s * 1000.0
+        
+        # Generate human trajectory
+        trajectory = generate_human_trajectory(
+            start_angle=start_angle,
+            target_angle=target_angle,
+            skill_aim=skills.raw_aim,
+            skill_consistency=skills.consistency,
+            duration_ms=movement_time_ms,
+            tick_rate=128,
+            rng=self.rng,
+        )
+        
+        # 4. Apply aimbot modification if active
+        has_aimbot = (
+            cheat_behavior is not None and
+            CheatType.AIMBOT in cheat_behavior.config.cheat_types
+        )
+        
+        if has_aimbot:
+            n_ticks = len(trajectory)
+            # Target positions (enemy moves slightly)
+            target_positions = np.tile(target_angle, (n_ticks, 1))
+            target_positions += self.rng.normal(0, 0.5, (n_ticks, 2))  # Small enemy movement
+            
+            trajectory = generate_aimbot_trajectory(
+                natural_trajectory=trajectory,
+                target_positions=target_positions,
+                intensity=cheat_behavior.config.intensity,
+                humanization=cheat_behavior.config.humanization,
+                rng=self.rng,
+            )
+        
+        # 5. Extract trajectory features
+        trajectory_features = extract_extended_trajectory_features(trajectory)
+        
+        # 6. Compute timing features
+        rt_low, rt_high = rank_stats["reaction_time_ms"]
+        base_reaction_time = self.rng.uniform(rt_low, rt_high)
+        
+        # Apply session modifiers
+        reaction_time_ms = base_reaction_time * modifiers.get("reaction_time_mult", 1.0) * modifiers.get("focus_reaction_mult", 1.0)
+        
+        # Aimbot affects reaction time (but adds artificial delay for humanization)
+        if has_aimbot:
+            cheat_delay = cheat_behavior.config.humanization.get("reaction_delay_ms", 0.0)
+            reaction_time_ms = max(50.0, reaction_time_ms * 0.7 + cheat_delay)
+        
+        # Triggerbot affects time to first shot
+        has_triggerbot = (
+            cheat_behavior is not None and
+            CheatType.TRIGGERBOT in cheat_behavior.config.cheat_types
+        )
+        
+        time_to_first_shot_ms = reaction_time_ms + movement_time_ms * 0.5
+        if has_triggerbot:
+            # Triggerbot fires instantly when crosshair is on target
+            time_to_first_shot_ms *= 0.6  # Suspiciously fast
+        
+        time_to_damage_ms = time_to_first_shot_ms + self.rng.uniform(0, 100)
+        time_to_kill_ms = time_to_damage_ms + self.rng.uniform(100, 500)
+        
+        shot_timing_variance = self.rng.uniform(10.0, 50.0) * (1.0 - skills.consistency / 150.0)
+        if has_triggerbot:
+            shot_timing_variance *= 0.3  # Too consistent
+        
+        inter_shot_interval_mean = 100.0 + self.rng.uniform(-20, 50)  # ms
+        inter_shot_interval_cv = self.rng.uniform(0.1, 0.4) * (1.0 - skills.consistency / 150.0)
+        
+        crosshair_on_enemy_to_shot_ms = self.rng.uniform(50, 200) * (1.0 - skills.reaction_speed / 150.0)
+        if has_triggerbot:
+            crosshair_on_enemy_to_shot_ms = self.rng.uniform(5, 30)  # Inhuman speed
+        
+        anticipatory_shot_rate = 0.02 + skills.game_sense / 1000.0
+        if prefire_indicator:
+            anticipatory_shot_rate += 0.1
+        
+        perfect_timing_rate = skills.consistency / 200.0
+        if has_triggerbot:
+            perfect_timing_rate = min(1.0, perfect_timing_rate * 2.0)
+        
+        # 7. Compute accuracy features
+        base_accuracy = self.rng.uniform(*rank_stats["accuracy"])
+        accuracy = base_accuracy * modifiers.get("accuracy_mult", 1.0)
+        
+        if has_aimbot:
+            # Aimbot improves accuracy but may intentionally miss
+            if cheat_behavior.should_miss_intentionally(self.rng):
+                accuracy *= 0.5
+            else:
+                accuracy = min(1.0, accuracy + 0.3 * cheat_behavior.config.intensity)
+        
+        shots_fired = int(self.rng.integers(3, 15))
+        shots_hit = int(np.clip(shots_fired * accuracy * self.rng.uniform(0.8, 1.2), 0, shots_fired))
+        
+        hs_low, hs_high = rank_stats["hs_percent"]
+        hs_rate = self.rng.uniform(hs_low, hs_high)
+        if has_aimbot:
+            hs_rate = min(1.0, hs_rate + 0.2 * cheat_behavior.config.intensity)
+        
+        headshots = int(np.clip(shots_hit * hs_rate, 0, shots_hit))
+        
+        damage_per_hit = 25.0 + headshots * 75.0 / max(1, shots_hit)  # Headshots do more damage
+        damage_dealt = shots_hit * damage_per_hit
+        
+        spray_accuracy = accuracy * self.rng.uniform(0.6, 1.0) * (0.5 + skills.spray_control / 200.0)
+        first_bullet_accuracy = accuracy * self.rng.uniform(0.8, 1.2) * (0.5 + skills.crosshair_placement / 200.0)
+        
+        headshot_rate = headshots / max(1, shots_hit)
+        damage_efficiency = damage_dealt / max(1, shots_fired * 100.0)
+        
+        kill_secured = damage_dealt >= enemy_health
+        
+        return EngagementData(
+            # Context features
+            enemy_distance=enemy_distance,
+            enemy_velocity=enemy_velocity,
+            player_velocity=player_velocity,
+            player_health=player_health,
+            enemy_health=enemy_health,
+            weapon_type=weapon_type,
+            is_scoped=is_scoped,
+            is_crouched=is_crouched,
+            round_time_remaining=round_time_remaining,
+            score_differential=score_differential,
+            is_clutch=is_clutch,
+            enemies_alive=enemies_alive,
+            # Pre-engagement features
+            crosshair_angle_to_hidden_enemy=crosshair_angle_to_hidden,
+            time_tracking_hidden_ms=time_tracking_hidden,
+            prefire_indicator=prefire_indicator,
+            check_pattern_efficiency=check_pattern_efficiency,
+            rotation_timing_vs_enemy=rotation_timing_vs_enemy,
+            flank_awareness_score=flank_awareness_score,
+            info_advantage_score=info_advantage_score,
+            position_optimality=position_optimality,
+            # Trajectory features
+            trajectory_features=trajectory_features,
+            # Timing features
+            reaction_time_ms=reaction_time_ms,
+            time_to_first_shot_ms=time_to_first_shot_ms,
+            time_to_damage_ms=time_to_damage_ms,
+            time_to_kill_ms=time_to_kill_ms,
+            shot_timing_variance=shot_timing_variance,
+            inter_shot_interval_mean=inter_shot_interval_mean,
+            inter_shot_interval_cv=inter_shot_interval_cv,
+            crosshair_on_enemy_to_shot_ms=crosshair_on_enemy_to_shot_ms,
+            anticipatory_shot_rate=anticipatory_shot_rate,
+            perfect_timing_rate=perfect_timing_rate,
+            # Accuracy features
+            shots_fired=shots_fired,
+            shots_hit=shots_hit,
+            headshots=headshots,
+            damage_dealt=damage_dealt,
+            spray_accuracy=spray_accuracy,
+            first_bullet_accuracy=first_bullet_accuracy,
+            headshot_rate=headshot_rate,
+            damage_efficiency=damage_efficiency,
+            kill_secured=kill_secured,
+        )
+        
+    def generate_batch(
+        self,
+        num_legit: int,
+        num_cheaters: int,
+        cheater_distribution: Optional[Dict[str, float]] = None,
+    ) -> List[PlayerSession]:
+        """Generate batch of player sessions."""
+        if cheater_distribution is None:
+            # Default distribution across cheat profiles
+            cheater_distribution = {
+                "blatant_rage": 0.1,
+                "obvious": 0.2,
+                "closet_moderate": 0.3,
+                "closet_subtle": 0.3,
+                "wallhack_only": 0.1,
+            }
+        
+        sessions: List[PlayerSession] = []
+        
+        # Generate legit players
+        for _ in range(num_legit):
+            sessions.append(self.generate_player(is_cheater=False))
+        
+        # Generate cheaters with distribution
+        cheat_profiles = list(cheater_distribution.keys())
+        cheat_probs = list(cheater_distribution.values())
+        
+        for _ in range(num_cheaters):
+            profile = self.rng.choice(cheat_profiles, p=cheat_probs)
+            sessions.append(self.generate_player(is_cheater=True, cheat_profile=profile))
+        
+        # Shuffle
+        self.rng.shuffle(sessions)
+        
+        return sessions
+        
+    def generate_stream(
+        self,
+        num_legit: int,
+        num_cheaters: int,
+    ) -> Iterator[PlayerSession]:
+        """Memory-efficient streaming generator."""
+        total = num_legit + num_cheaters
+        
+        # Create shuffled indices for legit vs cheater
+        is_cheater_flags = [False] * num_legit + [True] * num_cheaters
+        self.rng.shuffle(is_cheater_flags)
+        
+        for is_cheater in is_cheater_flags:
+            yield self.generate_player(is_cheater=is_cheater)

src/manifold/data/profiles.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any, Tuple
+from enum import Enum
+
+
+# Skill correlation matrix - represents realistic correlations between player skills
+# Rows/cols: raw_aim, spray_control, crosshair_placement, reaction_speed, game_sense, movement, consistency, mental_resilience
+SKILL_CORRELATION_MATRIX = np.array([
+    # aim   spray cross react sense  move  cons  mental
+    [1.00, 0.70, 0.50, 0.30, 0.20, 0.40, 0.30, 0.10],  # raw_aim
+    [0.70, 1.00, 0.40, 0.20, 0.30, 0.30, 0.40, 0.10],  # spray_control
+    [0.50, 0.40, 1.00, 0.20, 0.60, 0.50, 0.50, 0.20],  # crosshair_placement
+    [0.30, 0.20, 0.20, 1.00, 0.30, 0.40, 0.20, 0.30],  # reaction_speed
+    [0.20, 0.30, 0.60, 0.30, 1.00, 0.50, 0.40, 0.40],  # game_sense
+    [0.40, 0.30, 0.50, 0.40, 0.50, 1.00, 0.30, 0.20],  # movement
+    [0.30, 0.40, 0.50, 0.20, 0.40, 0.30, 1.00, 0.50],  # consistency
+    [0.10, 0.10, 0.20, 0.30, 0.40, 0.20, 0.50, 1.00],  # mental_resilience
+])
+
+SKILL_STD = np.array([15.0, 15.0, 15.0, 12.0, 15.0, 12.0, 18.0, 20.0])
+SKILL_NAMES = ["raw_aim", "spray_control", "crosshair_placement", "reaction_speed", 
+               "game_sense", "movement", "consistency", "mental_resilience"]
+
+
+class Rank(Enum):
+    SILVER = "silver"
+    GOLD_NOVA = "gold_nova"
+    MASTER_GUARDIAN = "master_guardian"
+    LEGENDARY_EAGLE = "legendary_eagle"
+    SUPREME_GLOBAL = "supreme_global"
+    PRO = "pro"
+
+
+RANK_STATISTICS = {
+    Rank.SILVER: {
+        "skill_mean": 25.0,
+        "hs_percent": (0.25, 0.35),
+        "accuracy": (0.06, 0.08),
+        "reaction_time_ms": (280.0, 350.0),
+        "kd_ratio": (0.5, 0.85),
+        "adr": (35.0, 55.0),
+        "edpi": (1200, 2400),
+        "hours_played": (0, 300),
+    },
+    Rank.GOLD_NOVA: {
+        "skill_mean": 40.0,
+        "hs_percent": (0.35, 0.42),
+        "accuracy": (0.08, 0.10),
+        "reaction_time_ms": (250.0, 290.0),
+        "kd_ratio": (0.85, 1.1),
+        "adr": (50.0, 70.0),
+        "edpi": (1000, 1800),
+        "hours_played": (200, 600),
+    },
+    Rank.MASTER_GUARDIAN: {
+        "skill_mean": 55.0,
+        "hs_percent": (0.40, 0.48),
+        "accuracy": (0.10, 0.12),
+        "reaction_time_ms": (220.0, 260.0),
+        "kd_ratio": (1.0, 1.2),
+        "adr": (60.0, 80.0),
+        "edpi": (800, 1400),
+        "hours_played": (400, 1200),
+    },
+    Rank.LEGENDARY_EAGLE: {
+        "skill_mean": 70.0,
+        "hs_percent": (0.45, 0.52),
+        "accuracy": (0.12, 0.14),
+        "reaction_time_ms": (200.0, 240.0),
+        "kd_ratio": (1.15, 1.35),
+        "adr": (70.0, 90.0),
+        "edpi": (700, 1200),
+        "hours_played": (800, 2000),
+    },
+    Rank.SUPREME_GLOBAL: {
+        "skill_mean": 82.0,
+        "hs_percent": (0.48, 0.55),
+        "accuracy": (0.14, 0.16),
+        "reaction_time_ms": (180.0, 220.0),
+        "kd_ratio": (1.25, 1.5),
+        "adr": (75.0, 95.0),
+        "edpi": (600, 1100),
+        "hours_played": (1200, 3500),
+    },
+    Rank.PRO: {
+        "skill_mean": 92.0,
+        "hs_percent": (0.55, 0.66),
+        "accuracy": (0.17, 0.20),
+        "reaction_time_ms": (140.0, 180.0),
+        "kd_ratio": (1.3, 2.0),
+        "adr": (85.0, 110.0),
+        "edpi": (550, 1000),
+        "hours_played": (3000, 10000),
+    },
+}
+
+
+@dataclass
+class SkillVector:
+    """8-dimensional skill vector with realistic correlations."""
+    raw_aim: float
+    spray_control: float
+    crosshair_placement: float
+    reaction_speed: float
+    game_sense: float
+    movement: float
+    consistency: float
+    mental_resilience: float
+    
+    def to_array(self) -> np.ndarray:
+        return np.array([
+            self.raw_aim, self.spray_control, self.crosshair_placement,
+            self.reaction_speed, self.game_sense, self.movement,
+            self.consistency, self.mental_resilience
+        ])
+    
+    @classmethod
+    def from_array(cls, arr: np.ndarray) -> SkillVector:
+        return cls(*arr.tolist())
+    
+    @property
+    def mean_skill(self) -> float:
+        return float(self.to_array().mean())
+
+
+def generate_correlated_skills(
+    rank: Rank,
+    rng: Optional[np.random.Generator] = None
+) -> np.ndarray:
+    """Generate correlated skill vector using Cholesky decomposition."""
+    if rng is None:
+        rng = np.random.default_rng()
+    
+    stats = RANK_STATISTICS[rank]
+    skill_mean = stats["skill_mean"]
+    
+    # Create covariance matrix from correlation and std
+    cov = np.outer(SKILL_STD, SKILL_STD) * SKILL_CORRELATION_MATRIX
+    
+    # Cholesky decomposition for correlated sampling
+    L = np.linalg.cholesky(cov)
+    
+    # Generate uncorrelated standard normal
+    z = rng.standard_normal(8)
+    
+    # Transform to correlated with correct mean/cov
+    skills = skill_mean + L @ z
+    
+    # Clip to valid range [0, 100]
+    skills = np.clip(skills, 0.0, 100.0)
+    
+    return skills
+
+
+@dataclass
+class PlayerProfile:
+    """Complete player profile with skill and metadata."""
+    profile_id: str
+    rank: Rank
+    skill_vector: SkillVector
+    hours_played: int
+    is_cheater: bool = False
+    
+    @classmethod
+    def generate(
+        cls,
+        rank: str | Rank,
+        seed: Optional[int] = None,
+        profile_id: Optional[str] = None,
+    ) -> PlayerProfile:
+        """Generate a random player profile for given rank."""
+        if isinstance(rank, str):
+            rank = Rank(rank)
+        
+        rng = np.random.default_rng(seed)
+        
+        # Generate correlated skills
+        skills = generate_correlated_skills(rank, rng)
+        skill_vector = SkillVector.from_array(skills)
+        
+        # Generate hours played
+        stats = RANK_STATISTICS[rank]
+        hours_low, hours_high = stats["hours_played"]
+        hours_played = int(rng.uniform(hours_low, hours_high))
+        
+        # Generate profile ID if not provided
+        if profile_id is None:
+            profile_id = f"player_{rng.integers(0, 2**32):08x}"
+        
+        return cls(
+            profile_id=profile_id,
+            rank=rank,
+            skill_vector=skill_vector,
+            hours_played=hours_played,
+            is_cheater=False,
+        )
+    
+    def get_expected_stats(self) -> Dict[str, Tuple[float, float]]:
+        """Get expected stat ranges based on rank and skill."""
+        return RANK_STATISTICS[self.rank].copy()

src/manifold/data/temporal.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class SessionState:
+    """
+    Tracks player state over a session.
+    Models fatigue, tilt, and focus using Ornstein-Uhlenbeck processes.
+    """
+    fatigue: float = 0.0      # 0 = fresh, 1 = exhausted
+    tilt: float = 0.0         # -1 = tilted, 0 = neutral, 1 = confident
+    focus: float = 1.0        # 0 = distracted, 1 = locked in
+    time_elapsed_ms: float = 0.0
+    
+    def to_dict(self) -> Dict[str, float]:
+        return {
+            "fatigue": self.fatigue,
+            "tilt": self.tilt,
+            "focus": self.focus,
+            "time_elapsed_ms": self.time_elapsed_ms,
+        }
+    
+    @classmethod
+    def from_dict(cls, d: Dict[str, float]) -> SessionState:
+        return cls(
+            fatigue=d.get("fatigue", 0.0),
+            tilt=d.get("tilt", 0.0),
+            focus=d.get("focus", 1.0),
+            time_elapsed_ms=d.get("time_elapsed_ms", 0.0),
+        )
+
+
+@dataclass
+class SessionSimulator:
+    """
+    Simulates player state evolution over a gaming session.
+    
+    Uses Ornstein-Uhlenbeck processes for realistic temporal dynamics:
+    - Fatigue: Slowly increases, slowly recovers
+    - Tilt: Affected by wins/losses, mean-reverts
+    - Focus: Affected by round importance
+    """
+    # OU process parameters
+    fatigue_reversion: float = 0.001   # Slow recovery
+    fatigue_drift: float = 0.0001      # Gradual increase
+    fatigue_volatility: float = 0.001
+    
+    tilt_reversion: float = 0.01       # Faster emotional recovery
+    tilt_volatility: float = 0.01
+    
+    focus_reversion: float = 0.005
+    focus_volatility: float = 0.005
+    
+    # Mental resilience affects tilt response (0-100)
+    mental_resilience: float = 50.0
+    
+    # Current state
+    state: SessionState = field(default_factory=SessionState)
+    
+    # Random generator
+    _rng: Optional[np.random.Generator] = field(default=None, repr=False)
+    
+    def __post_init__(self):
+        if self._rng is None:
+            self._rng = np.random.default_rng()
+    
+    @classmethod
+    def from_skill(
+        cls,
+        mental_resilience: float = 50.0,
+        seed: Optional[int] = None,
+    ) -> SessionSimulator:
+        """Create simulator with skill-based parameters."""
+        return cls(
+            mental_resilience=mental_resilience,
+            _rng=np.random.default_rng(seed),
+        )
+    
+    def update(self, event: str, dt_ms: float) -> None:
+        """
+        Update session state based on game event.
+        
+        Args:
+            event: One of "round_win", "round_loss", "kill", "death", 
+                   "clutch_situation", "idle"
+            dt_ms: Time elapsed in milliseconds
+        """
+        self.state.time_elapsed_ms += dt_ms
+        
+        # Fatigue: OU process with drift (slowly increases)
+        # dF = θ(0 - F)dt + drift*dt + σ*dW
+        fatigue_noise = self._rng.normal(0, self.fatigue_volatility * np.sqrt(dt_ms))
+        self.state.fatigue += (
+            self.fatigue_reversion * (0 - self.state.fatigue) * dt_ms +
+            self.fatigue_drift * dt_ms +
+            fatigue_noise
+        )
+        self.state.fatigue = np.clip(self.state.fatigue, 0.0, 1.0)
+        
+        # Tilt: affected by outcomes
+        tilt_impact = 0.0
+        if event == "round_loss":
+            # More impact if low mental resilience
+            tilt_impact = -0.1 * (1.0 - self.mental_resilience / 100.0)
+        elif event == "round_win":
+            tilt_impact = 0.05
+        elif event == "death":
+            tilt_impact = -0.02 * (1.0 - self.mental_resilience / 100.0)
+        elif event == "kill":
+            tilt_impact = 0.01
+        
+        self.state.tilt += tilt_impact
+        
+        # Tilt mean reversion (OU process)
+        tilt_noise = self._rng.normal(0, self.tilt_volatility * np.sqrt(dt_ms))
+        self.state.tilt += (
+            self.tilt_reversion * (0 - self.state.tilt) * dt_ms +
+            tilt_noise
+        )
+        self.state.tilt = np.clip(self.state.tilt, -1.0, 1.0)
+        
+        # Focus: affected by round importance
+        if event == "clutch_situation":
+            # Focus increases in clutch (if mentally strong)
+            focus_boost = 0.2 * (0.5 + self.mental_resilience / 200.0)
+            self.state.focus = min(1.0, self.state.focus + focus_boost)
+        
+        # Focus mean reversion
+        focus_noise = self._rng.normal(0, self.focus_volatility * np.sqrt(dt_ms))
+        self.state.focus += (
+            self.focus_reversion * (1.0 - self.state.focus) * dt_ms +
+            focus_noise
+        )
+        self.state.focus = np.clip(self.state.focus, 0.0, 1.0)
+    
+    def get_modifiers(self) -> Dict[str, float]:
+        """
+        Get performance modifiers based on current state.
+        
+        Returns:
+            Dict with multipliers for different stats
+        """
+        return {
+            # Fatigue slows reactions and reduces accuracy
+            "reaction_time_mult": 1.0 + self.state.fatigue * 0.2,  # Up to 20% slower
+            "accuracy_mult": 1.0 - self.state.fatigue * 0.15,      # Up to 15% less accurate
+            
+            # Tilt affects consistency
+            "consistency_mult": (
+                1.0 - abs(self.state.tilt) * 0.3 if self.state.tilt < 0 
+                else 1.0 + self.state.tilt * 0.1
+            ),
+            
+            # Tilt affects game sense when negative
+            "game_sense_mult": 1.0 - max(0, -self.state.tilt) * 0.2,
+            
+            # Focus improves reaction time
+            "focus_reaction_mult": 1.0 - (self.state.focus - 0.5) * 0.1,
+        }
+    
+    def apply_to_stats(self, base_stats: Dict[str, float]) -> Dict[str, float]:
+        """
+        Apply session modifiers to base stats.
+        
+        Args:
+            base_stats: Dict with keys like "reaction_time", "accuracy", etc.
+            
+        Returns:
+            Modified stats dict
+        """
+        mods = self.get_modifiers()
+        modified = base_stats.copy()
+        
+        if "reaction_time" in modified:
+            modified["reaction_time"] *= mods["reaction_time_mult"] * mods["focus_reaction_mult"]
+        
+        if "accuracy" in modified:
+            modified["accuracy"] *= mods["accuracy_mult"]
+        
+        if "consistency" in modified:
+            modified["consistency"] *= mods["consistency_mult"]
+        
+        if "game_sense" in modified:
+            modified["game_sense"] *= mods["game_sense_mult"]
+        
+        return modified
+    
+    def reset(self) -> None:
+        """Reset session state to fresh."""
+        self.state = SessionState()
+
+
+def simulate_round_sequence(
+    n_rounds: int,
+    win_probability: float = 0.5,
+    seed: Optional[int] = None,
+) -> list[str]:
+    """
+    Simulate a sequence of round outcomes.
+    
+    Args:
+        n_rounds: Number of rounds
+        win_probability: Base probability of winning each round
+        seed: Random seed
+        
+    Returns:
+        List of events ("round_win" or "round_loss")
+    """
+    rng = np.random.default_rng(seed)
+    events = []
+    
+    for _ in range(n_rounds):
+        if rng.random() < win_probability:
+            events.append("round_win")
+        else:
+            events.append("round_loss")
+    
+    return events
+
+
+def generate_session_trace(
+    n_rounds: int = 24,
+    mental_resilience: float = 50.0,
+    win_probability: float = 0.5,
+    round_duration_ms: float = 90000.0,  # 1.5 minutes per round
+    seed: Optional[int] = None,
+) -> list[Dict[str, Any]]:
+    """
+    Generate complete session trace with states at each round.
+    
+    Args:
+        n_rounds: Number of rounds
+        mental_resilience: Player's mental resilience (0-100)
+        win_probability: Base win probability
+        round_duration_ms: Average round duration
+        seed: Random seed
+        
+    Returns:
+        List of dicts with round number, event, state, and modifiers
+    """
+    rng = np.random.default_rng(seed)
+    sim = SessionSimulator.from_skill(mental_resilience, seed)
+    
+    events = simulate_round_sequence(n_rounds, win_probability, seed)
+    trace = []
+    
+    for round_num, event in enumerate(events):
+        # Add some kills/deaths during round
+        n_kills = rng.poisson(1.0)
+        n_deaths = rng.poisson(0.5)
+        
+        for _ in range(n_kills):
+            sim.update("kill", round_duration_ms / (n_kills + n_deaths + 1))
+        for _ in range(n_deaths):
+            sim.update("death", round_duration_ms / (n_kills + n_deaths + 1))
+        
+        # Round outcome
+        sim.update(event, round_duration_ms / 3)
+        
+        trace.append({
+            "round": round_num,
+            "event": event,
+            "state": sim.state.to_dict(),
+            "modifiers": sim.get_modifiers(),
+        })
+    
+    return trace

src/manifold/data/trajectories.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+import numpy as np
+from dataclasses import dataclass
+from typing import Optional, Tuple
+
+
+def minimum_jerk(t: np.ndarray) -> np.ndarray:
+    """
+    Minimum jerk trajectory (5th order polynomial).
+    
+    This is the optimal trajectory that minimizes jerk (rate of change of acceleration).
+    Human movements closely follow this profile.
+    
+    Args:
+        t: Normalized time array [0, 1]
+        
+    Returns:
+        Normalized position [0, 1]
+    """
+    # 5th order polynomial: 10t³ - 15t⁴ + 6t⁵
+    return 10.0 * t**3 - 15.0 * t**4 + 6.0 * t**5
+
+
+def signal_dependent_noise(
+    velocity: np.ndarray,
+    k: float = 0.1,
+    rng: Optional[np.random.Generator] = None,
+) -> np.ndarray:
+    """
+    Signal-dependent noise following Harris-Wolpert model.
+    
+    Noise variance scales with signal magnitude (Weber's law).
+    This is a fundamental property of human motor control.
+    
+    Args:
+        velocity: Velocity array
+        k: Noise coefficient (higher = noisier)
+        rng: Random generator
+        
+    Returns:
+        Noise array with signal-dependent variance
+    """
+    if rng is None:
+        rng = np.random.default_rng()
+    
+    std = k * np.abs(velocity)
+    return rng.normal(0, std + 1e-8)  # Small epsilon for stability
+
+
+def generate_micro_corrections(
+    n_ticks: int,
+    frequency: float = 5.0,
+    amplitude: float = 0.02,
+    rng: Optional[np.random.Generator] = None,
+) -> np.ndarray:
+    """
+    Generate micro-corrections that humans make during aiming.
+    
+    These are small corrective movements with quasi-periodic timing.
+    
+    Args:
+        n_ticks: Number of time ticks
+        frequency: Average number of corrections per trajectory
+        amplitude: Maximum correction amplitude (degrees)
+        rng: Random generator
+        
+    Returns:
+        Array of shape [n_ticks, 2] with x,y corrections
+    """
+    if rng is None:
+        rng = np.random.default_rng()
+    
+    corrections = np.zeros((n_ticks, 2))
+    
+    if frequency <= 0 or n_ticks < 2:
+        return corrections
+    
+    # Generate correction times using exponential intervals
+    mean_interval = n_ticks / frequency
+    current_tick = 0
+    
+    while current_tick < n_ticks:
+        interval = int(rng.exponential(mean_interval))
+        current_tick += max(1, interval)
+        
+        if current_tick < n_ticks:
+            # Small correction impulse
+            amp = rng.exponential(amplitude)
+            direction = rng.uniform(0, 2 * np.pi)
+            corrections[current_tick, 0] = amp * np.cos(direction)
+            corrections[current_tick, 1] = amp * np.sin(direction)
+    
+    # Smooth corrections (they're not instant) using simple moving average
+    kernel_size = min(5, n_ticks // 2)
+    if kernel_size > 1:
+        kernel = np.ones(kernel_size) / kernel_size
+        for i in range(2):
+            corrections[:, i] = np.convolve(corrections[:, i], kernel, mode='same')
+    
+    return corrections
+
+
+def generate_human_trajectory(
+    start_angle: np.ndarray,
+    target_angle: np.ndarray,
+    skill_aim: float,
+    skill_consistency: float,
+    duration_ms: float,
+    tick_rate: int = 128,
+    rng: Optional[np.random.Generator] = None,
+) -> np.ndarray:
+    """
+    Generate realistic human mouse trajectory using minimum jerk principle
+    with signal-dependent noise and micro-corrections.
+    
+    Args:
+        start_angle: Starting crosshair angle [x, y] in degrees
+        target_angle: Target angle [x, y] in degrees
+        skill_aim: Aim skill (0-100)
+        skill_consistency: Consistency skill (0-100)
+        duration_ms: Movement duration in milliseconds
+        tick_rate: Ticks per second (CS2 uses 128)
+        rng: Random generator
+        
+    Returns:
+        Array of shape [n_ticks-1, 2] with delta (dx, dy) per tick
+    """
+    if rng is None:
+        rng = np.random.default_rng()
+    
+    start_angle = np.asarray(start_angle, dtype=np.float64)
+    target_angle = np.asarray(target_angle, dtype=np.float64)
+    
+    n_ticks = max(2, int(duration_ms * tick_rate / 1000))
+    t = np.linspace(0, 1, n_ticks)
+    
+    # Minimum jerk profile
+    s = minimum_jerk(t)
+    
+    # Planned trajectory
+    displacement = target_angle - start_angle
+    planned = start_angle[:, None] + displacement[:, None] * s  # [2, n_ticks]
+    
+    # Velocity for signal-dependent noise (derivative of position)
+    velocity = np.gradient(s) * np.linalg.norm(displacement)
+    
+    # Signal-dependent noise (Harris-Wolpert model)
+    # Noise scale inversely proportional to skill
+    noise_scale = (1.0 - skill_aim / 150.0) * 0.1  # 0.033 - 0.1 degrees
+    noise_x = signal_dependent_noise(velocity, noise_scale, rng)
+    noise_y = signal_dependent_noise(velocity, noise_scale, rng)
+    noise = np.stack([noise_x, noise_y], axis=0)  # [2, n_ticks]
+    
+    # Micro-corrections (human feedback control)
+    correction_frequency = 3.0 + skill_consistency / 20.0  # 3-8 corrections
+    correction_amplitude = 0.02 * (1.0 - skill_aim / 100.0)  # Less corrections for skilled
+    corrections = generate_micro_corrections(n_ticks, correction_frequency, correction_amplitude, rng)
+    
+    # Combine: planned + noise + corrections
+    actual = planned + noise + corrections.T
+    
+    # Convert to deltas
+    deltas = np.diff(actual, axis=1).T  # [n_ticks-1, 2]
+    
+    return deltas
+
+
+def generate_aimbot_trajectory(
+    natural_trajectory: np.ndarray,
+    target_positions: np.ndarray,
+    intensity: float,
+    humanization: dict,
+    rng: Optional[np.random.Generator] = None,
+) -> np.ndarray:
+    """
+    Modify natural trajectory with aimbot assistance.
+    
+    Even with humanization, leaves detectable artifacts:
+    - Too smooth (lacks human micro-corrections)
+    - Noise is too uniform
+    - Delay is too consistent
+    
+    Args:
+        natural_trajectory: Human trajectory [n_ticks, 2]
+        target_positions: Target angle at each tick [n_ticks, 2]
+        intensity: Cheat intensity (0-1)
+        humanization: Dict with aim_smoothing, noise_amplitude, fov_degrees
+        rng: Random generator
+        
+    Returns:
+        Modified trajectory [n_ticks, 2]
+    """
+    if rng is None:
+        rng = np.random.default_rng()
+    
+    modified = natural_trajectory.copy()
+    n_ticks = len(modified)
+    
+    # Cumulative positions from deltas
+    positions = np.zeros((n_ticks + 1, 2))
+    positions[1:] = np.cumsum(modified, axis=0)
+    
+    fov_limit = humanization.get("fov_degrees", 90.0)
+    smoothing = humanization.get("aim_smoothing", 0.5)
+    noise_amp = humanization.get("noise_amplitude", 0.0)
+    
+    for i in range(n_ticks):
+        current_pos = positions[i]
+        target_pos = target_positions[i]
+        correction_needed = target_pos - current_pos
+        distance = np.linalg.norm(correction_needed)
+        
+        if distance < fov_limit:
+            # Apply aimbot correction
+            if smoothing > 0:
+                # Humanized: exponential approach (ARTIFACT: too smooth)
+                correction = correction_needed * (1.0 - smoothing) * intensity
+            else:
+                # Blatant: instant (ARTIFACT: infinite jerk)
+                correction = correction_needed * intensity
+            
+            # Add humanization noise (ARTIFACT: noise is too uniform)
+            if noise_amp > 0:
+                correction += rng.normal(0, noise_amp, 2)
+            
+            modified[i] += correction
+            
+            # Update subsequent positions
+            positions[i+1:] += correction
+    
+    return modified
+
+
+def fitts_law_time(
+    distance: float,
+    target_width: float,
+    a: float = 0.0,
+    b: float = 0.1,
+) -> float:
+    """
+    Calculate movement time using Fitts' Law.
+    
+    MT = a + b * log2(2D/W)
+    
+    Args:
+        distance: Distance to target
+        target_width: Width of target
+        a: Intercept (reaction time offset)
+        b: Slope (movement time per bit)
+        
+    Returns:
+        Movement time in seconds
+    """
+    if target_width <= 0:
+        target_width = 1e-6
+    
+    index_of_difficulty = np.log2(2.0 * distance / target_width + 1.0)
+    return a + b * index_of_difficulty
+
+
+def extract_trajectory_features(trajectory: np.ndarray) -> dict:
+    """
+    Extract features from trajectory for cheat detection.
+    
+    Args:
+        trajectory: Delta trajectory [n_ticks, 2]
+        
+    Returns:
+        Dict of extracted features
+    """
+    if len(trajectory) < 3:
+        return {
+            "max_jerk": 0.0,
+            "mean_jerk": 0.0,
+            "jerk_variance": 0.0,
+            "path_efficiency": 1.0,
+            "velocity_peak_timing": 0.5,
+        }
+    
+    # Compute velocity and acceleration
+    velocity = np.linalg.norm(trajectory, axis=1)
+    acceleration = np.diff(velocity)
+    jerk = np.diff(acceleration) if len(acceleration) > 1 else np.array([0.0])
+    
+    # Jerk statistics
+    max_jerk = float(np.max(np.abs(jerk))) if len(jerk) > 0 else 0.0
+    mean_jerk = float(np.mean(np.abs(jerk))) if len(jerk) > 0 else 0.0
+    jerk_variance = float(np.var(jerk)) if len(jerk) > 0 else 0.0
+    
+    # Path efficiency (actual distance / direct distance)
+    total_distance = np.sum(velocity)
+    direct_distance = np.linalg.norm(np.sum(trajectory, axis=0))
+    path_efficiency = direct_distance / (total_distance + 1e-8)
+    
+    # Velocity peak timing (should be ~0.5 for bell-shaped profile)
+    if len(velocity) > 0:
+        peak_idx = np.argmax(velocity)
+        velocity_peak_timing = peak_idx / len(velocity)
+    else:
+        velocity_peak_timing = 0.5
+    
+    return {
+        "max_jerk": max_jerk,
+        "mean_jerk": mean_jerk,
+        "jerk_variance": jerk_variance,
+        "path_efficiency": path_efficiency,
+        "velocity_peak_timing": velocity_peak_timing,
+    }

src/manifold/evaluation/__init__.py

@@ -0,0 +1,16 @@
+from manifold.evaluation.metrics import CheatDetectionMetrics, compute_ece
+from manifold.evaluation.analysis import (
+    PredictionAnalysis,
+    analyze_predictions,
+    compute_feature_importance,
+    format_analysis_report,
+)
+
+__all__ = [
+    "CheatDetectionMetrics",
+    "compute_ece",
+    "PredictionAnalysis",
+    "analyze_predictions",
+    "compute_feature_importance",
+    "format_analysis_report",
+]

src/manifold/evaluation/analysis.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+import numpy as np
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass
+
+
+@dataclass
+class PredictionAnalysis:
+    """Analysis results for a set of predictions."""
+    total_samples: int
+    correct: int
+    incorrect: int
+    accuracy: float
+    
+    by_class: Dict[str, Dict[str, int]]  # {class: {correct, incorrect, total}}
+    by_uncertainty: Dict[str, Dict[str, float]]  # {low/medium/high: {accuracy, count}}
+    
+    high_confidence_errors: List[Dict[str, Any]]  # Samples with high confidence but wrong
+    low_confidence_correct: List[Dict[str, Any]]  # Samples with low confidence but correct
+
+
+def analyze_predictions(
+    predictions: np.ndarray,
+    labels: np.ndarray,
+    probabilities: Optional[np.ndarray] = None,
+    uncertainties: Optional[np.ndarray] = None,
+) -> PredictionAnalysis:
+    """Detailed analysis of model predictions."""
+    correct_mask = predictions == labels
+    
+    # Basic stats
+    total = len(predictions)
+    correct = correct_mask.sum()
+    incorrect = total - correct
+    accuracy = correct / total if total > 0 else 0
+    
+    # By class
+    by_class = {}
+    for c in [0, 1, 2]:
+        class_mask = labels == c
+        class_name = ["clean", "suspicious", "cheating"][c]
+        by_class[class_name] = {
+            "correct": int((correct_mask & class_mask).sum()),
+            "incorrect": int((~correct_mask & class_mask).sum()),
+            "total": int(class_mask.sum()),
+        }
+    
+    # By uncertainty (if available)
+    by_uncertainty = {}
+    if uncertainties is not None:
+        low_mask = uncertainties < 0.3
+        med_mask = (uncertainties >= 0.3) & (uncertainties < 0.7)
+        high_mask = uncertainties >= 0.7
+        
+        for name, mask in [("low", low_mask), ("medium", med_mask), ("high", high_mask)]:
+            if mask.sum() > 0:
+                by_uncertainty[name] = {
+                    "accuracy": float(correct_mask[mask].mean()),
+                    "count": int(mask.sum()),
+                }
+    
+    # Error analysis
+    high_conf_errors = []
+    low_conf_correct = []
+    
+    if probabilities is not None:
+        confidences = probabilities.max(axis=1)
+        
+        # High confidence errors
+        high_conf_wrong = (~correct_mask) & (confidences > 0.9)
+        for idx in np.where(high_conf_wrong)[0][:10]:  # Top 10
+            high_conf_errors.append({
+                "idx": int(idx),
+                "predicted": int(predictions[idx]),
+                "actual": int(labels[idx]),
+                "confidence": float(confidences[idx]),
+            })
+        
+        # Low confidence correct
+        low_conf_right = correct_mask & (confidences < 0.5)
+        for idx in np.where(low_conf_right)[0][:10]:
+            low_conf_correct.append({
+                "idx": int(idx),
+                "predicted": int(predictions[idx]),
+                "actual": int(labels[idx]),
+                "confidence": float(confidences[idx]),
+            })
+    
+    return PredictionAnalysis(
+        total_samples=total,
+        correct=int(correct),
+        incorrect=int(incorrect),
+        accuracy=accuracy,
+        by_class=by_class,
+        by_uncertainty=by_uncertainty,
+        high_confidence_errors=high_conf_errors,
+        low_confidence_correct=low_conf_correct,
+    )
+
+
+def compute_feature_importance(
+    model_outputs: Dict[str, np.ndarray],
+    method: str = "gradient",
+) -> Dict[str, float]:
+    """Compute feature importance from model outputs."""
+    # Placeholder - actual implementation would use gradients
+    return {"placeholder": 1.0}
+
+
+def format_analysis_report(analysis: PredictionAnalysis) -> str:
+    """Format analysis as readable report string."""
+    lines = [
+        "=" * 50,
+        "PREDICTION ANALYSIS REPORT",
+        "=" * 50,
+        f"Total Samples: {analysis.total_samples}",
+        f"Accuracy: {analysis.accuracy:.4f} ({analysis.correct}/{analysis.total_samples})",
+        "",
+        "By Class:",
+    ]
+    
+    for cls, stats in analysis.by_class.items():
+        acc = stats["correct"] / stats["total"] if stats["total"] > 0 else 0
+        lines.append(f"  {cls}: {acc:.4f} ({stats['correct']}/{stats['total']})")
+    
+    if analysis.by_uncertainty:
+        lines.append("")
+        lines.append("By Uncertainty:")
+        for level, stats in analysis.by_uncertainty.items():
+            lines.append(f"  {level}: acc={stats['accuracy']:.4f}, n={stats['count']}")
+    
+    if analysis.high_confidence_errors:
+        lines.append("")
+        lines.append(f"High Confidence Errors ({len(analysis.high_confidence_errors)}):")
+        for err in analysis.high_confidence_errors[:3]:
+            lines.append(f"  idx={err['idx']}: pred={err['predicted']}, "
+                        f"actual={err['actual']}, conf={err['confidence']:.3f}")
+    
+    lines.append("=" * 50)
+    return "\n".join(lines)

src/manifold/evaluation/metrics.py

@@ -0,0 +1,141 @@
+"""Detection metrics for cheat evaluation."""
+from __future__ import annotations
+
+import numpy as np
+from sklearn.metrics import (
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    roc_auc_score,
+    precision_recall_curve,
+    auc,
+    confusion_matrix,
+)
+from typing import Optional, Dict, Any, List
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CheatDetectionMetrics:
+    """Accumulator for cheat detection evaluation metrics."""
+
+    predictions: List[int] = field(default_factory=list)
+    labels: List[int] = field(default_factory=list)
+    probabilities: List[np.ndarray] = field(default_factory=list)
+    uncertainties: List[float] = field(default_factory=list)
+    cheat_types: List[str] = field(default_factory=list)
+
+    def update(
+        self,
+        preds: np.ndarray,
+        labels: np.ndarray,
+        probs: Optional[np.ndarray] = None,
+        uncertainties: Optional[np.ndarray] = None,
+        cheat_types: Optional[List[str]] = None,
+    ) -> None:
+        """Add batch of predictions to metrics."""
+        self.predictions.extend(preds.tolist())
+        self.labels.extend(labels.tolist())
+        if probs is not None:
+            self.probabilities.extend(probs.tolist())
+        if uncertainties is not None:
+            self.uncertainties.extend(uncertainties.tolist())
+        if cheat_types is not None:
+            self.cheat_types.extend(cheat_types)
+
+    def reset(self) -> None:
+        """Clear all accumulated data."""
+        self.predictions.clear()
+        self.labels.clear()
+        self.probabilities.clear()
+        self.uncertainties.clear()
+        self.cheat_types.clear()
+
+    def compute(self) -> Dict[str, float]:
+        """Compute all metrics."""
+        preds = np.array(self.predictions)
+        labels = np.array(self.labels)
+
+        # Convert to binary (0=clean, 1/2=cheater)
+        binary_preds = (preds > 0).astype(int)
+        binary_labels = (labels > 0).astype(int)
+
+        metrics = {
+            "accuracy": accuracy_score(binary_labels, binary_preds),
+            "precision": precision_score(binary_labels, binary_preds, zero_division=0),
+            "recall": recall_score(binary_labels, binary_preds, zero_division=0),
+            "f1": f1_score(binary_labels, binary_preds, zero_division=0),
+        }
+
+        # AUC-ROC if probabilities available
+        if self.probabilities:
+            probs = np.array(self.probabilities)
+            cheat_prob = (
+                probs[:, 1] + probs[:, 2] if probs.shape[1] == 3 else probs[:, 1]
+            )
+            try:
+                metrics["auc_roc"] = roc_auc_score(binary_labels, cheat_prob)
+            except ValueError:
+                metrics["auc_roc"] = 0.0
+
+            # AUC-PR
+            precision_arr, recall_arr, _ = precision_recall_curve(
+                binary_labels, cheat_prob
+            )
+            metrics["auc_pr"] = auc(recall_arr, precision_arr)
+
+        # Confusion matrix
+        cm = confusion_matrix(binary_labels, binary_preds)
+        if cm.shape == (2, 2):
+            tn, fp, fn, tp = cm.ravel()
+            metrics["true_positives"] = int(tp)
+            metrics["true_negatives"] = int(tn)
+            metrics["false_positives"] = int(fp)
+            metrics["false_negatives"] = int(fn)
+            metrics["false_positive_rate"] = fp / (fp + tn) if (fp + tn) > 0 else 0
+
+        return metrics
+
+    def compute_by_cheat_type(self) -> Dict[str, Dict[str, float]]:
+        """Compute recall by cheat type."""
+        if not self.cheat_types:
+            return {}
+
+        results = {}
+        types = set(self.cheat_types)
+
+        for ctype in types:
+            if ctype == "none":
+                continue
+            mask = [t == ctype for t in self.cheat_types]
+            type_labels = np.array(self.labels)[mask]
+            type_preds = np.array(self.predictions)[mask]
+
+            if len(type_labels) > 0:
+                binary_preds = (type_preds > 0).astype(int)
+                binary_labels = (type_labels > 0).astype(int)
+                results[ctype] = {
+                    "recall": recall_score(binary_labels, binary_preds, zero_division=0),
+                    "count": len(type_labels),
+                }
+
+        return results
+
+
+def compute_ece(probs: np.ndarray, labels: np.ndarray, n_bins: int = 10) -> float:
+    """Expected Calibration Error."""
+    bin_boundaries = np.linspace(0, 1, n_bins + 1)
+    confidences = probs.max(axis=1)
+    predictions = probs.argmax(axis=1)
+    accuracies = (predictions == labels).astype(float)
+
+    ece = 0.0
+    for i in range(n_bins):
+        mask = (confidences > bin_boundaries[i]) & (confidences <= bin_boundaries[i + 1])
+        if mask.sum() > 0:
+            bin_acc = accuracies[mask].mean()
+            bin_conf = confidences[mask].mean()
+            ece += mask.sum() * abs(bin_acc - bin_conf)
+
+    return ece / len(labels)

src/manifold/models/__init__.py

@@ -0,0 +1,5 @@
+"""MANIFOLD models."""
+
+from manifold.models.manifold_lite import MANIFOLDLite
+
+__all__ = ["MANIFOLDLite"]

src/manifold/models/components/__init__.py

@@ -0,0 +1,57 @@
+from manifold.models.components.cca import (
+    CounterfactualProbe,
+    CausalCounterfactualAttention,
+)
+from manifold.models.components.hse import (
+    HyperbolicSkillEmbedding,
+    initialize_skill_anchors,
+)
+from manifold.models.components.ihe import (
+    IHEBlock,
+    InformationHorizonEncoder,
+)
+from manifold.models.components.mdm import (
+    MotorDynamicsModule,
+    NeuralODEFunc,
+    fixed_euler_solve,
+)
+from manifold.models.components.mpl import (
+    MPLEncoder,
+    MPLDecoder,
+    ManifoldProjectionLayer,
+)
+from manifold.models.components.tiv import (
+    DomainClassifier,
+    GradientReversalFunction,
+    GradientReversalLayer,
+    TemporalInvariantVerifier,
+)
+from manifold.models.components.verdict import (
+    EvidentialHead,
+    SequencePooling,
+    compute_uncertainty,
+    dirichlet_strength,
+)
+
+__all__ = [
+    "CausalCounterfactualAttention",
+    "CounterfactualProbe",
+    "DomainClassifier",
+    "EvidentialHead",
+    "GradientReversalFunction",
+    "GradientReversalLayer",
+    "HyperbolicSkillEmbedding",
+    "IHEBlock",
+    "InformationHorizonEncoder",
+    "ManifoldProjectionLayer",
+    "MotorDynamicsModule",
+    "MPLDecoder",
+    "MPLEncoder",
+    "NeuralODEFunc",
+    "SequencePooling",
+    "TemporalInvariantVerifier",
+    "compute_uncertainty",
+    "dirichlet_strength",
+    "fixed_euler_solve",
+    "initialize_skill_anchors",
+]

src/manifold/models/components/cca.py

@@ -0,0 +1,161 @@
+"""Causal Counterfactual Attention (CCA) for MANIFOLD."""
+
+from __future__ import annotations
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, Any
+from manifold.models.layers.attention import MultiHeadLinearAttention
+
+
+class CounterfactualProbe(nn.Module):
+    """
+    Learnable query vectors for counterfactual reasoning.
+    
+    These probes ask "what if" questions about the input sequence.
+    """
+    
+    def __init__(self, embed_dim: int = 256, num_probes: int = 16):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_probes = num_probes
+        
+        # Learnable probe vectors - "what if" questions
+        self.probes = nn.Parameter(torch.randn(num_probes, embed_dim) * 0.02)
+        
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Compute attention between probes and sequence.
+        
+        Args:
+            x: Input [batch, seq, embed_dim]
+            
+        Returns:
+            Probe outputs [batch, num_probes, embed_dim]
+        """
+        batch, seq, dim = x.shape
+        
+        # Probes as queries: [num_probes, embed_dim] -> [batch, num_probes, embed_dim]
+        q = self.probes.unsqueeze(0).expand(batch, -1, -1)
+        
+        # x as keys and values: [batch, seq, embed_dim]
+        k = x
+        v = x
+        
+        # Scaled dot-product attention (sparse: only num_probes queries)
+        # Attention weights: [batch, num_probes, seq]
+        scale = dim ** -0.5
+        attn = torch.bmm(q, k.transpose(1, 2)) * scale
+        attn = F.softmax(attn, dim=-1)
+        
+        # Weighted sum of values: [batch, num_probes, embed_dim]
+        output = torch.bmm(attn, v)
+        
+        return output
+
+
+class CausalCounterfactualAttention(nn.Module):
+    """
+    Dual-path attention: factual (standard) + counterfactual (sparse probes).
+    
+    Factual path: Linear attention O(T) on actual sequence
+    Counterfactual path: 16 sparse probes asking "what if" questions
+    """
+    
+    def __init__(
+        self,
+        embed_dim: int = 256,
+        num_cf_probes: int = 16,
+        num_heads: int = 8,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_cf_probes = num_cf_probes
+        
+        # Factual path: causal linear attention O(T)
+        self.factual_attention = MultiHeadLinearAttention(
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            dropout=dropout,
+            causal=True,
+            use_rotary=True,
+        )
+        
+        # Counterfactual path: sparse probes
+        self.cf_probes = CounterfactualProbe(
+            embed_dim=embed_dim,
+            num_probes=num_cf_probes,
+        )
+        
+        # Project counterfactual probe outputs to sequence contribution
+        self.cf_proj = nn.Linear(embed_dim, embed_dim)
+        
+        # Learnable weights to broadcast cf probes to sequence positions
+        # Maps [batch, num_probes, embed_dim] -> contribution at each position
+        self.cf_to_seq = nn.Linear(num_cf_probes, 1)
+        
+        # Combine factual + counterfactual
+        self.combine = nn.Linear(embed_dim * 2, embed_dim)
+        
+        # Layer normalization
+        self.norm = nn.LayerNorm(embed_dim)
+        
+        self.dropout = nn.Dropout(dropout)
+        
+    def forward(
+        self,
+        x: torch.Tensor,
+        mask: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Args:
+            x: Input [batch, seq, embed_dim]
+            
+        Returns:
+            Dict with:
+            - "output": combined output [batch, seq, embed_dim]
+            - "factual": factual attention output
+            - "counterfactual": counterfactual probe outputs [batch, num_probes, embed_dim]
+        """
+        batch, seq, _ = x.shape
+        
+        # Factual path: linear attention on sequence
+        factual_out = self.factual_attention(x, mask=mask)["output"]
+        
+        # Counterfactual path: probe attention
+        cf_out = self.cf_probes(x)  # [batch, num_probes, embed_dim]
+        cf_projected = self.cf_proj(cf_out)  # [batch, num_probes, embed_dim]
+        
+        # Broadcast counterfactual to sequence length
+        # [batch, num_probes, embed_dim] -> [batch, seq, embed_dim]
+        # Transpose for linear: [batch, embed_dim, num_probes]
+        cf_transposed = cf_projected.transpose(1, 2)
+        # Apply linear to last dim: [batch, embed_dim, 1]
+        cf_seq = self.cf_to_seq(cf_transposed)
+        # Squeeze and expand: [batch, embed_dim] -> [batch, seq, embed_dim]
+        cf_contribution = cf_seq.squeeze(-1).unsqueeze(1).expand(-1, seq, -1)
+        
+        # Combine: concatenate factual and counterfactual contributions
+        combined = torch.cat([factual_out, cf_contribution], dim=-1)
+        output = self.combine(combined)
+        output = self.dropout(output)
+        
+        # Normalize
+        output = self.norm(output)
+        
+        return {
+            "output": output,
+            "factual": factual_out,
+            "counterfactual": cf_out,
+        }
+    
+    @classmethod
+    def from_config(cls, config) -> "CausalCounterfactualAttention":
+        """Create from ModelConfig."""
+        return cls(
+            embed_dim=config.embed_dim,
+            num_cf_probes=config.num_cf_probes,
+            num_heads=config.cca_heads,
+            dropout=config.dropout,
+        )

src/manifold/models/components/hse.py

@@ -0,0 +1,137 @@
+"""Hyperbolic Skill Embedding (HSE) for player skill hierarchy representation."""
+
+from __future__ import annotations
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, Any
+
+from manifold.models.layers.hyperbolic import (
+    TangentSpaceProjection,
+    HyperbolicDistanceLayer,
+    hyperbolic_distance_tangent,
+    expmap0,
+)
+
+
+def initialize_skill_anchors(num_levels: int = 7, dim: int = 32) -> torch.Tensor:
+    """
+    Initialize skill level anchors in hyperbolic space.
+    
+    Higher skill = further from origin (hierarchy property).
+    
+    Args:
+        num_levels: Number of skill levels (default 7: silver to pro)
+        dim: Dimension of the embedding space
+        
+    Returns:
+        Tensor of shape [num_levels, dim] with anchors at increasing distances
+    """
+    distances = torch.linspace(0.1, 0.8, num_levels)
+    directions = F.normalize(torch.randn(num_levels, dim), dim=-1)
+    return directions * distances.unsqueeze(-1)
+
+
+class HyperbolicSkillEmbedding(nn.Module):
+    """
+    Embed player behavior in hyperbolic space with skill hierarchy.
+    
+    Hyperbolic geometry naturally represents hierarchies:
+    - Lower skill players cluster near origin
+    - Higher skill players further out
+    - Cheaters may appear "impossible" - high skill indicators
+      but behavioral patterns inconsistent with skill level
+    """
+    
+    def __init__(
+        self,
+        input_dim: int = 256,
+        manifold_dim: int = 32,
+        num_skill_levels: int = 7,
+        init_curvature: float = 1.0,
+    ):
+        """
+        Initialize HyperbolicSkillEmbedding.
+        
+        Args:
+            input_dim: Dimension of input features
+            manifold_dim: Dimension of hyperbolic manifold embedding
+            num_skill_levels: Number of skill level anchors
+            init_curvature: Initial curvature value (learnable)
+        """
+        super().__init__()
+        self.input_dim = input_dim
+        self.manifold_dim = manifold_dim
+        self.num_skill_levels = num_skill_levels
+        
+        self.projection = TangentSpaceProjection(
+            input_dim=input_dim,
+            output_dim=manifold_dim,
+            curvature=init_curvature,
+        )
+        
+        self.curvature = nn.Parameter(torch.tensor(init_curvature))
+        
+        self.skill_anchors = nn.Parameter(
+            initialize_skill_anchors(num_skill_levels, manifold_dim)
+        )
+        
+        self.distance_layer = HyperbolicDistanceLayer(
+            dim=manifold_dim,
+            num_anchors=num_skill_levels,
+            curvature=init_curvature,
+            use_tangent_approx=True,
+        )
+        self.distance_layer.anchors = self.skill_anchors
+    
+    def forward(self, x: torch.Tensor) -> Dict[str, torch.Tensor]:
+        """
+        Forward pass through hyperbolic skill embedding.
+        
+        Args:
+            x: Input features [batch, seq, input_dim]
+            
+        Returns:
+            Dict with:
+            - "embedding": hyperbolic embedding [batch, seq, manifold_dim]
+            - "skill_distances": distances to skill anchors [batch, seq, num_skill_levels]
+            - "predicted_skill": softmax over distances (closest anchor)
+            - "curvature": current learned curvature value
+        """
+        proj_out = self.projection(x)
+        tangent = proj_out["tangent"]
+        
+        tangent_expanded = tangent.unsqueeze(-2)
+        
+        skill_distances = hyperbolic_distance_tangent(
+            tangent_expanded,
+            self.skill_anchors,
+            c=self.curvature.abs().clamp(min=0.1),
+        )
+        
+        predicted_skill = F.softmax(-skill_distances, dim=-1)
+        
+        return {
+            "embedding": tangent,
+            "skill_distances": skill_distances,
+            "predicted_skill": predicted_skill,
+            "curvature": self.curvature,
+        }
+    
+    @classmethod
+    def from_config(cls, config: Any) -> "HyperbolicSkillEmbedding":
+        """
+        Create HyperbolicSkillEmbedding from ModelConfig.
+        
+        Args:
+            config: ModelConfig with HSE parameters
+            
+        Returns:
+            Configured HyperbolicSkillEmbedding instance
+        """
+        return cls(
+            input_dim=getattr(config, "embed_dim", 256),
+            manifold_dim=getattr(config, "manifold_dim", 32),
+            num_skill_levels=getattr(config, "num_skill_levels", 7),
+            init_curvature=getattr(config, "init_curvature", 1.0),
+        )

src/manifold/models/components/ihe.py

@@ -0,0 +1,164 @@
+"""Information Horizon Encoder - Causal transformer with linear attention."""
+
+from __future__ import annotations
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, Any, List
+
+from manifold.models.layers.attention import MultiHeadLinearAttention, RotaryPositionEncoding
+
+
+class IHEBlock(nn.Module):
+    """
+    Single IHE transformer block with linear attention + FFN.
+    
+    Uses pre-norm architecture for training stability.
+    """
+    
+    def __init__(
+        self,
+        embed_dim: int = 256,
+        num_heads: int = 8,
+        ff_dim: int = 1024,
+        dropout: float = 0.1,
+    ):
+        super().__init__()
+        
+        self.norm1 = nn.LayerNorm(embed_dim)
+        self.norm2 = nn.LayerNorm(embed_dim)
+        
+        self.attention = MultiHeadLinearAttention(
+            embed_dim=embed_dim,
+            num_heads=num_heads,
+            dropout=dropout,
+            causal=True,
+            use_rotary=True,
+        )
+        
+        self.ffn = nn.Sequential(
+            nn.Linear(embed_dim, ff_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(ff_dim, embed_dim),
+            nn.Dropout(dropout),
+        )
+    
+    def forward(
+        self, 
+        x: torch.Tensor, 
+        mask: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Forward pass through transformer block.
+        
+        Args:
+            x: Input tensor [batch, seq, embed_dim]
+            mask: Optional attention mask [batch, seq]
+            
+        Returns:
+            Dict with 'output' and 'attention_weights'
+        """
+        normed = self.norm1(x)
+        attn_out = self.attention(normed, mask=mask)
+        x = x + attn_out["output"]
+        
+        normed = self.norm2(x)
+        x = x + self.ffn(normed)
+        
+        return {
+            "output": x,
+            "attention_weights": None,
+        }
+
+
+class InformationHorizonEncoder(nn.Module):
+    """
+    Multi-layer causal transformer for encoding player action sequences.
+    
+    Uses linear attention O(T) and rotary position encoding.
+    Causal masking ensures actions can't see future information.
+    """
+    
+    def __init__(
+        self,
+        embed_dim: int = 256,
+        num_layers: int = 4,
+        num_heads: int = 8,
+        ff_dim: int = 1024,
+        dropout: float = 0.1,
+        max_seq_len: int = 128,
+    ):
+        super().__init__()
+        
+        self.embed_dim = embed_dim
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.max_seq_len = max_seq_len
+        
+        head_dim = embed_dim // num_heads
+        self.pos_encoding = RotaryPositionEncoding(
+            dim=head_dim,
+            max_seq_len=max_seq_len,
+        )
+        
+        self.layers = nn.ModuleList([
+            IHEBlock(
+                embed_dim=embed_dim,
+                num_heads=num_heads,
+                ff_dim=ff_dim,
+                dropout=dropout,
+            )
+            for _ in range(num_layers)
+        ])
+        
+        self.final_norm = nn.LayerNorm(embed_dim)
+    
+    def forward(
+        self,
+        x: torch.Tensor,
+        mask: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        """
+        Encode action sequence through causal transformer layers.
+        
+        Args:
+            x: Input tensor [batch, seq, embed_dim]
+            mask: Optional attention mask [batch, seq]
+            
+        Returns:
+            Dict with 'encoding' and 'all_layer_outputs'
+        """
+        all_layer_outputs: List[torch.Tensor] = []
+        
+        for layer in self.layers:
+            layer_out = layer(x, mask=mask)
+            x = layer_out["output"]
+            all_layer_outputs.append(x)
+        
+        encoding = self.final_norm(x)
+        
+        return {
+            "encoding": encoding,
+            "all_layer_outputs": all_layer_outputs,
+        }
+    
+    @classmethod
+    def from_config(cls, config: Any) -> "InformationHorizonEncoder":
+        """
+        Create InformationHorizonEncoder from ModelConfig.
+        
+        Args:
+            config: ModelConfig instance with IHE parameters
+            
+        Returns:
+            Configured InformationHorizonEncoder instance
+        """
+        return cls(
+            embed_dim=config.embed_dim,
+            num_layers=config.ihe_layers,
+            num_heads=config.ihe_heads,
+            ff_dim=config.ihe_ff_dim,
+            dropout=config.ihe_dropout,
+            max_seq_len=config.sequence_length,
+        )

src/manifold/models/components/mdm.py

@@ -0,0 +1,176 @@
+"""Motor Dynamics Module for MANIFOLD.
+
+Neural ODE with fixed Euler solver for modeling motor dynamics.
+Integrates physics constraints to enforce human biomechanical limits.
+"""
+
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional, Dict, Any, TYPE_CHECKING
+
+from manifold.models.layers.physics import PhysicsConstraintLayer
+
+if TYPE_CHECKING:
+    from manifold.config import ModelConfig
+
+
+class NeuralODEFunc(nn.Module):
+    """Neural network defining the ODE dynamics dz/dt = f(z, t).
+    
+    Implements a 3-layer MLP with GELU activations to learn
+    continuous-time dynamics in the latent space.
+    """
+    
+    def __init__(self, hidden_dim: int = 512, input_dim: int = 256):
+        super().__init__()
+        
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.GELU(),
+            nn.Linear(hidden_dim, input_dim),
+        )
+    
+    def forward(self, t: torch.Tensor, z: torch.Tensor) -> torch.Tensor:
+        """Compute dz/dt.
+        
+        Args:
+            t: Current time (scalar tensor, unused but required for ODE interface)
+            z: Current state [batch, seq, input_dim] or [batch, input_dim]
+            
+        Returns:
+            dz/dt with same shape as z
+        """
+        return self.net(z)
+
+
+def fixed_euler_solve(
+    func: NeuralODEFunc,
+    z0: torch.Tensor,
+    t_span: tuple = (0.0, 1.0),
+    num_steps: int = 4,
+) -> torch.Tensor:
+    """Fixed-step Euler ODE solver.
+    
+    Much more memory efficient than adaptive solvers like dopri5.
+    Uses simple forward Euler: z_{n+1} = z_n + dt * f(t_n, z_n)
+    
+    Args:
+        func: Neural ODE function computing dz/dt
+        z0: Initial state [batch, ...]
+        t_span: Integration interval (t0, t1)
+        num_steps: Number of Euler steps (default 4 for memory efficiency)
+        
+    Returns:
+        Final state z(t1) with same shape as z0
+    """
+    dt = (t_span[1] - t_span[0]) / num_steps
+    z = z0
+    t = t_span[0]
+    
+    for _ in range(num_steps):
+        t_tensor = torch.tensor(t, device=z.device, dtype=z.dtype)
+        dz = func(t_tensor, z)
+        z = z + dt * dz
+        t += dt
+    
+    return z
+
+
+class MotorDynamicsModule(nn.Module):
+    """Neural ODE module for motor dynamics with physics constraints.
+    
+    Uses fixed 4-step Euler solver for memory efficiency during training.
+    Integrates physics constraints (jerk, turn rate, acceleration limits)
+    to ensure learned dynamics respect human biomechanical limits.
+    
+    Args:
+        input_dim: Dimension of input features (default 256)
+        hidden_dim: Hidden dimension for ODE function (default 512)
+        num_steps: Number of Euler integration steps (default 4)
+        use_physics_constraints: Whether to apply physics constraints (default True)
+    """
+    
+    def __init__(
+        self,
+        input_dim: int = 256,
+        hidden_dim: int = 512,
+        num_steps: int = 4,
+        use_physics_constraints: bool = True,
+    ):
+        super().__init__()
+        
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.num_steps = num_steps
+        self.use_physics_constraints = use_physics_constraints
+        
+        self.ode_func = NeuralODEFunc(hidden_dim=hidden_dim, input_dim=input_dim)
+        
+        if use_physics_constraints:
+            self.physics = PhysicsConstraintLayer(learnable=True)
+        else:
+            self.physics = None
+        
+        self.output_proj = nn.Linear(input_dim, input_dim)
+    
+    def forward(
+        self,
+        x: torch.Tensor,
+        trajectory: Optional[torch.Tensor] = None,
+    ) -> Dict[str, torch.Tensor]:
+        """Forward pass through motor dynamics module.
+        
+        Args:
+            x: Input tensor [batch, seq, input_dim]
+            trajectory: Optional trajectory for physics violation computation
+                       [batch, seq, 2] mouse deltas (dx, dy)
+                       
+        Returns:
+            Dict containing:
+                - "output": Transformed features [batch, seq, input_dim]
+                - "physics_violations": Physics constraint violations (if applicable)
+        """
+        z = fixed_euler_solve(
+            func=self.ode_func,
+            z0=x,
+            t_span=(0.0, 1.0),
+            num_steps=self.num_steps,
+        )
+        
+        output = self.output_proj(z)
+        result = {"output": output}
+        
+        if self.use_physics_constraints and self.physics is not None:
+            if trajectory is not None:
+                physics_violations = self.physics(trajectory)
+            else:
+                dummy_trajectory = output[..., :2].detach()
+                physics_violations = self.physics(dummy_trajectory)
+            
+            result["physics_violations"] = physics_violations
+        else:
+            result["physics_violations"] = {"total_violation": torch.tensor(0.0, device=x.device)}
+        
+        return result
+    
+    @classmethod
+    def from_config(cls, config: "ModelConfig") -> "MotorDynamicsModule":
+        """Create MotorDynamicsModule from ModelConfig.
+        
+        Args:
+            config: Model configuration object
+            
+        Returns:
+            Configured MotorDynamicsModule instance
+        """
+        return cls(
+            input_dim=config.embed_dim,
+            hidden_dim=config.mdm_hidden,
+            num_steps=config.mdm_steps,
+            use_physics_constraints=True,
+        )