Lumbda positioning: Lisp/Scheme-derived, EML + MOAD isolation, 4 tiers

Sharpen the tagline per fox. Lumbda is not a "new" language; it is
a Lisp/Scheme-derived language whose two distinctive claims are
(a) EML mathematical universality (single-operator foundation,
machine-checked in Lean 4) and (b) MOAD defect isolation — each
of the four implementation tiers audited against the canonical
Mother-of-All-Defects patterns and hardened independently, so a
defect in one tier never propagates through shared infrastructure.

Whitepaper:

- Title subtitle now: "A Lisp/Scheme-derived, just-in-time lambda
  language. Four implementation tiers with EML mathematical
  universality and MOAD defect isolation. Workloads migrate
  across basic UNIX systems."
- Abstract opens by naming the two invariants (EML, MOAD) before
  getting to the feedback-primitive story. The bullet list now
  shows four tiers: Python VM, C tree-walker, C bytecode VM, C
  x86_64 JIT, pure assembly. The C binary bundles three tiers
  under one executable, flag-selectable.
- §11 renamed from "Three Implementations" to "Four Implementation
  Tiers" and opens with a paragraph framing MOAD isolation as the
  architectural contract between them.

README gets the same framing up top so clones see the positioning
immediately.

No code changes, no test reruns, still 975 assertions green.

README.md

@@ -1,8 +1,15 @@
 # Lumbda
 
-**A just-in-time lambda language — fast from first principles, workloads migratable across basic UNIX systems.**
+**A Lisp/Scheme-derived, just-in-time lambda language. Four implementation tiers with EML mathematical universality and MOAD defect isolation. Workloads migrate across basic UNIX systems.**
 
-Three implementations of R7RS Scheme (Python bytecode VM, C with x86_64 JIT, pure x86_64 assembly) sharing one wire format: Scheme source itself. Continuations within a process, portal files across processes, S-expressions across implementations, TCP sockets across machines.
+Four implementation tiers sharing one wire format — Scheme source itself:
+
+- **Python bytecode VM** — reference, full first-class continuations
+- **C tree-walker + bytecode VM** — portable C, JSON portal
+- **C + x86_64 JIT** — pattern-matched native code, 7–10× faster than CPython
+- **Pure x86_64 assembly** — 22 KB stripped, zero libc, 14 syscalls
+
+Feedback is the primitive across four scopes: continuations within a process, portal files across processes, S-expressions across implementations, TCP sockets across machines.
 
 Home: [lumbda.com](https://lumbda.com)
 

whitepaper/uncommonlisp-whitepaper.rst

@@ -29,7 +29,7 @@ Lumbda
 
 .. class:: center
 
-**A just-in-time lambda language — fast from first principles, workloads migratable across basic UNIX systems.**
+**A Lisp/Scheme-derived, just-in-time lambda language. Four implementation tiers with EML mathematical universality and MOAD defect isolation. Workloads migrate across basic UNIX systems.**
 
 .. class:: center
 
@@ -56,12 +56,13 @@ Abstract
 
 **License: AGPL-3.0-only** · This implementation, its bytecode VM, & all associated code carry the GNU Affero General Public License v3.0 (only). You may use, modify, & distribute under those terms. No proprietary relicensing exists.
 
-A programming language needs one primitive to become universal: feedback. A function that receives its own continuation can loop, branch, yield, checkpoint, resume, & migrate. Every control flow pattern reduces to a continuation captured & invoked. Extend feedback across time (portals) & across implementations (source-as-wire-format) and you recover the full scope of computation without new primitives.
+**Lumbda** is a Lisp/Scheme-derived language designed around two invariants that most languages discover late or never: **EML mathematical universality** (every elementary function expressible from a single operator, machine-checked in Lean 4 — see §8) and **MOAD defect isolation** (every implementation audited against the five canonical Mother-of-all-Defects patterns, with every defect confined to its own implementation tier rather than propagating through shared infrastructure — see §12). The rest of the design follows: one primitive, feedback, becomes universal when a function receives its own continuation. A continuation lets a program loop, branch, yield, checkpoint, resume, & migrate. Every control flow pattern reduces to a continuation captured & invoked. Extend feedback across time (portals) & across implementations (source-as-wire-format) and you recover the full scope of computation without new primitives.
 
-**Lumbda** proves this by implementing R7RS Scheme three ways:
+Lumbda ships in **four implementation tiers** — each independently built, each MOAD-isolated, each able to run every test in the shared functional suite byte-identically:
 
 - **Python bytecode VM** — 3,743 lines, full first-class continuations, JSON portal, reference implementation
-- **C interpreter + x86_64 JIT** — 9,164 lines of runtime C (plus ~1,200 in the test harness), 7--10× faster than CPython on recursive workloads, JSON portal
+- **C interpreter** — tree-walker + bytecode VM, 9,164 lines of runtime C, JSON portal
+- **C + x86_64 JIT** — pattern-matched native code emission via ``mmap(PROT_EXEC)``, 7--10× faster than CPython on recursive workloads
 - **Pure x86_64 assembly** — 4,968 lines, 22 KB stripped binary, zero external dependencies, **91 builtins including a full TCP stack, `eval`, and `read-from-string`**, binary heap-dump portal
 
 All three share one interchange format: **Scheme source itself**. An S-expression portal (``(define x 42)``) written by any implementation loads in any other — a 3×3 producer×consumer matrix, 9/9 cells green. The language *is* the wire protocol. This is not a property we added; it is what a parser has always made possible. We report it because most systems forget.
@@ -746,11 +747,13 @@ Lumbda forms one piece of a larger permacomputer machine learning stack:
 Lumbda provides the runtime layer: a language that can checkpoint its own execution, migrate between machines, & resume from serialized state. The portal system enables distributed computation across permacomputer nodes. Categorization & feedback activities could run inside Lumbda's VM, with ``call/cc`` providing the state machine transitions & portal providing persistence.
 
 
-11. Three Implementations, One Language
----------------------------------------
+11. Four Implementation Tiers, One Language
+--------------------------------------------
 
     *"A diagram is worth 10,000 words."* — russell@unturf.com
 
+Lumbda ships as four independently built tiers: a Python bytecode VM, a C tree-walker, a C bytecode VM, and a C x86_64 JIT (the last three packaged in one binary, selectable by flag), plus a pure-assembly interpreter. Each tier is MOAD-isolated from the others — a defect surfaced in one is fixed in that tier, not patched across shared infrastructure. All four run the same ``.lsp`` source files and exchange the same S-expression portal format; §11.3-§11.5 demonstrate this end-to-end across sockets, relays, and HTTP portal transfers.
+
 .. figure:: diagrams/c-architecture.png
    :width: 80%
    :align: center