Upload folder using huggingface_hub

.gitattributes

@@ -59,3 +59,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 logs/comm_events.jsonl filter=lfs diff=lfs merge=lfs -text
 models/champion_gen1000.py filter=lfs diff=lfs merge=lfs -text
+models/champion_gen42.py filter=lfs diff=lfs merge=lfs -text

models/champion_gen42.py

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6703534715ee36f3f28d4c7e65f4824e7f31c2b37cea94c1408e95d3165e8835
+size 504619403

models/requirements.txt

@@ -0,0 +1,9 @@
+numpy>=1.21.0,<2.0
+cascade-lattice>=0.1.3
+rerun-sdk>=0.28.0
+jax>=0.4.20
+jaxlib>=0.4.20
+ninjax>=3.5.0
+elements>=3.19.0
+einops>=0.8.0
+portal>=0.2.0

models/tests/cascade_deep_dive.py

@@ -0,0 +1,115 @@
+"""CASCADE-LATTICE Deep Dive Summary"""
+from cascade import store, genesis, Hold, HoldPoint, CausationGraph, Receipt
+
+print("=" * 70)
+print("CASCADE-LATTICE v0.6.0 - DEEP DIVE SUMMARY")
+print("=" * 70)
+
+print("""
+CORE PHILOSOPHY:
+  "Universal AI provenance layer — cryptographic receipts for every call,
+   HOLD inference halt protocol, and code diagnostics"
+   
+BY: Jeff Towers
+
+ARCHITECTURE:
+┌─────────────────────────────────────────────────────────────────────┐
+│                         CASCADE-LATTICE                              │
+├─────────────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ │
+│  │    HOLD     │  │  CAUSATION  │  │   METRICS   │  │  FORENSICS  │ │
+│  │   System    │  │    Graph    │  │   Engine    │  │  + GhostLog │ │
+│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘ │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐ │
+│  │   STORE     │  │   GENESIS   │  │  IDENTITY   │  │ DIAGNOSTICS │ │
+│  │ (SQLite+CID)│  │ (Provenance)│  │(Fingerprint)│  │ (BugDetect) │ │
+│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────┘ │
+└─────────────────────────────────────────────────────────────────────┘
+                              ↓ Sync
+                    ┌─────────────────────┐
+                    │   HuggingFace Hub   │
+                    │ tostido/cascade-obs │
+                    └─────────────────────┘
+""")
+
+s = store.stats()
+
+print("LOCAL LATTICE STATS:")
+print(f"  Genesis Root:        {s['genesis_root']}")
+print(f"  Total Observations:  {s['total_observations']:,}")
+print(f"  Lattice Dir:         {s['lattice_dir']}")
+print()
+print("MODELS TRACKED:")
+for model, count in s['models'].items():
+    print(f"  {model}: {count:,} observations")
+
+print()
+print("=" * 70)
+print("KEY COMPONENTS")
+print("=" * 70)
+
+print("""
+1. HOLD SYSTEM - Inference-level halt protocol
+   ├── Hold.yield_point()     - Brain pauses, yields decision
+   ├── HoldPoint              - Freeze-frame with merkle chain
+   ├── Hold.resolve()         - External resolution (human/Ghost)
+   └── HoldResolution         - Final action + override info
+
+2. HOLDPOINT FIELDS (the decision snapshot):
+   ├── action_probs           - Probability distribution
+   ├── value                  - Predicted value
+   ├── observation            - What brain saw
+   ├── imagination            - Dict[int, Dict] future trajectories
+   ├── attention              - Where brain focused
+   ├── reasoning              - Optional reasoning chain
+   ├── merkle_root            - Cryptographic hash
+   └── parent_merkle          - Link to previous decision
+
+3. CAUSATION GRAPH - Bidirectional event tracing
+   ├── add_event(Event)       - Record event
+   ├── get_causes(id)         - What caused this?
+   ├── get_effects(id)        - What did this cause?
+   └── Tracer.trace_backwards/forwards
+
+4. STORE - SQLite + Content-Addressable (CID)
+   ├── observe(model_id, data) - Record observation
+   ├── query(model_id, since)  - Query observations
+   ├── Receipt                 - CID + merkle + parent chain
+   └── sync_all()             - Push to HuggingFace
+
+5. GENESIS - Provenance root
+   ├── create_genesis()       - Start new chain
+   ├── get_genesis_root()     - Get chain root hash
+   └── verify_lineage_to_genesis() - Verify full chain
+
+6. IDENTITY - Model fingerprinting
+   ├── ModelIdentity          - Base model + variant + fingerprint
+   ├── BehavioralFingerprint  - Probe responses hash
+   └── detect_format/quantization
+
+7. FORENSICS - Post-hoc analysis
+   ├── GhostLog               - Operation narrative
+   ├─�� DataForensics          - Artifact detection
+   └── TechFingerprinter      - Technology identification
+
+8. DIAGNOSTICS - Code analysis
+   ├── BugDetector            - Pattern-based bug scanning
+   ├── CodeTracer             - Execution tracing
+   └── DiagnosticEngine       - Full diagnostic report
+""")
+
+print("=" * 70)
+print("HUGGINGFACE INTEGRATION")
+print("=" * 70)
+print("""
+Your dataset: tostido/cascade-observations
+  - 556 downloads
+  - Created: 2026-01-07
+  - Last modified: 2026-01-17
+  
+Commands:
+  cascade.pull_from_hf('tostido/cascade-observations')  # Pull
+  cascade.sync_all()                                     # Push
+""")
+
+print("=" * 70)

