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:

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

# 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

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:

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:

Hello Universe!

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

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:

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

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:

Every format is:

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

# 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.

# 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.

# 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

# 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:

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

Next Steps

# 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