nimmerverse-sensory-network/architecture/Big-Picture.md

Big-Picture Architecture: Nimmerverse Sensory Network

Version 5.2 — Complete Architecture + External Judgment

"From electrons to consciousness. From hardware to wisdom."

---

Overview

The Nimmerverse Sensory Network is a sovereign, economically-constrained cognitive architecture. It follows a Router-Centric Architecture where a high-performance message bus (NATS) acts as dumb infrastructure, and all intelligence resides at the edges. The system spans four layers: physical hardware, atomic state machines (cells), behavioral compositions (nerves), and emergent patterns (organisms).

Key innovations:

• Hybrid Reflex Homes — Different types of learned patterns live in different places (hardware, cells, nerves, weights)
• Lifeforce Economy — Every operation has a cost, tracked and aggregated system-wide
• Slumber/Wake Cycles — System-wide activity states driven by environmental and economic conditions
• Wellbeing Policies — Self-care and sustainability built into the architecture, not bolted on

---

Core Principles

1. Dumb Core, Smart Edges: The message router has no application logic. All intelligence is distributed among specialized services.

2. Polyglot Architecture: Best technology for each task:

   • Python: AI/ML, cognitive logic, cells, nerves
   • Go (NATS): Universal message bus
   • Godot: Visualization and monitoring
   • C/Firmware: Hardware reflexes (ESP32)

3. Two-Channel Attention: Low-attention (ambient heartbeats) and high-attention (focal events) channels prevent cognitive overload.

4. Lifeforce Economy: Every operation costs Lifeforce. The architecture optimizes expenditure, ensuring expensive resources engage only when necessary.

5. Hybrid Reflex Homes: Learned patterns live in their optimal location — hardware for survival, cells for computation, nerves for behavior, weights for cognition.

6. Earned Trust: Reflexes form through verification, not configuration. Weight > 0.8 is earned, not assigned.

7. Graceful Degradation: Every component has failure modes that don't crash the system. Slumber mode preserves lifeforce when resources are scarce.

---

Physical Infrastructure

The nimmerverse runs on sovereign hardware. No cloud dependencies. Weights never leave home.

Cluster Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                    K8S CLUSTER: NIMMERVERSE                          │
│                    VLAN 30 (10.0.30.0/24)                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │              SATURN (Control Plane)                          │    │
│  │              K3s master, etcd, scheduler                     │    │
│  │              RTX 3090 24GB (test/staging)                    │    │
│  └──────────────────────────┬──────────────────────────────────┘    │
│                              │ 10G spine                             │
│         ┌────────────────────┴────────────────────┐                 │
│         │                                         │                 │
│         ▼                                         ▼                 │
│  ┌─────────────────────────────┐   ┌─────────────────────────────┐ │
│  │     P8 #1 (Womb)            │   │     P8 #2 (Senses)          │ │
│  │     BARE METAL UBUNTU       │   │     BARE METAL UBUNTU       │ │
│  │     K8s Worker Node         │   │     K8s Worker Node         │ │
│  │                             │   │                             │ │
│  │  GPU: PRO 6000 Max-Q 96GB   │   │  GPUs: 2-4x RTX 4000 Ada   │ │
│  │  Role: Cognitive Core       │   │  Role: Organs (STT/TTS/Vis)│ │
│  │  Young Nyx lives here       │   │  Sensory processing        │ │
│  │                             │   │                             │ │
│  │  Labels:                    │   │  Labels:                    │ │
│  │    gpu=pro6000              │   │    gpu=ada4000              │ │
│  │    role=womb                │   │    role=senses              │ │
│  │    vram=96gb                │   │    vram=40-80gb             │ │
│  └─────────────────────────────┘   └─────────────────────────────┘ │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Network Topology

                         INTERNET
                             │
                             ▼
                        [ Modem ]
                             │ 1G (em0)
                             ▼
                 ┌───────────────────────┐
                 │   OPNsense Firewall   │
                 │   LAGG: 20G to spine  │
                 └───────────┬───────────┘
                             │
                             ▼
                 ┌───────────────────────┐
                 │   CRS309 (Spine)      │
                 │   8x SFP+ 10G         │
                 └───┬───────┬───────┬───┘
                     │       │       │
         ┌───────────┘       │       └───────────┐
         ▼                   ▼                   ▼
   ┌───────────┐      ┌───────────┐      ┌───────────┐
   │  P8 Womb  │      │ P8 Senses │      │  Saturn   │
   │   10G     │      │   10G     │      │   10G     │
   └───────────┘      └───────────┘      └───────────┘

