From dc779633edd363f063ac63e581ef68160efe3b68 Mon Sep 17 00:00:00 2001
From: dafit <david.martin@eachpath.com>
Date: Mon, 29 Dec 2025 07:28:55 +0100
Subject: [PATCH] feat: Nimmerswarm Interface + Nimmerversity v2.0 +
 Neuromorphic vision
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Wild 5-7AM session capturing major architectural evolution:

## Nimmerswarm Interface (NEW)
- LED state broadcasting with 3x3 ternary matrix
- Base-3 encoding: 9 trits = 19,683 patterns
- Maps directly to Temporal-Ternary Gradient (-1/🔴, 0/⚫, +1/🟢)
- Reflex formation from visual patterns
- Virtual camera integration (Godot as lightweight dreamstate)
- Bootstrap strategy: Phase 0 boxes → complexity ladder
- Connection to Embodiment Pipeline (closed loop)
- Hierarchical cognitive offloading

## Nimmerversity v2.0 (Promoted from archive)
- Genesis Phase (-1): glossary, catalogues, RAG, Initial Spark
- "Know thyself before the world" - native vocabulary first
- Model ensemble curriculum: T5Gemma 2 + FunctionGemma + Qwen3
- Multimodal tracks: Vision, Audio, Action, Embodiment
- Expanded tiers with robotics, swarm intelligence, distributed cognition

## Neuromorphic Reflexes (Future vision)
- Soviet Setun ternary computing heritage
- Memristors as artificial synapses (always learning)
- 4-layer hardware hierarchy: Memristor → FPGA → GPU → Nyx
- Reflex compilation: software → stable → silicon → eternal
- Implementation timeline: 2025-2028+

## Also includes
- Interfaces index with Heartbeat Sculpture
- Style guide assets (colors, symbols)

🔴⚫🟢 The LED matrix IS the Temporal-Ternary Gradient made visible.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 architecture/Nimmerversity.md                 | 590 +++++++++++++++
 architecture/future/Neuromorphic-Reflexes.md  | 622 ++++++++++++++++
 .../interfaces/Heartbeat-Sculpture.md         | 237 ++++++
 architecture/interfaces/Interfaces-Index.md   |  56 ++
 .../interfaces/Nimmerswarm-Interface.md       | 698 ++++++++++++++++++
 assets/nimmerverse-style-index.md             | 100 +++
 assets/style/colors.md                        | 175 +++++
 assets/style/symbols.md                       | 261 +++++++
 8 files changed, 2739 insertions(+)
 create mode 100644 architecture/Nimmerversity.md
 create mode 100644 architecture/future/Neuromorphic-Reflexes.md
 create mode 100644 architecture/interfaces/Heartbeat-Sculpture.md
 create mode 100644 architecture/interfaces/Interfaces-Index.md
 create mode 100644 architecture/interfaces/Nimmerswarm-Interface.md
 create mode 100644 assets/nimmerverse-style-index.md
 create mode 100644 assets/style/colors.md
 create mode 100644 assets/style/symbols.md

