Advisory review: attribution & lineage correction (credit Norman Nunley)

DEV.md

@@ -15,11 +15,11 @@ capabilities, and durable state:
 - **Fjall-backed persistence** for live image and streaming overflow
 - **Pattern matching via `@` operator** for parsing and data transformation
 
-**Historical note**: FMPL ("of Accardi") was created in 1992 by Jon Blow at UC
-Berkeley's Experimental Computing Facility — a MUD server language in the
-LambdaMOO / ColdMUD tradition. This repository is a Rust revival adding modern
-streaming and agent capabilities. See [`README.md`](README.md) and
-[`project.md`](project.md).
+**Historical note**: this FMPL is Norman Nunley's descendant of the original
+FMPL ("of Accardi", UC Berkeley XCF, c. 1992, interpreter by Jon Blow) — seeded
+from an EBNF grammar Nunley extracted from the original sources in the late
+1990s, with new syntax and semantics beyond it. See [`README.md`](README.md)
+and [`project.md`](project.md).
 
 ## Workspace layout
 
@@ -70,7 +70,7 @@ comments):
 - `fmpl-core/src/parser_epoch.rs` — generator epoch; read its bump policy before changing codegen
 - `fmpl-core/src/error.rs` — Unified error types with `thiserror`
 - `fmpl-core/src/object.rs` — Prototype-based object system (spawn, facets)
