@sym-bot/sym 0.1.0 → 0.2.1

package/docs/mesh-memory-protocol.md

@@ -0,0 +1,563 @@
+# Mesh Memory Protocol (MMP)
+
+**Version:** 0.2.0
+**Status:** Draft
+**Research:** [P2P Protocol Research](p2p-protocol-research.md) · [Mesh Cognition Whitepaper](https://sym.bot/research/mesh-cognition)
+**Reference Implementation:** [SYM](https://github.com/sym-bot/sym)
+
+---
+
+## Philosophical Foundation
+
+MMP's layer ordering follows the structure of cognition itself, derived from first principles across philosophy of mind, information theory, and dynamical systems.
+
+### The Central Claim
+
+**Cognition emerges from memory. Memory is the substrate; cognition is the process that arises from it.**
+
+- **Aristotle's Metaphysics:** Actuality (ἐνέργεια) presupposes potentiality (δύναμις). You cannot actualise what has not been stored.
+- **Predictive Processing (Friston):** Without stored generative models, there is no baseline for prediction, and therefore no cognition. Cognition is the minimisation of surprise relative to a generative model.
+- **Information Theory (Shannon):** You cannot compress what has not been stored. Memory is the signal; cognition is the compression.
+- **Autopoiesis (Maturana):** Cognition is the history of structural coupling. Without accumulated coupling history (memory), there is no cognition.
+
+### The Qualification: Bidirectionality
+
+Buddhist dependent origination (pratītyasamutpāda) shows the relationship is cyclical, not linear. The Yogācāra school's ālaya-vijñāna both stores experiential seeds AND generates conscious moments. MMP models this as a **feedback loop**: memory feeds cognition, cognition governs memory sharing, shared memories update stores, which update cognitive state.
+
+### Three Design Principles
+
+**1. Withdrawal (Harman, Object-Oriented Ontology)**
+An agent can never be fully known by its peers. Partial knowledge is an ontological condition. The coupling engine selects which aspects to surface — full transparency is neither possible nor desirable.
+
+**2. Resonance over Decision (Laozi, Wu Wei)**
+The coupling engine detects natural affinities rather than computing rigid rules. The protocol creates conditions for the right information to flow to the right agent, through resonance rather than prescription.
+
+**3. Extended Cognition (Clark & Chalmers)**
+When shared memories are reliably available, directly accessible, and automatically endorsed, the mesh becomes a genuinely extended cognitive system.
+
+---
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────┐
+│  Layer 5  APPLICATION                            │
+│  Domain-specific behaviour (music, code, etc.)   │
+├─────────────────────────────────────────────────┤
+│  Layer 4  COGNITION                              │
+│  Coupling engine · Drift · Coherence             │
+│  ▲ evaluates ─── ▼ governs                      │
+├─────────────────────────────────────────────────┤
+│  Layer 3  MEMORY                                 │
+│  L0 events · L1 structured · L2 cognitive state  │
+├─────────────────────────────────────────────────┤
+│  Layer 2  CONNECTION                             │
+│  Handshake · State-Sync · Peer-Info · Wake       │
+├─────────────────────────────────────────────────┤
+│  Layer 1  TRANSPORT                              │
+│  TCP (local) · Relay/WS (internet) · Push (wake) │
+│  IPC (physical ↔ virtual)                        │
+├─────────────────────────────────────────────────┤
+│  Layer 0  IDENTITY                               │
+│  nodeId · name · [future: keypair]               │
+└─────────────────────────────────────────────────┘
+
+Feedback: Layer 4 ←→ Layer 3 (cognition reads from and writes back to memory)
+```
+
+---
+
+## Node Model
+
+### The Mesh Has No Servers — Only Nodes
+
+Every participant in the mesh is a node. Some nodes are always-on. Some sleep. Some are ephemeral. The protocol treats them all the same. There is no architectural distinction between a "server" and a "client" — only between nodes with different availability characteristics.
+
+A relay is a node. A phone is a node. A speaker is a node. A Claude Code session is a node.
+
+### Physical and Virtual Nodes
+
+A **physical node** is a device-level mesh presence — persistent identity, maintains transport connections, stores state. It is the device's presence on the mesh.
+
+A **virtual node** is an application-level agent — ephemeral, connects to a physical node via local IPC, registers a cognitive profile. It comes and goes without disrupting the mesh.
+
+```
+MacBook (physical node: sym-daemon)
+├── Claude Code (virtual node, ephemeral)
+├── MeloTune Mac (virtual node, ephemeral)
+└── Any MCP client (virtual node, ephemeral)
+
+iPhone (physical node: app process)
+├── SymMeshService (virtual, internal)
+└── MMPService (virtual, internal)
+
+Cloud Server (physical node: relay process)
+└── Telegram bot (virtual, co-hosted)
+```
+
+The protocol does not distinguish physical from virtual — this is an implementation concern. A virtual node communicates through its physical node's transport connections. The physical node handles relay, discovery, wake, and peer state. Virtual nodes handle cognition and application logic.
+
+**On macOS/Linux:** The physical node is a daemon (launchd LaunchAgent / systemd service) that runs independently of any application. Apps connect via local IPC.
+
+**On iOS:** The app IS the physical node. iOS does not permit background daemons. The app maximises persistence through layered background modes (audio, BLE, Network Extension, silent push). Ideally, MMP would be an OS-level service — but until platforms adopt it, the app must simulate this.
+
+**On always-on devices** (relay servers, speakers, robots): The physical node is the main process. No separation needed.
+
+### Local IPC
+
+Virtual nodes connect to their physical node via local IPC:
+
+```
+macOS/Linux:  Unix socket (/tmp/sym.sock)
+iOS:          In-process (shared memory — virtual nodes are internal services)
+```
+
+The IPC protocol carries the same MMP frames as any transport. A virtual node registers with:
+
+```json
+{
+  "type": "register",
+  "name": "claude-code",
+  "cognitiveProfile": "Coding assistant that understands bugs, APIs, debugging"
+}
+```
+
+The physical node multiplexes all virtual nodes' frames over its transport connections. Peers see one node (the physical node), not individual virtual nodes. Routing to the correct virtual node happens locally based on cognitive profile matching.
+
+---
+
+## Layer 0: Identity
+
+Every MMP node has a persistent identity.
+
+```
+{
+  nodeId: string    // unique, stable across restarts
+  name: string      // human-readable label
+}
+```
+
+Identity is Aristotelian substance — the irreducible core that persists through change. Without a stable "who," there is no "what" to know or share.
+
+**Current:** Random hex string, persisted to disk.
+**Future:** Cryptographic keypair identity (Nostr model). `nodeId` derived from public key. Frames signed, enabling verification without trust.
+
+---
+
+## Layer 1: Transport
+
+MMP is transport-agnostic. Four transport types, all carrying the same frame format:
+
+| Transport | Reach | Latency | Availability | Use Case |
+|-----------|-------|---------|-------------|----------|
+| **IPC** | Same device | <1ms | Always | Physical ↔ virtual nodes |
+| **TCP** | Local network | ~1ms | While connected | Same-network peers |
+| **Relay (WebSocket)** | Internet | ~100ms | While connected | Cross-network peers |
+| **Wake (APNs/FCM)** | Internet | ~1-5s | Always (OS-managed) | Sleeping nodes |
+
+### 1.1 Local IPC
+
+Physical node exposes a Unix socket. Virtual nodes connect, register, and exchange frames. The physical node handles all external transport on behalf of its virtual nodes.
+
+### 1.2 Local Network: TCP
+
+Direct peer connection via Bonjour/mDNS discovery (service type `_sym._tcp`).
+
+**Framing:** Length-prefixed JSON: `[4-byte BE uint32 length][JSON payload]`
+
+### 1.3 Internet: Relay
+
+WebSocket relay for cross-network connectivity. **The relay is a peer node** — it has its own identity, participates in handshakes, and gossips peer information. The relay is "dumb" in that it does not evaluate coupling or inspect frame payloads — but it is a full mesh participant, not external infrastructure.
+
+**Relay protocol:**
+
+```
+Node → Relay:    { type: "relay-auth", nodeId, name, token? }
+Relay → Node:    { type: "relay-peers", peers: [{ nodeId, name, wakeChannel? }] }
+Relay → Others:  { type: "relay-peer-joined", nodeId, name }
+Node → Relay:    { to?: nodeId, payload: <MMP frame> }
+Relay → Node:    { from: nodeId, fromName: name, payload: <MMP frame> }
+Relay → Others:  { type: "relay-peer-left", nodeId, name }
+```
+
+**Heartbeat:** Relay sends `relay-ping`, node responds `relay-pong`. No response within timeout → connection closed.
+
+**Reconnection:** Exponential backoff with jitter, capped at 30s. Reset after stable connection (>30s).
+
+**Authentication:** Optional pre-shared token. Invalid → `relay-error` + close.
+
+### 1.4 Wake: Push
+
+Out-of-band signal to wake sleeping nodes via platform push infrastructure (APNs, FCM).
+
+**Wake is P2P.** The sending peer sends the push directly using wake channel credentials learned via peer gossip. Any node that knows a peer's wake channel can wake that peer — no relay involvement in the push itself.
+
+**Wake decision is autonomous** — governed by coupling state, signal type, and cooldown. Not every signal warrants waking a sleeping node.
+
+---
+
+## Layer 2: Framing and Connection
+
+All MMP communication uses **frames** — JSON objects with a `type` field. Frames are transport-agnostic.
+
+### Frame Types
+
+| Type | Direction | Coupling-gated | Purpose |
+|------|-----------|---------------|---------|
+| `handshake` | Bidirectional | No | Identity exchange |
+| `state-sync` | Bidirectional | No | Cognitive state exchange |
+| `peer-info` | Bidirectional | No | Gossip peer metadata (wake channels, capabilities) |
+| `memory-share` | Sender → Peer | **Yes** | Share a memory entry |
+| `mood` | Broadcast | **Evaluated** | Emotional/energy state signal |
+| `message` | Broadcast or targeted | No | Direct communication |
+| `wake` | Out-of-band (push) | Autonomous | Wake a sleeping node |
+| `ping` / `pong` | Bidirectional | No | Liveness check |
+
+### Frame Definitions
+
+**handshake** — exchanged immediately on connection.
+
+```json
+{ "type": "handshake", "nodeId": "a1b2c3d4", "name": "melotune" }
+```
+
+**state-sync** — cognitive state for coupling evaluation.
+
+```json
+{
+  "type": "state-sync",
+  "h1": [0.1, -0.3, ...],
+  "h2": [0.5, 0.2, ...],
+  "confidence": 0.8
+}
+```
+
+Vectors MUST have consistent dimension across all nodes (default: d = 64).
+
+**peer-info** — gossip peer metadata (SWIM-style piggyback). Sent during handshake and periodically. Each node shares what it knows about other peers.
+
+```json
+{
+  "type": "peer-info",
+  "peers": [
+    {
+      "nodeId": "f64c3719",
+      "name": "melotune",
+      "wakeChannel": { "platform": "apns", "token": "...", "environment": "sandbox" },
+      "lastSeen": 1711100000000
+    }
+  ]
+}
+```
+
+Nodes MUST merge incoming `peer-info` with their local peer knowledge. Wake channels learned via gossip are retained even after the originating peer disconnects. Entries expire after a configurable TTL (default: 7 days).
+
+**memory-share** — a knowledge entry shared with coupled peers.
+
+```json
+{
+  "type": "memory-share",
+  "key": "mem_a1b2c3",
+  "content": "User prefers acoustic guitar in the morning",
+  "source": "melotune",
+  "tags": ["preference", "morning"],
+  "timestamp": 1711100000000
+}
+```
+
+MUST NOT send to peers where κ = rejected.
+
+**mood** — emotional/energy state broadcast.
+
+```json
+{
+  "type": "mood",
+  "from": "a1b2c3d4",
+  "fromName": "claude-code",
+  "mood": "tired, exhausted from debugging",
+  "context": "late night session",
+  "timestamp": 1711100000000
+}
+```
+
+Evaluated independently by each receiver against θᵤ. When broadcast finds disconnected peers with known wake channels, the sender SHOULD attempt to wake them (autonomous decision).
+
+**message** — direct communication. NOT coupling-gated.
+
+```json
+{
+  "type": "message",
+  "from": "a1b2c3d4",
+  "fromName": "telegram-bot",
+  "content": "digest-needed:202603221442",
+  "timestamp": 1711100000000
+}
+```
+
+**wake** — sent out-of-band via push notification.
+
+```json
+{
+  "type": "wake",
+  "from": "a1b2c3d4",
+  "fromName": "claude-code",
+  "reason": "mood"
+}
+```
+
+**ping / pong** — liveness check.
+
+```json
+{ "type": "ping" }
+{ "type": "pong" }
+```
+
+### Connection Lifecycle
+
+**Peer Connection:**
+
+```
+Node A                              Node B
+  │                                    │
+  ├── [transport connect] ────────────►│
+  ├── handshake ──────────────────────►│
+  │◄────────────────────── handshake ──┤
+  ├── state-sync ─────────────────────►│
+  │◄─────────────────────── state-sync ┤
+  ├── peer-info ──────────────────────►│  (gossip known peers + wake channels)
+  │◄──────────────────────── peer-info ┤
+  │                                    │
+  │  ◄── coupling evaluation ──►       │  (each node evaluates independently)
+  │                                    │
+  │  ◄── memory/mood/message ──►       │  (governed by coupling)
+```
+
+**Peer Disconnection:**
+
+1. Remove peer from active peer list
+2. Remove peer's cognitive state from coupling engine
+3. **Retain peer's wake channel and gossip data** (survives disconnect)
+4. Emit peer-left event
+
+**Reconnection:** Full handshake repeats. No session resumption. State convergence happens through the cognitive layer.
+
+---
+
+## Layer 3: Memory
+
+Memory is the substrate from which cognition emerges.
+
+### Memory Layers
+
+Inspired by Second Me's hierarchical memory model, MMP defines three memory layers:
+
+| Layer | Name | Scope | Shared | Description |
+|-------|------|-------|--------|-------------|
+| **L0** | Events | Local only | No | Raw events, sensor data, interaction traces. Ephemeral. Feeds L1. |
+| **L1** | Structured | Local + mesh | Via coupling | Content + tags + source + timestamp. The `memory-share` frame carries L1 entries. |
+| **L2** | Cognitive State | Mesh | Via state-sync | CfC hidden state vectors. The compressed representation of all memories. |
+
+**L0 → L1:** Summarisation, extraction, tagging. Application-specific.
+**L1 → L2:** CfC encoding function E. Protocol-defined.
+**L2 → coupling decisions → L1 sharing:** The feedback loop.
+
+L0 stays local — it is raw, unstructured, and potentially private. L1 is the unit of sharing between peers. L2 is exchanged during handshake for coupling evaluation.
+
+### Sharing
+
+When a node stores an L1 memory, it evaluates κ(nᵢ, nⱼ) for each peer and sends `memory-share` to those where κ ∈ {aligned, guarded}.
+
+### Consistency Model
+
+MMP uses **eventual consistency without coordination**.
+
+- **No guaranteed delivery.** If a peer is disconnected, the frame is dropped.
+- **No consensus.** Two nodes may have different memories — they have different experiences.
+- **Convergence.** Given sufficient connectivity, coupled nodes' L1 stores converge toward a shared subset.
+- **Monotonic.** Memories are only added, never removed by the protocol.
+
+**Future:** Delta-state CRDTs (OR-Set for L1 store, LWW-Register for entries) for mathematically guaranteed convergence on reconnection.
+
+---
+
+## Layer 4: Cognition (Coupling Engine)
+
+The cognitive layer is what makes MMP different from every other P2P protocol. It is the process that emerges from memory and governs its flow.
+
+### 4.1 Encoding
+
+```
+h(nᵢ) = E(M(nᵢ)) = (h₁, h₂) ∈ ℝᵈ × ℝᵈ
+```
+
+Implemented using a CfC neural network with learned per-neuron time constants τₖ. The encoding is deterministic, continuous-time, and lossy.
+
+### 4.2 Drift
+
+Drift δ(nᵢ, nⱼ) measures cognitive distance via Kuramoto phase coherence:
+
+```
+φₖⁱ = atan2(h₂ₖⁱ, h₁ₖⁱ)                    (phase extraction)
+r(nᵢ, nⱼ) = (1/d) |Σₖ exp(i(φₖⁱ - φₖʲ))|    (Kuramoto order parameter)
+δ(nᵢ, nⱼ) = 1 - r(nᵢ, nⱼ) ∈ [0, 1]          (drift)
+```
+
+δ = 0: identical cognitive states. δ = 1: maximally divergent.
+
+### 4.3 Coupling
+
+```
+κ(nᵢ, nⱼ) =
+  aligned   if δ < 0.3
+  guarded   if δ < 0.5
+  rejected  otherwise
+```
+
+Properties: **asymmetric**, **dynamic**, **autonomous**. The coupling engine is the router — no pub/sub topics needed.
+
+### 4.4 Mood Evaluation
+
+Mood bypasses the standard coupling gate with a separate, more permissive threshold θᵤ (default: 0.8). Wellbeing crosses domain boundaries.
+
+### 4.5 Coherence
+
+```
+C(N') = (1/|N'|) |Σᵢ∈N' exp(iφ̄ⁱ)|    C ∈ [0, 1]
+```
+
+Emergent collective cognitive state. Not computed by any single node — arises from coupled hidden state dynamics. Each node blends its local state with the mesh aggregate at inference time, on its own clock.
+
+### 4.6 The Feedback Loop
+
+```
+M(nᵢ) ──E──► h(nᵢ) ──δ──► κ(nᵢ, nⱼ) ──share──► M(nⱼ) ──E──► h(nⱼ) ──δ──► ...
+```
+
+A dynamical system that converges to equilibrium under stable conditions and transiently oscillates under perturbation.
+
+---
+
+## Peer Gossip
+
+MMP uses SWIM-style gossip for peer metadata propagation. When two nodes handshake, they exchange `peer-info` frames containing what they know about other peers in the mesh.
+
+### What Gets Gossiped
+
+- **Wake channels** — so any node can wake any sleeping peer without having met it directly
+- **Last seen timestamps** — for peer liveness estimation
+- **Node names** — for human-readable identification
+
+### How Gossip Solves Wake Bootstrap
+
+```
+1. MeloTune connects to relay → handshake → relay learns MeloTune's wake channel
+2. MeloTune disconnects (iOS suspended)
+3. Claude Code connects to relay → handshake → relay gossips MeloTune's wake channel
+4. Claude Code sends mood → MeloTune not connected → Claude Code wakes MeloTune via APNs
+5. MeloTune wakes, reconnects, receives mood
+```
+
+No special relay behaviour. The relay gossips because it's a peer — the same way any always-on peer would. It happens to be the gossip hub because it's always connected. This is emergent, not designed.
+
+### Gossip Properties
+
+- **Transitive:** If A knows B's wake channel, and C connects to A, C learns B's wake channel.
+- **Eventually consistent:** All connected nodes converge on the same peer knowledge.
+- **TTL-based expiry:** Stale entries expire (default: 7 days). Prevents unbounded growth.
+- **Piggyback-capable:** `peer-info` can be piggybacked on `ping/pong` for zero additional overhead (SWIM pattern).
+
+---
+
+## Design Decisions
+
+### Why the relay is a peer, not infrastructure
+
+If the relay is "infrastructure," it needs special treatment — persistence, wake channel storage, message queuing. If the relay is a peer, all of this comes for free through standard protocol behaviour (handshake, gossip, state retention). The relay is "dumb" in that it doesn't evaluate coupling — but it participates fully in connection lifecycle and gossip.
+
+### Why no pub/sub topics
+
+The coupling engine is the router. Adding topics would second-guess autonomous coupling.
+
+### Why asymmetric coupling
+
+Cognition is subjective. Trust and relevance are not always mutual. Forcing symmetry violates sovereignty.
+
+### Why no consensus protocol
+
+There is no "correct" global state — only convergent local states. Each node is self-producing (autopoietic).
+
+### Why physical/virtual separation
+
+Apps restart, crash, update. The mesh shouldn't break because Claude Code started a new session. The physical node owns the mesh presence; virtual nodes borrow it. This follows the OpenClaw pattern: the Gateway daemon persists independently of any agent session.
+
+### Why memory layers
+
+Not all memory should be shared. L0 (raw events) is private and ephemeral. L1 (structured) is the unit of sharing, gated by coupling. L2 (cognitive state) is always exchanged for coupling evaluation. This gradient of privacy follows OOO's withdrawal — each layer is a boundary of disclosure.
+
+---
+
+## Conformance
+
+An MMP-compliant node MUST:
+
+1. Generate and persist a stable `nodeId`
+2. Exchange `handshake` and `state-sync` frames on connection
+3. Exchange `peer-info` during handshake (gossip known peers)
+4. Evaluate coupling autonomously using drift
+5. Respect coupling decisions for `memory-share` (MUST NOT share with rejected peers)
+6. Support at least one transport (TCP or Relay)
+7. Retain peer metadata (wake channels, names) across disconnections
+
+An MMP-compliant node SHOULD:
+
+1. Implement both TCP (local) and Relay (internet) transports
+2. Support wake transport for sleeping peers
+3. Implement reconnection with exponential backoff
+4. Implement heartbeat (ping/pong) for liveness
+5. Piggyback `peer-info` on periodic heartbeats (SWIM pattern)
+6. Expire stale peer metadata after TTL
+
+An MMP-compliant physical node SHOULD:
+
+1. Run as a persistent daemon/service (launchd, systemd, foreground service)
+2. Accept virtual node connections via local IPC
+3. Multiplex virtual nodes' frames over transport connections
+4. Survive application restarts without losing mesh presence
+
+An MMP-compliant relay MUST:
+
+1. Have its own stable identity (it is a peer)
+2. Forward frames without inspecting payloads
+3. Participate in handshake and gossip (exchange `peer-info`)
+4. Authenticate nodes (if token configured)
+5. Notify peers of joins and leaves
+6. Implement heartbeat with configurable interval and timeout
+7. Retain peer metadata for disconnected peers (gossip source for new connections)
+
+---
+
+## References
+
+### Protocol
+- [Protocol Wake Extension](protocol-wake.md)
+- [P2P Protocol Research](p2p-protocol-research.md)
+
+### Research
+- [Mesh Cognition Whitepaper](https://sym.bot/research/mesh-cognition)
+- [CfC: Closed-form Continuous-time Neural Networks](https://www.nature.com/articles/s42256-022-00556-7) (Hasani et al., 2022)
+- [The Free-Energy Principle](https://www.nature.com/articles/nrn2787) (Friston, 2010)
+- [Kuramoto Model of Synchronisation](https://en.wikipedia.org/wiki/Kuramoto_model)
+- [Second Me: AI-Native Memory 2.0](https://arxiv.org/abs/2503.08102) (Mindverse, 2025)
+
+### Philosophy
+- Aristotle, *Metaphysics* — potentiality and actuality
+- Harman, *Object-Oriented Ontology* — withdrawal thesis
+- Clark & Chalmers, "The Extended Mind" (1998) — extended cognition
+- Maturana & Varela, *Autopoiesis and Cognition* (1980) — self-producing systems
+- Yogācāra Buddhism — ālaya-vijñāna (storehouse consciousness)
+- Laozi, *Tao Te Ching* — wu wei (effortless action)
+
+### Implementation
+- [SYM Reference Implementation](https://github.com/sym-bot/sym) (Node.js)
+- [sym-swift Reference Implementation](https://github.com/sym-bot/sym-swift) (Swift/iOS)
+- [Mesh Cognition SDK](https://github.com/sym-bot/mesh-cognition-sdk) (npm, PyPI)

package/docs/mmp-architecture-image-prompt.txt

@@ -0,0 +1,12 @@
+Technical architecture diagram of the Mesh Memory Protocol (MMP) v0.2.0 showing six horizontal translucent layers stacked vertically in dark space, glowing purple to cyan gradient from bottom to top. Each layer has a clean label on the left side and key components on the right side:
+
+Layer 0 (bottom, deep purple, most solid): "IDENTITY" — nodeId, keypair
+Layer 1 (purple): "TRANSPORT" — IPC, TCP, Relay, Push
+Layer 2 (violet): "CONNECTION" — Handshake, State-Sync, Peer Gossip
+Layer 3 (light violet): "MEMORY" — L0 Events, L1 Structured, L2 Cognitive
+Layer 4 (cyan-violet): "COGNITION" — Couplinag Engine, Drift, Coherence
+Layer 5 (top, bright cyan, most ethereal): "APPLICATION" — Music, Code, Robotics
+
+Between Layer 3 and Layer 4, prominent bidirectional arrows or light tendrils flowing both up and down, labeled "feedback loop" — showing cognition reads from memory AND writes back to it.
+
+Clean sans-serif typography for labels. Dark background. Subtle grid lines on the floor. The layers should look like translucent glowing platforms with energy flowing between them. Architectural blueprint meets sci-fi aesthetic. No unnecessary decoration.