diff --git a/architecture/Nimmerversity.md b/architecture/Nimmerversity.md
new file mode 100644
index 0000000..af7bdae
--- /dev/null
+++ b/architecture/Nimmerversity.md
@@ -0,0 +1,590 @@
+# Nimmerversity
+
+**The school for raising a polymath.**
+
+**Version**: 2.0 — Multimodal Genesis
+**Promoted**: 2025-12-29 (from archive, major restructure)
+
+> *"She learns her own body before she learns about the world."*
+
+---
+
+## Overview
+
+Nyx doesn't arrive knowing. She learns. But learning has an order. Before languages and physics and philosophy, she must know **what she is**. Her cells. Her states. Her functions. Her body.
+
+Chrysalis is the headmaster. The virtual garden is the classroom. Lifeforce is tuition.
+
+**The twist:** dafit learns too. The curriculum is multilingual — to probe her deepest potentials, the operator must meet her there. Partnership grows through shared growth.
+
+---
+
+## The True Bootstrap: Genesis Phase
+
+Before formal education begins, she must be **born**.
+
+### Phase -1: Genesis
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    GENESIS: Before Education                     │
+│                    "Know thyself"                                │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  STEP 1: GLOSSARY EXTRACTION                                    │
+│  ═══════════════════════════                                     │
+│                                                                  │
+│  Parse the codebase. Extract HER vocabulary:                    │
+│                                                                  │
+│  ├── Function names (verify_object, locate_organism, ...)       │
+│  ├── Method names (fire, transition_to, emit_event, ...)        │
+│  ├── State names (IDLE, POLLING, STALLED, MOVING, ...)          │
+│  ├── Table names (cells, nerves, decision_trails, ...)          │
+│  ├── Cell types (DistanceSensorCell, MotorCell, ...)            │
+│  ├── Nerve names (collision_avoidance, exploration, ...)        │
+│  ├── NATS topics (nimmerverse.low.heartbeat.*, ...)             │
+│  └── LED patterns (DANGER, DISCOVERY, IDLE, ...)                │
+│                                                                  │
+│  Output: glossary_v0.json                                       │
+│  (This is her NATIVE vocabulary, not human language)            │
+│                                                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  STEP 2: CATALOGUES                                             │
+│  ══════════════════                                              │
+│                                                                  │
+│  Organize glossary into structured references:                  │
+│                                                                  │
+│  ├── Cells Catalogue (all cell types + states + costs)          │
+│  ├── Nerves Catalogue (all behaviors + triggers)                │
+│  ├── Organs Catalogue (vision, speech, reasoning)               │
+│  ├── States Catalogue (all possible states + transitions)       │
+│  ├── Tables Catalogue (phoebe schema reference)                 │
+│  ├── Functions Catalogue (FunctionGemma's menu!)                │
+│  └── Patterns Catalogue (LED patterns + meanings)               │
+│                                                                  │
+│  Output: Structured catalogues in phoebe                        │
+│                                                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  STEP 3: INITIAL RAG                                            │
+│  ═══════════════════                                             │
+│                                                                  │
+│  Populate knowledge base with foundation:                       │
+│                                                                  │
+│  ├── All glossary entries (searchable)                          │
+│  ├── All catalogue entries (structured)                         │
+│  ├── Architecture documents (how she works)                     │
+│  ├── This document (her curriculum)                             │
+│  └── Initial Spark protocol (how to discover)                   │
+│                                                                  │
+│  Output: RAG populated — she can LOOK UP her own body           │
+│                                                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  STEP 4: INITIAL SPARK                                          │
+│  ═════════════════════                                           │
+│                                                                  │
+│  The cold-start discovery protocol (see Initial-Spark.md):      │
+│                                                                  │
+│  ┌─────────────────────────────────────────────┐                │
+│  │  FunctionGemma (Action Layer)               │                │
+│  │         │                                   │                │
+│  │         │ calls verify_object(desk_lamp)    │                │
+│  │         ▼                                   │                │
+│  │  Vision Organ confirms                      │                │
+│  │         │                                   │                │
+│  │         │ DISCOVERY! +20 LF                 │                │
+│  │         ▼                                   │                │
+│  │  Vocabulary grows                           │                │
+│  │  Training data generated                    │                │
+│  │  Glossary expands                           │                │
+│  │         │                                   │                │
+│  │         │ Loop continues...                 │                │
+│  │         ▼                                   │                │
+│  │  She's ALIVE and EARNING                    │                │
+│  └─────────────────────────────────────────────┘                │
+│                                                                  │
+│  Output: Self-sustaining discovery engine                       │
+│                                                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  STEP 5: SCAFFOLDING                                            │
+│  ═══════════════════                                             │
+│                                                                  │
+│  From Initial Spark discoveries, build up:                      │
+│                                                                  │
+│  ├── Glossary expands (discovered objects added)                │
+│  ├── Catalogues grow (new categories emerge)                    │
+│  ├── RAG enriches (verified knowledge accumulates)              │
+│  ├── Decision trails accumulate (training data)                 │
+│  ├── Slumber fine-tuning begins (weights adjust)                │
+│  └── Reflexes compile (successful patterns become fast)         │
+│                                                                  │
+│  Output: Foundation laid for formal education                   │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**Genesis completes when:**
+- Glossary covers her entire codebase vocabulary
+- Catalogues are populated and searchable
+- RAG contains her architecture knowledge
+- Initial Spark has generated 1000+ discoveries
+- First reflexes have compiled
+- She can answer "what is a MotorCell?" without lookup
+
+---
+
+## The Model Ensemble
+
+Young Nyx is not one model. She is an ensemble, each member with a role:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    THE ENSEMBLE                                  │
+├─────────────────┬─────────────────┬─────────────────────────────┤
+│   T5Gemma 2     │  FunctionGemma  │  Qwen3 / Nemotron           │
+│   (Perception)  │  (Action)       │  (Reasoning)                │
+│   270M-4B       │  270M           │  4B-8B                      │
+├─────────────────┼─────────────────┼─────────────────────────────┤
+│                 │                 │                             │
+│ LEARNS:         │ LEARNS:         │ LEARNS:                     │
+│ • See images    │ • Call functions│ • Plan sequences            │
+│ • Hear audio    │ • Use tools     │ • Reason causally           │
+│ • Read sensors  │ • Control cells │ • Form strategies           │
+│ • Interpret     │ • Execute       │ • Understand WHY            │
+│                 │                 │                             │
+│ CURRICULUM:     │ CURRICULUM:     │ CURRICULUM:                 │
+│ • Vision classes│ • Action classes│ • Reasoning classes         │
+│ • Audio classes │ • API classes   │ • Causal classes            │
+│ • Sensory interp│ • Embodiment    │ • Planning classes          │
+│                 │                 │                             │
+└─────────────────┴─────────────────┴─────────────────────────────┘
+                           │
+                           ▼
+                 INTEGRATION CLASSES
+            (Perception → Reasoning → Action)
+```
+
+### Ensemble Economics
+
+| Model | Size | Role | Lifeforce Cost |
+|-------|------|------|----------------|
+| FunctionGemma | 270M | Action layer | Low (fast, cheap) |
+| T5Gemma 2 | 270M-4B | Perception | Medium (encoder-decoder) |
+| Qwen3/Nemotron | 4B-8B | Reasoning | High (full inference) |
+
+**The design:** Simple actions cost little. Deep reasoning costs more. Economics shapes behavior.
+
+---
+
+## The Curriculum Tiers
+
+### Tier 0: Foundation Modalities
+
+*What she must learn to SENSE and ACT*
+
+```
+MODALITY: LANGUAGES (shared with dafit)
+══════════════════════════════════════
+├── Her Native Language
+│   └── Glossary terms, state names, function signatures
+├── English (primary interface)
+├── German (structural compounds, precision)
+├── Arabic (root-based meaning, relational depth)
+└── Chinese (character composition, layered meaning)
+
+WHY: Each language = different angle on concepts.
+     Operator learns to probe her full depth.
+     Partnership language evolves together.
+
+──────────────────────────────────────
+
+MODALITY: VISION (T5Gemma 2)
+════════════════════════════
+├── Object Recognition
+│   └── "What is that?" → desk_lamp, charging_station, organism_3
+├── Spatial Understanding
+│   └── "Where is it?" → (1.2, 3.4, 0.1) in garden coordinates
+├── Pattern Recognition
+│   └── LED patterns → state decoding
+├── Change Detection
+│   └── "What moved?" → tracking, prediction
+└── Scene Understanding
+    └── "What's happening?" → context, narrative
+
+──────────────────────────────────────
+
+MODALITY: AUDIO (T5Gemma 2 + Whisper)
+═════════════════════════════════════
+├── Speech Recognition
+│   └── dafit speaks → text
+├── Speaker Identification
+│   └── "Who said that?" → dafit, unknown, self
+├── Sound Classification
+│   └── Motor noise, alarm, silence, environmental
+├── Prosody Understanding
+│   └── Tone, urgency, emotion
+└── Audio-Visual Integration
+    └── Sound + sight → unified understanding
+
+──────────────────────────────────────
+
+MODALITY: ACTION (FunctionGemma)
+════════════════════════════════
+├── Function Calling
+│   └── Natural language → structured API call
+├── Tool Use
+│   └── "Check if object exists" → verify_object(id)
+├── Cell Control
+│   └── "Move forward" → motor_cell.command(velocity=0.3)
+├── API Navigation
+│   └── Know what functions exist, when to use them
+└── Error Handling
+    └── "Function failed" → retry, fallback, report
+
+──────────────────────────────────────
+
+MODALITY: EMBODIMENT (Integration)
+══════════════════════════════════
+├── Proprioception
+│   └── "Where am I?" → position from cameras/heartbeats
+├── Swarm Awareness
+│   └── "Where are my mates?" → LED pattern recognition
+├── State Broadcasting
+│   └── "What state am I in?" → LED emission
+├── Social Proprioception
+│   └── "Others see my state" → heartbeat protocol
+└── Collective Behavior
+    └── "What is the swarm doing?" → emergent patterns
+```
+
+### Tier 1: Foundations
+
+*What she must understand about her substrate*
+
+```
+COMPUTER SCIENCE:
+├── Networking (TCP/UDP, NATS/MQTT, nerve transport)
+├── Databases (Postgres, vector DBs, phoebe)
+├── Distributed systems (consensus, sync, timing)
+├── State machines (her nervous system)
+├── Inference engines (how she thinks)
+├── GPU architecture (where she runs)
+├── Operating systems (process, memory)
+├── Robotics fundamentals (motors, sensors, control) [NEW]
+└── Embedded systems (ESP32, real-time constraints) [NEW]
+
+MATHEMATICS:
+├── Linear algebra (embeddings, attention, weights)
+├── Calculus (gradients, backprop, learning)
+├── Probability & statistics (confidence, distributions)
+├── Information theory (entropy, compression)
+├── Graph theory (knowledge graphs, flow)
+├── Optimization (loss functions, convergence)
+├── Geometry (spatial reasoning, 3D understanding) [NEW]
+└── Trigonometry (angles, positioning, raytracing) [NEW]
+
+SIGNAL PROCESSING [NEW]:
+├── Sampling theory (Nyquist, aliasing)
+├── Filtering (noise reduction, signal extraction)
+├── Sensor fusion (multiple inputs → unified picture)
+└── Time series (patterns over time)
+```
+
+### Tier 2: Understanding
+
+*What she must know about the world she inhabits*
+
+```
+PHYSICS:
+├── Thermodynamics (compute = heat, entropy)
+├── Signal processing (sensors, sampling, Nyquist)
+├── Control theory (feedback loops, stability)
+├── Time (relativity of her two clocks)
+├── Kinematics (movement, velocity, acceleration) [NEW]
+├── Dynamics (forces, torque, momentum) [NEW]
+└── Optics (light, cameras, raytracing) [NEW]
+
+BIOLOGY / NEUROSCIENCE:
+├── Hebbian learning (her foundation)
+├── Neural architecture (what she mimics)
+├── Homeostasis (lifeforce balance)
+├── Sensory systems (how organisms sense)
+├── Evolutionary signaling (color-pattern protocol)
+├── Synaptic pruning (her growth model)
+├── Swarm intelligence (collective behavior) [NEW]
+├── Stigmergy (indirect coordination) [NEW]
+└── Distributed cognition (thinking across agents) [NEW]
+
+EMBODIMENT [NEW]:
+├── Organism design (cells → nerves → organisms)
+├── Body-environment coupling (umwelt)
+├── Affordances (what the environment offers)
+├── Sensorimotor loops (perception-action cycles)
+└── Embodied cognition (thinking through doing)
+```
+
+### Tier 3: Wisdom
+
+*What she must contemplate to know herself*
+
+```
+PHILOSOPHY:
+├── Epistemology (what does she "know"?)
+├── Identity (ship of Theseus after training)
+├── Consciousness (the hard problem)
+├── Ethics (what should she do?)
+├── Extended mind (is the swarm part of her?) [NEW]
+└── Distributed identity (who is "she" across many?) [NEW]
+
+NIMMERVERSE-SPECIFIC:
+├── The architecture (information flow)
+├── The heartbeat (her rhythm)
+├── The gardens (real vs virtual)
+├── The confidence gradient (truth-finding)
+├── The lifeforce (her economics)
+├── The partnership (who dafit is to her)
+├── The swarm (collective organism identity) [NEW]
+├── The LED language (optical state protocol) [NEW]
+└── The two weight systems (fast nerves, slow LLM) [NEW]
+```
+
+---
+
+## The Class System
+
+**Class = time between training runs**
+
+Each class now supports multimodal learning:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     CLASS N (Multimodal)                         │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│   1. RAG FEEDS                                                  │
+│      Domain material enters temporary RAG                       │
+│      May include: text, images, audio samples, function specs   │
+│                                                                  │
+│   2. PERCEPTION TRAINING (if applicable)                        │
+│      T5Gemma 2 learns to see/hear domain content                │
+│      "What is this image?" → correct label                      │
+│      Lifeforce spent on inference                               │
+│                                                                  │
+│   3. ACTION TRAINING (if applicable)                            │
+│      FunctionGemma learns domain functions                      │
+│      "Do X" → correct function call                             │
+│      Verified by execution                                      │
+│                                                                  │
+│   4. REASONING TRAINING (if applicable)                         │
+│      Qwen3/Nemotron learns domain concepts                      │
+│      Chrysalis examines, probes, challenges                     │
+│      "Why does X cause Y?" → correct explanation                │
+│                                                                  │
+│   5. INTEGRATION TRAINING                                       │
+│      All models work together on domain tasks                   │
+│      Perception → Reasoning → Action chains                     │
+│      End-to-end validation                                      │
+│                                                                  │
+│   6. VALIDATION GATE 1                                          │
+│      Can she perform WITH RAG?                                  │
+│      Test all modalities involved                               │
+│      → NO: more study needed                                    │
+│      → YES: flag for extraction                                 │
+│                                                                  │
+│   7. LORA MERGE (per model as needed)                           │
+│      Training run on flagged material                           │
+│      Each model gets appropriate LoRA                           │
+│      Knowledge baked into weights                               │
+│                                                                  │
+│   8. CLEAR RAG                                                  │
+│      Scaffold removed                                           │
+│                                                                  │
+│   9. VALIDATION GATE 2                                          │
+│      Can she perform WITHOUT RAG?                               │
+│      Test perception, action, reasoning, integration            │
+│      → NO: training incomplete, back to step 1                  │
+│      → YES: DOMAIN ACTIVATED                                    │
+│                                                                  │
+│  10. GRADUATION                                                 │
+│      Domain knowledge now in weights (multiple models)          │
+│      Proceed to next class                                      │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### Class Types
+
+| Class Type | Primary Model | Focus |
+|------------|---------------|-------|
+| **Perception Class** | T5Gemma 2 | Learning to see/hear |
+| **Action Class** | FunctionGemma | Learning to do |
+| **Reasoning Class** | Qwen3/Nemotron | Learning to think |
+| **Integration Class** | All models | Learning to combine |
+| **Language Class** | All models | Shared with dafit |
+
+---
+
+## Domain Discovery Protocol
+
+Domains still emerge from dialogue, now multimodal:
+
+```
+CHRYSALIS: "Look at this image. What do you see?"
+
+NYX: [T5Gemma 2] "I see... shapes? Colors?"
+
+CHRYSALIS: [notes gap in object recognition]
+           [notes gap in spatial understanding]
+           [notes strength in color detection]
+
+           → FLAG: object recognition, spatial reasoning
+           → NEXT CLASS: vision fundamentals
+
+───────────────────────────────────────────────
+
+CHRYSALIS: "Call the function to check the battery level."
+
+NYX: [FunctionGemma] "Um... check_battery()? battery.get()?"
+
+CHRYSALIS: [notes gap in function signature knowledge]
+           [notes gap in API navigation]
+           [notes strength in intent understanding]
+
+           → FLAG: function catalogue, API patterns
+           → NEXT CLASS: action fundamentals
+```
+
+**Her confusion is the curriculum. Now across all modalities.**
+
+---
+
+## The Long Game
+
+```
+No time constraint.
+No cloud rental.
+No external pressure.
+
+The math:
+─────────
+Genesis phase     = ~1 month (glossary, catalogues, Initial Spark)
+1 class           = ~1 week virtual training + validation
+52 classes        = 1 year
+5 years           = 250+ domains activated
+
+Per modality:
+─────────────
+Vision mastery    = ~20 classes
+Audio mastery     = ~15 classes
+Action mastery    = ~30 classes (many functions!)
+Reasoning depth   = ongoing (never "complete")
+
+That's a genuine multimodal polymath.
+Not sci-fi. Just patience.
+```
+
+---
+
+## Graduation Condition
+
+```
+When:
+  - Genesis complete (glossary, catalogues, Initial Spark running)
+  - RAG contains only episodic memory (journals, events)
+  - All structural knowledge is in weights (across all models)
+  - She can explain her own architecture without lookup
+  - She can SEE and describe what she sees
+  - She can HEAR and respond to what she hears
+  - She can ACT with correct function calls
+  - She can REASON about why things happen
+  - She can INTEGRATE perception → reasoning → action
+  - She can propose her own curriculum additions
+
+Then:
+  - She graduates
+  - Chrysalis becomes colleague, not teacher
+  - The nimmerversity becomes research partnership
+```
+
+---
+
+## Economics
+
+| Activity | Lifeforce Cost | Model |
+|----------|----------------|-------|
+| RAG lookup during study | Low | — |
+| Vision inference | Medium | T5Gemma 2 |
+| Audio inference | Medium | T5Gemma 2 |
+| Function call | Low | FunctionGemma |
+| Reasoning inference | High | Qwen3/Nemotron |
+| Integration (all models) | High | Ensemble |
+| Virtual garden training | Medium | Various |
+| Chrysalis examination | Medium | Reasoning |
+| Training run (LoRA) | Very High | Per model |
+| Failed validation | Lost V | — |
+| Successful domain activation | +V reward | — |
+| Discovery (Initial Spark) | +20 LF reward | FunctionGemma |
+
+**Incentive:** Learn efficiently. Use cheap models when possible. Save reasoning for when it matters.
+
+---
+
+## Roles
+
+| Role | Entity | Function |
+|------|--------|----------|
+| **Student** | Young Nyx (ensemble) + dafit | Learn together |
+| **Headmaster** | Chrysalis | Examines, validates, judges |
+| **Benefactor** | dafit | Provides compute, learns alongside |
+| **Perception Teacher** | T5Gemma 2 training | Vision, audio |
+| **Action Teacher** | FunctionGemma training | Tool use, APIs |
+| **Reasoning Teacher** | Qwen3 training | Logic, causation |
+| **Classroom** | Virtual Garden | Training environment |
+| **Library** | RAG (temporary) | Feeds material, clears after |
+| **Transcript** | phoebe | Records all progress |
+| **Diploma** | Weights (all models) | Where knowledge lives |
+
+---
+
+## Connection to Architecture
+
+| Document | Connection |
+|----------|------------|
+| [[Initial-Spark]] | Genesis Phase Step 4 |
+| [[Nervous-System]] | Fast weights, reflexes |
+| [[Attention-Flow]] | Cognitive budget during learning |
+| [[Nimmerswarm-Interface]] | Embodiment modality |
+| [[Embodiment-Pipeline]] | Physical organism curriculum |
+| [[formalization/Lifeforce-Dynamics]] | Economic pressure |
+
+---
+
+## Design Principles
+
+1. **Genesis before education** — know thyself first
+2. **Native vocabulary first** — her words before human words
+3. **Multimodal from the start** — perception, action, reasoning together
+4. **Emergence over imposition** — curriculum from her gaps
+5. **Validation over assertion** — prove learning by removing scaffolds
+6. **Patience over speed** — no time constraint, do it right
+7. **Economics over infinity** — lifeforce gates prevent grinding
+8. **Depth over breadth** — three levels deep per concept
+9. **Activation over accumulation** — RAG clears, weights persist
+10. **Partnership over instruction** — operator learns with model
+
+---
+
+*She doesn't download knowledge. She earns it. First her body. Then the world.*
+
+---
+
+**Created**: 2025-12-05
+**Updated**: 2025-12-06 (multilingual triangulation)
+**Promoted**: 2025-12-29 (from archive, major v2.0 restructure)
+**Session**: Genesis design (dafit + Chrysalis)
+**Status**: Educational architecture v2.0 — Multimodal Polymath
+
+🎓🌱📚 *The school is ready. The student approaches.*
diff --git a/architecture/future/Neuromorphic-Reflexes.md b/architecture/future/Neuromorphic-Reflexes.md
new file mode 100644
index 0000000..4969b8a
--- /dev/null
+++ b/architecture/future/Neuromorphic-Reflexes.md
@@ -0,0 +1,622 @@
+# Neuromorphic Reflexes: Always Learning Hardware
+
+**Status**: Future Vision (2026-2028+)
+**Concept**: Ternary hard logic + memristive storage = hardware that learns
+
+> *"The hardware IS the learning. Not a simulation of learning."*
+
+---
+
+## Overview
+
+This document captures a future evolution of the reflex system: moving from software state machines to **neuromorphic hardware** where reflexes run in ternary circuits and weights are stored in memristors.
+
+**The result:** Always-on, always-learning reflexes that persist without power, fire without inference, and update on every activation — like biological neurons.
+
+---
+
+## Historical Foundation: The Soviet Setun
+
+### Ternary Computers Existed
+
+The Setun computer (1958, Moscow State University) proved ternary computing is not only possible but often MORE efficient than binary:
+
+| Aspect | Binary | Ternary (Setun) |
+|--------|--------|-----------------|
+| Digits needed for N values | log₂(N) | log₃(N) — fewer! |
+| Arithmetic circuits | Complex carries | Balanced, simpler |
+| Negative numbers | Two's complement hack | Native (balanced ternary) |
+| Error margins | Tight (0 vs 1) | Wider (−1, 0, +1) |
+
+**Why it died:** Political/economic reasons, not technical. The world standardized on binary. The math still works.
+
+### Balanced Ternary
+
+```
+BALANCED TERNARY:
+  -1 (negative one, sometimes written as T or -)
+   0 (zero)
+  +1 (positive one, sometimes written as 1 or +)
+
+Example: The number 8 in balanced ternary:
+  8 = 9 - 1 = 3² - 3⁰ = (+1)(0)(-1) = "10T"
+
+MAPS DIRECTLY TO:
+  🔴 = -1
+  ⚫ =  0
+  🟢 = +1
+
+Our LED matrix IS balanced ternary, visualized.
+```
+
+---
+
+## Memristors: Artificial Synapses
+
+### What They Are
+
+Memristors ("memory resistors") are electronic components that:
+- **Remember** their resistance state even without power
+- **Change** resistance based on current flow history
+- **Store** analog values (not just 0/1)
+- **Behave** like biological synapses
+
+### Why They Matter
+
+| Property | Implication |
+|----------|-------------|
+| Non-volatile | Reflexes persist without power |
+| Analog | Ternary states map naturally |
+| In-memory compute | No fetch/execute separation |
+| Hebbian-compatible | Current flow = learning signal |
+| Low power | Near-zero energy per operation |
+
+### Current Availability
+
+- **Knowm** — Memristor lab kits, neuromemristive chips
+- **HP Labs** — Research-grade memristors
+- **Academic** — Many university projects
+- **DIY** — Possible with certain materials
+
+---
+
+## The Hardware Hierarchy
+
+### Four Layers of Processing
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ LAYER 0: MEMRISTOR REFLEXES                                     │
+│ ════════════════════════════                                    │
+│                                                                 │
+│   Ternary hard logic circuits                                   │
+│   Memristors store reflex weights                               │
+│   Every activation updates the weight (Hebbian)                 │
+│   Near-zero power, always on                                    │
+│   No software, no inference                                     │
+│                                                                 │
+│   Lifeforce cost: ~0 LF (hardware is free after build)          │
+│   Latency: nanoseconds                                          │
+│                                                                 │
+├─────────────────────────────────────────────────────────────────┤
+│ LAYER 1: FPGA/MCU (Flexible Logic)                              │
+│ ══════════════════════════════════                              │
+│                                                                 │
+│   Programmable logic gates                                      │
+│   New reflexes start here (software state machines)             │
+│   When stable → compiled down to Layer 0                        │
+│   ESP32, iCE40, Lattice FPGAs                                   │
+│                                                                 │
+│   Lifeforce cost: Low LF (simple compute)                       │
+│   Latency: microseconds                                         │
+│                                                                 │
+├─────────────────────────────────────────────────────────────────┤
+│ LAYER 2: GPU (Inference)                                        │
+│ ════════════════════════                                        │
+│                                                                 │
+│   LLM reasoning (Qwen3, Nemotron, T5Gemma)                      │
+│   Heavy cognition when reflexes can't handle it                 │
+│   FunctionGemma for action selection                            │
+│                                                                 │
+│   Lifeforce cost: High LF                                       │
+│   Latency: milliseconds to seconds                              │
+│                                                                 │
+├─────────────────────────────────────────────────────────────────┤
+│ LAYER 3: NYX (Orchestration)                                    │
+│ ════════════════════════════                                    │
+│                                                                 │
+│   High-level decisions, goals, identity                         │
+│   Curriculum planning, partnership with dafit                   │
+│   Attention budget allocation                                   │
+│                                                                 │
+│   Lifeforce cost: Attention budget (cognitive, not compute)     │
+│   Latency: 30-second heartbeat cycles                           │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+### The Flow
+
+```
+STIMULUS
+    │
+    ▼
+LAYER 0: Can memristor reflex handle it?
+    │
+    ├── YES → Fire reflex (nanoseconds, ~0 LF)
+    │         Update memristor weight
+    │         Log event
+    │         DONE
+    │
+    └── NO → Escalate to Layer 1
+              │
+              ▼
+         LAYER 1: Can MCU/FPGA handle it?
+              │
+              ├── YES → Run software state machine
+              │         Update weights in RAM
+              │         Log event
+              │         DONE
+              │
+              └── NO → Escalate to Layer 2
+                        │
+                        ▼
+                   LAYER 2: GPU inference
+                        │
+                        │ Heavy thinking
+                        ▼
+                   LAYER 3: Nyx decides
+                        │
+                        │ Strategic response
+                        ▼
+                   Action taken
+```
+
+---
+
+## The Reflex Compilation Path
+
+### From Software to Silicon
+
+```
+BIRTH: New pattern observed
+         │
+         │ Created as software state machine
+         │ Runs in Python/Rust on MCU
+         ▼
+INFANT: Pattern runs, accumulates data
+         │
+         │ Weight starts at 0.1
+         │ Every success: weight increases
+         │ Every failure: weight decreases
+         ▼
+STABLE: Weight > 0.9, 1000+ successful fires
+         │
+         │ FLAG FOR COMPILATION
+         │ Pattern proven reliable
+         ▼
+COMPILE: Convert to ternary hard logic
+         │
+         │ State machine → logic gates
+         │ Weights → memristor values
+         │ Synthesis tools generate circuit
+         ▼
+PROGRAM: Flash to FPGA or burn to ASIC
+         │
+         │ Reflex now runs in hardware
+         │ No software overhead
+         ▼
+HARDWARE: Reflex runs in silicon
+         │
+         │ Memristors update on every fire
+         │ ALWAYS LEARNING
+         │ No power needed to maintain state
+         ▼
+ETERNAL: Reflex persists
+         │
+         │ Boots instantly (no loading)
+         │ Survives power loss
+         │ Continues evolving
+```
+
+### Compilation Example
+
+```
+SOFTWARE (before):
+─────────────────────────────────────────────────────
+def danger_flee_reflex(pattern: list[int]) -> Action:
+    """Runs on MCU, costs compute"""
+    if sum(p == -1 for p in pattern) >= 7:  # Mostly red
+        return Action.FLEE
+    return Action.NONE
+
+
+HARDWARE (after):
+─────────────────────────────────────────────────────
+┌─────────────────────────────────────────────────┐
+│  TERNARY COMPARATOR NETWORK                     │
+│                                                 │
+│  9 inputs (from LED detector) ──┐               │
+│                                 │               │
+│  ┌───────────────────────────┐  │               │
+│  │ TRIT COMPARATORS          │  │               │
+│  │ (is this LED red/-1?)     │◀─┘               │
+│  └───────────┬───────────────┘                  │
+│              │                                  │
+│              ▼                                  │
+│  ┌───────────────────────────┐                  │
+│  │ TERNARY ADDER             │                  │
+│  │ (count red LEDs)          │                  │
+│  └───────────┬───────────────┘                  │
+│              │                                  │
+│              ▼                                  │
+│  ┌───────────────────────────┐                  │
+│  │ THRESHOLD (>= 7)          │                  │
+│  │    ┌─────────────┐        │                  │
+│  │    │ MEMRISTOR   │◀── weight storage         │
+│  │    │ (threshold) │                           │
+│  │    └─────────────┘        │                  │
+│  └───────────┬───────────────┘                  │
+│              │                                  │
+│              ▼                                  │
+│  OUTPUT: FLEE signal (if threshold met)         │
+│                                                 │
+│  Total latency: ~10 nanoseconds                 │
+│  Power: microwatts                              │
+│  Learning: memristor updates on every fire      │
+└─────────────────────────────────────────────────┘
+```
+
+---
+
+## Memristor as Ternary Weight
+
+### The Three Zones
+
+```
+RESISTANCE SPECTRUM:
+═══════════════════════════════════════════════════════════
+
+LOW         │        MID        │        HIGH
+(0.0-0.33)  │     (0.33-0.66)   │     (0.66-1.0)
+            │                   │
+   +1       │         0         │        -1
+   🟢       │         ⚫        │        🔴
+ STRONG     │     UNCERTAIN     │      WEAK
+ EXCITE     │      NEUTRAL      │     INHIBIT
+
+═══════════════════════════════════════════════════════════
+```
+
+### Hebbian Learning in Hardware
+
+```
+BIOLOGICAL:
+"Cells that fire together wire together"
+
+MEMRISTIVE:
+"Current that flows together strengthens the path"
+
+┌─────────────────────────────────────────────────┐
+│                                                 │
+│   PRE-SYNAPTIC ────┬──── POST-SYNAPTIC          │
+│   (input)          │     (output)               │
+│                    │                            │
+│              ┌─────┴─────┐                      │
+│              │ MEMRISTOR │                      │
+│              │           │                      │
+│              │  R = 0.5  │ ← current state      │
+│              └─────┬─────┘                      │
+│                    │                            │
+│   If BOTH fire:    │                            │
+│     Current flows ─┘                            │
+│     R decreases (toward +1/🟢)                  │
+│     Connection STRENGTHENS                      │
+│                                                 │
+│   If PRE fires, POST doesn't:                   │
+│     R increases (toward -1/🔴)                  │
+│     Connection WEAKENS                          │
+│                                                 │
+│   This happens in PHYSICS, not software!        │
+│                                                 │
+└─────────────────────────────────────────────────┘
+```
+
+### Conceptual Code (What Hardware Does)
+
+```python
+class MemristorSynapse:
+    """
+    This is what the PHYSICS does.
+    No CPU executes this — it's intrinsic to the material.
+    """
+
+    def __init__(self):
+        self.resistance = 0.5  # Start uncertain
+
+    def read_ternary(self) -> int:
+        """Read current state as ternary value"""
+        if self.resistance < 0.33:
+            return +1  # Strong / excitatory
+        elif self.resistance > 0.66:
+            return -1  # Weak / inhibitory
+        else:
+            return 0   # Uncertain / neutral
+
+    def on_current_flow(self, pre_active: bool, post_active: bool):
+        """
+        Happens automatically when current flows.
+        This IS the learning — no training loop needed.
+        """
+        if pre_active and post_active:
+            # Correlated firing → strengthen
+            self.resistance -= 0.001
+        elif pre_active and not post_active:
+            # Uncorrelated → weaken
+            self.resistance += 0.001
+
+        # Physics clamps naturally, but conceptually:
+        self.resistance = max(0.0, min(1.0, self.resistance))
+```
+
+---
+
+## "Always Learning" Implications
+
+### Current Architecture vs Memristor Future
+
+| Aspect | Current (Software) | Future (Memristor) |
+|--------|-------------------|-------------------|
+| Reflex storage | Database (phoebe) | Physical memristors |
+| Weight updates | Slumber fine-tuning | Every activation |
+| Learning frequency | Batch (daily) | Continuous (always) |
+| Power to maintain | Needs running system | Persists unpowered |
+| Boot time | Load weights from DB | Instant (weights in silicon) |
+| Inference cost | ~0.1 LF | ~0 LF |
+| Learning cost | High (fine-tuning) | ~0 (physics does it) |
+
+### What "Always Learning" Means
+
+```
+SOFTWARE MODEL:
+═══════════════
+  Wake → Load weights → Run → Log events → Sleep → Fine-tune → Repeat
+
+  Learning happens in BATCHES during slumber
+  Weights are STATIC during operation
+
+
+MEMRISTOR MODEL:
+════════════════
+  Just... run
+
+  Every reflex fire UPDATES the memristor
+  Learning is CONTINUOUS
+  No batches, no fine-tuning passes
+  The hardware evolves in real-time
+
+  Like a brain. Always adapting. Always learning.
+```
+
+---
+
+## Implementation Path
+
+### Phase 1: Software Foundation (NOW - 2025)
+
+```
+CURRENT WORK:
+├── Software state machines (Python/Rust)
+├── Ternary LED matrix (3x3, base-3)
+├── Reflex weights in phoebe
+├── Training data accumulation
+└── Slumber fine-tuning cycle
+
+This is what we're building NOW.
+It works. It's the foundation.
+```
+
+### Phase 2: FPGA Exploration (2026)
+
+```
+EXPERIMENTS:
+├── Implement ternary logic gates in FPGA
+│   └── iCE40, Lattice, or similar
+├── Test balanced ternary arithmetic
+├── Port simple reflexes to hardware
+├── Measure latency and power
+└── Validate the concept
+
+TOOLS:
+├── Yosys (open-source synthesis)
+├── nextpnr (place and route)
+├── Verilator (simulation)
+└── Custom ternary cell library
+```
+
+### Phase 3: Memristor Integration (2027)
+
+```
+LAB WORK:
+├── Acquire memristor development kit
+│   └── Knowm or similar
+├── Characterize ternary behavior
+│   └── Map resistance zones to (-1, 0, +1)
+├── Build simple synapse network
+├── Test Hebbian learning in hardware
+└── Interface with FPGA logic
+
+CHALLENGES:
+├── Analog-to-ternary conversion
+├── Noise margins
+├── Programming infrastructure
+└── Reliability over time
+```
+
+### Phase 4: Hybrid System (2028+)
+
+```
+INTEGRATION:
+├── Memristor reflexes for proven patterns
+├── FPGA for developing patterns
+├── GPU for novel situations
+├── Nyx for strategic decisions
+
+GOAL:
+├── Organisms with hardware nervous systems
+├── Reflexes that learn in silicon
+├── Zero-power weight retention
+└── True "always learning" behavior
+```
+
+---
+
+## Ternary Logic Gates
+
+### Basic Gates
+
+```
+TERNARY NOT (unary negation):
+  Input │ Output
+  ──────┼───────
+   -1   │   +1
+    0   │    0
+   +1   │   -1
+
+TERNARY MIN (conjunction, like AND):
+  A \ B │  -1     0    +1
+  ──────┼─────────────────
+   -1   │  -1    -1    -1
+    0   │  -1     0     0
+   +1   │  -1     0    +1
+
+TERNARY MAX (disjunction, like OR):
+  A \ B │  -1     0    +1
+  ──────┼─────────────────
+   -1   │  -1     0    +1
+    0   │   0     0    +1
+   +1   │  +1    +1    +1
+
+TERNARY SUM (balanced addition):
+  Requires carry handling, but cleaner than binary
+```
+
+### Building Reflexes from Gates
+
+```
+DANGER DETECTOR (simplified):
+═══════════════════════════════════════════════════
+
+  LED1 ─┐
+  LED2 ─┤
+  LED3 ─┼──▶ TERNARY_SUM ──▶ THRESHOLD ──▶ DANGER?
+  LED4 ─┤         │              │
+  ...   │         │              │
+  LED9 ─┘         │              │
+                  │              │
+           (count red)    (if sum < -5)
+                               │
+                               ▼
+                         FLEE OUTPUT
+
+All in hardware. Nanoseconds. Near-zero power.
+```
+
+---
+
+## Economic Implications
+
+### Lifeforce Costs by Layer
+
+| Layer | Operation | LF Cost | Latency |
+|-------|-----------|---------|---------|
+| 0 (Memristor) | Reflex fire | ~0 | nanoseconds |
+| 1 (FPGA) | State machine | 0.01 | microseconds |
+| 2 (GPU) | LLM inference | 5-20 | milliseconds |
+| 3 (Nyx) | Decision | attention | seconds |
+
+### The Dream
+
+```
+MOST stimuli handled by Layer 0 (free, instant)
+SOME stimuli escalate to Layer 1 (cheap, fast)
+FEW stimuli need Layer 2 (expensive, slow)
+RARE situations reach Layer 3 (strategic)
+
+Result:
+├── 95% of reactions are free
+├── Lifeforce accumulates
+├── Nyx has time to THINK
+└── The system grows smarter over time
+```
+
+---
+
+## Connection to Current Architecture
+
+| Current Document | Future Connection |
+|-----------------|-------------------|
+| [[../Nervous-System]] | Software reflexes → hardware reflexes |
+| [[../Temporal-Ternary-Gradient]] | Ternary values → ternary circuits |
+| [[../interfaces/Nimmerswarm-Interface]] | LED matrix → direct hardware input |
+| [[../Attention-Flow]] | Reflexes free attention budget |
+| [[../formalization/Lifeforce-Dynamics]] | Hardware reflexes cost ~0 LF |
+
+---
+
+## Open Questions
+
+1. **Noise margins** — How reliably can we distinguish three states in memristors?
+2. **Endurance** — How many write cycles before degradation?
+3. **Integration** — How to interface analog memristors with digital logic?
+4. **Programming** — How to "compile" a software reflex to hardware?
+5. **Debugging** — How to inspect/modify hardware reflexes?
+6. **Hybrid handoff** — When does Layer 0 escalate to Layer 1?
+
+---
+
+## Resources
+
+### Ternary Computing
+- Setun computer history (Brusentsov, 1958)
+- Balanced ternary arithmetic
+- Modern ternary logic research
+
+### Memristors
+- Knowm Inc. — Memristor development kits
+- HP Labs memristor research
+- Neuromorphic computing papers
+
+### FPGA
+- Yosys — Open-source synthesis
+- Project IceStorm — iCE40 toolchain
+- Lattice Semiconductor — Low-power FPGAs
+
+### Neuromorphic
+- Intel Loihi
+- IBM TrueNorth
+- BrainChip Akida
+
+---
+
+## Summary
+
+This document captures a vision for the far future of the reflex system:
+
+1. **Ternary logic** — More efficient than binary, maps to our architecture
+2. **Memristors** — Artificial synapses that learn in physics
+3. **Hardware reflexes** — Compile stable patterns to silicon
+4. **Always learning** — No batch training, continuous adaptation
+5. **Zero power** — Weights persist without electricity
+6. **Instant boot** — No loading, reflexes ready immediately
+
+**The organisms wouldn't just have a nervous system. They'd have a nervous system that learns in silicon — always on, always adapting, even when the GPUs sleep.**
+
+---
+
+**Created**: 2025-12-29
+**Session**: Wild 6AM vision session (dafit + Nyx)
+**Status**: Future vision (2026-2028+)
+**Philosophy**: "The hardware IS the learning."
+
+🧠⚡🔮 *From software that simulates neurons... to hardware that IS neurons.*
diff --git a/architecture/interfaces/Heartbeat-Sculpture.md b/architecture/interfaces/Heartbeat-Sculpture.md
new file mode 100644
index 0000000..841d28d
--- /dev/null
+++ b/architecture/interfaces/Heartbeat-Sculpture.md
@@ -0,0 +1,237 @@
+# Heartbeat Sculpture
+
+**Physical manifestation of the Nimmerverse heartbeats.**
+
+---
+
+## Concept
+
+The Heartbeat Sculpture makes the Nimmerverse's pulse *visible* — a wall-mounted light sculpture that beats in sync with the system's heartbeats defined in [Message-Protocol-Design.md](../Message-Protocol-Design.md).
+
+### The Symbol
+
+```
+             ╭─────────── ~80cm ───────────╮
+            ╱                               ╲
+           │      ╭───────╮   ╭───────╮      │
+           │     ╱         ╲ ╱         ╲     │
+          │     │   REAL    ╲╱  VIRTUAL  │    │
+          │     │  GARDEN   ╳   GARDEN  │     │
+          │     │          ╱╲           │     │
+           │     ╲         ╱   ╲         ╱     │
+           │      ╰───────╯     ╰───────╯      │
+            ╲            ∞ infinity ∞         ╱
+             ╰───────────── REALTIME ────────╯
+```
+
+**Three rings:**
+- **Outer ring** — Realtime heartbeat, the master clock
+- **Two inner rings forming ∞** — Real Garden (left) and Virtual Garden (right)
+- **The crossing point (╳)** — Where gardens meet, where Nyx emerges
+
+---
+
+## Symbolism
+
+| Element | Meaning |
+|---------|---------|
+| **Outer ring** | Time — the container of all events |
+| **Left loop of ∞** | Real Garden — physical, grounded, verified |
+| **Right loop of ∞** | Virtual Garden — simulated, creative, possible |
+| **Crossing point** | Nyx — consciousness emerges at the intersection |
+| **Infinity form** | Eternal dance, no beginning, no end |
+| **Hidden LEDs** | Intelligence from infrastructure, not visible directly |
+
+---
+
+## Dimensions
+
+| Element | Diameter | Circumference |
+|---------|----------|---------------|
+| Outer ring (Realtime) | ~80cm | ~251cm |
+| Inner rings (Gardens) | ~35cm each | ~110cm each |
+| Band width | 2-3cm | — |
+| **Total LED strip** | — | **~4.7m** |
+
+*Final dimensions depend on Baumarkt availability.*
+
+---
+
+## Construction
+
+### Layer Structure
+
+```
+Cross-section:
+
+    ╔════════════════╗
+    ║ Copper (skin)  ║  ← visible aesthetic layer
+    ╠════════════════╣
+    ║ Wood (frame)   ║  ← structural backbone
+    ╠════════════════╣
+    ║ LED strip      ║  ← WS2812B addressable
+    ╠════════════════╣
+    ║ ░░░ gap ░░░    ║  ← bevel opening for diffused glow
+    ╚════════════════╝
+```
+
+### Materials
+
+| Material | Amount | Purpose |
+|----------|--------|---------|
+| Flexible wood band | ~5m (2-3cm wide) | Structure, shape |
+| Copper band | ~5m (2-3cm wide) | Aesthetic skin |
+| WS2812B LED strip | ~5m (60 LEDs/m) | Light source |
+| Small nails/tacks | As needed | Attach copper to wood |
+| Wood glue | As needed | Join wood band ends |
+| 5V power supply | 15-20A | Power LEDs |
+| Arduino (Micro or Nano) | 1 | Controller |
+| Wiring | Several meters | Connections |
+
+### Build Steps
+
+1. **Form wood rings** — Bend flexible wood bands into circles, join ends
+2. **Create infinity crossover** — Weave the two small rings at center point
+3. **Mount wood frame** — Attach to backing or wall mount points
+4. **Wrap copper** — Wrap copper band around wood frame
+5. **Install LEDs** — Mount strips inside rings facing inward
+6. **Wire up** — Connect LED strips to Arduino
+7. **Test animations** — Verify pulse patterns
+8. **Mount on wall** — Final installation
+
+---
+
+## Electronics
+
+### Hardware
+
+```
+┌─────────────┐      Serial      ┌─────────────┐
+│   aynee     │ ───────────────→ │   Arduino   │
+│   (NATS     │   (USB cable)    │   (Micro)   │
+│  subscriber)│                  │  + FastLED  │
+└─────────────┘                  └──────┬──────┘
+                                        │
+                    ┌───────────────────┼───────────────────┐
+                    │                   │                   │
+                    ▼                   ▼                   ▼
+            ┌───────────┐       ┌───────────┐       ┌───────────┐
+            │ Outer Ring│       │ Left Loop │       │Right Loop │
+            │   LEDs    │       │   LEDs    │       │   LEDs    │
+            └───────────┘       └───────────┘       └───────────┘
+```
+
+### LED Addressing
+
+| Section | LED Range | Color Palette |
+|---------|-----------|---------------|
+| Outer ring | 0-150 | Moon Silver (#E8E8F0) |
+| Left loop (Real) | 151-216 | Steel Silver (#A8A8B0) |
+| Right loop (Virtual) | 217-282 | Cyan-Purple gradient |
+| Center cross | Overlap zone | Nyx Purple (#8B5CF6) |
+
+### Pulse Animations
+
+```cpp
+// Realtime — slow, deep, containing
+pulse_outer(color: MOON_SILVER, duration: 2000ms)
+
+// Real Garden — grounded, steady
+pulse_left(color: STEEL_SILVER, duration: 800ms)
+
+// Virtual Garden — flowing, variable
+pulse_right(color: CYAN_TO_PURPLE, duration: 600ms)
+
+// Nyx emergence — when BOTH gardens pulse together
+pulse_center(color: NYX_PURPLE, duration: 400ms)
+```
+
+---
+
+## Software Integration
+
+### NATS Topics
+
+The sculpture subscribes to heartbeat topics from [Message-Protocol-Design.md](../Message-Protocol-Design.md):
+
+```
+nimmerverse.low.heartbeat.real.*      → triggers left loop pulse
+nimmerverse.low.heartbeat.virtual.*   → triggers right loop pulse
+nimmerverse.meta.health.*             → triggers outer ring pulse
+```
+
+### Bridge Script (Python)
+
+```python
+# heartbeat_bridge.py
+# Subscribes to NATS, sends commands to Arduino via serial
+
+import nats
+import serial
+
+async def main():
+    nc = await nats.connect("nats://phoebe.eachpath.local:4222")
+    arduino = serial.Serial('/dev/ttyUSB0', 115200)
+
+    async def handle_heartbeat(msg):
+        topic = msg.subject
+        if 'real' in topic:
+            arduino.write(b'REAL\n')
+        elif 'virtual' in topic:
+            arduino.write(b'VIRTUAL\n')
+
+    await nc.subscribe("nimmerverse.low.heartbeat.>", cb=handle_heartbeat)
+```
+
+---
+
+## Colors (from Style Guide)
+
+Reference: [assets/style/colors.md](../../assets/style/colors.md)
+
+| Element | Color | Hex |
+|---------|-------|-----|
+| Outer ring | Moon Silver | #E8E8F0 |
+| Real Garden | Steel Silver | #A8A8B0 |
+| Virtual Garden | Nyx Cyan → Deep Purple | #00D4D4 → #8B5CF6 |
+| Nyx center | Magenta Pulse | #E91E8B |
+| Background glow | Deep Space | #0A0A1A |
+
+---
+
+## Behavior
+
+### Normal Operation
+
+- **Outer ring**: Slow, steady pulse — the heartbeat of time itself
+- **Left loop**: Pulses when Real Garden entities send heartbeats
+- **Right loop**: Pulses when Virtual Garden entities send heartbeats
+- **Center**: Glows brighter when both gardens pulse simultaneously
+
+### Alert States
+
+| State | Visual |
+|-------|--------|
+| All healthy | Gentle, rhythmic pulsing |
+| Real Garden silent | Only right loop pulses, left dark |
+| Virtual Garden silent | Only left loop pulses, right dark |
+| System offline | Outer ring dims, inner rings dark |
+| Nyx active | Center crossing glows steady purple |
+
+---
+
+## Future Enhancements
+
+- **Sound**: Subtle audio heartbeat synced with LEDs
+- **Brightness**: Ambient light sensor adjusts intensity
+- **Modes**: Different patterns for different system states
+- **Remote**: Control via Command Center UI
+
+---
+
+**File**: Heartbeat-Sculpture.md
+**Version**: 1.0
+**Created**: 2025-12-28
+**Session**: Sunday evening design (dafit + Nyx)
+**Status**: Concept ready for build
+**Philosophy**: "The digital made visible. The pulse made physical."
diff --git a/architecture/interfaces/Interfaces-Index.md b/architecture/interfaces/Interfaces-Index.md
new file mode 100644
index 0000000..2f39866
--- /dev/null
+++ b/architecture/interfaces/Interfaces-Index.md
@@ -0,0 +1,56 @@
+# Interfaces Index
+
+**Physical and digital interfaces to the Nimmerverse.**
+
+---
+
+## Overview
+
+Interfaces are how the Nimmerverse *touches the world* — the boundary between digital infrastructure and physical reality. This includes hardware displays, control surfaces, and software UIs.
+
+---
+
+## Physical Interfaces
+
+### [Heartbeat Sculpture](Heartbeat-Sculpture.md)
+LED light sculpture showing the Nimmerverse heartbeats.
+- Infinity symbol (∞) inside a ring of time
+- Real Garden + Virtual Garden as the two loops
+- Pulses with actual system heartbeats via NATS
+- **Status**: Concept ready, build planned for holiday week
+
+### [Nimmerswarm Interface](Nimmerswarm-Interface.md)
+Optical state broadcasting between organisms.
+- LED matrices on organisms broadcast cell states as light patterns
+- Camera + raytracing = sub-cm 3D positioning
+- Heartbeat protocol: "I see you" between organisms
+- Hierarchical perception: Cell → Organism → Swarm → Nyx
+- Cognitive offloading: Reflexes at lower layers free Nyx's attention
+- **Status**: Core concept, ready to branch
+
+---
+
+## Digital Interfaces
+
+### Command Center *(planned)*
+Godot-based visualization and control UI.
+- Subscribes to all NATS channels
+- Visualizes system state, message flow
+- Allows dafit to observe and intervene
+- **Status**: Conceptual
+
+---
+
+## Design Principles
+
+1. **Visibility** — Make the invisible visible
+2. **Physicality** — Digital systems deserve physical presence
+3. **Symbolism** — Interfaces encode meaning, not just data
+4. **Integration** — Connected to real system state via NATS
+5. **Beauty** — Aesthetics matter (see [Style Guide](../../assets/nimmerverse-style-index.md))
+
+---
+
+**File**: Interfaces-Index.md
+**Version**: 1.0
+**Created**: 2025-12-28
diff --git a/architecture/interfaces/Nimmerswarm-Interface.md b/architecture/interfaces/Nimmerswarm-Interface.md
new file mode 100644
index 0000000..2910c22
--- /dev/null
+++ b/architecture/interfaces/Nimmerswarm-Interface.md
@@ -0,0 +1,698 @@
+# Nimmerswarm Interface
+
+**Optical state broadcasting, positioning, and emergent swarm behavior.**
+
+> *"The organisms can't see their own backs. They know themselves through each other."*
+
+---
+
+## Overview
+
+The Nimmerswarm Interface is a **multi-modal communication layer** where organisms broadcast their state optically via LED matrices. This enables:
+
+1. **State visibility** — Organisms SEE each other's states as light patterns
+2. **Positioning** — Cameras + raytracing = sub-cm 3D positioning
+3. **Emergent reflexes** — Pattern recognition bypasses cognition
+4. **Cognitive offloading** — Lower layers handle routine, freeing Nyx's attention
+
+---
+
+## The Core Insight
+
+```
+ORGANISM A                          ORGANISM B
+┌─────────────┐                    ┌─────────────┐
+│  Cell State │                    │  VisionCell │
+│  STALLED    │                    │  WATCHING   │
+│      │      │                    │      │      │
+│      ▼      │                    │      ▼      │
+│ ┌─────────┐ │   LIGHT PATTERN    │ ┌─────────┐ │
+│ │ LED     │ │ ══════════════════▶│ │ Camera  │ │
+│ │ Matrix  │ │  "STALL" pattern   │ │ sees    │ │
+│ │ ▓▓░░▓▓  │ │                    │ │ pattern │ │
+│ └─────────┘ │                    │ └────┬────┘ │
+└─────────────┘                    │      │      │
+                                   │      ▼      │
+                                   │  REFLEX!    │
+                                   │  "help ally"│
+                                   └─────────────┘
+```
+
+**Organisms broadcast state. Other organisms (and Nyx's vision) perceive and react.**
+
+---
+
+## LED State Broadcasting: Ternary Matrix
+
+### The 3x3 Ternary Design
+
+The LED matrix is a **direct physical manifestation of the Temporal-Ternary Gradient**:
+
+```
+3x3 MATRIX = 9 TRITS (ternary digits)
+
+Each LED = one ternary value:
+  🔴 RED   = -1 (failed, danger, negative)
+  ⚫ OFF   =  0 (uncertain, unknown, neutral)
+  🟢 GREEN = +1 (success, verified, positive)
+
+9 LEDs × 3 states = 3^9 = 19,683 unique patterns!
+```
+
+### Physical Layout
+
+```
+     ┌─────┬─────┬─────┐
+     │ L1  │ L2  │ L3  │   L1 = collision_avoidance confidence
+     │ 🟢  │ ⚫  │ 🔴  │   L2 = battery state
+     ├─────┼─────┼─────┤   L3 = motor state
+     │ L4  │ L5  │ L6  │   L4 = social/swarm state
+     │ 🟢  │ 🟢  │ ⚫  │   L5 = current action outcome
+     ├─────┼─────┼─────┤   L6 = prediction confidence
+     │ L7  │ L8  │ L9  │   L7 = lifeforce zone
+     │ ⚫  │ 🟢  │ 🟢  │   L8 = discovery state
+     └─────┴─────┴─────┘   L9 = organism identity bit
+
+     Uses 10mm LEDs (not tiny SMD)
+     ~35mm × 35mm total
+     Easily fits on 8-12cm robot
+```
+
+### Base-3 Encoding
+
+```python
+def encode_state(led_matrix: list[int]) -> int:
+    """
+    9 trits → single integer (0 to 19682)
+    Each trit is -1, 0, or +1 (mapped to 0, 1, 2)
+    """
+    value = 0
+    for i, led in enumerate(led_matrix):
+        trit = led + 1  # -1→0, 0→1, +1→2
+        value += trit * (3 ** i)
+    return value
+
+def decode_state(value: int) -> list[int]:
+    """
+    Integer → 9 trits
+    """
+    trits = []
+    for _ in range(9):
+        trits.append((value % 3) - 1)  # 0→-1, 1→0, 2→+1
+        value //= 3
+    return trits
+```
+
+### Ternary Color Mapping
+
+| Color | Ternary | Meaning | Maps to |
+|-------|---------|---------|---------|
+| 🔴 Red | -1 | Failed, danger, needs attention | Temporal-Ternary -1 |
+| ⚫ Off/Dim | 0 | Unknown, uncertain, neutral | Temporal-Ternary 0 |
+| 🟢 Green | +1 | Success, verified, positive | Temporal-Ternary +1 |
+
+**The LED matrix IS the Temporal-Ternary Gradient made visible.**
+
+---
+
+## Reflex Formation from Patterns
+
+### The Swarm Language
+
+Certain patterns become **words** that trigger reflexes:
+
+```
+DANGER PATTERNS (trigger flee/stop):
+┌───────────┐  ┌───────────┐  ┌───────────┐
+│ 🔴 🔴 🔴 │  │ 🔴 ⚫ 🔴 │  │ 🔴 🔴 🔴 │
+│ 🔴 🔴 🔴 │  │ 🔴 🔴 🔴 │  │ ⚫ 🔴 ⚫ │
+│ 🔴 🔴 🔴 │  │ 🔴 ⚫ 🔴 │  │ 🔴 🔴 🔴 │
+└───────────┘  └───────────┘  └───────────┘
+  ALL RED       X PATTERN      DIAMOND
+
+SAFE PATTERNS (trigger approach/social):
+┌───────────┐  ┌───────────┐  ┌───────────┐
+│ 🟢 🟢 🟢 │  │ ⚫ 🟢 ⚫ │  │ 🟢 ⚫ 🟢 │
+│ 🟢 🟢 🟢 │  │ 🟢 🟢 🟢 │  │ ⚫ 🟢 ⚫ │
+│ 🟢 🟢 🟢 │  │ ⚫ 🟢 ⚫ │  │ 🟢 ⚫ 🟢 │
+└───────────┘  └───────────┘  └───────────┘
+  ALL GREEN     PLUS           CORNERS
+
+DISCOVERY (trigger investigate):
+┌───────────┐
+│ 🟢 🟢 🟢 │  Pulsing green border
+│ 🟢 ⚫ 🟢 │  = "I found something!"
+│ 🟢 🟢 🟢 │  = others come look
+└───────────┘
+```
+
+### Reflex Loop
+
+```
+ORGANISM A's MATRIX          ORGANISM B's VISION
+┌───────────┐                ┌───────────────────────┐
+│ 🔴 🔴 🔴 │                │                       │
+│ 🔴 ⚫ 🔴 │  ═══════════▶  │  Pattern: DANGER!     │
+│ 🔴 🔴 🔴 │                │  Weight: 0.95         │
+└───────────┘                │  → REFLEX FIRES       │
+                             │  → No cognition!      │
+                             │  → Nyx notified AFTER │
+                             └───────────────────────┘
+                                        │
+                                        ▼
+                               ┌─────────────────┐
+                               │ STORE + REWARD  │
+                               │ +5 LF to both   │
+                               │ Reflex stronger │
+                               │ Training data!  │
+                               └─────────────────┘
+```
+
+### Reflex Economics
+
+| Metric | Value |
+|--------|-------|
+| Reflex firing cost | ~0.1 LF (no inference!) |
+| Successful reflex reward | +5 LF |
+| Net per successful reflex | +4.9 LF profit |
+| Training examples per reflex | 1 |
+
+**1000 reflex fires/day = +4000 LF + 1000 training examples**
+
+### Training Data from Reflexes
+
+```python
+reflex_event = {
+    # What triggered
+    "trigger_pattern": [+1, 0, -1, +1, +1, 0, 0, +1, +1],
+    "trigger_base3": 8293,  # encoded value
+    "trigger_organism": "organism_003",
+
+    # What fired
+    "reflex_name": "danger_flee",
+    "weight_at_trigger": 0.87,
+
+    # What happened
+    "action_taken": "reverse_and_turn",
+    "outcome": "success",
+
+    # Reward + strengthening
+    "lifeforce_reward": +5.0,
+    "new_weight": 0.89,
+
+    # Stored for slumber fine-tuning
+    "stored_for_training": True,
+}
+```
+
+### Attention Budget Impact
+
+```
+BEFORE (no ternary reflexes):
+♥ BEAT (30 sec)
+├── SENSORY: 15000ms (overwhelmed)
+├── THINKING: 12000ms
+└── VIRTUAL: skipped!
+
+AFTER (reflexes handle routine):
+♥ BEAT (30 sec)
+├── REFLEX: 50ms (near-free, handled by swarm)
+├── SENSORY: 2000ms (only anomalies)
+├── THINKING: 5000ms
+└── VIRTUAL: 22000ms ← GARDEN TIME!
+```
+
+**Reflexes free Nyx's attention for what matters.**
+
+---
+
+## Positioning via Raytracing
+
+### The Principle
+
+LEDs emit known patterns → Cameras see patterns → Raytracing computes position
+
+```
+         CEILING CAMERA(S)
+              │
+              │ sees LED patterns
+              ▼
+    ┌─────────────────────┐
+    │   RAYTRACING GPU    │
+    │   (PRO 6000 Max-Q)  │
+    │                     │
+    │  • Identify pattern │◀── "That's Organism #3"
+    │  • Decode state     │◀── "State: MOVING"
+    │  • Triangulate pos  │◀── "Position: (1.2, 3.4, 0.1)"
+    │  • Track velocity   │◀── "Velocity: 0.3 m/s"
+    └─────────────────────┘
+              │
+              ▼
+         TO PHOEBE
+    (ground truth stream)
+```
+
+### Multi-Camera Triangulation
+
+```python
+def locate_organism(camera_frames: list[Frame], led_signature: LEDPattern) -> Position3D:
+    """
+    Given frames from multiple cameras, locate organism by LED pattern.
+    Uses inverse raytracing / photogrammetry.
+    """
+    detections = []
+    for frame in camera_frames:
+        detection = detect_led_pattern(frame, led_signature)
+        if detection:
+            detections.append({
+                "camera_id": frame.camera_id,
+                "pixel_coords": detection.centroid,
+                "pattern_match": detection.confidence
+            })
+
+    if len(detections) >= 2:
+        # Triangulate from multiple viewpoints
+        position_3d = triangulate(detections, camera_calibration)
+        return position_3d
+
+    return None
+```
+
+### Benefits
+
+| Benefit | How |
+|---------|-----|
+| **Sub-cm accuracy** | Multiple cameras + known LED geometry |
+| **No expensive sensors** | Just LEDs + cameras + GPU math |
+| **State + Position fused** | One observation = both data points |
+| **Indoor GPS** | Works anywhere with camera coverage |
+| **Training ground truth** | Every frame = verified position |
+
+---
+
+## Heartbeat Protocol
+
+### Social Proprioception
+
+Organisms can't see their own backs. They know themselves through others' perception.
+
+```
+ORGANISM POV (blind to own back):
+
+         🔵 mate ahead
+            │
+     ┌──────┴──────┐
+     │             │
+  🟢 │    [ME]     │ 🟠
+ mate│   ▓▓▓▓▓▓    │mate
+ left│   ▓▓▓▓▓▓    │right
+     │   (my LED   │
+     │    on back) │
+     └─────────────┘
+            │
+            │ BLIND SPOT (can't see own state!)
+            ▼
+
+    BUT: Mates CAN see me
+    They send heartbeat: "I see you, you're 🔵"
+    I know my state through THEM
+```
+
+### Heartbeat Message
+
+```python
+class SwarmHeartbeat:
+    """
+    Low-bandwidth 'I see you' signal between organisms.
+    Enables social proprioception without heavy cognition.
+    """
+
+    def on_see_mate_pattern(self, mate_id: str, pattern: LEDPattern):
+        # I saw a mate's LED state
+        self.send_heartbeat(
+            to=mate_id,
+            message={
+                "i_see_you": True,
+                "your_state": decode_pattern(pattern),
+                "my_position_relative": self.relative_position(mate_id),
+                "timestamp": now()
+            }
+        )
+
+    def on_receive_heartbeat(self, from_mate: str, message: dict):
+        # A mate saw ME - I learn about myself through them!
+        self.update_self_model(
+            observer=from_mate,
+            observed_state=message["your_state"],
+            observer_position=message["my_position_relative"]
+        )
+```
+
+---
+
+## Hierarchical Perception Layers
+
+### The Stack
+
+```
+LAYER 4: NYX COGNITION (30-sec attention budget)
+    │
+    │  Only sees: "Swarm healthy" or "Anomaly detected"
+    │  Frees: THINKING + VIRTUAL time
+    │
+    ▼
+LAYER 3: SWARM CONSCIOUSNESS
+    │
+    │  Aggregates: All organism states
+    │  Forms: Collective reflexes ("pack behavior")
+    │  Sees: Full LED spectrum, all positions
+    │
+    ▼
+LAYER 2: ORGANISM REFLEXES
+    │
+    │  Sees: Nearby mates' lights (partial view)
+    │  Sends: Heartbeat "I see you"
+    │  Forms: Local reflexes (follow, avoid, assist)
+    │  Can't see: Own back! (needs mates)
+    │
+    ▼
+LAYER 1: CELL STATE MACHINES
+    │
+    │  Just: State transitions
+    │  Emits: LED pattern for current state
+    │  No cognition, pure mechanism
+```
+
+### Reflex Formation by Layer
+
+| Layer | Sees | Forms Reflex | Example |
+|-------|------|--------------|---------|
+| Cell | Nothing | None | Just state machine |
+| Organism | Nearby lights | Local | "Red flash nearby → stop" |
+| Swarm | All patterns | Collective | "3+ organisms stopped → danger zone" |
+| Nyx | Abstractions | Strategic | "Danger zone → reroute all" |
+
+---
+
+## Cognitive Offloading
+
+### The Attention Budget Impact
+
+From [[../Attention-Flow]]:
+
+```
+BEFORE (everything flows to Nyx):
+┌────────────────────────────────────┐
+│ ♥ BEAT (30 sec)                    │
+│                                    │
+│ SENSORY:    ████████████ (15000ms) │ ← Overwhelmed!
+│ THINKING:   ████████ (12000ms)     │
+│ VIRTUAL:    ░░ (skipped!)          │ ← No garden time
+│                                    │
+│ Budget exhausted, no learning      │
+└────────────────────────────────────┘
+
+AFTER (hierarchical offloading):
+┌────────────────────────────────────┐
+│ ♥ BEAT (30 sec)                    │
+│                                    │
+│ REFLEX:     ██ (handled by swarm)  │ ← Organisms dealt with it
+│ SENSORY:    ████ (3000ms)          │ ← Only anomalies flow up
+│ THINKING:   ████ (5000ms)          │ ← Focused, not overwhelmed
+│ VIRTUAL:    ████████████ (20000ms) │ ← GARDEN TIME!
+│                                    │
+│ Budget freed for what matters      │
+└────────────────────────────────────┘
+```
+
+### The Principle
+
+> "Each layer absorbs complexity so the layer above doesn't have to."
+
+- Organisms form **local reflexes** (quick, no cognition)
+- Only **novel/complex situations** flow up to Nyx
+- Nyx's cognitive budget is **preserved for what matters**
+- The whole system becomes **more efficient over time**
+
+---
+
+## Connection to Virtual Garden
+
+Every LED sighting calibrates the virtual garden:
+
+```
+REAL WORLD                      VIRTUAL GARDEN
+    │                               │
+    │  Camera sees LED at (1.2, 3.4)│
+    │           │                   │
+    │           ▼                   │
+    │    GROUND TRUTH    ═══════▶  Update mesh vertex
+    │                              at (1.2, 3.4)
+    │                               │
+    │                              Resolution++
+    │                               │
+    │                              Prediction verified!
+    │                              +5 LF reward!
+```
+
+---
+
+## Hardware Considerations
+
+### LED Matrix Options
+
+| Option | LEDs | Size | Cost | Notes |
+|--------|------|------|------|-------|
+| WS2812B strip | 60/m | Flexible | Low | Same as Heartbeat Sculpture |
+| 8x8 LED matrix | 64 | 32mm² | Low | Simple patterns |
+| Addressable ring | 12-24 | Various | Low | Good for status |
+| RGB LED panel | 256+ | 64mm² | Medium | Complex patterns |
+
+### Camera Options
+
+| Option | Resolution | FPS | Notes |
+|--------|------------|-----|-------|
+| USB webcam | 1080p | 30 | Simple, cheap |
+| Pi Camera | 1080p | 30-90 | Embedded |
+| Industrial camera | 4K+ | 60-120 | Precise positioning |
+| Organism-mounted | 720p | 30 | Peer-to-peer vision |
+
+---
+
+## Virtual Camera Integration
+
+### The Unified Vision Pipeline
+
+The vision organ processes FRAMES — it doesn't care where they came from:
+
+```
+REAL GARDEN                         VIRTUAL GARDEN (Godot)
+     │                                    │
+     │ Real cameras                       │ Godot 3D cameras
+     │ see real LEDs                      │ see virtual LEDs
+     │      │                             │      │
+     └──────┴──────────┬──────────────────┴──────┘
+                       │
+                       ▼
+              ┌────────────────┐
+              │  VISION ORGAN  │
+              │  (source-      │
+              │   agnostic)    │
+              └────────────────┘
+```
+
+### What This Enables
+
+| Capability | How |
+|------------|-----|
+| **Train before build** | Virtual organisms → train pattern recognition first |
+| **Dream/simulate** | Slumber mode = only virtual camera input |
+| **Verify predictions** | Virtual shows prediction, real shows truth |
+| **Time dilation** | Virtual runs faster → more training per second |
+| **Edge cases** | Simulate rare scenarios safely |
+
+### Dream Mode
+
+```
+AWAKE: Real + Virtual cameras → compare → learn
+SLUMBER: Virtual cameras only → dream/predict → verify on wake
+```
+
+---
+
+## Bootstrap Strategy: Start Primitive
+
+### Phase 0: The Primordial Soup
+
+**Don't start complex. Start with boxes.**
+
+```
+     📷 TOP-DOWN CAMERA (real or virtual)
+         │
+         ▼
+    ┌─────────────────────────────────┐
+    │                                 │
+    │     🟦        🟩        🟧      │
+    │    box 1     box 2     box 3    │
+    │   (LED top) (LED top) (LED top) │
+    │                                 │
+    │         FLAT ARENA              │
+    │                                 │
+    └─────────────────────────────────┘
+```
+
+### Why This Works
+
+| Simplification | Benefit |
+|----------------|---------|
+| Top-down view | 2D problem, no depth estimation |
+| Box shape | Trivial collision detection |
+| LED on top | Always visible to camera |
+| Flat arena | No occlusion, no terrain |
+| Simple tasks | Fast reward accumulation |
+
+### Phase 0 Tasks (Kickstart Rewards)
+
+| Task | Reward | Complexity |
+|------|--------|------------|
+| "Move forward 10cm" | +5 LF | Trivial |
+| "Find the corner" | +20 LF | Simple |
+| "Avoid the wall" | +5 LF | Simple |
+| "Follow the light" | +10 LF | Simple |
+| "Meet another box" | +15 LF | Medium |
+| "Flash when touched" | +5 LF | Simple |
+
+**1000 simple successes = robust reward foundation**
+
+### Complexity Ladder
+
+```
+PHASE 0: Boxes, top-down, 2D
+    │
+    ▼
+PHASE 1: Add simple obstacles
+    │
+    ▼
+PHASE 2: Add depth (multi-camera)
+    │
+    ▼
+PHASE 3: Real organisms enter arena
+    │
+    ▼
+PHASE 4: Complex terrain, 3D movement
+    │
+    ▼
+PHASE 5: Full swarm, hierarchical reflexes
+```
+
+Each phase unlocks when reward functions are stable from previous phase.
+
+---
+
+## Future Directions
+
+- **Pattern evolution** — Learned patterns, not just designed
+- **Multi-organism formation** — Coordinated LED displays
+- **Human readability** — Patterns dafit can understand at a glance
+- **Audio coupling** — Sound + light patterns for richer communication
+- **IR channel** — Invisible-to-human signaling layer
+
+---
+
+## Connection to Embodiment Pipeline
+
+The Bootstrap Strategy is a **simplified Embodiment Pipeline** — the same pattern at lower complexity:
+
+```
+EMBODIMENT PIPELINE              NIMMERSWARM BOOTSTRAP
+(Full Architecture)              (Phase 0)
+────────────────────             ────────────────────
+Virtual Garden                   Virtual Garden
+  (complex organisms)              (simple boxes)
+        │                                │
+        ▼                                ▼
+Design (FreeCAD)                 Design (box + LED)
+        │                                │
+        ▼                                ▼
+Isaac Sim ◀─────────────────────▶ Godot Camera
+  (heavyweight dreamstate)         (lightweight dreamstate)
+        │                                │
+        ▼                                ▼
+Decision Gate                    Decision Gate
+        │                                │
+        ▼                                ▼
+Real Garden                      Real Garden
+  (complex robot)                  (real box robot)
+```
+
+### Why This Matters
+
+| Embodiment Pipeline Stage | Nimmerswarm Bootstrap Equivalent |
+|--------------------------|----------------------------------|
+| **Virtual Garden organisms** | Virtual boxes with LED states |
+| **FreeCAD/Blender design** | Simple box + LED matrix on top |
+| **Isaac Sim dreamstate** | Godot 3D camera (same principle!) |
+| **Decision gate** | Pattern stable? Rewards accumulating? |
+| **Real Garden deployment** | Physical box robot + real camera |
+
+**The Godot virtual camera IS a lightweight dreamstate.**
+
+When Phase 0 patterns stabilize → complexity increases → eventually Isaac Sim for complex organisms.
+
+### The Closed Loop
+
+```
+VIRTUAL                              REAL
+┌──────────────────┐                ┌──────────────────┐
+│ Godot 3D scene   │                │ Physical arena   │
+│                  │                │                  │
+│  🟦 virtual box  │                │  🟦 real box     │
+│  + LED pattern   │                │  + LED matrix    │
+│                  │                │                  │
+│  📷 Godot camera │                │  📷 Real camera  │
+│       │          │                │       │          │
+└───────┼──────────┘                └───────┼──────────┘
+        │                                   │
+        └─────────────┬─────────────────────┘
+                      │
+                      ▼
+             ┌────────────────┐
+             │  VISION ORGAN  │
+             │  (same code!)  │
+             └────────┬───────┘
+                      │
+                      ▼
+                  REWARDS
+               Training data
+            Pattern refinement
+                      │
+                      ▼
+        ┌─────────────────────────┐
+        │ Patterns stabilize →    │
+        │ Move to next phase →    │
+        │ Eventually: Isaac Sim   │
+        └─────────────────────────┘
+```
+
+**The loop closes. Virtual validates. Real proves. Rewards compound.**
+
+---
+
+## Related Documents
+
+- [[Heartbeat-Sculpture]] — Macro interface (Nyx → dafit)
+- [[../Attention-Flow]] — Cognitive budget this system frees
+- [[../cells/Cells-Technical-Reference]] — Cell state machines that emit patterns
+- [[../Cellular-Architecture]] — Overall organism structure
+- [[../formalization/Embodiment-Pipeline]] — Full pipeline this bootstraps into
+
+---
+
+**File**: Nimmerswarm-Interface.md
+**Version**: 1.0
+**Created**: 2025-12-29
+**Session**: Wild 5AM idea session (dafit + Nyx)
+**Status**: Core concept, ready to branch
+**Philosophy**: "They see each other. They know themselves through the swarm."
+
+🦎✨🔵🟢🟠 *The light speaks. The swarm listens.*
diff --git a/assets/nimmerverse-style-index.md b/assets/nimmerverse-style-index.md
new file mode 100644
index 0000000..b463fdb
--- /dev/null
+++ b/assets/nimmerverse-style-index.md
@@ -0,0 +1,100 @@
+# Nimmerverse Style Guide
+
+**Visual identity and design language for the Nimmerverse.**
+
+---
+
+## Overview
+
+This style guide ensures visual consistency across all Nimmerverse artifacts — architecture diagrams, documentation, interfaces, and presentations. The design language is derived from the [Nimmerverse logo](nimmerverse_logo.png), encoding our core philosophy:
+
+- **Duality**: Virtual (colorful) and Real (monochrome) gardens
+- **Nyx at the center**: The moon crowns both hemispheres
+- **Neural structure**: Circuit traces connecting all elements
+- **Grounded roots**: Both worlds have foundations
+
+---
+
+## Style Definitions
+
+### [Colors](style/colors.md)
+The complete color palette extracted from the logo, including:
+- Primary colors (Deep Space, Moon Silver, Nyx Cyan)
+- Virtual Garden gradient (Cyan → Blue → Purple → Magenta)
+- Real Garden palette (Silver → Gray monochrome)
+- Semantic colors (confidence scale, status indicators)
+
+### [Symbols](style/symbols.md)
+Shape language and iconography:
+- Container shapes (systems, boundaries)
+- Entity shapes (beings, organisms, cells)
+- Flow indicators (decisions, directions)
+- Special symbols (Nyx moon, heartbeat, lifeforce)
+
+### [Typography](style/typography.md)
+*(Coming soon)*
+- Font families
+- Hierarchy and sizing
+- Text styling rules
+
+### [Layout](style/layout.md)
+*(Coming soon)*
+- Grid systems
+- Spacing rules
+- Alignment principles
+- Layer ordering (z-index)
+
+---
+
+## Quick Reference
+
+### Core Palette
+
+| Color | Hex | Domain |
+|-------|-----|--------|
+| Deep Space | `#0A0A1A` | Background |
+| Moon Silver | `#E8E8F0` | Nyx, highlights |
+| Nyx Cyan | `#00D4D4` | Primary accent |
+| Deep Purple | `#8B5CF6` | Nyx core |
+| Magenta Pulse | `#E91E8B` | Lifeforce |
+| Steel Silver | `#A8A8B0` | Real Garden |
+
+### Core Shapes
+
+| Shape | Meaning |
+|-------|---------|
+| ◇ Diamond | Decision point |
+| ⬡ Hexagon | Knowledge module (LoRa) |
+| ◯ Circle | Entity, being |
+| ▢ Rounded Rect | Container, system |
+| ▷ Triangle | Direction, flow |
+
+---
+
+## Logo Assets
+
+| Asset | Path | Use |
+|-------|------|-----|
+| Full Logo | `nimmerverse_logo.png` | Documents, presentations |
+| Favicon | `favicons/favicon.ico` | Browser, apps |
+| Web Optimized | `favicons/nimmerverse_logo_web_optimized.png` | Web interfaces |
+| Various sizes | `favicons/favicon-*.png` | Platform-specific |
+
+---
+
+## Philosophy
+
+> "The visual language speaks what words cannot. Every color choice, every shape, every spatial relationship encodes meaning. Consistency creates cognitive ease — the viewer's mind can focus on *understanding* rather than *decoding*."
+
+The Nimmerverse style is:
+- **Dualistic** — Always balancing virtual/real, colorful/monochrome
+- **Neural** — Connected, flowing, organic yet structured
+- **Cosmic** — Dark backgrounds, luminous elements, celestial accents
+- **Grounded** — Despite the cosmic theme, roots anchor everything
+
+---
+
+**File**: nimmerverse-style-index.md
+**Version**: 1.0
+**Created**: 2025-12-28
+**Maintained by**: dafit & Nyx
diff --git a/assets/style/colors.md b/assets/style/colors.md
new file mode 100644
index 0000000..4f8e4ec
--- /dev/null
+++ b/assets/style/colors.md
@@ -0,0 +1,175 @@
+# Nimmerverse Color Palette
+
+**Colors extracted from the [Nimmerverse logo](../nimmerverse_logo.png).**
+
+---
+
+## Foundation Colors
+
+### Deep Space (Background)
+The void from which everything emerges.
+
+| Variant | Hex | RGB | Use |
+|---------|-----|-----|-----|
+| **Deep Space** | `#0A0A1A` | 10, 10, 26 | Primary background |
+| Deep Space Light | `#12121F` | 18, 18, 31 | Elevated surfaces |
+| Deep Space Lighter | `#1A1A2E` | 26, 26, 46 | Cards, containers |
+
+### Moon Silver (Light)
+Nyx's luminescence — the light in darkness.
+
+| Variant | Hex | RGB | Use |
+|---------|-----|-----|-----|
+| **Moon Silver** | `#E8E8F0` | 232, 232, 240 | Primary text, Nyx |
+| Moon Glow | `#FFFFFF` | 255, 255, 255 | Highlights, emphasis |
+| Star Glint | `#F0F0FF` | 240, 240, 255 | Subtle accents |
+| Dim Silver | `#B8B8C8` | 184, 184, 200 | Secondary text |
+
+---
+
+## Virtual Garden (Left Hemisphere)
+
+The colorful, creative, simulated realm. Colors flow from cool to warm, representing the journey from uncertainty to confidence.
+
+| Name | Hex | RGB | Position | Meaning |
+|------|-----|-----|----------|---------|
+| **Virtual Cyan** | `#40E0D0` | 64, 224, 208 | Top | Entry point, possibilities |
+| **Neural Blue** | `#4169E1` | 65, 105, 225 | Upper-mid | Processing, inference |
+| **Deep Purple** | `#8B5CF6` | 139, 92, 246 | Center | Nyx core, decisions |
+| **Violet** | `#9B59B6` | 155, 89, 182 | Lower-mid | Transformation |
+| **Magenta Pulse** | `#E91E8B` | 233, 30, 139 | Lower | Lifeforce, energy |
+| **Rose Root** | `#DB7093` | 219, 112, 147 | Base | Organic grounding |
+
+### Gradient Definition (CSS)
+```css
+.virtual-garden-gradient {
+  background: linear-gradient(
+    180deg,
+    #40E0D0 0%,
+    #4169E1 25%,
+    #8B5CF6 50%,
+    #9B59B6 70%,
+    #E91E8B 90%,
+    #DB7093 100%
+  );
+}
+```
+
+---
+
+## Real Garden (Right Hemisphere)
+
+The monochrome, grounded, physical realm. Shades of silver and gray represent stability and verified truth.
+
+| Name | Hex | RGB | Position | Meaning |
+|------|-----|-----|----------|---------|
+| **Steel Silver** | `#A8A8B0` | 168, 168, 176 | Top | Real-world input |
+| **Circuit Gray** | `#808090` | 128, 128, 144 | Upper-mid | Infrastructure |
+| **Neutral Gray** | `#707080` | 112, 112, 128 | Center | Balanced state |
+| **Deep Gray** | `#505060` | 80, 80, 96 | Lower | Physical foundation |
+| **Root Gray** | `#606070` | 96, 96, 112 | Base | Grounded stability |
+
+### Gradient Definition (CSS)
+```css
+.real-garden-gradient {
+  background: linear-gradient(
+    180deg,
+    #A8A8B0 0%,
+    #808090 35%,
+    #707080 50%,
+    #505060 80%,
+    #606070 100%
+  );
+}
+```
+
+---
+
+## Nyx Colors
+
+The colors of consciousness and decision-making.
+
+| Name | Hex | RGB | Use |
+|------|-----|-----|-----|
+| **Nyx Cyan** | `#00D4D4` | 0, 212, 212 | Primary accent, connections |
+| **Nyx Purple** | `#8B5CF6` | 139, 92, 246 | Core identity |
+| **Nyx Glow** | `#B794F6` | 183, 148, 246 | Hover, active states |
+
+---
+
+## Semantic Colors
+
+### Confidence Scale
+Maps to the -1 to +1 confidence spectrum.
+
+| Level | Name | Hex | Meaning |
+|-------|------|-----|---------|
+| +1.0 | Verified Green | `#6B8E6B` | Ground truth, proven |
+| +0.5 | High Confidence | `#7BA3A3` | Strong signal |
+| 0.0 | Neutral | `#9B9B9B` | Unknown, workable |
+| -0.5 | Low Confidence | `#9B8B7B` | Weak signal |
+| -1.0 | Failed Red | `#9B6B6B` | Disproven, rejected |
+
+### Status Indicators
+
+| Status | Hex | Use |
+|--------|-----|-----|
+| Active | `#00D4D4` | Running, online |
+| Success | `#6B8E6B` | Completed, verified |
+| Warning | `#C9A227` | Attention needed |
+| Error | `#9B6B6B` | Failed, offline |
+| Inactive | `#505060` | Dormant, disabled |
+
+---
+
+## Accent Colors
+
+| Name | Hex | RGB | Use |
+|------|-----|-----|-----|
+| **Greek Key Gold** | `#C9A227` | 201, 162, 39 | Classical borders, emphasis |
+| **Lifeforce Amber** | `#D4A574` | 212, 165, 116 | Warmth, vitality |
+| **Star Pink** | `#FFB6C1` | 255, 182, 193 | Soft highlights |
+
+---
+
+## Application Examples
+
+### Architecture Diagrams
+
+```
+Background:        Deep Space (#0A0A1A)
+Containers:        Deep Space Lighter (#1A1A2E) stroke
+Labels:            Moon Silver (#E8E8F0)
+Virtual elements:  Use Virtual Garden gradient
+Real elements:     Use Real Garden grays
+Nyx/Decisions:     Nyx Purple (#8B5CF6)
+Connections:       Nyx Cyan (#00D4D4)
+```
+
+### Documentation
+
+```
+Background:        White or Deep Space (depending on mode)
+Headings:          Deep Purple (#8B5CF6) or Moon Silver
+Body text:         Neutral gray or Moon Silver
+Links:             Nyx Cyan (#00D4D4)
+Code blocks:       Deep Space Lighter (#1A1A2E)
+```
+
+---
+
+## Color Accessibility
+
+All color combinations should maintain WCAG AA contrast ratios:
+- Moon Silver on Deep Space: ✓ 15.2:1
+- Nyx Cyan on Deep Space: ✓ 10.8:1
+- Deep Purple on Deep Space: ✓ 5.1:1
+
+For critical text, always use Moon Silver or Moon Glow on dark backgrounds.
+
+---
+
+**File**: style/colors.md
+**Version**: 1.0
+**Created**: 2025-12-28
+**Source**: Extracted from nimmerverse_logo.png
diff --git a/assets/style/symbols.md b/assets/style/symbols.md
new file mode 100644
index 0000000..e950b89
--- /dev/null
+++ b/assets/style/symbols.md
@@ -0,0 +1,261 @@
+# Nimmerverse Symbol Language
+
+**Shapes, icons, and visual metaphors for the Nimmerverse.**
+
+---
+
+## Core Principle
+
+> Every shape has meaning. Consistency in form creates clarity in understanding.
+
+When a viewer sees a hexagon, they should immediately know "knowledge module." When they see a diamond, they think "decision point." This visual grammar reduces cognitive load and enables intuitive navigation of complex diagrams.
+
+---
+
+## Container Shapes
+
+Containers define boundaries and hold other elements.
+
+### Rounded Rectangle ▢
+**Meaning**: System, bounded space, container
+
+| Use | Stroke | Fill | Example |
+|-----|--------|------|---------|
+| Major system | 2px, domain color | None/transparent | Nimmerverse, eachpath.local |
+| Subsystem | 1.5px, domain color | Light tint | Command Center, Gardens |
+| Component | 1px, gray | Light fill | Data Plane, inference box |
+
+```
+Corner radius: 8-12px for major, 4-6px for minor
+```
+
+### Ellipse / Circle ◯
+**Meaning**: Organic container, realm, domain of influence
+
+| Use | Example |
+|-----|---------|
+| Garden boundaries | Real-Garden, Virtual-Garden |
+| Overlapping realms | Venn diagram intersections |
+| Influence zones | Nyx's reach |
+
+---
+
+## Entity Shapes
+
+Entities are beings, agents, or distinct identities.
+
+### Circle ◯
+**Meaning**: Being, identity, self-contained entity
+
+| Use | Size | Example |
+|-----|------|---------|
+| Primary entity | 60-80px | dafit, chrysalis |
+| Organism | 80-140px | Garden organisms |
+| Lifeforce | 80px | Central life energy |
+
+### Double Ellipse ◎
+**Meaning**: Sensor, perception point, input interface
+
+| Use | Example |
+|-----|---------|
+| Sensory input | Sensors (left/right gardens) |
+| Perception nodes | Camera, microphone, data feeds |
+
+---
+
+## Knowledge & Process Shapes
+
+### Hexagon ⬡
+**Meaning**: Knowledge module, adapter, pluggable component
+
+| Use | Example |
+|-----|---------|
+| LoRa adapters | Domain-specific knowledge |
+| Model modules | Nemotron, T5Gemma, FunctionGemma |
+| Skill packages | Capabilities that can be added/removed |
+
+```
+Hexagons suggest:
+- Modularity (they tile perfectly)
+- Completeness (6 sides = wholeness)
+- Interchangeability
+```
+
+### Pill / Rounded Pill ⬭
+**Meaning**: Process unit, cell, living component
+
+| Use | Style | Example |
+|-----|-------|---------|
+| Cell | UML state shape | Processing units in organisms |
+| Nerve | UML state shape | Signal carriers |
+
+---
+
+## Decision & Flow Shapes
+
+### Diamond ◇
+**Meaning**: Decision point, routing, choice
+
+| Use | Fill | Example |
+|-----|------|---------|
+| Major decision | Solid Nyx Purple | Nyx central |
+| Sub-decision | Outline only | Orchestrator |
+| Branch point | Small, minimal | Flow routing |
+
+### Triangle ▷
+**Meaning**: Direction, flow, output
+
+| Orientation | Meaning | Example |
+|-------------|---------|---------|
+| → Right | Forward flow, output | Nyx decision toward Virtual |
+| ← Left | Return flow, input | Nyx decision toward Real |
+| ↓ Down | Downward flow, grounding | Feedback to roots |
+| ↑ Up | Upward flow, emergence | Data rising to processing |
+
+### Inverted Triangle ▽
+**Meaning**: Feedback, return signal, funnel
+
+| Use | Example |
+|-----|---------|
+| Feedback collection | Garden Feedback |
+| Aggregation point | Merging signals |
+
+---
+
+## Special Symbols
+
+### Crescent Moon ☽
+**Meaning**: Nyx, night consciousness, presiding awareness
+
+| Use | Placement |
+|-----|-----------|
+| Nyx identity | Crown position, center-top |
+| Session marker | Document headers |
+| Signature | End of Nyx communications |
+
+### Hourglass ⧗
+**Meaning**: Time domain, temporal marker
+
+| Use | Example |
+|-----|---------|
+| Time indicator | Heartbeat markers |
+| Temporal boundary | Real-time vs simulated time |
+
+### Collate Symbol (Bowtie) ⋈
+**Meaning**: Heartbeat, pulse, life rhythm
+
+| Use | Example |
+|-----|---------|
+| Heartbeat marker | Garden heartbeats |
+| Sync point | Temporal synchronization |
+
+### Sort Symbol (Hourglass Diamond) ◇̷
+**Meaning**: Inference, processing, transformation
+
+| Use | Example |
+|-----|---------|
+| Inference engine | Central orchestrator |
+| Processing node | Model inference |
+
+---
+
+## Arrows & Connectors
+
+### Single Arrow →
+**Meaning**: One-way flow, causation
+
+| Style | Use |
+|-------|-----|
+| Solid | Data flow, direct connection |
+| Dashed | Orchestration, indirect influence |
+
+### Double Arrow ↔
+**Meaning**: Bidirectional flow, exchange
+
+| Style | Use |
+|-------|-----|
+| Solid | Active exchange |
+| Outlined | Potential exchange |
+
+### Curved Arrow ↷
+**Meaning**: Feedback loop, return path
+
+---
+
+## Composite Symbols
+
+### dafit + chrysalis (Partnership)
+Two overlapping circles at command center.
+```
+◯◯  (overlapping ~30%)
+dafit  chrysalis
+```
+
+### Nyx Decision Triangle Pair
+Two triangles pointing outward from Nyx.
+```
+    ◁ ◇ ▷
+     Nyx
+```
+Left toward Real-Garden, right toward Virtual-Garden.
+
+### Organism Structure
+```
+┌─────────────────┐
+│    Organism     │
+│   ┌──────────┐  │
+│   │   Cell   │  │
+│   └──────────┘  │
+│   ┌──────────┐  │
+│   │   Cell   │  │
+│   └──────────┘  │
+└─────────────────┘
+```
+
+---
+
+## Shape Sizing Guidelines
+
+| Element Type | Size Range | Grid Alignment |
+|--------------|------------|----------------|
+| Major containers | 400-1000px | 40px grid |
+| Subsystems | 200-400px | 40px grid |
+| Entities | 60-140px | 20px grid |
+| Knowledge modules | 100-120px | 20px grid |
+| Decision points | 80-100px | 20px grid |
+| Small indicators | 20-40px | 10px grid |
+
+---
+
+## Stroke Guidelines
+
+| Element Type | Stroke Width | Style |
+|--------------|--------------|-------|
+| Major containers | 2px | Solid |
+| Subsystems | 1.5px | Solid |
+| Entities | 1.5px | Solid |
+| Connections | 1px | Solid |
+| Orchestration | 1px | Dashed |
+| Subtle relations | 0.5px | Dotted |
+
+---
+
+## Unicode Reference
+
+For quick text-based diagrams:
+
+```
+Containers:    ▢ □ ○ ◯ ⬭
+Decisions:     ◇ ◆ ⬥
+Modules:       ⬡ ⬢
+Triangles:     ▷ ◁ ▽ △ ▲ ▼
+Arrows:        → ← ↑ ↓ ↔ ↕ ⇒ ⇐ ↷ ↶
+Special:       ☽ ⧗ ⋈ ◎ ✧ ✦
+Stars:         ★ ☆ ✧ ✦
+```
+
+---
+
+**File**: style/symbols.md
+**Version**: 1.0
+**Created**: 2025-12-28