-- `fmpl.ebnf` — Language grammar (reference only, not used by the parser)
+- `fmpl.ebnf` — Language grammar (reference only, not used by the parser; descends from Nunley's late-1990s extraction of the original FMPL grammar)
 
 ## Test organization
 

README.md

@@ -17,11 +17,20 @@ or try the **[browser REPL](https://mparrett.github.io/fmpl/repl.html)**
 
 ## Lineage
 
-FMPL ("of Accardi") was created in 1992 by Jon Blow at UC Berkeley's
-Experimental Computing Facility — a MUD server language in the LambdaMOO /
-ColdMUD tradition. This is a 2025-present revival as a Rust implementation,
-combining that MUD heritage with modern streaming, first-class PEG grammars, and
-capability security. See [`project.md`](project.md) for the full north star.
+The original FMPL ("of Accardi") came out of UC Berkeley's Experimental
+Computing Facility around 1992 — a MUD server language in the LambdaMOO /
+ColdMUD tradition, with an interpreter written by Jon Blow.
+
+This FMPL was created by [Norman Nunley, Jr.](https://github.com/nnunley) and
+is a descendant of the original, not a restoration of it. Nunley extracted an
+EBNF grammar from the original FMPL sources in the late 1990s; decades later
+that grammar (see [`fmpl.ebnf`](fmpl.ebnf)) seeded this project. The syntax is
+only lightly similar to the 1992 language, and everything beyond the grammar —
+the streaming model, first-class PEG grammars, the indexed-RPN VM, capability
+security, the metacircular bootstrap — is new design. The MUD lineage is
+first-hand: Nunley also co-wrote cool++, a C++ rewrite of Stephen White's
+CoolMUD (White created MOO, from which LambdaMOO was forked). See
+[`project.md`](project.md) for the full north star.
 
 ## A taste
 

docs/fmpl-field-log.html

@@ -398,7 +398,7 @@ <h1>Closing the Loop<span class="of">, in three moves</span></h1>
   <div class="sec-head"><span class="sec-num">§3</span><h2>The VM in a browser tab</h2></div>
   <div class="prose">
     <p>Issue #3&rsquo;s opening assumption — that wasm would need a <code>no_std</code> campaign — died in the first hour, pleasantly. <code>wasm32-unknown-unknown</code> ships full <code>std</code> (threads and files trap at runtime rather than failing to compile), so the real blockers were exactly four native-only dependencies: curl, fjall, stacker, and tokio&rsquo;s multi-threaded runtime. Target- and feature-gating those got <code>fmpl-core</code> compiling for wasm32 with the native build untouched.</p>
-    <p>The gating surfaced a wrong assumption worth recording: fjall was <em>not</em> all behind the <code>fjall-persistence</code> feature flag. Stream overflow spill, parse-state save, and the persistence envelope are live in default native builds — so the wasm exclusion had to be <code>cfg(not(target_arch = "wasm32"))</code> seams at each touchpoint, not a feature toggle. Those seams are now the documented slot-in points if a persistent browser image (IndexedDB-backed) ever becomes a goal — a direction the upstream author raised in review.</p>
+    <p>The gating surfaced a wrong assumption worth recording: fjall was <em>not</em> all behind the <code>fjall-persistence</code> feature flag. Stream overflow spill, parse-state save, and the persistence envelope are live in default native builds — so the wasm exclusion had to be <code>cfg(not(target_arch = "wasm32"))</code> seams at each touchpoint, not a feature toggle. Those seams are now the documented slot-in points if a persistent browser image (IndexedDB-backed) ever becomes a goal — a direction the project&rsquo;s creator, Norman Nunley, raised in review.</p>
     <p>The deploy fork point: commit the built <code>.wasm</code> to the repo (simple, binary-in-git) or switch GitHub Pages to Actions-based deploys that rebuild it from source on every push. We chose Actions — the binary never lands in git, and the <a href="repl.html">live REPL</a> can&rsquo;t drift from <code>main</code>. That choice quietly paid off in §4: when the parser changed, the browser REPL picked it up on the next push with zero extra work.</p>
   </div>
 </section>

docs/fmpl-rehab-log.html

@@ -362,7 +362,7 @@ <h1>The Revival, Revived<span class="of">, in four tiers</span></h1>
 
 <span class="bar">$ just build && just test</span><span class="c">-- after four tiers and a publish pass, 2026-07-21:</span>
 <span class="o">1,390 passed / 0 failed / 185 ignored — each with a written reason</span></div>
-  <p class="term-cap">This log is the prequel to <a href="fmpl-field-log.html">Closing the Loop</a> and the making-of behind <a href="fmpl-tour.html">the engineering tour</a>. FMPL itself is a Rust revival of a 1992 MUD language; this is the log of reviving the revival.</p>
+  <p class="term-cap">This log is the prequel to <a href="fmpl-field-log.html">Closing the Loop</a> and the making-of behind <a href="fmpl-tour.html">the engineering tour</a>. FMPL itself is Norman Nunley&rsquo;s Rust-built descendant of a 1992 MUD language; this is the log of reviving his revival.</p>
 </header>
 
 <nav class="toc" aria-label="Contents">
@@ -380,7 +380,7 @@ <h1>The Revival, Revived<span class="of">, in four tiers</span></h1>
 <section id="estate">
   <div class="sec-head"><span class="sec-num">§1</span><h2>What the machine left behind</h2></div>
   <div class="prose">
-    <p>The repo we inherited was written almost entirely by an autonomous agent loop — &ldquo;ralph,&rdquo; iterating against a roadmap for months. What it produced is genuinely impressive: a working language with a bytecode VM, a PEG grammar engine, an object system, and a parser that generates itself. What it also produced is the sediment of its own process: a 107-file <code>.agent/</code> memory system, 41 files of &ldquo;superpowers&rdquo; process documentation, ralph driver scripts, run logs, a bespoke <code>.git-issue/</code> tracker, and prompt files — roughly 30,000 lines of machinery <em>about</em> building the thing, interleaved with the thing.</p>
+    <p>The repo we inherited was written almost entirely by an autonomous agent loop — &ldquo;ralph,&rdquo; set up and steered by the project&rsquo;s creator, Norman Nunley, iterating against a roadmap for months. What it produced is genuinely impressive: a working language with a bytecode VM, a PEG grammar engine, an object system, and a parser that generates itself. What it also produced is the sediment of its own process: a 107-file <code>.agent/</code> memory system, 41 files of &ldquo;superpowers&rdquo; process documentation, ralph driver scripts, run logs, a bespoke <code>.git-issue/</code> tracker, and prompt files — roughly 30,000 lines of machinery <em>about</em> building the thing, interleaved with the thing.</p>
     <p>And the repo did not build. Not subtly: <code>cargo build</code> failed at manifest resolution, before compiling a line, because one workspace member had a path dependency on <code>execution_tape</code> — a &ldquo;verified bytecode VM&rdquo; crate that existed on exactly one machine, and this wasn&rsquo;t it. Cargo resolves every member&rsquo;s manifest before building any of them, so the missing path failed everything, including <code>cargo build -p fmpl-cli</code>. The agent never noticed because the agent never had to do a fresh clone.</p>
     <p>The first day was recon before surgery: a static read plus live runs of the REPL, TUI, and web app, written up as findings <em>before any code changed</em>. That ordering was deliberate. With an inherited codebase — especially an agent-inherited one — the temptation is to start fixing what you see; the discipline is to first record what is actually true, because you will not get a second chance to observe the artifact undisturbed.</p>
   </div>

docs/fmpl-tour.html

@@ -402,7 +402,7 @@
 <header class="masthead">
   <p class="eyebrow">Engineering tour &middot; github.com/mparrett/fmpl</p>
   <h1>FMPL<span class="of">, &ldquo;of Accardi&rdquo;</span></h1>
-  <p class="dek">A 1992 MUD-server language, revived in Rust as a streaming-first substrate for AI agents — with first-class PEG grammars, an indexed-RPN bytecode VM, and a parser that compiles itself.</p>
+  <p class="dek">Norman Nunley&rsquo;s streaming-first language for AI agents — grown in Rust from the grammar of a 1992 MUD-server language, with first-class PEG grammars, an indexed-RPN bytecode VM, and a parser that compiles itself.</p>
   <div class="meta-row">
     <span><b>Rust</b> edition 2024</span>
     <span><b>7</b> workspace crates</span>
@@ -442,9 +442,10 @@ <h1>FMPL<span class="of">, &ldquo;of Accardi&rdquo;</span></h1>
 <section id="lineage">
   <div class="sec-head"><span class="sec-num">§1</span><h2>Lineage and thesis</h2></div>
   <div class="prose">
-    <p>FMPL was created in 1992 by Jon Blow at UC Berkeley&rsquo;s Experimental Computing Facility — a MUD server language in the LambdaMOO / ColdMUD tradition. Those systems shared a distinctive shape: a <em>live image</em> of prototype-based objects, edited from inside, serving many users at once, persisting across restarts. The program wasn&rsquo;t a file you ran; it was a world you inhabited.</p>
-    <p>This repository is a from-scratch Rust revival that bets that the MUD shape is the right shape for AI agents. A modern agent system wants exactly what a MUD had: long-lived stateful objects, many concurrent actors (now LLMs as well as humans), capability-scoped access between them, and durable state that survives a crash mid-conversation. FMPL adds the modern half: streaming as a first-class concern, OMeta-style PEG grammars as the universal tool for parsing any stream — text, bytes, or structured values — and an async runtime for tool calls.</p>
-    <p>One more thing worth saying plainly, because it shapes the codebase: most of this implementation was written by an autonomous LLM agent loop, iterating against a roadmap for months. It was recently <a href="fmpl-rehab-log.html">rehabilitated for public release by hand</a> — the agent harness sidelined to an archive branch (~30,000 lines), a build that works on a fresh clone, CI, and a documentation pass in which every claim in the tutorial was re-verified against a live REPL. The result is unusually honest about itself: the test suite encodes where the language <em>is</em> and, via 74 deliberately-ignored tests, where it is <em>going</em>.</p>
+    <p>The original FMPL (&ldquo;of Accardi&rdquo;) came out of UC Berkeley&rsquo;s Experimental Computing Facility around 1992 — a MUD server language in the LambdaMOO / ColdMUD tradition, with an interpreter written by Jon Blow. Those systems shared a distinctive shape: a <em>live image</em> of prototype-based objects, edited from inside, serving many users at once, persisting across restarts. The program wasn&rsquo;t a file you ran; it was a world you inhabited.</p>
+    <p>This FMPL is <a href="https://github.com/nnunley">Norman Nunley&rsquo;s</a> — a descendant of the original, not a restoration of it. The surviving link to the 1992 language is an EBNF grammar Nunley extracted from its sources back in the late 1990s; decades later, that grammar became the seed of this project. The syntax is only lightly similar to the original, and everything beyond the grammar — the streaming model, the PEG grammar system, the indexed-RPN VM, the metacircular bootstrap — is new design. The MUD lineage is first-hand, too: Nunley co-wrote cool++, a C++ rewrite of Stephen White&rsquo;s CoolMUD (White also created MOO, the server LambdaMOO grew from).</p>
+    <p>The project bets that the MUD shape is the right shape for AI agents. A modern agent system wants exactly what a MUD had: long-lived stateful objects, many concurrent actors (now LLMs as well as humans), capability-scoped access between them, and durable state that survives a crash mid-conversation. FMPL adds the modern half: streaming as a first-class concern, OMeta-style PEG grammars as the universal tool for parsing any stream — text, bytes, or structured values — and an async runtime for tool calls.</p>
+    <p>One more thing worth saying plainly, because it shapes the codebase: most of this implementation was written by an autonomous LLM agent loop that Nunley set up and steered, iterating against a roadmap for months. It was recently <a href="fmpl-rehab-log.html">rehabilitated for public release</a> in much the same mode it was built — Claude doing the grinding, steered by a couple dozen human prompts over a few hours — the agent harness sidelined to an archive branch (~30,000 lines), a build that works on a fresh clone, CI, and a documentation pass in which every claim in the tutorial was re-verified against a live REPL. The result is unusually honest about itself: the test suite encodes where the language <em>is</em> and, via 74 deliberately-ignored tests, where it is <em>going</em>.</p>
   </div>
 </section>
 

docs/index.html

@@ -114,7 +114,7 @@
 <header>
   <p class="eyebrow">github.com/mparrett/fmpl</p>
   <h1>FMPL<span class="of">, &ldquo;of Accardi&rdquo;</span></h1>
-  <p class="dek">A 1992 MUD-server language, revived in Rust as a streaming-first substrate for AI agents — with first-class PEG grammars, an indexed-RPN bytecode VM, and a parser that compiles itself.</p>
+  <p class="dek">Norman Nunley&rsquo;s streaming-first language for AI agents — grown in Rust from the grammar of a 1992 MUD-server language, with first-class PEG grammars, an indexed-RPN bytecode VM, and a parser that compiles itself.</p>
 </header>
 
 <nav class="surfaces" aria-label="Site surfaces">
@@ -137,7 +137,7 @@ <h1>FMPL<span class="of">, &ldquo;of Accardi&rdquo;</span></h1>
 </nav>
 
 <footer>
-  FMPL &middot; MIT &middot; <a href="https://github.com/mparrett/fmpl">source</a> (fork of nnunley/fmpl)
+  FMPL &middot; MIT &middot; created by <a href="https://github.com/nnunley">Norman Nunley, Jr.</a> &middot; <a href="https://github.com/mparrett/fmpl">source</a> (fork of nnunley/fmpl)
 </footer>
 
 </div>

fmpl.ebnf

@@ -1,3 +1,12 @@
+Grammar reference for this FMPL dialect (reference only — the working parsers
+are fmpl-core/src/parser.rs and lib/core/fmpl_parser.fmpl).
+
+Provenance: descends from an EBNF that Norman Nunley, Jr. extracted from the
+sources of the original FMPL ("of Accardi", UC Berkeley XCF, c. 1992) in the
+late 1990s. It has since been extended with constructs the original never had
+(grammars, namespaces, pattern matching); the dialect described here is only
+lightly similar to the 1992 language.
+
 The terminal tokens defined in the grammar:
 TOKEN_OFFSET, FMPL_GC_COPIED, FLOAT, OBJ_TAG, TAG, STRING, SYMBOL, FN_TAG,
 NAMESPACE_TAG, GRAMMAR_TAG

project.md

@@ -10,8 +10,9 @@ The long-term design borrows from VPRI FoNC's emphasis on live, inspectable syst
 
 ## Lineage
 
-- **1992**: FMPL ("of Accardi") created by Jon Blow at UC Berkeley's Experimental Computing Facility (XCF). A MUD server language similar to ColdMUD and LambdaMOO.
-- **2025-present**: Revival as a Rust implementation combining MUD heritage with modern streaming, grammars, and agent capabilities.
+- **c. 1992**: The original FMPL ("of Accardi") at UC Berkeley's Experimental Computing Facility (XCF), interpreter written by Jon Blow. A MUD server language similar to ColdMUD and LambdaMOO.
+- **Late 1990s**: Norman Nunley, Jr. extracts an EBNF grammar from the original FMPL sources.
+- **2025-present**: Nunley builds this language from that grammar — a Rust implementation whose syntax is only lightly similar to the original, combining the MUD heritage with modern streaming, grammars, and agent capabilities.
 
 ## Inspirations