Cursors guides

Working local apps and verified HTTPS parts when peer connections are missing, blocked, or stalled. Recovery and cloud limits remain explicit.

A story-led first visit: what Cursors is, what is live today, and what to click without learning the protocol first.

Create or import a local encrypted self, understand mailbox addresses, and prepare a chat-only contact safely.

A picture-led explanation of the local encrypted Self, public curso.rs descriptor, cloud mailbox, recovery export, and GitHub’s proper role.

Use narrowly scoped GitHub sign-in to carry encrypted recovery and an optional public hydration README without making GitHub your identity.

Swap public handles, accept a signed introduction, use the address book, and understand what today’s retained notes do and do not encrypt.

Trace one piece of intent through a pointer, mailbox, fabric, memory, and eventual recovery store.

What remains available when a browser feature, a module download, storage, or JavaScript itself is unavailable.

A plain-language map of Cursors, the cockpit, and the shortest useful reading path.

Read the system through diagrams before opening the protocol details.

Definitions for cursor, body, world, fabric, capability, mailbox, swarm, and receipt.

How authority travels with causal history while coordination, operational storage, and transport keep distinct jobs.

The immutable signed records that make execution portable, inspectable, and resumable.

Assertions, interests, facets, and authority-relative projections of a shared world.

Targets, requested views, resolver constraints, curve hints, and the boundary between reference and authority.

Local, relative, and invitation-only meeting curves—and how ECC identity differs from curve addressing.

Signed, attenuating grants that decide who may continue a cursor or cause an effect.

What CURSO/0 encodes today, where BitTorrent bencoding stops, and how Linda-like dataspaces and portable continuations fit above it.

Bounded antichain frontiers, Dedalus-style temporal rules, causal cones, relation completeness, and truthful why and why-not answers.

Commentable diagrams connecting signed records, SQLite, languages, logic, dataspaces, fabrics, effects, receipts, and cockpit lenses.

Private discovery, encrypted manifests, untrusted seeders, and verifiable directory heads.

Addressed envelope families, local chat, receipts, storage tiers, and explicit outward admission.

How local, browser, native, and opt-in relay fabrics carry the same envelope semantics.

Which browser, native, webseed, TURN, and relay paths exist—and what each path cannot prove.

How to read the live cockpit without confusing transport observations with authority.

How device, LAN, direct, relayed, mailbox-mediated, and unknown peer locations are observed without guessing.

What remains useful after the network disappears, what browser storage can preserve, and what still needs an independent recovery carrier.

A truthful LAN-only startup model: explicit rendezvous, verified identities, meeting curves, partitions, and the browser/native boundary.

How stable locality backplanes, real machinery glyphs, the orbiting Self, traffic photons, and semantic zoom encode observed state.

What Cursors protects, what remains observable, and which failures are still real.

How bodies find rendezvous and useful encrypted state without trusting discovery as identity.

A QR-sized recovery edge that pins trust and names independent ways to recover a signed Cursors release and world horizon.

Run restricted Lua through the dedicated SQLite Wasm Worker and inspect its continuation graph, leased assertion, and transactional outbox.

A capability-scoped path from conversation to a reviewable draft pull request.

Per-mailbox SQLite, hibernatable WebSockets, signaling, settings, request proof, and the disabled-by-default deployment boundary.

The root HTTP batch, official SQLite MessagePort body, signed preview effects, failure recovery, and measured durable outbox path.

Use a bounded local-first WebRTC data channel for the same ephemeral Cap’n Web capabilities, with HTTP batch as the universal fallback.

A signed mailbox challenge that can meet OAuth-shaped systems without making OAuth the root identity.

Create an Ed25519 mailbox identity locally, encrypt it before browser storage, and keep Cloudflare admission separate.

How device keys become admitted mailboxes without pretending a web challenge can prove someone is human.

Clear roles for SQLite, DuckDB, immutable blocks, rclone carriers, fountain recovery, and future virtual filesystems.

A precise plan for operational SQLite, portable immutable truth, browser VFS adapters, later WASM, DuckDB views, and replication receipts.

The pinned Nelua-to-C-to-Wasm path, strict scalar/SIMD selection, shared vectors, and the JS compatibility boundary.

Versioned formulas, deterministic dependency levels, column chunks, Workers, SQLite outbox state, and bounded peer exchange.

The official SQLite WASM Worker, transactional body contract, stored restricted Lua programs, and semantic Cloudflare sync boundary.

SQLite-owned scheduling, worker leases, explicit continuation state, Linda wakeups, duplicate-safe effects, and portable host mappings.

Why the cockpit never asks for an API key, how to hand bounded public context to ChatGPT, and how future app/MCP capabilities remain review-gated.

A staged path from a GitHub golden repository to signed mailbox proposals, checks, runners, artifacts, and review receipts.

How browser, Imba, JavaScript, WASM, and later native programs become reviewable cursor apps without discovery becoming execution authority.

Observable milestones, including the explicit boundary that defers native hardware implementation.

Unresolved semantic, authority, transport, identity, and compatibility questions.

A bounded Datalog core, Prolog-like query surface, canonical S-expressions, Lua tables, provenance, and parity-gated evaluators.

Typed S-expression and Lua plans, semantic barriers, e-graph candidate rewrites, measured cost vectors, and Lego component contracts.

A direct-link watchlist spanning causal debugging, dataspaces, capabilities, incremental logic, mobility, recovery, and ideas that may invalidate current assumptions.

Twenty-three themes restated as invariants, smallest experiments, cockpit evidence, and conditions that should narrow or delete an idea.

The stable legacy wire/profile identifier for canonical records; the public product is Cursors.

Selected changes in this UI, with real guides and inspectable objects; not a complete commit changelog.

How to propose focused changes while keeping claims, protocol behavior, and tests aligned.