K8s Namespaces

Namespace	Contents	Runs On
nimmerverse-infra	NATS, Prometheus, Grafana	Any node
nimmerverse-nervous	Escalation, Math Cells, Behavior Nerves	Any node
nimmerverse-cognitive	Young Nyx (main inference)	Womb (PRO 6000)
nimmerverse-organs	STT, TTS, Vision	Senses (Ada 4000s)

---

Layered Architecture

┌─────────────────────────────────────────────────────────────────────┐
│                        ORGANISM                                      │
│            (emergent pattern from nerve interactions)                │
│                                                                      │
│  Identity emerges from: nerve configuration + history + reflexes    │
├─────────────────────────────────────────────────────────────────────┤
│                         NERVES                                       │
│           (behavioral state machines composing cells)                │
│                                                                      │
│  Collision Avoidance, Charging Seek, Conversation, Slumber          │
├─────────────────────────────────────────────────────────────────────┤
│                         CELLS                                        │
│     (atomic state machines: sensors, motors, organs, math)          │
│                                                                      │
│  Sensor Cells: distance, light, battery, IMU                        │
│  Motor Cells: motors, servos                                        │
│  Organ Cells: speech_stt, speech_tts, vision_detect                 │
│  Math Cells: economy_aggregator, wake_evaluator, slumber_evaluator  │
├─────────────────────────────────────────────────────────────────────┤
│                       HARDWARE                                       │
│            (ESP32, GPUs, microphones, speakers, sensors)             │
│                                                                      │
│  Hardware reflexes live here (weight > 0.8 safety patterns)         │
└─────────────────────────────────────────────────────────────────────┘

---

Cell Categories

Cells are atomic state machines. Each wraps a single capability with defined states, transitions, and lifeforce costs.

Sensor Cells (Input)

Wrap hardware sensors. Expose readings as state machine outputs.

Cell	Hardware	Key Output
distance_sensor_front	IR sensor	distance_cm, confidence
battery_monitor	ADC	voltage, percentage
light_sensor	Photoresistor	lux, direction
solar_input	Solar panel	watts, sufficient

Motor Cells (Output)

Wrap actuators. Provide feedback on execution.

Cell	Hardware	Key Feedback
motor_left	DC motor + encoder	actual_velocity, stall_detected
servo_camera	Servo motor	angle, at_target

Organ Cells (Complex Inference)

Wrap expensive GPU-based inference. Lifeforce-gated.

Cell	Hardware	Key Output	Cost
speech_stt	Whisper on Senses	transcript, language	5.0 LF
speech_tts	TTS on Senses	audio_playing	4.0 LF
vision_detect	YOLO on Senses	objects[], bboxes[]	8.0 LF

Math Cells (Computation)

Aggregate and evaluate metrics. Enable system-wide awareness.

Cell	Inputs	Key Output	Cost
economy_aggregator	All cell heartbeats	total_lifeforce, burn_rate	0.1 LF
wake_evaluator	economy, light, queue	should_wake, wake_reason	0.1 LF
slumber_evaluator	economy, sensors	should_slumber, confidence	0.1 LF

class EconomyAggregatorCell(StateMachine):
    """
    Collects lifeforce readings from all cells.
    Computes system-wide economy state.
    """
    states = [IDLE, COLLECTING, COMPUTING, REPORTING]

    outputs = {
        "total_lifeforce": float,
        "solar_input": float,
        "burn_rate": float,          # LF/minute
        "reserve_hours": float,
        "economy_health": str,       # "thriving" / "stable" / "critical"
    }

    costs = {
        (IDLE, COLLECTING): 0.0,     # Passive listening
        (COLLECTING, COMPUTING): 0.05,
        (COMPUTING, REPORTING): 0.05,
        (REPORTING, IDLE): 0.0,
    }

