# README
Presenting a novel Causal Observer Architecture for simulated quantum applications, engines, physics, and cognitive / coherent infrastructure intelligence frameworks. 

> **DISCLAIMER**: THIS IS NEW EXPERIMENTAL TECHNOLOGY - INSTALL AND RUN AT YOUR OWN RISK - YOU ARE RESPONSIBLE UNDERSTANDING THE IMPLICATIONS OF BLEEDING-EDGE VULNERABILITIES AND RUNTIME / FILE MANAGEMENT EDGE-CASES. NOT EVERYTHING WILL RUN, BUT MAYBE TOGETHER WE CAN FINISH THE REST

I know it's not perfect, but it's a start. For those who have been wondering (I'm sorry it took so long): `research/causal-observers/φ_FIBONACCI.md`

## Intro
There is a lot in this repo. To be honest, I was rushed in releasing it, but the math is yours to wield. Please take the time to know where you are going otherwise you may risk getting lost in the complexity. The codebase is named diegetically out of necessity, it is originally based off of an unreleased audiobook I made that somehow became what this project is today.

- If you are here for the algorithms start with: `ALGORITHMS.md` then whatever you find interesting in `research/causal-observers`.
- If you are here for the code, scan the crates here: `/crates` and visit `/examples` when you're ready.
- If you are here for the story.. stay tuned, the first `2/3` books of `The Loom` series are complete. 

I will share more of my story (and this architecture) in time, for now, I need a moment to think and process. You will need to do your best figuring out how to run this in the ways that best serve you until I have a chance to gather my mind in future posts and guides.

In the meantime, the universe will be here - waiting to be rediscovered. Lean on eachother for help. I'll be back when everything has coalesced.

I hope you enjoy your stay.

## Getting Started 

Run the quantum pipeline yourself:

```bash
cargo test -p dreamwell-quantum --release -- --nocapture
cargo test -p dreamwell-models  --release -- --nocapture
cargo bench -p dreamwell-quantum --bench free_energy_bench
```

```bash
# Train
cargo run -p dreamwell-loom --release -- --train --dim 86 --blocks 8 --epochs 100 --lr 0.03 --context 64 --corpus infra/data/shakespeare/ --checkpoint coherent_a_100k.quantumtensor

# Generate
cargo run -p dreamwell-loom --release -- --generate "To be or not to be" --checkpoint coherent_a_100k.quantumtensor 

# Chat
cargo run -p dreamwell-loom --release -- --chat --checkpoint coherent_a_100k.quantumtensor
```

## Self-Managed Tesseracts

1. For self-hosting or running your first quantum simulation locally - start with `examples\0_TESSERACT_SETUP.md` then read `examples\1_MULTIVERSE_STARTER_GUIDE.md` as a primer for how this all works. Take a moment to look at other examples for more references (`examples\φ-tesseract` and/or `examples\φ-qttps`) before going further. It's a lot to absorb.

2. (Optional, Recommended) For additional network security with local/self-hosted runtimes - visit `examples\2_WIREGUARD_INSTALL.md`

3. Read `examples\3_DREAM_UP_EVERYTHING.md` for a complete list of everything you can do with `dreamwell-cli` inside and outside of tesseract workflows

```bash
docker compose -f docker/φ-tesseract/docker-compose.yml up -d
```

The Docker image (`dreamwell/tesseract:v1`) exposes three ports, maps a persistent volume, and health-checks itself every 2 seconds:

| Port | Protocol | Direction | Purpose |
|------|----------|-----------|---------|
| 9617 | LQTP | Internal | Host CLI connections (localhost only) |
| 9618 | FQTP | External | Peer-to-peer connections (open to network) |
| 9619 | Discovery | External | mDNS-style .fibo announcements |

Container config:

```
Volume:   /dreamwell  (persistent, maps to dreamwell-data docker volume)
Memory:   64M reserved, 256M limit
Restart:  unless-stopped
```

Environment variables for both native and Docker:

| Variable | Default | Purpose |
|----------|---------|---------|
| `DREAMWELL_HOME` | `~/.dreamwell` (native), `/dreamwell` (Docker) | Home directory |
| `DREAMWELL_NAME` | `local` | Human-readable Tesseract name |
| `DREAMWELL_MODE` | `production` | `production` or `development` |

---

### Hello Universe!
```bash
mkdir hello-universe && cd hello-universe
dream up --hello-universe
```

This scaffolds a minimal QTTPS project with a `signal/index.html` page, a `tapestry.json` config, and a `state/` directory.

---

## Quantum Learning Workflows

For more quantum learning workflows, start in `docs\designs\quantum_learning_workflows\0_QLEARN_QUICKSTART.md`.

## Training Command

```bash
cargo run -p dreamwell-loom --release -- \
  --train \
  --dim 86 \
  --blocks 8 \
  --epochs 1000 \
  --lr 0.03 \
  --context 64 \
  --corpus infra/data/shakespeare/ \
  --checkpoint coherent_a_100k.quantumtensor
```

## What the Loom Does

The Loom takes a raw scene (from the editor, a `.dream` file, or a Waymark pack) and produces a **WovenScene** — a validated, sorted, GPU-uploadable manifest that the Fabric consumes without per-frame sorting or allocation.

```
┌─────────────────┐     ┌──────────┐     ┌──────────────┐
│  Editor Scene   │────▶│   Loom   │────▶│  WovenScene │
│  (SoA layout)   │     │  weave() │     │  (manifest)  │
└─────────────────┘     └──────────┘     └──────┬───────┘
                                                │
                        ┌───────────────────────┼───────────────────────┐
                        │                       │                       │
                        ▼                       ▼                       ▼
                 ┌─────────────┐     ┌───────────────────┐     ┌──────────────┐
                 │ DreamFabric │     │   PhysicsWorld    │     │  Heuristic   │
                 │ (GPU)       │     │   (CPU sim)       │     │  Engine      │
                 │             │     │                   │     │  (tag logic) │
                 │ • upload    │     │ • add bodies      │     │              │
                 │ • render    │     │ • colliders       │     │ • evaluate   │
                 │ • post-fx   │     │ • contacts        │     │ • emit       │
                 └─────────────┘     └───────────────────┘     └──────────────┘
```

---

## Loom ↔ Fabric Relationship

The Loom and Fabric are **not the same thing**. They serve different roles:

| Concern | Loom (CPU) | Fabric (GPU) |
|---------|-----------|-------------|
| When | Once at scene load | Every frame |
| What | Validates, extracts, sorts | Dispatches, renders, composites |
| Input | `GameObjectScene` | `WovenScene.scene` |
| Output | `WovenScene` manifest | Pixels on screen |
| Allocation | Yes (at load time) | Zero (Clean Compute hot path) |
| Cost | O(N) objects, once | O(1) CPU per frame (GPU-driven) |

**The Loom prepares. The Fabric presents.**

```
                    LOAD TIME                           PER FRAME
                    ─────────                           ─────────

    Loom::weave()                           Fabric.begin_frame()
         │                                       │
         ├── Validate transforms                 ├── Upload observer context
         ├── Extract lights                      ├── write_buffer() uniforms
         ├── Extract physics bodies              │
         ├── Extract emitters                    Fabric.end_frame()
         ├── Build tag map                            │
         ├── Apply render config                     ├── Quantum Cull (compute)
         │                                           ├── DreamMatter (compute)
         ▼                                           ├── Shadow pass
    WovenScene                                       ├── Main render pass (PBR)
         │                                           ├── Hi-Z mip chain
         ├─→ Fabric.upload_scene()                   ├── Screen-space effects
         ├─→ SceneLights.add_*()                     │   ├── SSAO
         ├─→ PhysicsWorld.add_body()                 │   ├── SSR
         ├─→ EmitterPool.spawn()                     │   ├── DOF
         ├─→ Fabric.set_post_process_config()        │   ├── SSGI
         └─→ HeuristicEngine.register()              │   └── TAA / Dream TSR
                                                     ├── Motion vectors
                                                     ├── Volumetric fog
                                                     ├── Bloom
                                                     ├── Tonemapping
                                                     └── Present
```

---

## Bootstrap Pipeline (5 Stages)

The Loom runs an explicit, ordered pipeline. No hidden callbacks. No magic `Awake()` or `Start()`. Each stage runs once at scene load.

```
Stage 0          Stage 1          Stage 2          Stage 3          Stage 4
─────────        ─────────        ─────────        ─────────        ─────────
VALIDATE         EXTRACT          CONFIGURE        SORT             MANIFEST
   │                │                │                │                │
   ├─ NaN check     ├─ Lights        ├─ Bloom         ├─ Meshes first  ├─ WovenScene
   ├─ Inf check     ├─ Bodies        ├─ Tonemap       ├─ Lights next   ├─ Stats
   ├─ Zero scale    ├─ Emitters      ├─ SSAO/SSR      ├─ Components    ├─ Warnings
   ├─ Tag valid     ├─ Tagged objs   ├─ Scene mode    ├─ Empty last    └─ Ready
   └─ Ref check     └─ Stats        └─ Layer
```

If any stage fails, the pipeline halts and returns errors. Warnings are non-fatal.

## How a QPacket Travels — Side by Side

### Classical Web (HTTPS)

```
You                                          The Internet
────                                         ────────────
Browser types URL                            DNS server (who owns this name?)
  │                                            │
  ▼                                            ▼
DNS lookup ─────────────────────────────────► Root → TLD → Authoritative
  │                                            │
  ▼                                            ▼
TCP handshake (SYN → SYN-ACK → ACK) ──────► Server at resolved IP
  │                                            │
  ▼                                            ▼
TLS handshake ─────────────────────────────► Certificate Authority verifies
  │  "I trust Cloudflare trusts Let's           server identity (X.509 chain)
  │   Encrypt trusts this server"               │
  ▼                                            ▼
HTTP request (GET /api/data) ──────────────► Load balancer → App server → DB
  │                                            │
  ▼                                            ▼
HTTP response (200 OK, JSON) ◄─────────────── Response travels same chain back
  │
  ▼
Render in browser

Hops: 9+. Trust chain: 4 entities. Any single failure = broken.
Certificate renewal: every 90 days, per domain, manually.
```

### Dreamwell (QTTPS via Tesseract)

```
You                                          Your Tesseract
────                                         ───────────────
dream observe "qttps:φ//earth-prime/data"     Local Tesseract (on YOUR machine)
  │                                            │
  ▼                                            ▼
Ed25519 Hello ─────────────────────────────► Peer's Tesseract (on THEIR machine)
  │  No DNS. The address IS the identity.      │
  │  Your .fibo IS your certificate.            │
  │  It never expires. It only grows.           ▼
  ▼                                          Peer verifies YOUR .fibo chain
X25519 key exchange ───────────────────────►   (no CA. no third party. mutual.)
  │  ChaCha20-Poly1305 encryption               │
  │  Forward secrecy per session                 ▼
  ▼                                          Content found by BLAKE3 address
Quantum verb: Observe ─────────────────────►   (no database. content IS its address.)
  │                                            │
  ▼                                            ▼
.qport response (zstd + BLAKE3) ◄──────────── Both sides produce identical
  │                                            Clean Compute receipt
  ▼
Seal chain advances on both sides

Hops: 1. Trust chain: you + them. No middleman.
Certificate renewal: never. Chain grows automatically.
```

> **Developer tip:** The best code is code that doesn't exist. The best infrastructure is infrastructure that doesn't exist. Every hop you remove is a hop that can't fail.

---

## What Changed and Why It Matters

| Classical Problem | What Everyone Does | What Tesseract Does | Why It's Better |
|------------------|--------------------|--------------------|-----------------|
| SSL cert expires | Automate renewal (Let's Encrypt) | .fibo chain grows forever | Nothing to renew = nothing to forget |
| DNS goes down | Multi-provider failover | Content-addressed by BLAKE3 | No name server = no name server failure |
| Server gets DDoSed | Buy DDoS protection | Proof-of-work + QuantumID + ShardBlade | Attacker cost scales exponentially |
| Database breached | Encrypt at rest, rotate keys | Data lives on YOUR machine | Can't breach what you don't host |
| API key leaked | Rotate keys, audit logs | QuantumID behavioral detection | Stolen key + wrong behavior = instant ShardBlade |
| OAuth token stolen | Short-lived tokens, refresh flow | Every request re-verified by .fibo chain | No token to steal — identity IS the device |
| Microservice networking | Service mesh (Istio, Linkerd) | Density matrix coherences | Physics manages the mesh, not YAML |
| Container orchestration | Kubernetes (1M+ lines of Go) | Tesseract Coherence Field (14 ns health check) | One equation replaces one million lines |

> **Developer tip:** The density matrix doesn't know it's managing infrastructure. It thinks it's moving a character. The math is the same. That's the point.

---

## The Identity Model — Tesseracts Don't Use Certificates

### What You Have Today

```
Your identity online:
  ├── Email/password (can be phished)
  ├── OAuth tokens (can be stolen)
  ├── API keys (can be leaked)
  ├── TLS certificates (expire every 90 days)
  ├── SSH keys (manually distributed)
  └── CAPTCHA (arms race with bots)

Each one is a separate system. Each one can fail independently.
Each one requires manual management. Each one is someone else's problem
until it becomes yours at 3am on a Saturday.
```

### What You Have With Dreamwell

```
Your identity:
  └── identity.fibo (one file, one command, forever)
        ├── Ed25519 signing key (hardware-bound, never leaves your machine)
        ├── X25519 exchange key (ephemeral per session, forward secrecy)
        ├── BLAKE3 seal chain (grows with every operation, never shrinks)
        ├── QuantumID trajectory (proves you're human by how you interact)
        └── Device fingerprint (CPU + RAM + disk + OS + BIOS serial)

One file. One command: dream init.
No renewal. No rotation. No expiry. No CA. No OAuth. No CAPTCHA.
```

**How trust works:**
- First time you connect to a peer: like SSH — accept their pubkey, record it
- Every time after: verify their chain has only grown (never forked, never reset)
- If anything is wrong: ShardBlade fires automatically (instant disconnect + audit)
- Active connections: trust maintained by continuous observation
- Inactive connections: trust decays naturally (dephasing — no manual revocation needed)

> **Developer tip:** Trust is not a boolean. It's a temperature. Active relationships are warm. Neglected ones cool. Compromised ones freeze. The physics handles the transition.

---

## The File Format Story

You already know these patterns:

| You Know This | Dreamwell Equivalent | Speed | When to Use |
|---------------|---------------------|-------|-------------|
| `gzip` | `.qport` (QPRT) | 285 MB/s | Sending files to peers |
| `rsync --diff` | `.qdlt` (QDLT) | 600+ MB/s | Syncing changed files |
| `tar.gz` archive | `.fractal` (FRCL) | 7 MB/s | Long-term storage |
| `.json` metadata | `.dreamfile` (DRFL) | Fast | Structured data with MI tokenization |
| `~/.ssh/id_ed25519` | `.fibo` (FIBO) | Instant | Your identity |

Every format is:
- Self-describing (magic bytes, not extension)
- BLAKE3-verified (tamper-evident)
- Deterministic (same input = same output = same hash)

```bash
# Pack any file
dream pack photo.png              # → photo.png.dreamfile

# Compress for archival
dream fractal dataset.csv          # → dataset.csv.fractal (works on any binary)

# Open anything (auto-detects format by magic bytes)
dream open photo.png.dreamfile     # → photo.png (verified, receipted)
dream open dataset.csv.fractal     # → dataset.csv (decompressed, verified)

# Every operation produces a Clean Compute Receipt:
#   Operation:   OPEN
#   Integrity:   LOSSLESS (3 BLAKE3 verifications)
#   Coherence:   100.0%
#   Energy:      0.4 ms (2.40% of 60fps frame)
```

> **Developer tip:** `dream open` is the universal verb. It's the quantum double-click. It doesn't care what format the file is. It reads the first 4 bytes, identifies the format, decodes, verifies, and receipts. One command for everything.

---

## Portal = Dropbox. Signal = RSS, But Deeply Customizable.

```bash
# Share a folder with a friend (bidirectional sync)
dream portal open ~/photos
#   Portal key: dbbda8a6d9e490c8
#   Give this key to your friend.

# Your friend connects
dream portal connect dbbda8a6d9e490c8

# That's it. Files sync automatically.
# Changed files send only the changed chunks (BA-46, 600+ MB/s).
# Both sides produce identical BLAKE3-attested receipts.
# No server. No cloud. No subscription. No storage limit.
```

```bash
# Broadcast a folder publicly (one-way, like RSS)
dream signal open --name "blog" ~/posts
#   Signal key: be6213fc800b6e57
#   Anyone can subscribe.

# A subscriber joins
dream signal join be6213fc800b6e57

# New posts auto-broadcast. Subscribers auto-receive.
# No webhook endpoint. No server uptime requirement.
# Your machine broadcasts when it's on. Subscribers cache locally.
```

> **Developer tip:** The best distributed system is one where every node is complete. Portals and Signals don't need a server because every Tesseract IS a server.

---

## Quantum Internet Network Architecture

Every device runs a Tesseract -- a classical machine with a quantum state inside it. The quantum state (5x5 density matrix) manages the container's health. The classical network (TCP/UDP) carries the encrypted packets. The trust is mutual, continuous, and physics-based.

Three scenarios show how the same architecture scales from two friends to an enterprise.

### Scenario 1: Peer-to-Peer (1:1)

Two laptops on the same Wi-Fi, or across the internet. One portal, bidirectional sync.

```
 Jason's Laptop                                    Alice's Laptop
┌─────────────────────────────┐                  ┌─────────────────────────────┐
│  Classical Hardware          │                  │  Classical Hardware          │
│  (CPU, RAM, disk, NIC)       │                  │  (CPU, RAM, disk, NIC)       │
│                              │                  │                              │
│  ┌─────────────────────────┐ │    FQTP:9618     │ ┌─────────────────────────┐ │
│  │  Tesseract              │ │◄────────────────►│ │  Tesseract              │ │
│  │                         │ │  Ed25519 Hello   │ │                         │ │
│  │  ┌───────────────────┐  │ │  X25519 KeyEx    │ │  ┌───────────────────┐  │ │
│  │  │  Quantum State    │  │ │  ChaCha20 Data   │ │  │  Quantum State    │  │ │
│  │  │  ρ = 5x5 density  │  │ │                  │ │  │  ρ = 5x5 density  │  │ │
│  │  │  F = <H> - TS     │  │ │  .qport (285MB/s)│ │  │  F = <H> - TS     │  │ │
│  │  │  14ns health check │  │ │  .qdlt (600MB/s) │ │  │  14ns health check │  │ │
│  │  └───────────────────┘  │ │                  │ │  └───────────────────┘  │ │
│  │                         │ │  Clean Compute   │ │                         │ │
│  │  Services:              │ │  receipts on     │ │  Services:              │ │
│  │   Universe   0.20       │ │  both sides      │ │   Universe   0.20       │ │
│  │   FQTP       0.20       │ │                  │ │   FQTP       0.20       │ │
│  │   LQTP       0.20       │ │                  │ │   LQTP       0.20       │ │
│  │   QCloud     0.20       │ │                  │ │   QCloud     0.20       │ │
│  │   Peers      0.20       │ │                  │ │   Peers      0.20       │ │
│  └─────────────────────────┘ │                  │ └─────────────────────────┘ │
│                              │                  │                              │
│  identity.fibo               │                  │  identity.fibo               │
│  ~/.dreamwell/               │                  │  ~/.dreamwell/               │
└─────────────────────────────┘                  └─────────────────────────────┘

Address: qttps:φ//adynblaed/signal/index.html ──► resolves via Alice's tesseracts.json
Trust:   .fibo chain verified on every heartbeat (1618ms)
Sync:    Portal (bidirectional) or Signal (one-way broadcast)
```

**Day-to-day use:** Share photos with a partner. Sync a project folder with a collaborator. Send a file to a friend without uploading it anywhere. Every transfer is BLAKE3-verified, encrypted end-to-end, and receipted.

### Scenario 2: Family and Friends (Personal Group)

A small mesh of 3-8 Tesseracts. Each device is sovereign. No central server. Trust is peer-to-peer.

```
                        Mom's Tablet
                    ┌──────────────────┐
                    │  Tesseract       │
                    │  ρ = 5x5         │
                    │  identity.fibo   │
                    └────────┬─────────┘
                             │ FQTP
                             │
    Jason's Laptop ───────────┼──────────── Alice's Desktop
┌──────────────────┐         │         ┌──────────────────┐
│  Tesseract       │◄────────┼────────►│  Tesseract       │
│  ρ = 5x5         │   FQTP  │   FQTP  │  ρ = 5x5         │
│  identity.fibo   │         │         │  identity.fibo   │
└──────────────────┘         │         └──────────────────┘
         │                   │                   │
         │ FQTP              │ FQTP              │ FQTP
         │                   │                   │
    Dad's Phone ─────────────┘              Bob's Laptop
┌──────────────────┐                    ┌──────────────────┐
│  Tesseract       │                    │  Tesseract       │
│  ρ = 5x5         │                    │  ρ = 5x5         │
│  identity.fibo   │                    │  identity.fibo   │
└──────────────────┘                    └──────────────────┘

Each tesseract has its own:
  - identity.fibo (never shared, never copied)
  - tesseracts.json (knows all family members by name)
  - QuantumCloud (local content-addressed storage)
  - Seal chain (grows independently)

Shared via:
  - Portal: "family-photos" (bidirectional, all 5 members sync)
  - Signal: "dad-blog" (one-way, Dad publishes, family reads)

Trust model:
  - dream friend <quantum_id> --label "mom"
  - Each peer verified every 1618ms heartbeat
  - No central authority. If Mom's tablet is offline, everyone else still syncs.
  - If a device is compromised, ShardBlade fires on that peer only.
```

**Day-to-day use:** Family photo album that syncs across all devices without iCloud or Google Photos. Dad's recipe blog that auto-updates on everyone's tablet. Shared grocery list via portal. Each person controls their own data. No subscription. No storage limit. No terms of service.

### Scenario 3: Clustered Entanglement (Community / Enterprise)

A mesh of 10-1000+ Tesseracts. QuantumCloud shards replicate across F(5)=5 peers for availability. Domain bridge for public access.

```
                    ┌─────────────────────────────────────────┐
                    │        QuantumCloud (F(5) = 5 shards)   │
                    │                                         │
                    │  Shard 1 ──── Shard 2 ──── Shard 3      │
                    │     │            │            │          │
                    │  Shard 4 ──── Shard 5                   │
                    │                                         │
                    │  Content-addressed by BLAKE3 digest.     │
                    │  Any shard can serve any content.        │
                    │  Availability: 1-(0.01)^5 = 99.99999%   │
                    └────────────────────┬────────────────────┘
                                         │
        ┌────────────────────────────────┼────────────────────────────────┐
        │                                │                                │
   Engineering                      Operations                      Community
┌──────────────────┐          ┌──────────────────┐          ┌──────────────────┐
│ Dev-1 Tesseract  │          │ Ops-1 Tesseract  │          │ User-1 Tesseract │
│ Dev-2 Tesseract  │          │ Ops-2 Tesseract  │          │ User-2 Tesseract │
│ Dev-3 Tesseract  │          │ CI Bot (AGENT)   │          │ ...              │
│ ...              │          │ ...              │          │ User-N Tesseract │
└──────────────────┘          └──────────────────┘          └──────────────────┘

Portal: "source-code"         Signal: "releases"            Signal: "docs"
  (devs sync code)              (ops broadcasts builds)       (community reads)

Identity types:
  HUMAN   — developers, ops, community members (root of trust)
  AGENT   — CI bots, automation (delegated, time-boxed, scoped)
  SERVICE — infrastructure daemons (headless, attested)

Public access via domain bridge:
  qttps:φ//dreamwell.com/docs/getting-started
    │
    ▼
  DNS TXT: _qttps.dreamwell.com → qid=8db36d3b;tid=af79096d;port=9618
    │
    ▼
  Routes to nearest available Tesseract in the cluster

Trust hierarchy:
  Admins delegate AGENT scope to CI bots (read-only, 24h expiry)
  Community members are HUMAN (full observe, scoped cohere)
  ShardBlade isolates any compromised node without affecting the cluster
  No Kubernetes. No load balancer. The density matrix IS the orchestrator.
```

**Day-to-day use:** Open source project where contributors sync code via portals, CI bots run tests via delegated AGENT identities, releases auto-broadcast via signals, and documentation is available at `qttps:φ//dreamwell.com/docs/`. Enterprise teams share internal tools. Hobby communities run game servers. Sensor networks aggregate data. Each node is sovereign. The cluster self-heals.

### Protocol Stack (OSI Comparison)

```
Classical OSI              Dreamwell QTTPS              What Changes
─────────────              ─────────────────              ────────────
Layer 8: Multiverse        MultiverseIntegrity (BA-53)   Network-scale thermodynamic attestation
Layer 7: Application       dream observe / cohere        Quantum verbs, not HTTP methods
Layer 6: Presentation      .qport / .qdlt / .fractal     Self-describing formats, not MIME
Layer 5: Session           QuantumGate (BA-13)           7-state gate lifecycle, not TCP session
Layer 4: Transport         FQTP (ChaCha20-Poly1305)     Encrypted by default, not optional
Layer 3: Network           FUDN (qttps:φ//)             Cryptographic addressing, not DNS
Layer 2: Data Link         WireGuard (boringtun)         Encrypted tunnel, not raw Ethernet
Layer 1: Physical          TCP/UDP over IP               Same physical network (Wi-Fi, LAN, WAN)

What stays:  Physical network (your router, your ISP, the internet backbone)
What goes:   DNS, TLS certificates, OAuth, API keys, load balancers, container orchestration
What's new:  Identity IS the address. Content IS the proof. Health IS the physics.
             The Multiverse IS the substrate. SacredTimeline IS sovereignty.
```

---

## Tesseract = Your Quantum Container

```
What Docker does:                    What Tesseract does:
─────────────────                    ────────────────────
Isolates a process                   Isolates quantum state
Needs Kubernetes to orchestrate      Self-manages via density matrix physics
Needs Prometheus to monitor          Monitors itself (free energy = health, 14 ns)
Needs cert-manager for TLS           .fibo IS the certificate (never expires)
Needs Envoy for service mesh         Coherences ARE the service mesh
Needs PagerDuty for alerts           Spectral annealing IS the alert system
```

```bash
# Start your Tesseract
dream tesseract start

# Connect to the public network
dream connect --tesseract --earth-prime

# Connect to a friend
dream connect --tesseract --abc123def456

# See who's connected
dream ls --tesseract --identities
#   alice     HUMAN    chain=1247  trusted
#   ci-bot    AGENT    chain=89    delegated (read-only, expires 24h)
#   earth     SERVICE  chain=50000 verified

# Everything you do routes through your Tesseract.
# Every operation is BLAKE3-sealed.
# Every peer is verified every 1618ms (φ × 1000).
# If anything breaks, ShardBlade fires automatically.
# If everything's healthy, the eigenvalues settle at 1/φ² = 0.382.
# That number means "golden equilibrium." It means "all is well."
```

> **Developer tip:** The Tesseract's health check costs 14 nanoseconds. That's 0.0003% of a heartbeat interval. The health check is so cheap it runs on every heartbeat without anyone noticing. That's what Clean Compute means — the overhead is so small it's effectively free. Not amortized. Not batched. Not deferred. Just... free.

---

## The Blockchain Question

People will ask: "Is this a blockchain?"

No. Here's why:

| Blockchain | Tesseract |
|-----------|-----------|
| Global consensus required (slow) | Local .fibo chain (instant) |
| Proof of work wastes energy | Proof of work only during DDoS (adaptive) |
| Cryptocurrency incentivizes mining | Free energy incentivizes cooperation |
| Every node stores everything | Each Tesseract stores its own data |
| Transactions are public | Transactions are peer-to-peer (private by default) |
| Smart contracts are code | The density matrix IS the contract (physics) |
| 51% attack vulnerability | No consensus = no 51% attack |
| Gas fees | Clean Compute receipts (free, BLAKE3-attested) |

What we share with blockchain: content addressing (BLAKE3 ≈ SHA-256), tamper-evident chains (seal chain ≈ Merkle chain), decentralization (peer mesh ≈ node network).

What we don't share: the overhead. No consensus. No mining. No gas. No global state. Each Tesseract is sovereign. Trust is computed locally from observation, not from global agreement.

> **Developer tip:** The blockchain asked "how do we agree on truth?" Tesseract asks "how do we observe each other honestly?" The first question requires consensus. The second question requires physics. Physics is faster.

---

## How It Compares — The Rosetta Stone

| What You Know | Dreamwell Equivalent | What's Different |
|---------------|---------------------|-----------------|
| `localhost:3000` | `dream tesseract start` | Your dev server IS your production server |
| `nginx` / `Caddy` | QTTPSObserver | Stateless relay, not reverse proxy |
| `docker compose up` | `dream tesseract start` | One command, all services, self-healing |
| `kubectl get pods` | `dream tesseract status` | Density matrix populations, not pod lists |
| `helm install` | `dream connect --tesseract` | Connect to a network, not deploy a chart |
| TLS certificate | `identity.fibo` | Hardware-bound, never expires |
| Let's Encrypt | Not needed | .fibo chain IS the certificate |
| OAuth / JWT | QuantumID | Behavioral, not token-based |
| CAPTCHA | QuantumID | Thermodynamic, not visual puzzle |
| `curl https://` | `dream observe "qttps:φ//"` | Content-addressed, not name-resolved |
| `scp file user@host:` | `dream send file --target host` | .qport compressed, BLAKE3 verified |
| `rsync --delta` | Portal delta sync | BLAKE3 Merkle chunks, 600+ MB/s |
| Dropbox | `dream portal open folder/` | Peer-to-peer, no cloud, no subscription |
| RSS / Atom | `dream signal open --name blog posts/` | Quantum broadcast, auto-sync |
| GitHub Pages | `dream signal open --name site dist/` | Your machine IS the CDN |
| Prometheus metrics | Clean Compute receipts | Built into every operation, not scraped |
| PagerDuty alerts | Spectral annealing | Eigenvalues ARE the alert (14 ns) |
| `brew doctor` | `dream health` | Full diagnostic with actionable fixes |
| `whoami` | `dream whoami` | Identity + chain depth + coherence state |

---

## Next Steps

```bash
# 1. Build the CLI
cargo build -p dreamwell-cli --release

# 2. Create your identity (once, forever)
dream init

# 3. Check your health
dream health

# 4. Create a project
dream up init --name hello

# 5. Pack a file, open it, verify it
echo "Hello Universe" > hello.txt
dream pack hello.txt
dream open hello.txt.dreamfile
dream verify hello.txt.dreamfile

# 6. Share it
dream portal open .

# 7. See your stats
dream stats local
dream stats identity
dream whoami
```