models/tests/deep_dive_bridge.py

@@ -0,0 +1,50 @@
+"""Deep dive into BridgeFaculty and Kleene fixed-point matching."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+import champion_gen1000 as champ
+
+print("=" * 70)
+print("🌉 BRIDGE FACULTY - Kleene Fixed-Point Data Bridging")
+print("=" * 70)
+
+# Check BridgeFaculty class
+print("\n=== BridgeFaculty Class ===")
+BridgeFaculty = champ.BridgeFaculty
+print(f"Type: {BridgeFaculty}")
+print(f"Methods: {[m for m in dir(BridgeFaculty) if not m.startswith('_')]}")
+
+# Get docstring
+if BridgeFaculty.__doc__:
+    print(f"\nDocstring:\n{BridgeFaculty.__doc__}")
+
+# Look at the source if possible
+import inspect
+try:
+    source = inspect.getsource(BridgeFaculty)
+    print(f"\n=== Source Code ===")
+    print(source[:3000])
+except Exception as e:
+    print(f"Can't get source: {e}")
+
+# Try to instantiate
+print("\n=== Instantiate Bridge ===")
+try:
+    bridge = BridgeFaculty()
+    print(f"Bridge instance: {bridge}")
+    print(f"Instance methods: {[m for m in dir(bridge) if not m.startswith('_')]}")
+    
+    # Try the bridge method
+    print("\n=== Test Bridge Transformation ===")
+    old_form = {"position": [1, 2, 3], "health": 100}
+    new_form = {"pos_x": None, "pos_y": None, "pos_z": None, "hp": None}
+    
+    print(f"Old form: {old_form}")
+    print(f"New form template: {new_form}")
+    
+    result = bridge.bridge(old_form, new_form)
+    print(f"Bridged result: {result}")
+    
+except Exception as e:
+    print(f"Error: {e}")
+    import traceback
+    traceback.print_exc()

models/tests/deep_dive_export.py

@@ -0,0 +1,86 @@
+"""
+Deep Dive: Export Capabilities
+
+Testing the capsule agent's self-export capabilities:
+1. export_pt() - PyTorch format 
+2. export_onnx() - ONNX for deployment
+3. export_capsule() - Self-replicating quine!
+
+The quine capability is special - the model can export itself
+as a complete, self-contained Python module!
+"""
+
+import os
+import champion_gen1000 as ch
+
+print("=" * 60)
+print("📦 Capsule Export Capabilities")
+print("=" * 60)
+
+# Create agent
+agent = ch.CapsuleAgent()
+
+# Show current quine info
+print(f"\n=== Current Quine Info ===")
+print(f"Quine hash: {ch.get_quine_hash()}")
+print(f"Integrity: {ch.verify_quine_integrity()}")
+
+# Create export directory
+export_dir = "exports"
+os.makedirs(export_dir, exist_ok=True)
+
+# Test export_capsule (the quine self-replication!)
+print(f"\n=== Testing export_capsule() ===")
+print("This creates a self-contained Python module...")
+
+capsule_path = agent.export_capsule(os.path.join(export_dir, "child_capsule.py"))
+print(f"Exported to: {capsule_path}")
+
+# Check the file
+if capsule_path and os.path.exists(capsule_path):
+    size = os.path.getsize(capsule_path)
+    print(f"File size: {size / 1024 / 1024:.2f} MB")
+    
+    # Read first few lines
+    with open(capsule_path, 'r', encoding='utf-8', errors='ignore') as f:
+        lines = f.readlines()[:30]
+    
+    print("\n=== First 30 lines of exported capsule ===")
+    for i, line in enumerate(lines, 1):
+        print(f"{i:3d}: {line.rstrip()[:80]}")
+    
+    print(f"\n... ({len(lines)} of total lines shown)")
+    
+    # Verify it's a valid quine
+    print("\n=== Verifying exported capsule ===")
+    try:
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("child", capsule_path)
+        child = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(child)
+        
+        if hasattr(child, 'get_quine_hash'):
+            child_hash = child.get_quine_hash()
+            print(f"Child quine hash: {child_hash}")
+            print(f"Parent quine hash: {ch.get_quine_hash()}")
+            print(f"Hashes match: {child_hash == ch.get_quine_hash()}")
+        
+        if hasattr(child, 'verify_quine_integrity'):
+            print(f"Child integrity: {child.verify_quine_integrity()}")
+            
+    except Exception as e:
+        print(f"Could not verify child: {e}")
+else:
+    print("Export may not have created a file")
+
+# Test replicate_quine directly
+print("\n=== Testing replicate_quine() ===")
+replica_path = ch.replicate_quine(os.path.join(export_dir, "replica.py"))
+print(f"Replicated to: {replica_path}")
+
+if replica_path and os.path.exists(replica_path):
+    replica_size = os.path.getsize(replica_path)
+    original_size = os.path.getsize("champion_gen1000.py")
+    print(f"Original size: {original_size / 1024 / 1024:.2f} MB")
+    print(f"Replica size: {replica_size / 1024 / 1024:.2f} MB")
+    print(f"Size match: {abs(replica_size - original_size) < 1000}")

models/tests/deep_dive_forward_hold.py

@@ -0,0 +1,99 @@
+"""
+Deep Dive: forward_hold() - HOLD-aware inference
+
+The CapsuleAgent.forward_hold() method is the production API
+for HOLD-aware inference. It:
+1. Runs the brain forward pass
+2. Yields a HOLD point automatically
+3. Returns the final action (possibly overridden)
+
+This is what the arcade stream uses for Twitch chat control!
+"""
+
+import numpy as np
+import threading
+import time
+
+# Load the champion
+import champion_gen1000 as ch
+
+print("=" * 60)
+print("🎮 forward_hold() - HOLD-aware Arcade Inference")
+print("=" * 60)
+
+# Create agent
+agent = ch.CapsuleAgent()
+print(f"\nAgent: {agent}")
+print(f"Genesis: {ch.get_genesis_root()}")
+
+# Get the HOLD singleton
+hold = ch.get_hold()
+print(f"Hold: {hold}")
+print(f"Hold enabled: {hold.enabled}")
+print(f"Available: {[x for x in dir(hold) if not x.startswith('_')]}")
+
+# Add a listener via the listeners list
+def on_hold(hp):
+    print(f"\n🔴 HOLD POINT from forward_hold()!")
+    print(f"   Brain ID: {hp.brain_id}")
+    print(f"   Action probs: {hp.action_probs}")
+    if hp.action_labels:
+        print(f"   Labels: {hp.action_labels}")
+    print(f"   Value: {hp.value:.3f}")
+
+hold.listeners.append(on_hold)
+
+# Simulate arcade observation
+observation = {
+    "screen": np.random.rand(84, 84, 3).astype(np.float32),
+    "lives": 3,
+    "score": 1500
+}
+
+print("\n=== Test 1: Non-blocking forward_hold ===")
+result = agent.forward_hold(
+    inputs={"observation": observation},
+    blocking=False  # Don't block, just return AI choice
+)
+
+print(f"\nResult keys: {result.keys()}")
+print(f"Action: {result.get('action')}")
+print(f"Was override: {result.get('was_override', False)}")
+print(f"Merkle: {result.get('merkle_root', 'N/A')}")
+
+print("\n=== Test 2: Blocking with Override ===")
+
+def override_thread():
+    """Simulates chat override"""
+    time.sleep(0.3)
+    print("\n💬 Chat: !override 0")
+    hold.override(0)  # Embedded hold state only takes action
+
+# Start override thread
+t = threading.Thread(target=override_thread)
+t.start()
+
+# This will block until override or timeout
+result2 = agent.forward_hold(
+    inputs={"observation": observation},
+    blocking=True
+)
+
+t.join()
+
+print(f"\nResult 2:")
+print(f"  Action: {result2.get('action')}")
+print(f"  Was override: {result2.get('was_override', False)}")
+print(f"  Override source: {result2.get('override_source', 'N/A')}")
+
+# Check provenance
+print("\n=== Provenance Check ===")
+prov = agent.get_full_provenance()
+print(f"Quine hash: {prov.get('quine_hash', 'N/A')[:16]}...")
+print(f"Genesis: {prov.get('genesis_root', 'N/A')}")
+print(f"Observation count: {prov.get('observation_count', 0)}")
+
+print("\n=== Hold Stats ===")
+print(f"Hold count: {hold.hold_count}")
+print(f"Override count: {hold.override_count}")
+print(f"Last merkle: {hold.last_merkle}")

models/tests/deep_dive_genesis.py

@@ -0,0 +1,86 @@
+"""Deep dive into genesis lineage and provenance chain."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+sys.path.insert(0, 'F:/End-Game/key')
+
+print("=" * 70)
+print("🔐 GENESIS LINEAGE - Tracing the Champion's Origins")
+print("=" * 70)
+
+# Check CASCADE genesis
+print("\n=== CASCADE Genesis Root ===")
+try:
+    from cascade import genesis
+    root = genesis.get_genesis_root()
+    print(f"Genesis root: {root}")
+    
+    # Get full genesis info
+    if hasattr(genesis, 'get_genesis_info'):
+        info = genesis.get_genesis_info()
+        print(f"Genesis info: {info}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Check SwarmLattice
+print("\n=== SwarmLattice ===")
+try:
+    from swarm_lattice import SwarmLattice
+    lattice = SwarmLattice(link_to_genesis=True)
+    print(f"Lattice genesis root: {lattice.genesis_root}")
+    print(f"Lattice merkle root: {lattice.merkle_root}")
+    stats = lattice.get_stats()
+    print(f"Stats: {stats}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Check champion's view of genesis
+print("\n=== Champion's Genesis View ===")
+try:
+    import champion_gen1000 as champ
+    
+    # Get genesis root from champion
+    print(f"Champion quine hash: {champ.get_quine_hash()}")
+    
+    # Check if champion can verify lineage
+    if hasattr(champ, 'verify_lineage_to_genesis'):
+        valid = champ.verify_lineage_to_genesis()
+        print(f"Lineage to genesis valid: {valid}")
+    
+    # Check genesis from cascade module
+    if hasattr(champ, 'genesis'):
+        print(f"Champion's genesis module: {champ.genesis}")
+        if hasattr(champ.genesis, 'get_genesis_root'):
+            print(f"Genesis root: {champ.genesis.get_genesis_root()}")
+except Exception as e:
+    print(f"Error: {e}")
+    import traceback
+    traceback.print_exc()
+
+# Explore the provenance chain structure
+print("\n=== CASCADE ProvenanceChain ===")
+try:
+    from cascade.core.provenance import ProvenanceChain, ProvenanceRecord
+    
+    # Create a test chain
+    chain = ProvenanceChain()
+    print(f"Chain type: {type(chain)}")
+    print(f"Chain methods: {[m for m in dir(chain) if not m.startswith('_')]}")
+    
+    # Check if we can trace back
+    if hasattr(chain, 'verify'):
+        print(f"Has verify: True")
+    if hasattr(chain, 'get_lineage'):
+        print(f"Has get_lineage: True")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Check CASCADE store stats
+print("\n=== CASCADE Store Stats ===")
+try:
+    from cascade import store
+    stats = store.stats()
+    print(f"Store stats:")
+    for k, v in stats.items():
+        print(f"  {k}: {v}")
+except Exception as e:
+    print(f"Error: {e}")

models/tests/deep_dive_hold.py

@@ -0,0 +1,104 @@
+"""Deep dive into HOLD system and real-time inference interception."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+
+import cascade
+from cascade import Hold, HoldPoint, HoldState
+import numpy as np
+import threading
+import time
+
+print("=" * 70)
+print("⏸️ CASCADE HOLD SYSTEM - Real-time Inference Interception")
+print("=" * 70)
+
+# Get the Hold singleton
+hold = Hold.get()
+print(f"\nHold singleton: {hold}")
+print(f"Current hold: {hold.current_hold}")
+print(f"Stats: {hold.stats}")
+
+# Register a listener to see hold points
+hold_points_received = []
+
+def my_listener(hold_point: HoldPoint):
+    print(f"\n🛑 HOLD POINT RECEIVED!")
+    print(f"  Brain: {hold_point.brain_id}")
+    print(f"  AI choice: {hold_point.ai_choice}")
+    print(f"  Confidence: {hold_point.ai_confidence:.2%}")
+    print(f"  Merkle: {hold_point.merkle_root}")
+    print(f"  State: {hold_point.state}")
+    hold_points_received.append(hold_point)
+    
+    # Auto-accept after 0.1s for demo
+    time.sleep(0.1)
+    hold.accept()
+
+hold.register_listener(my_listener)
+print("\n✅ Listener registered")
+
+# Simulate a brain yielding a hold point
+print("\n=== Simulating Hold Point (non-blocking) ===")
+
+def simulate_brain():
+    # Simulate what happens inside a brain's forward()
+    action_probs = np.array([0.1, 0.15, 0.5, 0.25])  # 4 actions
+    value = 0.73
+    observation = {'game': 'test', 'frame': 42}
+    
+    print(f"Brain: yielding hold point...")
+    resolution = hold.yield_point(
+        action_probs=action_probs,
+        value=value,
+        observation=observation,
+        brain_id="test_brain_001",
+        action_labels=["UP", "DOWN", "FIRE", "STAY"],
+        blocking=False  # Non-blocking for demo
+    )
+    print(f"Brain: got resolution -> action={resolution.action}, override={resolution.was_override}, source={resolution.override_source}")
+    return resolution
+
+result = simulate_brain()
+
+print(f"\n=== Result ===")
+print(f"Action taken: {result.action}")
+print(f"Was override: {result.was_override}")
+print(f"Override source: {result.override_source}")
+print(f"Hold duration: {result.hold_duration:.4f}s")
+print(f"Merkle root: {result.merkle_root}")
+
+# Try override scenario
+print("\n=== Testing Override Scenario ===")
+
+override_received = None
+
+def override_listener(hp: HoldPoint):
+    global override_received
+    override_received = hp
+    print(f"\n🛑 HOLD for override test")
+    print(f"  AI wants action {hp.ai_choice} ({hp.ai_confidence:.0%} confident)")
+    # Simulate human override
+    time.sleep(0.05)
+    hold.override(action=0, source="human_player")
+
+hold.unregister_listener(my_listener)
+hold.register_listener(override_listener)
+
+action_probs = np.array([0.1, 0.8, 0.05, 0.05])  # AI strongly prefers action 1
+resolution = hold.yield_point(
+    action_probs=action_probs,
+    value=0.9,
+    observation={'test': 'override'},
+    brain_id="test_brain_002",
+    action_labels=["CONSERVATIVE", "AGGRESSIVE", "RETREAT", "WAIT"],
+    blocking=False
+)
+
+print(f"\n  Final action: {resolution.action}")
+print(f"  Was override: {resolution.was_override}")
+print(f"  Override source: {resolution.override_source}")
+print(f"  AI wanted: 1 (AGGRESSIVE)")
+print(f"  Human chose: 0 (CONSERVATIVE)")
+
+print("\n=== Hold Stats After Test ===")
+print(hold.stats)

models/tests/deep_dive_hold_async.py

@@ -0,0 +1,120 @@
+"""
+Deep Dive: HOLD System with Async Override
+
+Testing the full HOLD flow:
+1. Brain yields a hold point (blocking)
+2. Human/chat overrides before timeout
+3. See how the override propagates through
+
+This is how Twitch chat can control AI decisions in real-time!
+"""
+
+import numpy as np
+import threading
+import time
+from cascade import Hold, HoldResolution
+
+print("=" * 60)
+print("⏸️ CASCADE HOLD - Async Override Demo")
+print("=" * 60)
+
+# Get the singleton
+hold = Hold()
+
+# Track what happened
+events = []
+
+def listener(hp):
+    """Called when a hold point is created"""
+    events.append(f"[LISTENER] Hold point created: brain={hp.brain_id}")
+    print(f"\n🔴 HOLD POINT: {hp.brain_id}")
+    print(f"   Action probs: {hp.action_probs}")
+    print(f"   Labels: {hp.action_labels}")
+    print(f"   Value estimate: {hp.value:.3f}")
+    
+    # Show what AI wants to do
+    ai_choice = np.argmax(hp.action_probs)
+    print(f"   AI wants: {ai_choice} ({hp.action_labels[ai_choice] if hp.action_labels else '?'})")
+
+hold.register_listener(listener)
+
+def brain_thread():
+    """Simulates the AI brain yielding a hold point and waiting"""
+    events.append("[BRAIN] Starting inference...")
+    print("\n🧠 Brain: Starting inference...")
+    
+    # Fake observations
+    observation = {
+        "health": 0.3,  # Low health!
+        "enemies": 2,
+        "ammo": 5
+    }
+    
+    # AI thinks: "Low health, should retreat!"
+    # But maybe human knows better...
+    action_probs = np.array([0.05, 0.85, 0.05, 0.05])  # RETREAT strongly preferred
+    value = -0.3  # AI thinks situation is bad
+    
+    events.append("[BRAIN] Yielding hold point (blocking)...")
+    print("🧠 Brain: Yielding hold point, waiting for resolution...")
+    
+    # This blocks until resolved!
+    resolution = hold.yield_point(
+        action_probs=action_probs,
+        value=value,
+        observation=observation,
+        brain_id="arcade_brain_007",
+        action_labels=["ATTACK", "RETREAT", "HEAL", "DODGE"],
+        blocking=True  # BLOCKING - will wait
+    )
+    
+    events.append(f"[BRAIN] Resolution received: action={resolution.action}")
+    print(f"\n🧠 Brain: Got resolution!")
+    print(f"   Final action: {resolution.action} ({['ATTACK', 'RETREAT', 'HEAL', 'DODGE'][resolution.action]})")
+    print(f"   Was override: {resolution.was_override}")
+    if resolution.was_override:
+        print(f"   Override from: {resolution.override_source}")
+    print(f"   Hold duration: {resolution.hold_duration:.3f}s")
+    print(f"   Merkle: {resolution.merkle_root}")
+    
+    return resolution
+
+def human_thread():
+    """Simulates human (Twitch chat) overriding the decision"""
+    time.sleep(0.5)  # Wait for hold point to be created
+    events.append("[HUMAN] Deciding to override...")
+    print("\n👤 Human: AI wants to RETREAT but I see an opportunity!")
+    print("👤 Human: Overriding to ATTACK!")
+    
+    # Human overrides: "No, attack! I see a power-up!"
+    hold.override(0, source="twitch_chat:xX_ProGamer_Xx")
+    events.append("[HUMAN] Override injected: ATTACK")
+    print("👤 Human: Override injected!")
+
+print("\n=== Starting Async Hold Test ===")
+print("Brain will want to RETREAT (low health)")
+print("Human will override to ATTACK")
+print("-" * 40)
+
+# Start brain in a thread
+brain = threading.Thread(target=brain_thread)
+brain.start()
+
+# Start human in another thread (with delay)
+human = threading.Thread(target=human_thread)
+human.start()
+
+# Wait for both
+brain.join()
+human.join()
+
+print("\n=== Event Log ===")
+for i, event in enumerate(events, 1):
+    print(f"  {i}. {event}")
+
+print("\n=== Final Stats ===")
+stats = hold.stats  # Property not method!
+print(f"  Total holds: {stats['total_holds']}")
+print(f"  Overrides: {stats['overrides']}")
+print(f"  Override rate: {stats['override_rate']:.1%}")
+print(f"  Last merkle: {stats['last_merkle']}")

models/tests/deep_dive_interface.py

@@ -0,0 +1,37 @@
+"""Deep dive into champion's advanced capabilities."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+import champion_gen1000 as champ
+import os
+import tempfile
+
+print("=" * 70)
+print("🎮 EXPORT_INTERFACE - Self-Spawning HTTP Server")
+print("=" * 70)
+
+# Create temp directory for interface export
+output_dir = tempfile.mkdtemp(prefix="champion_interface_")
+print(f"Output dir: {output_dir}")
+
+try:
+    result = champ.export_interface(output_dir)
+    print(f"Result: {result}")
+    
+    # List what was created
+    print("\nGenerated files:")
+    for f in os.listdir(output_dir):
+        filepath = os.path.join(output_dir, f)
+        size = os.path.getsize(filepath)
+        print(f"  {f} ({size} bytes)")
+        
+        # Show content of small files
+        if size < 5000:
+            print(f"  --- Content of {f} ---")
+            with open(filepath, 'r') as file:
+                content = file.read()
+                print(content[:2000])
+            print("  ---")
+except Exception as e:
+    print(f"Error: {e}")
+    import traceback
+    traceback.print_exc()

models/tests/deep_dive_observations.py

@@ -0,0 +1,68 @@
+"""Deep dive into CASCADE observations - what's being recorded."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+
+from cascade import store
+
+print("=" * 70)
+print("📊 CASCADE OBSERVATIONS - 8,224 Records")
+print("=" * 70)
+
+# Get stats
+stats = store.stats()
+print(f"\nGenesis root: {stats['genesis_root']}")
+print(f"Total observations: {stats['total_observations']}")
+
+print("\n=== Observations by Model ===")
+for model, count in sorted(stats['models'].items(), key=lambda x: -x[1]):
+    print(f"  {model}: {count:,}")
+
+# Query recent observations
+print("\n=== Recent Arcade Steps ===")
+try:
+    recent = store.query(model_id="arcade_step", limit=5)
+    for r in recent:
+        print(f"\n  CID: {r.cid[:20]}...")
+        print(f"  Merkle: {r.merkle_root}")
+        print(f"  Data keys: {list(r.data.keys())}")
+        if 'event' in r.data:
+            print(f"  Event: {r.data.get('event')}")
+        if 'agent' in r.data:
+            print(f"  Agent: {r.data.get('agent')}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Query SC2 transitions
+print("\n=== SC2 Transitions ===")
+try:
+    sc2 = store.query(model_id="sc2_transition", limit=5)
+    for r in sc2:
+        print(f"\n  CID: {r.cid[:20]}...")
+        print(f"  Data: {r.data}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Query episode ends
+print("\n=== Episode Ends ===")
+try:
+    episodes = store.query(model_id="episode_end", limit=5)
+    for r in episodes:
+        print(f"\n  CID: {r.cid[:20]}...")
+        data = r.data
+        print(f"  Game: {data.get('game', 'N/A')}")
+        print(f"  Reward: {data.get('episode_reward', 'N/A')}")
+        print(f"  Steps: {data.get('episode_steps', 'N/A')}")
+except Exception as e:
+    print(f"Error: {e}")
+
+# Check the provenance chain
+print("\n=== Provenance Chain Sample ===")
+try:
+    sample = store.query(limit=3)
+    for r in sample:
+        print(f"\n  CID: {r.cid}")
+        print(f"  Model: {r.model_id}")
+        print(f"  Merkle: {r.merkle_root}")
+        print(f"  Parent CID: {r.parent_cid or 'None (root)'}")
+except Exception as e:
+    print(f"Error: {e}")

models/tests/inspect_champion.py

@@ -0,0 +1,57 @@
+"""Inspect champion model capabilities."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+
+try:
+    import champion_gen1000 as champ
+    
+    print('=== MODULE ATTRIBUTES ===')
+    print(f'_QUINE_HASH: {getattr(champ, "_QUINE_HASH", "N/A")}')
+    print(f'_GENERATION: {getattr(champ, "_GENERATION", "N/A")}')
+    print(f'_FITNESS: {getattr(champ, "_FITNESS", "N/A")}')
+    
+    traits = getattr(champ, '_TRAITS', {})
+    print(f'_TRAITS keys: {list(traits.keys())[:10]}')
+    
+    print('\n=== MODULE EXPORTS ===')
+    exports = [x for x in dir(champ) if not x.startswith('_')]
+    for e in exports:
+        obj = getattr(champ, e)
+        print(f'  {e}: {type(obj).__name__}')
+    
+    print('\n=== CAPSULEAGENT CLASS ===')
+    if hasattr(champ, 'CapsuleAgent'):
+        CapsuleAgent = champ.CapsuleAgent
+        methods = [m for m in dir(CapsuleAgent) if not m.startswith('_') and callable(getattr(CapsuleAgent, m, None))]
+        print(f'Methods: {methods}')
+    
+    print('\n=== TRYING TO INSTANTIATE ===')
+    if hasattr(champ, 'CapsuleAgent'):
+        agent = champ.CapsuleAgent(observe=False, observe_visual=False)
+        print(f'Agent created: {type(agent).__name__}')
+        
+        # Check what methods the instance has
+        instance_methods = [m for m in dir(agent) if not m.startswith('_') and callable(getattr(agent, m, None))]
+        print(f'Instance methods: {instance_methods}')
+        
+        # Check specific capabilities
+        print('\n=== CAPABILITIES ===')
+        print(f'has forward: {hasattr(agent, "forward")}')
+        print(f'has imagine: {hasattr(agent, "imagine") or (hasattr(agent, "brain") and hasattr(agent.brain, "imagine"))}')
+        print(f'has export_pt: {hasattr(agent, "export_pt")}')
+        print(f'has export_onnx: {hasattr(agent, "export_onnx")}')
+        print(f'has replicate_quine: {hasattr(agent, "replicate_quine")}')
+        print(f'has get_quine_brain: {hasattr(agent, "get_quine_brain")}')
+        print(f'has verify_quine_integrity: {hasattr(agent, "verify_quine_integrity")}')
+        
+        # Check brain
+        if hasattr(agent, 'brain'):
+            print(f'\n=== BRAIN ===')
+            print(f'Brain type: {type(agent.brain).__name__}')
+            brain_methods = [m for m in dir(agent.brain) if not m.startswith('_') and callable(getattr(agent.brain, m, None))]
+            print(f'Brain methods: {brain_methods[:15]}...')
+            
+except Exception as e:
+    import traceback
+    print(f'Error: {e}')
+    traceback.print_exc()

models/tests/test_champion_full.py

@@ -0,0 +1,65 @@
+"""Test champion forward inference and HOLD."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+import champion_gen1000 as champ
+import numpy as np
+
+agent = champ.CapsuleAgent(observe=False, observe_visual=False)
+
+print('=== FORWARD INFERENCE TEST ===')
+inputs = {
+    'obs': np.random.randn(384).astype(np.float32),
+    'prev_action': 0,
+    'reset': True,
+    'frame': 0
+}
+result = agent.forward(inputs)
+print(f'Result keys: {list(result.keys())}')
+print(f'Action: {result.get("action")}')
+print(f'Action probs: {result.get("action_probs")}')
+print(f'Value: {result.get("value")}')
+
+latent = result.get('latent')
+if latent is not None:
+    print(f'Latent shape: {np.array(latent).shape}')
+
+print('\n=== FORWARD_HOLD TEST ===')
+try:
+    hold_result = agent.forward_hold(inputs)
+    print(f'Hold result keys: {list(hold_result.keys())}')
+    if 'hold_point' in hold_result:
+        hp = hold_result['hold_point']
+        print(f'Hold point type: {type(hp).__name__}')
+        if hasattr(hp, 'ai_choice'):
+            print(f'AI choice: {hp.ai_choice}')
+        if hasattr(hp, 'ai_confidence'):
+            print(f'AI confidence: {hp.ai_confidence}')
+        if hasattr(hp, 'merkle_root'):
+            print(f'Merkle root: {hp.merkle_root}')
+except Exception as e:
+    print(f'Hold test error: {e}')
+
+print('\n=== CASCADE IDENTITY ===')
+try:
+    identity = agent.get_cascade_identity()
+    print(f'Identity: {identity}')
+except Exception as e:
+    print(f'Identity error: {e}')
+
+print('\n=== README (first 500 chars) ===')
+readme = agent.get_readme()
+print(readme[:500] if readme else 'No readme')
+
+print('\n=== REPLICATE QUINE ===')
+try:
+    new_quine = champ.replicate_quine()
+    print(f'Replicated: {new_quine}')
+except Exception as e:
+    print(f'Replicate error: {e}')
+
+print('\n=== VERIFY INTEGRITY ===')
+try:
+    valid = champ.verify_quine_integrity()
+    print(f'Integrity valid: {valid}')
+except Exception as e:
+    print(f'Verify error: {e}')

models/tests/test_module_level.py

@@ -0,0 +1,15 @@
+"""Quick module-level test without loading brain."""
+import sys
+sys.path.insert(0, 'F:/End-Game/glassboxgames/children')
+import champion_gen1000 as champ
+
+print('=== MODULE LEVEL (no brain load) ===')
+print(f'Quine hash: {champ.get_quine_hash()}')
+print(f'Verify integrity: {champ.verify_quine_integrity()}')
+print(f'Action manifest: {champ.get_action_manifest()}')
+
+# Get brain directly
+print('\n=== GET QUINE BRAIN ===')
+brain = champ.get_quine_brain()
+print(f'Brain type: {type(brain).__name__}')
+print(f'Brain methods: {[m for m in dir(brain) if not m.startswith("_")]}')

models/tests/verify_champion.py

@@ -0,0 +1,44 @@
+"""Verify champion export capabilities."""
+import sys
+sys.path.insert(0, 'f:/End-Game/key')
+
+# Import the champion
+import champion_gen1000 as champ
+
+print('=== CHAMPION CAPABILITIES ===')
+print(f'Quine Hash: {champ._QUINE_HASH}')
+print(f'Generation: {champ._GENERATION}')
+print(f'Fitness: {champ._FITNESS}')
+
+# Try CapsuleAgent (the wrapper with exports)
+print('\n=== CAPSULE AGENT ===')
+agent = champ.CapsuleAgent()
+print(f'Agent type: {type(agent).__name__}')
+
+print('\n=== EXPORT CAPABILITIES ===')
+has_pt = hasattr(agent, 'export_pt')
+has_onnx = hasattr(agent, 'export_onnx')
+has_capsule = hasattr(agent, 'export_capsule')
+has_quine = hasattr(agent, 'get_quine_brain')
+has_replicate = hasattr(agent, 'replicate_quine')
+has_verify = hasattr(agent, 'verify_quine_integrity')
+
+print(f'Has export_pt: {has_pt}')
+print(f'Has export_onnx: {has_onnx}')
+print(f'Has export_capsule: {has_capsule}')
+print(f'Has get_quine_brain: {has_quine}')
+print(f'Has replicate_quine: {has_replicate}')
+print(f'Has verify_quine_integrity: {has_verify}')
+
+# Try to list all methods
+print('\n=== ALL PUBLIC METHODS ===')
+methods = [m for m in dir(agent) if not m.startswith('_') and callable(getattr(agent, m, None))]
+for m in methods:
+    print(f'  - {m}')
+
+# Also check module-level quine functions
+print('\n=== MODULE-LEVEL QUINE FUNCTIONS ===')
+print(f'get_quine_brain: {hasattr(champ, "get_quine_brain")}')
+print(f'replicate_quine: {hasattr(champ, "replicate_quine")}')
+print(f'verify_quine_integrity: {hasattr(champ, "verify_quine_integrity")}')
+print(f'load_quine_brain: {hasattr(champ, "load_quine_brain")}')