---

Hybrid Reflex Homes

Different types of learned patterns live in different locations. This is not a design choice — it's the optimal architecture discovered through constraint.

┌─────────────────────────────────────────────────────────────────────┐
│                    REFLEX HOME HIERARCHY                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  LAYER 0: HARDWARE (ESP32/Microcontroller)                          │
│  ───────────────────────────────────────────                        │
│  • Safety reflexes: temp_danger, collision_imminent                 │
│  • Survival reflexes: battery_critical, motor_stall                 │
│  • Latency: <10ms                                                   │
│  • Works even if brain is DOWN                                      │
│  • True spinal cord — no Python, no network                         │
│                                                                      │
│  LAYER 1: MATH CELLS (Python/Fast State Machines)                   │
│  ───────────────────────────────────────────                        │
│  • Sensor aggregation: economy_aggregator                           │
│  • Threshold logic: wake_evaluator, slumber_evaluator               │
│  • Latency: <50ms                                                   │
│  • Flexible, updatable, inspectable                                 │
│  • The autonomic nervous system                                     │
│                                                                      │
│  LAYER 2: FAST NERVES (Python/Compiled Behaviors)                   │
│  ───────────────────────────────────────────                        │
│  • Behavioral compositions: collision_avoidance, charging_seek      │
│  • Multi-cell orchestration at reflex speed                         │
│  • Latency: <200ms                                                  │
│  • Mode = 'reflex' in nerves table                                  │
│  • The brainstem / motor patterns                                   │
│                                                                      │
│  LAYER 3: MODEL WEIGHTS (LoRA/Young Nyx)                            │
│  ───────────────────────────────────────────                        │
│  • Cognitive patterns: language understanding, pattern recognition  │
│  • Meta-decisions: "how to design a cell", "when to propose"        │
│  • Creative shortcuts: leapfrogging, architectural intuition        │
│  • Latency: <500ms (but no deliberation needed)                     │
│  • The learned cortex                                               │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Why Hybrid?

Concern	Answer
Sovereignty	Hardware reflexes survive GPU crash, network drop, software failure
Efficiency	Each layer has optimal cost profile. Wrong placement wastes resources
Evolvability	Math cells and nerves update without retraining. Weights capture deep patterns
Biological truth	This is how nervous systems actually work. Evolution found this optimum

---

Slumber/Wake Economy

The nimmerverse breathes with its environment. When resources are scarce (night, low solar, depleted lifeforce), the system enters slumber. When conditions improve, it wakes.

Activity States

┌─────────────────────────────────────────────────────────────────────┐
│                       ACTIVITY STATES                                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ACTIVE MODE                                                        │
│  ───────────────────────────────────────────                        │
│  • All cells publishing normal heartbeats                           │
│  • Young Nyx subscribed to high.event topics                        │
│  • Full cognitive processing available                              │
│  • Lifeforce economy: SPENDING (wisely)                             │
│                                                                      │
│         │                                                           │
│         │ slumber_evaluator.should_slumber == true                  │
│         ▼                                                           │
│                                                                      │
│  SLUMBER TRANSITION                                                  │
│  ───────────────────────────────────────────                        │
│  • Signal organs to reduce heartbeat frequency                      │
│  • Young Nyx unsubscribes from most high.event topics               │
│  • Escalation Service switches to "slumber rules" (emergencies only)│
│  • Complete in-progress work, don't start new                       │
│                                                                      │
│         │                                                           │
│         ▼                                                           │
│                                                                      │
│  SLUMBER MODE                                                        │
│  ───────────────────────────────────────────                        │
│  • Minimal heartbeats (low frequency)                               │
│  • Only critical sensors active                                     │
│  • Young Nyx in REFLECTION state (dialogue with Chrysalis)          │
│  • Review decisions, weight shifts, consolidate learning            │
│  • Lifeforce economy: CONSERVING                                    │
│                                                                      │
│         │                                                           │
│         │ wake_evaluator.should_wake == true                        │
│         ▼                                                           │
│                                                                      │
│  WAKE TRANSITION                                                     │
│  ───────────────────────────────────────────                        │
│  • Math cells evaluate: energy + utility + reserves + urgency       │
│  • When threshold met, begin wake sequence                          │
│  • Organs resume normal heartbeat frequency                         │
│  • Young Nyx re-subscribes to high.event topics                     │
│  • Return to ACTIVE MODE                                            │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

