Update dataset card and ignore rules

.gitignore

@@ -0,0 +1,10 @@
+.idea/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.log
+.DS_Store
+Thumbs.db
+sc2/
+models/champion_gen*.py

README.md

@@ -0,0 +1,590 @@
+---
+pretty_name: Ouroboros-Key Dataset
+license: mit
+tags:
+  - quine
+  - neuroevolution
+  - provenance
+  - rl
+  - world-model
+language:
+  - en
+---
+
+# 🔑 Ouroboros-Key Dataset
+
+This repository contains the **Ouroboros-Key dataset**, generated by the KEY production system that **converts existing models** (e.g., `.pt`, `.onnx`, and other compute-oriented formats) into **quine-replicant capable models**, then evolves and verifies their replication behavior. World-model backends (DreamerV3/RSSM) are optional; the dataset reflects the conversion + evolution pipeline across arbitrary architectures.
+
+---
+
+# 📦 Dataset Card
+
+## Dataset Viewer Status
+
+Hugging Face’s dataset viewer can’t load this dataset because **splits use different file formats**. This repo intentionally contains multiple JSONL streams with distinct schemas. Use direct file download or load specific files programmatically instead of relying on the viewer.
+
+This repository contains a dataset generated by the **Ouroboros-Key** production neural network (a.k.a. the KEY system described below). The dataset captures structured traces of evolution, inference, and provenance events emitted during runs of the system.
+
+## Dataset Summary
+
+- **Name**: Ouroboros-Key Dataset
+- **Source System**: Ouroboros-Key (production KEY quine-conversion + evolution system)
+- **Domain**: Quine conversion, evolution telemetry, inference traces, and provenance metadata
+- **Format**: Line-delimited JSON (JSONL)
+- **Primary Files**: `*.jsonl` logs in this repo (see file list below)
+
+## Supported Tasks
+
+- Evolution analytics
+- Provenance auditing
+- System telemetry analysis
+- Log-based debugging and visualization
+
+## Languages
+
+- English (metadata fields, comments, and annotations)
+
+## Source / Reference
+
+This dataset is **populated by the production Ouroboros-Key system**. The README content below describes the system architecture and behavior that produce these logs.
+
+If you need a code reference, the producing system is the KEY stack in:
+
+- `children/` (local project root)
+- `children/cascade_hyperlattice/` (DreamerV3 + provenance stack)
+- `key/` (core conversion + evolution engine)
+
+## What the Dataset Contains
+
+Each JSONL file captures a specific stream of events or metrics emitted by the system. Typical record types include:
+
+- Evolution events (e.g., generations, mutations, selections)
+- Fitness evaluations and performance metrics
+- Speciation and population dynamics
+- TUI/diagnostic events
+- Provenance/trace metadata emitted by CASCADE-LATTICE
+
+## File Index (Exported Logs)
+
+- `evolution_events.jsonl` — event bus stream (state changes, pressure, convergence, mutations)
+- `fitness.jsonl` — fitness evaluations and scores
+- `mutations.jsonl` — mutation operations and deltas
+- `selection.jsonl` — selection steps and tournament outcomes
+- `speciation.jsonl` — clustering/species assignments
+- `performance.jsonl` — runtime performance telemetry
+- `errors.jsonl` — system errors and warnings
+- `tui_events.jsonl` — UI and operator interaction events
+- `crossovers.jsonl` — crossover operations and metadata
+
+## Schema (Authoritative)
+
+The **authoritative schemas** are defined in the KEY data contracts:
+
+- [key/DATA_CONTRACTS.md](key/DATA_CONTRACTS.md)
+
+Below is a concise summary of the primary log schemas represented in this dataset export.
+
+Each row is a JSON object. Common fields include (not all files include all fields):
+
+### Mutations (`mutations.jsonl`)
+- `timestamp` (epoch), `iso_time` — event time
+- `event` = `mutation`
+- `generation`, `parent_id`, `child_id`
+- `parent_fitness`, `mutation_rate`
+- `parent_traits`, `child_traits`, `deltas`, `mutated_traits`
+
+### Crossovers (`crossovers.jsonl`)
+- `timestamp`, `iso_time`, `event` = `crossover`
+- `generation`, `parent1_id`, `parent2_id`, `child_id`
+- `parent*_fitness`, `parent*_traits`, `child_traits`
+- `inheritance`, `contribution_p1`, `contribution_p2`
+
+### Selection (`selection.jsonl`)
+- `timestamp`, `iso_time`, `event` = `selection`
+- `generation`, `method`
+- `survivors`, `eliminated`, `elites_preserved`
+- `survivor_fitnesses`, `eliminated_fitnesses`
+
+### Speciation (`speciation.jsonl`)
+- `timestamp`, `iso_time`
+- `event` = `species_created|species_extinct|species_snapshot`
+- `generation`, `species_id`, `founder_id`, `initial_size`
+- `species_snapshot[]` (size/fitness/age/stagnation)
+
+### Fitness (`fitness.jsonl`)
+- `timestamp`, `iso_time`, `event` = `fitness_evaluation`
+- `generation`, `node_id`, `fitness_function`, `raw_fitness`
+- `components{...}`, `weights{...}`, `eval_time_ms`
+
+### Evolution Events (`evolution_events.jsonl`)
+- `event_id`, `event_type` (e.g., `state_change|pressure|convergence|vlm_inference|lora_mutation`)
+- `data{...}`, `timestamp`, `source`
+
+### TUI Events (`tui_events.jsonl`)
+- TUI-originated events (see [key/DATA_CONTRACTS.md](key/DATA_CONTRACTS.md))
+
+### Performance / Errors (`performance.jsonl`, `errors.jsonl`)
+- Runtime and error telemetry emitted by the worker/TUI pipeline
+
+## How It’s Produced
+
+The Ouroboros-Key system logs structured JSONL events via its internal event bus and logging system (see `logger.py` and `bus.py` in the KEY stack). In production, logs are written under `data/logs/` and exported into this repository as a dataset snapshot.
+
+## Intended Use
+
+- Reproducing experiments and auditing evolutionary runs
+- Analyzing policy evolution dynamics
+- Debugging and performance profiling
+- Research on provenance, interpretability, and agent behavior
+
+## Limitations
+
+- Schema may evolve between runs or versions of Ouroboros-Key
+- The dataset is an export snapshot; canonical write locations are defined in [key/DATA_CONTRACTS.md](key/DATA_CONTRACTS.md)
+- Some fields are optional or component-specific
+- Logs reflect system behavior and may include intermittent failures
+
+## Data Sensitivity / Privacy
+
+- No human PII is intended to be collected
+- Operator actions may appear in `tui_events.jsonl`
+- Scrub or filter logs before external publication if needed
+
+## License
+
+This dataset inherits the repository license: **MIT**.
+
+---
+
+# 🔑 System Reference (Ouroboros-Key)
+
+## 💰 Access + Learn
+
+**Get access to KEY and learn to convert your own models into self-replicating quines.**
+
+| Tier | Price |
+|------|-------|
+| Access | $50/month |
+| Guided | $150/month (+ ongoing coaching) |
+| Hands-On | $500 (I do one with you + support) |
+
+→ [Full pricing details](PRICING.md)
+
+**DM "access" on X: @Toasteedo**
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                       PopulationManager                          │
+│                  (NEAT-style speciation)                         │
+└───────────────────────────┬─────────────────────────────────────┘
+                            │
+        ┌───────────────────┼───────────────────┐
+        │                   │                   │
+   ┌────▼────┐         ┌────▼────┐         ┌────▼────┐
+   │  Node   │         │  Node   │         │  Node   │  × N
+   │ traits  │         │ traits  │         │ traits  │
+   │ + brain │         │ + brain │         │ + brain │
+   └────┬────┘         └────┬────┘         └────┬────┘
+        │                   │                   │
+        └───────────────────┼───────────────────┘
+                            │
+                    ┌───────▼───────┐
+                    │  DreamerBrain │ (~200M params)
+                    └───────┬───────┘
+                            │
+    ┌───────────────────────┼───────────────────────┐
+    │                       │                       │
+┌───▼───────────┐    ┌──────▼──────┐    ┌──────────▼──────┐
+│ RSSM Encoder  │    │ GRU Core    │    │ Stochastic      │
+│ Observations  │    │ Deterministic│    │ Latent (32×32)  │
+│ → Latent      │    │ State (4096) │    │ Categorical     │
+└───────────────┘    └──────┬──────┘    └─────────────────┘
+                            │
+              ┌─────────────┴─────────────┐
+              │                           │
+       ┌──────▼──────┐             ┌──────▼──────┐
+       │ Policy Head │             │ Value Head  │
+       │ 5 layers    │             │ 5 layers    │
+       │ (EVOLVED)   │             │ (EVOLVED)   │
+       └──────┬──────┘             └──────┬──────┘
+              │                           │
+           action                   value estimate
+```
+
+## DreamerV3 Size Presets
+
+| Size | Deter | Hidden | Params | Use Case |
+|------|-------|--------|--------|----------|
+| XS | 512 | 512 | ~10M | Development/testing |
+| S | 1024 | 1024 | ~22M | Basic tasks |
+| M | 2048 | 2048 | ~100M | Minecraft survival |
+| **L** | **4096** | **4096** | **~200M** | **Diamond mining (current)** |
+| XL | 8192 | 8192 | ~400M | Full game mastery |
+
+**Current config: L (200M params)** - Same size DreamerV3 used to obtain diamonds in Minecraft.
+
+## Features
+
+### Evolution Engine
+- **NEAT-style speciation**: Genetic distance clustering
+- **Fitness sharing**: Prevents monoculture
+- **Tournament selection**: With elitism preservation
+- **Buffered logging**: High-performance JSONL logging (50x faster than unbuffered)
+- **Config-driven sizes**: Switch between XS/S/M/L/XL via config.json
+
+### Brain Types
+
+| Brain | Parameters | Description |
+|-------|------------|-------------|
+| `DreamerBrain` | **~200M (L)** | World model with imagination + policy/value heads |
+| `EmbeddingBrain` | ~99K | Lightweight embedding brain (disabled by default) |
+| `MLPBrain` | ~1K | Simple feedforward baseline |
+
+### DreamerBrain (World Model)
+
+DreamerBrain uses the DreamerV3 RSSM architecture to imagine future trajectories:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         DreamerBrain                             │
+│                                                                  │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │   DreamerV3 RSSM (World Model)                            │   │
+│  │   - 4096-dim deterministic state (L size)                 │   │
+│  │   - 32×32 categorical stochastic state                    │   │
+│  │   - Imagines 15-step futures                              │   │
+│  └──────────────────────┬───────────────────────────────────┘   │
+│                         │                                        │
+│              ┌──────────┴──────────┐                             │
+│              │                     │                             │
+│       ┌──────▼──────┐       ┌──────▼──────┐                      │
+│       │ Policy Head │       │ Value Head  │                      │
+│       │ (EVOLVED)   │       │ (EVOLVED)   │                      │
+│       │ 5 layers    │       │ 5 layers    │                      │
+│       └──────┬──────┘       └──────┬──────┘                      │
+│              │                     │                             │
+│           action              value estimate                     │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+Unique capabilities:
+- **Imagination rollouts**: See all possible futures before acting
+- **Decision matrix visualization**: Each future trajectory rendered in Rerun
+- **JAX-native**: GPU-accelerated world model inference
+- **Evolved heads only**: World model is pretrained, only policy/value evolve
+
+### Perception (MiniLM)
+- **all-MiniLM-L6-v2**: Frozen 22M param sentence transformer
+- **384-dimensional** embeddings
+- **Evolved projection**: Transforms base embeddings
+
+### Generation (SmolLM) - Optional
+- **SmolLM-135M**: Lightweight generative model
+- **Cross-modal**: Embeddings influence generation temperature
+- Can be disabled for embedding-only mode
+
+### Provenance & Tracking
+- **cascade-lattice integration**: IPFS auto-logging of all events
+- **SwarmLattice**: Fire-and-forget spawn/exploration tracking
+- **Genesis root**: `89f940c1a4b7aa65` (common anchor for all provenance)
+- **Embedding hashes**: Tensor content hashing for reproducibility
+
+### HOLD System (Inference-Level Halt)
+- **Architectural halt**: Blocks inference until human/policy resolution
+- **CASCADE-LATTICE required**: No cascade = No HOLD
+- **Merkle-linked decisions**: Every hold point and resolution recorded
+- **Decision matrix exposed**: action_probs, value, imagined futures visible
+
+```python
+from hold import Hold, HoldPoint
+
+# In any brain's forward pass:
+resolution = Hold.get().yield_point(
+    action_probs=probs,
+    value=value,
+    observation=obs,
+    brain_id="my_brain",
+)
+# Blocks until: accept(), override(action), or timeout
+final_action = resolution.action
+```
+
+### Quine Manifold (Branching Realities)
+- **Brain instantiation**: Not simulation - actual brain clones
+- **Exponential branching**: 8 actions → 8^depth parallel brains
+- **Collapse strategies**: max_value, max_prob, random, or HOLD (manual)
+- **Defensive cloning**: High uncertainty triggers branch spawning
+
+```python
+from manifold import QuineManifold
+
+manifold = QuineManifold(brain)
+manifold.expand(depth=2)  # 64 parallel realities
+best = manifold.collapse('max_value')  # Or HOLD to pick manually
+```
+
+### Collective Memory (Swarm Intelligence)
+- **SEEK on observe**: Every forward() queries CASCADE for similar experiences
+- **Latent similarity**: Cosine search over historical latent states
+- **Soft bias**: Retrieved experiences gently influence action selection
+- **Cross-agent learning**: Agents share experiences through CASCADE tapes
+
+### Glass Box Visualization
+- **Rerun.io integration**: Real-time visualization of CASCADE events
+- **Full computational transparency**: Hidden states, weight snapshots, computation paths
+- **Single source of truth**: Rerun shows what CASCADE cryptographically proves
+- **DatasetUnity pipeline**: Evolved embedding-based dataset bridging with Kleene fixed-point matching
+
+### Metrics & Logging
+- **wandb integration**: Full experiment tracking
+- **sklearn metrics**: Silhouette, Davies-Bouldin, Calinski-Harabasz
+
+### Classic Features
+- **Violation Pressure**: Trait deviation from stability envelopes
+- **Attractors**: Kleene-style fixed point search
+- **Convergence**: Weighted trait merging with mutation
+
+## Installation
+
+```bash
+# Clone
+git clone https://github.com/your/key
+cd key
+
+# Install dependencies
+pip install -r requirements.txt
+
+# For GPU acceleration (CUDA 11.8+)
+pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118
+```
+
+## Quick Start
+
+### 1. Configure (config.json)
+
+```json
+{
+  "dreamer_brain": {
+    "enabled": true,
+    "size": "L",
+    "deter_dim": 4096,
+    "hidden_dim": 4096,
+    "policy_layers": 5,
+    "value_layers": 5
+  },
+  "fitness": {
+    "function": "dreamer"
+  },
+  "population": {
+    "size": 6
+  }
+}
+```
+
+### 2. Run TUI
+
+```bash
+python app.py
+```
+
+### 3. Glass Box Mode (Compiled Agents)
+
+```python
+from children.champion_gen1000 import CapsuleAgent
+
+# Launch with visualization
+agent = CapsuleAgent(observe_visual=True)  # Spawns Rerun viewer
+
+# Every inference is visualized with CASCADE proof
+result = agent.forward({"traits": {"x0": 0.5, "x1": 0.3}})
+print(f"Merkle: {result['_merkle_root']}")
+
+# Dataset bridging
+unity = agent.data_unity
+old = unity.embed(unity.load_dataframe(df_2023, "2023"))
+new = unity.embed(unity.load_dataframe(df_2024, "2024"))
+matches = unity.bridge(old, new, min_confidence=0.7)
+```
+
+**TUI Controls:**
+- `D` - Dashboard (pulse, VP gauges, event stream)
+- `P` - Population (start/stop evolution, view nodes)
+- `C` - Config (edit any setting with descriptions)
+- `L` - Logs (JSONL log viewer)
+- `X` - Explorer (causation graph)
+- `N` - Neural (brain inspector)
+- `Q` - Quit
+
+## Configuration
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `dreamer_brain.enabled` | `true` | Enable DreamerBrain world models |
+| `dreamer_brain.size` | `L` | Size preset (XS/S/M/L/XL) |
+| `dreamer_brain.deter_dim` | `4096` | Deterministic state dimension |
+| `dreamer_brain.hidden_dim` | `4096` | MLP hidden layer size |
+| `fitness.function` | `dreamer` | Fitness function (dreamer, benchmark) |
+| `population.size` | `6` | Population size |
+| `evolution.generations` | `1000` | Max generations |
+
+## Hardware Requirements
+
+| Size | VRAM | RAM | Time/Gen | Notes |
+|------|------|-----|----------|-------|
+| XS (512) | ~2GB | 8GB | ~10s | Development/testing |
+| S (1024) | ~4GB | 8GB | ~30s | Basic tasks |
+| M (2048) | ~8GB | 16GB | ~60s | Minecraft survival |
+| **L (4096)** | **~12GB** | **16GB** | **~80s** | **Diamond mining (current)** |
+| XL (8192) | ~24GB | 32GB | ~120s | Full game mastery |
+
+## Project Structure
+
+```
+key/
+├── app.py              # Textual TUI - main entry point
+├── run.py              # Headless evolution runner
+├── brain.py            # Brain interface + EmbeddingBrain
+├── dreamer_brain.py    # DreamerBrain - world model with imagination
+├── dreamerv3/          # DreamerV3 RSSM implementation (JAX)
+├── pod_brain.py        # PodBrain - multi-model with LoRA adapter
+├── pod.py              # Pod communication (Swarm broadcasts)
+├── node.py             # Node organism with traits + brain
+├── population.py       # NEAT-style population manager
+├── mobile.py           # Async swarm with SwarmLattice
+├── fitness.py          # Pluggable fitness interface
+├── fitness_comm.py     # Communication fitness (embedding similarity)
+│
+├── # Dataset Bridging
+├── bridge.py           # DatasetBridge with provenance
+├── kleene.py           # Fixed-point matching + batch_compare()
+│
+├── # Provenance Infrastructure
+├── swarm_lattice.py    # Fire-and-forget spawn/exploration tracking
+│
+├── checkpoints.py      # Save/load evolution state
+├── bus.py              # Event bus for logging
+├── logger.py           # JSONL logging system
+├── config.json         # Runtime configuration
+├── children/           # Compiled agent capsules
+└── requirements.txt    # Dependencies
+```
+
+## Usage Examples
+
+### Creating Nodes with DreamerBrain
+
+```python
+from brain import create_brain
+from node import Node
+
+# Create a DreamerBrain (world model with imagination)
+brain = create_brain('dreamer')
+
+# Create a Node with the brain
+node = Node(
+    traits={"exploration": 0.7, "caution": 0.3},
+    brain=brain
+)
+
+# Forward pass - get action + value
+output = brain.forward({"obs": observation})
+action = output["action"]       # Discrete action
+value = output["value"]         # Estimated value
+latent = output["latent"]       # 1536-dim latent state
+
+# Imagination - see possible futures
+futures = brain.imagine(n_trajectories=5, horizon=15)
+for i, trajectory in enumerate(futures):
+    print(f"Future {i}: value={trajectory[-1]['value']:.3f}")
+
+# Evolution - mutate policy/value heads
+child = brain.mutate(rate=0.1)
+```
+
+### Creating Nodes with PodBrains
+
+```python
+from pod_brain import create_pod_brain
+from node import Node, create_population
+
+# Create a PodBrain (multi-model with LoRA adapter)
+brain = create_pod_brain(lora_rank=16, voice_enabled=False)
+
+# Create a Node with the brain
+node = Node(
+    traits={"creativity": 0.7, "focus": 0.5},
+    brain=brain
+)
+
+# Use the brain via node.think()
+output = node.think({"text": "hello world"})
+embedding = output["embedding"]  # (384,) evolved embedding
+
+# Evolution
+child = node.mutate(rate=0.1, mutate_brain=True)
+```
+
+### Population with PodBrains
+
+```python
+from pod_brain import create_pod_brain
+from node import create_population
+
+# Brain factory
+def make_pod():
+    return create_pod_brain(lora_rank=8, voice_enabled=False)
+
+# Create population
+pop = create_population(
+    size=20,
+    trait_keys=["speed", "strength", "perception"],
+    brain_factory=make_pod
+)
+
+# All nodes have PodBrains
+for node in pop:
+    print(f"Node {node.id}: brain={node.brain.id[:8]}")
+```
+
+### Pod Communication (Swarm Broadcasts)
+
+```python
+from pod import Pod, Swarm
+
+# Create swarm of communicating pods
+swarm = Swarm(size=5, embed_dim=384)
+
+# Initialize with diverse states
+for pod, topic in zip(swarm.pods, ["alpha", "beta", "gamma", "delta", "epsilon"]):
+    pod.sense(topic)
+
+# Run convergence (broadcast, consensus, align)
+alignments = swarm.converge(rounds=5, align_rate=0.2)
+print(f"Final alignment: {alignments[-1]:.3f}")
+
+# Get leader (closest to consensus)
+leader = swarm.get_leader()
+```
+
+## Swarm Provenance
+
+Track agent spawning with fire-and-forget logging:
+
+```python
+from swarm_lattice import SwarmLattice
+
+lattice = SwarmLattice(log_dir='runs/swarm')
+record = lattice.record_spawn(
+    parent_id='genesis',
+    child_id=child_node.id,
+    mutation_rate=0.1,
+    generation=5,
+)
+print(f"Spawn merkle: {record.merkle_root}")
+```
+
+## License
+
+MIT