diff --git a/.gitignore b/.gitignore
index edcc09a..0b4f823 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ Thumbs.db
 /.tools/
 /.npm-cache/
 /.quartz-build/
+/.quartz-verify-*/
 /quartz-site/node_modules/
 /quartz-site/public/
 /quartz-site/public-*/
diff --git a/GameCult/Projects/CultLib.md b/GameCult/Projects/CultLib.md
index 0722432..9ba75f7 100644
--- a/GameCult/Projects/CultLib.md
+++ b/GameCult/Projects/CultLib.md
@@ -1,14 +1,18 @@
 ---
 title: CultLib
-description: "Shared runtime and protocol family for GameCult code: CultLib itself plus the CultCache and CultNet ports spreading across C#, TypeScript, Rust, and Python."
-socialDeck: "Shared code for the studio's persistence and protocol mess."
+description: "GameCult's shared state, transport, and runtime substrate: CultCache persistence, CultNet reliable UDP, CultMesh distributed sync, and cross-runtime parity across C#, Rust, Kotlin, Python, and TypeScript."
+socialDeck: "Typed persistence, reliable UDP, distributed state, and runtime parity for the rest of the machine."
 ---
 
 # CultLib
 
-*"All the reusable parts that were tired of being copy-pasted between larger disasters."*
+*"The very large hammer hiding under the studio floorboards."*
 
-CultLib is the shared runtime and protocol family for GameCult code. The C# repo is the anchor, but the public shape is now larger than one language: `cultcache-ts`, `cultcache-rs`, `cultcache-py`, `cultnet-ts`, and `cultnet-rs` are all part of the same push to stop persistence and wire contracts from being rewritten as local folklore every time a new tool appears.
+CultLib is GameCult's shared state, transport, and runtime substrate. The C# repo is the anchor, but the real promise is parity: C#, Rust, Kotlin, Python, and TypeScript can read the same `.cc` documents, speak the same schema-v0 wire formats, discover compatible peers, and build native surfaces around the same state instead of translating through a new pile of glue every time a project crosses a runtime boundary.
+
+The three big pieces are CultCache, CultNet, and CultMesh. CultCache owns typed persistence and SoA memory shape. CultNet owns ergonomic networking over reliable UDP using CultCache document contracts, with LiteNetLib now treated as an adapter rather than the spec. CultMesh sits above them as the distributed database and simulation-consensus layer: peers publish facts, witnesses re-simulate disputed events, and the mesh gathers consensus before canonical state is committed.
+
+That is the practical reason Aetheria could move from single-player toward co-op in days. CultLib turns "make this a distributed MMO" from an open-ended networking rewrite into a question the stack already knows how to answer: persist the world, move the documents, discover the Verse, gather witness observations, reconcile state, and let the UI/runtime surface follow.
 
 <div class="gamecult-repo-links">
   <a class="gamecult-repo-link" href="https://github.com/GameCult/CultLib">GitHub Repo</a>
@@ -30,7 +34,7 @@ CultLib is the shared runtime and protocol family for GameCult code. The C# repo
   </div>
   <div class="gamecult-repo-fact">
     <p class="gamecult-repo-fact-label">Stack</p>
-    <p class="gamecult-repo-fact-value">C# / TypeScript / Rust / Python</p>
+    <p class="gamecult-repo-fact-value">C# / Rust / Kotlin / Python / TypeScript</p>
   </div>
   <div class="gamecult-repo-fact">
     <p class="gamecult-repo-fact-label">Status</p>
@@ -38,19 +42,30 @@ CultLib is the shared runtime and protocol family for GameCult code. The C# repo
   </div>
 </div>
 
+## What It Enables
+
+CultLib is not just a package. It is a capability layer for projects that need typed state to survive process boundaries, machine boundaries, and language boundaries.
+
+- CultCache gives every runtime a shared document and persistence model.
+- CultNet moves those documents through authenticated schema-aware transports, including GameCult's native cross-runtime RUDP pipe.
+- CultMesh turns the document stream into distributed state: shard replication, peer exchange, Verse discovery, authority leases, prediction, and witness-authoritative consensus.
+- CultUI and Eve-facing surfaces let the same state become inspectable native GUI or operator UI instead of another debug-only side channel.
+
+This is the nervous system behind the "Perfect Machine" instruction: spin up a multiplatform app, keep the data typed, keep the wire format honest, let the mesh decide where authority lives, and make the state visible to humans and agents.
+
 ## Founding Idea
 
 The founding idea was not glamorous. It was correct. Shared runtime machinery should live in a shared home instead of being smeared across project codebases until nobody can tell which copy is the cursed one.
 
 ## Trajectory
 
-CultLib starts with dependency updates, JSON backing store work, I/O fixes, security cleanup, and a full CultUI port away from legacy prefab residue. Then the focus hardens around schema, persistence, and wire contracts. On 06 May 2026 the family abruptly flowers outward: `cultcache-ts` ships the TypeScript port, `cultcache-rs` lands the Rust cache crate, `cultcache-py` appears as the Python control-plane sibling, `cultnet-ts` becomes the TypeScript client, and `cultnet-rs` becomes the Rust peer. All of them are one day old and already clearly related, which is either encouraging or a warning sign depending on how much sleep anyone got.
+CultLib starts with dependency updates, JSON backing store work, I/O fixes, security cleanup, and a full CultUI port away from legacy prefab residue. Then the focus hardens around schema, persistence, and wire contracts. On 06 May 2026 the family abruptly flowers outward: `cultcache-ts` ships the TypeScript port, `cultcache-rs` lands the Rust cache crate, `cultcache-py` appears as the Python control-plane sibling, `cultnet-ts` becomes the TypeScript client, and `cultnet-rs` becomes the Rust peer. Kotlin joins the surface as CultMesh and Eve work reaches Android-adjacent runtimes.
 
-The point is that CultLib stopped being "some useful C# libraries" and started becoming the canonical home for the studio's persistence and messaging vocabulary. The separate language repos are real, but they are satellites around the same core idea.
+The point is that CultLib stopped being "some useful C# libraries" and became the canonical home for the studio's persistence, transport, and distributed-state vocabulary. The separate language packages are real, but they orbit one core promise: if a GameCult runtime can read the document and speak the schema, it can participate in the mesh.
 
 ## Ambition
 
-The ambition is to become the boring center of gravity other repos can lean on: storage that behaves, schemas that survive, message formats that stay compatible, and runtime helpers that do not need to be reinvented whenever somebody opens a new runtime with fresh ideas and insufficient restraint.
+The ambition is to become the boring center of gravity other repos can lean on: storage that behaves, schemas that survive, message formats that stay compatible, native RUDP that does not belong to one runtime, and mesh authority that can scale from a co-op session to a Verse full of thousands of witnesses without rewriting the game around a single central server's opinion.
 
 ## Repo Family
 
@@ -60,6 +75,7 @@ The ambition is to become the boring center of gravity other repos can lean on:
 - [cultcache-py](https://github.com/GameCult/cultcache-py): Python CultCache port aimed at control-plane and bootstrap surfaces.
 - [cultnet-ts](https://github.com/GameCult/cultnet-ts): TypeScript CultNet client and cross-runtime contract surface.
 - [cultnet-rs](https://github.com/GameCult/cultnet-rs): Rust CultNet peer with schema discovery and raw replication lanes.
+- `cultmesh-kotlin`: Kotlin/JVM CultMesh and Eve surface for Android-adjacent runtimes, currently living inside the CultLib monorepo.
 
 ## History Tells On Itself