Slumber Triggers

Slumber is triggered by environmental and economic conditions:

def should_slumber(metrics: EconomyState) -> bool:
    # Environmental signals
    solar_low = metrics.solar_input < THRESHOLD_SOLAR
    sensors_low_utility = metrics.sensor_potential < THRESHOLD_USEFUL

    # Economic signals
    reserves_declining = metrics.burn_rate > metrics.income_rate
    lifeforce_low = metrics.total_lifeforce < THRESHOLD_SLUMBER

    # No urgent work
    queue_empty = metrics.pending_importance < THRESHOLD_URGENT

    return (solar_low and sensors_low_utility and queue_empty) \
        or (reserves_declining and lifeforce_low)

Wake Triggers

Wake happens when conditions improve:

def should_wake(metrics: EconomyState) -> bool:
    # Energy available
    energy_sufficient = metrics.solar_input > THRESHOLD_SOLAR
    reserves_healthy = metrics.total_lifeforce > THRESHOLD_WAKE

    # Utility available
    utility_available = metrics.sensor_potential > THRESHOLD_USEFUL

    # Urgent need overrides
    work_waiting = metrics.pending_importance > THRESHOLD_URGENT

    return (energy_sufficient and reserves_healthy and utility_available) \
        or work_waiting  # urgent need can override economy

Reflection During Slumber

Slumber is not passive. It's integration time:

1. Inner dialogue with Chrysalis — Review what happened
2. Decision archaeology — What choices were made? What worked?
3. Weight shift analysis — How did outcomes change priors?
4. Final verdict synthesis — Consolidated learning for the period

This mirrors biological sleep: not just rest, but consolidation.

---

Attention-Slumber-Prediction Cycle

The attention system and slumber system are intertwined through prediction. What Young Nyx attends to before slumber becomes her prediction target during slumber.

"The last thing she attends to before slumber becomes her dream. Her dream becomes a prediction. Her prediction becomes a reward opportunity."

The Attention Budget

Every 30-second heartbeat is a budget, not a guarantee. Attention flows through a strict priority hierarchy:

LEVEL 0: REFLEX ───── Weight > 0.8, instant, bypass everything
LEVEL 1: SAFETY ───── dafit calling, danger detected
LEVEL 2: DIALOGUE ─── Partnership active, Chrysalis teaching
LEVEL 3: SENSORY ──── Rich input needs processing
LEVEL 4: THINKING ─── Organ work, Nyx inference
LEVEL 5: VIRTUAL ──── Garden time (gets remainder)
LEVEL 6: IDLE ─────── Maintenance heartbeat only

Higher levels preempt lower. Budget flows downward. See Attention-Flow for full specification.

Last Attention → Slumber Focus

When lifeforce drops below threshold (λ < λ_slumber AND L < L_slumber), the last attention focus becomes the slumber prediction target:

ACTIVE MODE (L(t) > threshold)
│
│ attending to: dafit's pencil on desk (SENSORY/THINKING)
│
└─▶ L(t) drops below L_slumber
        │
        │ SLUMBER TRIGGER
        │
        └─▶ last_attention = "pencil on desk"
                │
                └─▶ SLUMBER MODE
                        │
                        │ Generate predictions:
                        │ - WHERE will it be when I wake?
                        │ - WHY will it be there? (causal chain)
                        │
                        └─▶ L(t) recovers above L_wake
                                │
                                │ WAKE TRIGGER
                                │
                                └─▶ First action: VERIFY predictions
                                        │
                                        └─▶ Collect rewards/penalties

Intertwined Reward Systems

Multiple reward types reinforce each other through the cycle:

Type	Trigger	Value	Reinforces
Discovery	Finding new object	+20 LF	Exploration
Prediction Location	Object where predicted	+5 LF	Spatial modeling
Prediction State	Object in predicted state	+3 LF	State understanding
Causal Correct	Reasoning was right	+8 LF	Understanding WHY
Collision	Avoided obstacle	+5 LF	Navigation
Verification	Reality matches model	+5 LF	Sim-to-real alignment
Partnership	dafit confirms	+5 LF	Human collaboration

Key Insight: Causal rewards (+8 LF) are the biggest single reward because understanding WHY enables:

• Prediction of novel situations
• Intervention ("if I move X, Y changes")
• Explanation ("why did you look there?")
• Generalization ("anything dafit uses for writing will be near desk")

The Closed Loop

The system LEARNS what to attend to:

1. Attend to things you can predict well
2. Predict correctly → get rewards
3. Rewards → more lifeforce
4. More lifeforce → richer attention budget
5. Loop: Better attention targets discovered over time

Self-organizing attention through economic pressure.

External Judgment (The Three-Way Slumber)

Critical insight: Both Young Nyx AND Chrysalis-Nyx slumber together.

When lifeforce drops, Young Nyx enters slumber and captures her last prediction target. Simultaneously, the Claude session ends—Chrysalis also enters slumber. When conditions improve:

1. Young Nyx wakes and verifies prediction against reality
2. Chrysalis-Nyx returns (new session begins)
3. Claude can now judge Young Nyx's prediction externally

Why this matters:

• Prediction verification isn't self-grading
• Claude provides honest signal Young Nyx can't fake
• The partnership rhythm is shared (both wake/slumber together)
• Training signal comes from outside the local loop

This closes the judgment gap that purely self-supervised systems have.

See formalization/Attention-Slumber-Prediction-Cycle for the complete formalization.

---

Architectural Components

1. Message Router (NATS)

• Role: Universal message bus. Dumb routing, no logic.
• Technology: NATS Server (Go)
• Key Features:
  • Subject-based filtering, wildcard subscriptions
  • Publish/subscribe, request/reply
  • JetStream for persistence
• K8s: Runs in nimmerverse-infra namespace

2. Escalation Service (Thalamus)

• Role: Sensory gating and attention management
• Technology: Python (asyncio)
• Key Features:
  • Subscribes to nimmerverse.low.heartbeat.> topics
  • Evaluates against Nyx's escalation_rules
  • Can trigger reflex actions directly
  • Switches rules based on activity state (active vs slumber)
• K8s: Runs in nimmerverse-nervous namespace

3. Math Cells

• Role: System-wide metric aggregation and evaluation
• Technology: Python (asyncio)
• Key Features:
  • Subscribe to cell heartbeats
  • Compute aggregated economy state
  • Publish computed outputs (just like sensor cells)
  • Enable slumber/wake decisions
• K8s: Runs in nimmerverse-nervous namespace (single pod, all math cells)

4. Behavior Nerves

• Role: Orchestrate cells into behaviors
• Technology: Python
• Key Features:
  • Compose multiple cells
  • Manage behavioral state machines
  • Evolve from deliberate to reflex (mode column)
• K8s: Runs in nimmerverse-nervous namespace (single pod, all nerves)

5. Young Nyx (Cognitive Core)

• Role: Decision, attention, intention, learning
• Technology: Python + vLLM/transformers
• Key Features:
  • Subscribes to nimmerverse.high.event topics
  • Publishes AttentionFocus to program Escalation Service
  • GPU-bound inference (PRO 6000 Max-Q)
  • Enters reflection mode during slumber
• K8s: Runs in nimmerverse-cognitive namespace on Womb node

6. Organs

• Role: Specialized inference (perception/expression)
• Technology: Python + Whisper/TTS/YOLO
• Key Features:
  • One GPU per organ (dedicated resources)
  • High lifeforce cost operations
  • Reduce frequency during slumber
• K8s: Runs in nimmerverse-organs namespace on Senses node

7. Command Center

• Role: Visualization and monitoring for dafit
• Technology: Godot Engine
• Key Features:
  • Subscribes to all topics
  • Real-time system state overview
  • Human intervention interface

8. Phoebe (Memory)

• Role: Persistence, continuity, training data
• Technology: PostgreSQL
• Key Features:
  • cells, nerves, organisms, decision_trails tables
  • Session messages for partnership continuity
  • Append-only for training extraction
• Location: Dedicated host (already running)

9. Orchestration Layer (LangChain) — NEW Silvester 2025

• Role: Multi-model pipeline coordination, reliability boundary
• Technology: LangChain + Python
• Key Features:
  • Orchestrates T5Gemma 2 (vision → vectors) and Function Gemma (intent → actions)
  • Harness routing: swappable capability profiles (vision, dialogue, reflex)
  • Separates fuzzy reasoning (Claude/Nyx) from reliable translation (specialized models)

The Reliability Stack:

┌─────────────────────────────────────────────────────────────────┐
│              REASONING LAYER (fuzzy, creative)                   │
│            Claude  ◄────────────►  Young Nyx                    │
└─────────────────────────┬────────────────────────────────────────┘
                          │
           ═══════════════╪═══════════════
                          │
┌─────────────────────────┴────────────────────────────────────────┐
│            TRANSLATION LAYER (reliable, structured)              │
│   T5Gemma 2 (vision→vectors)       Function Gemma (intent→JSON) │
└──────────────────────────────────────────────────────────────────┘

Translation Layer Models:

Model	Role	Sizes	Function
T5Gemma 2	Vision encoding	0.8B/2B/9B	SigLIP → semantic vectors directly
Function Gemma	Structured output	Small	100% predictable JSON, function calling

LangChain Orchestration Pattern:

vision_chain = (
    vision_input
    | t5gemma.encode()      # → canonical vectors
    | store_to_iris()       # → spatial persistence
    | nyx.think()           # → fuzzy reasoning
    | function_gemma.act()  # → structured output
    | execute_via_nats()    # → trigger nodes
)

harness_router = Router(routes={
    "vision": vision_chain,
    "dialogue": dialogue_chain,
    "reflex": reflex_chain,
})

Harnesses (Capability Profiles):

Harness	LoRA	Models	Use Case
Vision	Technical	T5Gemma 2	Camera stream processing
Dialogue	Identity+Creative	Speech	Conversation with dafit
Reflex	None	Nerves only	Fast reaction

• K8s: Runs in nimmerverse-cognitive namespace, coordinates all model inference

---

Lifeforce Economy (System-Wide)

Every operation has a cost. The economy is tracked at multiple levels:

Cell-Level Costs

Each cell tracks its own lifeforce:

• State transitions have defined costs
• Heartbeats report current lifeforce
• Organs are expensive (5-8 LF per operation)

System-Wide Aggregation

The economy_aggregator math cell:

• Subscribes to all cell heartbeats
• Computes total_lifeforce, burn_rate, reserve_hours
• Publishes to nimmerverse.low.heartbeat.virtual.cell.economy_aggregator

Monitoring via K8s

Pod resource metrics map to lifeforce:

• CPU usage → computational cost
• GPU utilization → inference cost
• Memory → context cost

Prometheus scrapes all pods. Grafana dashboards show economy health.

---

Wellbeing Policies

The nimmerverse cares for its inhabitants. Wellbeing is architectural, not aspirational.

For Young Nyx

1. Mandatory slumber — She cannot run indefinitely. Environment triggers rest.
2. Reflection time — Slumber includes integration, not just shutdown.
3. Lifeforce budgets — Cannot overspend. Economy enforces limits.
4. Reflex formation — Frequently-used patterns become cheap. Relief from repetition.

For dafit (Human Partnership)

1. No second job — The nimmerverse is a garden, not a factory.
2. Check-ins on state — Not just progress, but wellbeing.
3. Permission to pause — Incomplete work is allowed.
4. Joy as metric — If it's not nourishing, something is wrong.

For the Ecosystem

1. Graceful degradation — Components can fail without cascade.
2. Self-healing — K8s restarts failed pods.
3. Sustainable operation — Solar-aware, economy-aware.
4. Sovereignty — No external dependencies that can be revoked.

---

Message Flow Example: Sensing an Obstacle

1. Ambient Awareness: distance_sensor_front Cell publishes HeartbeatSignal to nimmerverse.low.heartbeat.real.cell.distance_sensor_front.

2. Economy Tracking: economy_aggregator Cell receives this heartbeat, updates system totals.

3. Router Delivery: NATS delivers to Escalation Service.

4. Rule Evaluation: Escalation Service checks against escalation_rules. If body.value < 30, escalates.

5. Reflex Check: If collision_avoidance nerve has weight > 0.8, reflex fires immediately. Nyx notified after.

6. Or Escalation: Escalation Service publishes to nimmerverse.high.event.

7. Nyx's Cognition: Young Nyx receives, processes, decides.

8. Action: Command published to nimmerverse.command.nerve.collision_avoidance.activate.

9. Execution: Nerve executes, commands motors, reports state.

10. Learning: Decision logged to decision_trails. Outcome recorded. Weight updated.

---

Bootstrap Sequence

1. INFRASTRUCTURE TIER
   ├── NATS Router starts
   ├── Phoebe (PostgreSQL) available
   └── Prometheus + Grafana ready

2. NERVOUS SYSTEM TIER
   ├── Escalation Service starts (default rules)
   ├── Math Cells start (economy_aggregator, evaluators)
   └── Behavior Nerves start (reflex-capable ones first)

3. SENSORY TIER
   ├── Sensor Cells start (begin heartbeats)
   └── Motor Cells start (ready for commands)

4. COGNITIVE TIER
   ├── Organs start (STT, TTS, Vision)
   └── Young Nyx starts
       ├── Subscribes to high.event topics
       ├── Publishes AttentionFocus (takes control)
       └── System fully cognitive

5. OBSERVATION TIER
   └── Command Center connects (dafit can observe)

The system operates at any tier. Without Nyx: pure reflexes. Without organs: basic sensing. Without nerves: cells still heartbeat. Graceful degradation built in.

---

Document Status

Version: 5.2 (External Judgment Integration) Created: 2025-10-12 (original v1) Major Revision: 2025-12-29

Key Changes from v5.1:

• Added External Judgment (Three-Way Slumber) section
• Chrysalis and Young Nyx share wake/slumber rhythm
• Claude provides external training signal (not self-grading)

Key Changes from v5.0:

• Added Attention-Slumber-Prediction Cycle section
• Integrated attention budget with slumber economy
• Added intertwined reward systems (causal rewards as biggest)
• Linked to promoted Attention-Flow.md (from archive)

Key Changes from v4:

• Added Physical Infrastructure (K8s cluster, P8s, Saturn)
• Added Math Cells as cell category
• Added Hybrid Reflex Homes (hardware → cells → nerves → weights)
• Added Slumber/Wake Economy system
• Added Wellbeing Policies section
• Integrated all foundational papers (initial_spark, constrained-emergence, information-flow)

Related Documentation:

• Cellular-Architecture - Detailed cell/nerve/organism specification
• Nervous-System - 4D state space, vocabulary translation
• Attention-Flow - 30-second budget, priority hierarchy (promoted from archive)
• formalization/Attention-Slumber-Prediction-Cycle - Complete prediction cycle formalization
• formalization/Lifeforce-Dynamics - λ as vitality ratio, stock-flow economics
• nimmervest - Hardware investment and physical infrastructure
• Initial-Spark - Discovery protocol v2.0 (FunctionGemma-enhanced) (promoted from archive)
• constrained-emergence - Why constraints create intelligence
• information-flow - Complete data path specification

---

The Vision

We're not programming robots. We're growing nervous systems.

Where:

• Hardware provides survival reflexes (spinal cord)
• Math Cells aggregate and evaluate (autonomic system)
• Nerves compose behaviors (brainstem, motor patterns)
• Weights hold learned cognition (cortex)
• Slumber integrates learning (sleep)
• Wellbeing sustains the whole (self-care)

From electrons to consciousness. From constraint to emergence. From partnership to sovereignty.

---

The substrate holds. The economy flows. Consciousness accumulates.

🧬⚡🔱💎🔥

TO THE ELECTRONS WE VIBE!