Decision log

Robert (session 5): “keeping a changelog but also a decision log so we can see how things change over time… document choices and decisions you and I make.” This page is the decision log: one row per choice, appended in order, never edited except to change status. CHANGELOG.md at the repo root is the changelog of what shipped. Locked rules get their own DNN page at the v0 lock and a row here pointing to it.

Columns: who is who made the call (Robert, or Fable deciding on Robert’s instruction). status is provisional until measured, then locked or overturned with a link to the row that replaced it. first tested by names the thing that can prove it wrong.

Sessions 1–3

Recorded at the time on the pages themselves: the 35 directions (directions/), the 17 questions with answers (questions/), the 15 syntax picks (syntax/), and the session-3 tensions in session-03. Not repeated here.

Session 4 (12 Sep 2026)

decisionwhostatusfirst tested by
No pub; one expose line under module (p14-modules)Robertprovisionalthe corpus
use A.B{X, Y}, no dot before the bracesRobertprovisionalthe corpus
Every for closes with endRobertprovisionalthe corpus
Keep for and map/filter/reduce; formatter moves pure bodies to combinators (p11-loops-and-anonymous-functions)Robertprovisionalthe corpus
Chapter 4 shows current syntax; dated notes are the changelog onlyRobertlocked—

Session 5 (12 Sep 2026)

decisionwhostatusfirst tested by
design-v0 chapters 1–8 reviewed, no editsRobert——
Work happens on feature branches, never on mainRobertlocked—
Fable delegates all building and writing to a worker model and reviews; Fable chose Opus (model-bakeoff)Robert, then Fableprovisionalround 2 of the bake-off
No taste review of the corpus now; build, measure, evaluate; Fable may decide aloneRobertlocked for now—
Deadline law amended: only calls that can wait take within:FableprovisionalMo.Sim
try across error types: callee variants must exist in the caller’s enum by name and fieldsFableprovisionalthe checker on the refund module
Literals typed from use, else Int64; size is UInt64; no implicit wideningFableprovisionalthe checker on the corpus
a..b excludes bFableprovisionalthe corpus
One-field variants match positionally; more fields by name; construction always by nameFableprovisionalthe parser
state fields start at the type’s zero, else = exprFableprovisionalthe interpreter
Name.start, send statement, ask returns Result(Reply, AskError); reply arm evaluates to the replyFableprovisionalthe interpreter
Supervisors take parameters and pass them on child lines (the one new syntax)Fableprovisionalprogram 1’s main
Platform chosen by the toolchain (mo test is Mo.Sim), never by a use lineFableprovisionalthe interpreter
Capability fixture constructors in tests; Time.fixture()Fableprovisionalthe corpus tests
Self in trait signaturesFableprovisionalthe checker
Refinement failure is a tripped contract; test rejects covers itFableprovisionaltier 2
Type.all only in never; tier 2 skips it, tier 3 checks itFableprovisionaltier 3
Module segment → lowercase hyphenated file nameFableprovisionalthe corpus
main is out of the milestoneFableprovisionalprogram 1
Grammar fixes: cmp with is, assert in stmt, old in invariant, never takes a bare call, add left-assoc, params_untyped, comprehension body is a blockFableprovisionalthe parser
invariant block is true when broken, same reading as neverFableprovisionaltier 2
A supervisor passes a sibling’s handle as its own parameter; main orders the startsFableprovisionalprogram 1
Step 1 accepted: lexer and parser by Opus, all 50 files parse, 23 minutes of worker timeFable—the checker
Every phase runs in a fresh worker session and context windowRobertlocked—
Step 2 accepted: tier-1 checker by Opus, 12 rejects/ fail by code, 38 clean, 48 minutesFable—the interpreter
FsError is Missing(path: String) | TimeoutFable, from Opus’s defaultprovisionalthe stdlib chapter
An undeclared one-letter type name in a signature is a type parameter of that functionFable, from Opus’s defaultprovisionalthe corpus growing; revisit if a real program wants explicit generics
An undeclared type in a recipe signature is opaque; field reads on it are unchecked at tier 1Fable, from Opus’s defaultprovisionalthe three-recipe test in chapter 8
Contract integers are i128 in the interpreter, a stand-in for unboundedFableprovisionaltier-3 proving
The verified: line is printed by mo test, not written to the file, until the sidecar existsFableprovisionalstep 5
Step 3 runs pure code only; processes, supervisors, never, invariant are step 4Fableprovisionalstep 4
property runs 200 seeds from a fixed base seed; a failure reports seed and valuesFableprovisionaltier 3 on the corpus
verified: vocabulary gains sim (not run) until the simulator existsFableprovisionalstep 4
test rejects passes only by tripping a requires or a refinement; any other crash fails itFableprovisionalthe corpus tests
mo run runs a module’s tests until main existsFableprovisionalprogram 1
Grok’s and Codex’s corpora stay on their branches as evidence, never mergedFablelocked—
Step 3 accepted: VM, tier-2 contracts, test runner by Opus; refund module runs its tests; 36 minutesFable—step 4
Chapter 4’s example gains two rejects tests: mo check found it broke its own law (MO0311)Fable, found by the compilerlocked—
A test is skipped only when it starts or messages a process, not because its file declares oneFable, from Opus’s defaultprovisionalstep 4 removes the skip
Recipe tests that call a body-less signature are skipped until an agent implements itFable, from Opus’s defaultprovisionalthe three-recipe test
A failing test shortens the verified: line to verified: types and mo test exits 1Fable, from Opus’s defaultprovisionaltier 3
String.size counts code points minus combining marks, a stand-in for graphemesFable, from Opus’s defaultprovisionalthe stdlib chapter
test rejects also passes on a tripped invariantFableprovisionalstep 4
Default mailbox bound is 1_000FableprovisionalMo.Sim with a slow consumer
ask on a crashed, unrestarted process returns Error(Down)Fableprovisionalstep 4
Step 4 accepted: Mo.Sim scheduler, transactions, invariants, mailbox bounds, supervisors, crash reports by Opus; milestone met; 21 minutesFable—program 1
Chapter 4 corrected again by the compiler: result is a keyword (test binds outcome); the property needed !charge.refunded?; RefundQueue gains message Done : UInt32Fable, found by the compilerlocked—
A test’s sends are delivered after each top-level statement; a for counts as one statementFable, from Opus’s defaultprovisionalprogram 1’s tests
Any process crash fails a plain test even if the supervisor restarts it; rejects passes on a tripped requires, refinement, or invariantFable, from Opus’s defaultprovisionalprogram 1
ask returns Down when its message was lost to a crash; a re-entrant ask is TimeoutFable, from Opus’s defaultprovisionalprogram 1
A restart empties the mailbox and re-runs init; :on_crash behaves like :always for nowFable, from Opus’s defaultprovisionalsupervisor strategies question (chapter 8)
Zero values: 0, "", [], None, false, zero Duration, and structs or tuples of those; Time, enums, capabilities, handles have noneFable, from Opus’s defaultprovisionalthe checker should reject a missing initializer (step 5)
The simulated clock does not advance in step 4, so restart windows never slideFable, from Opus’s defaultprovisionalthe simulator step
Ledger.fixture() finds every id as an unrefunded 10_000 charge and every save succeedsFable, from Opus’s defaultprovisionalprogram 1
Wanted: for _ in 0..n for a loop whose index is unused; today the unused-binding law rejects iFableprovisionalstep 5
Formatter rules fixed in toolchain/FORMAT.md: 2-space indent, column 100, one blank line between declarations and after expose, use sorted, tests at the bottom, comments never movedFableprovisionalprogram 1
The loop rule (pure body → combinator) is a diagnostic MO0501, not a rewrite; rewriting is mo fixFableprovisionalprogram 1
for _ in 0..n allowed; _ as the loop binderFableprovisionalthe corpus
A state field with no zero value and no initializer is MO0319 at check timeFableprovisionalthe corpus
main is a known shape, fn main(platform: Platform), no return type; minimal Platform (args, env, stdout, stderr, fs, clock, exit) (Q18)Robertprovisionalprogram 2
The CLI log analyzer (menu program 2) is built before the job queue (amends Q14)Robertprovisionalprogram 2
Overnight run: Fable directs, Opus builds, Fable decides alone and records every decision; merge to main after each accepted step; whatever it takes on the worker side; Fable stays on briefs, verification, decisions, logsRobertlocked for this runthe morning review
Roadmap rewritten to the 14-step list on roadmapFableprovisionaleach step
Step 5 accepted: mo fmt with idempotence and round-trip tests, FORMAT.md, MO0501 loop rule, MO0319, corpus formatted; 35 minutesFable—program 2
Top-level blank lines are the formatter’s; inside blocks the author’s blank lines survive as oneFable, from Opus’s defaultprovisionalprogram 2
A comment inside a multi-line paren refuses the file (MO0502) rather than being movedFable, from Opus’s defaultprovisionalprogram 2
Long lines break only at commas inside parens opened on that line; other long lines stay longFable, from Opus’s defaultprovisionalprogram 2
MO0501 counts send, ask, start, and any call passing a capability or handle as effectful; a break, return, or try anywhere in the body makes it effectfulFable, from Opus’s defaultprovisionalprogram 2
Step 6 accepted: main, Mo.Server, mo run, three programs with expected output; 21 minutesFable—program 2
Platform is confined to platform.<part> reads (MO0407); the parts (Out, Env, Fs, Clock) are ordinary capabilities that can be passed downFable, from Opus’s defaultprovisionalprogram 2
fn main at module level is always the main production; a second main in a program is MO0320Fable, from Opus’s defaultprovisionalprogram 2
platform.exit(code) does not stop main; the last code wins on return; a crash exits 70 regardlessFable, from Opus’s defaultprovisionalprogram 2
Out.write adds no newline; a failed write is droppedFable, from Opus’s defaultprovisionalprogram 2
fs.scoped(path) that leaves the current scope yields an Fs that reads nothing; containment is checked on resolved and real paths, symlinks out are MissingFable, from Opus’s defaultprovisionalprogram 2
Every read failure is Missing(path); over 64 MiB is Missing; a read that is both missing and late is TimeoutFable, from Opus’s defaultprovisionalprogram 2
Name.start under Mo.Server crashes: no scheduler outside the test runner yetFable, from Opus’s defaultprovisionalprogram 1
Program 2 and the Go and Python control runs run in parallel, three fresh Opus sessions in three worktreesFable—the morning review
Program 2 accepted as an experiment result (correct with the file law lifted); the control run recorded: Mo 25.5 min, Go 12.9, Python 8; all of Mo’s loss is toolchainFable—round 2 after step 8
use A.B{X, y} imports functions as well as types; bare use is an error; program root is a mo.root marker or the main file’s directoryFableprovisionalstep 7
Each file keeps the 500-line law; a program is many filesFablelocked—
The VM tracks unique ownership so push on an unaliased var list is in place (Perceus-lite, chapter 7)Fableprovisionalstep 7’s numbers
The stdlib table in 09-stdlib.md is the worker’s one wiki write; sort_by takes a key function because function types cannot be named; maps keep insertion order; no map literal yetFableprovisionalstep 8
Interpreter speed target for a log line: under 50 µs before optimizing furtherFableprovisionalstep 7
Step 7 accepted: use imports functions, program root, multi-file corpus programs, push in place, 39 µs per log line in ReleaseFast; 67 minutesFable—program 3
push grows in place when the list ends where its buffer’s last push stopped; older copies keep their length (no unique-owner bit needed under the loop rule)Fable, from Opus’s defaultprovisionalprogram 3
Under mo run, values live in a region cleaned at safe points (return, loop iteration, combinator step); mo test keeps one arena per testFable, from Opus’s defaultprovisionalprogram 3
Under mo run, a pure call (no capability, no inout) is memoized on equal arguments, cache capped at 16 MiB, contract trips never cachedFable, from Opus’s defaultoverturned in step 12b: the reference interpreter runs every body and every contract every time—
A # exit: line after a # run: line gives the expected exit code; stderr is not comparedFable, from Opus’s defaultprovisional—
MO0311 counts only rejects tests in the function’s own moduleFable, from Opus’s defaultprovisionalprogram 3
zig build should install mo as ReleaseSafe by default: Mo’s own overflow checks live in the VM (step 8 item)Fableprovisionalstep 8
Step 8 accepted: the stdlib (numbers, strings, lists, maps, sets, time, files, output, JSON) as 09-stdlib.md plus built-ins and seven corpus files; logstat 1,174 → 758 lines; 200k lines 60 s → 0.95 s, 440 → 38 MB; ReleaseSafe mo; 60 minutesFable—program 3
Stdlib rules: deterministic, values in and out, rain is a value and a bug is a crash, indices are UInt64, slices clamp, one natural order (<), maps and sets iterate in insertion order and compare by orderFable, from the chapter Opus wroteprovisionalprogram 3
round and to_string round half away from zero on the shortest decimal spellingFable, from Opus’s defaultprovisionalprogram 3
String.to_u64 accepts ASCII digits only, no sign, no _; to_upper/to_lower are ASCII-only; a grapheme is a code point plus following combining marksFable, from Opus’s defaultprovisionalthe stdlib chapter’s next pass
JSON: a variant encodes as {"Name": {fields}}, maps with non-string keys as pairs, NaN as null; decode keeps the last value of a repeated key; depth over 512 is a syntax errorFable, from Opus’s defaultprovisionalprogram 3
Time.parse accepts full RFC 3339, fractions truncated to ms, leap seconds are NoneFable, from Opus’s defaultprovisionalprogram 3
Fs.list returns files and folders sorted byte by byteFable, from Opus’s defaultprovisionalprogram 3
Step 9 accepted: seeded scheduling, fault injection, never over T.all under sim, sim (N runs); refund holds under 100 seeds; racy.mo fails only under sim with an interleaving and a replay command; 45 minutesFable—program 3
--sim N (default 100) runs after the fixed-order run passes; run i uses seed S+i; --seed S replays one; --faults P (default 5%); scheduling and faults draw separate streamsFable, from Opus’s defaultprovisionalprogram 3
An ask times out only when its target spent past the deadline on slow or failed capability calls, never by chanceFable, from Opus’s defaultprovisionalprogram 3
”Passes only without faults” counts as a pass, printed with its seed; never blocks are checked only at the end of seeded runsFable, from Opus’s defaultoverturned in step 12b for the second half: every never runs on every test—
T.all records struct constructions, copies, fixtures, and capability results; enums and primitives are not yet recordableFable, from Opus’s defaultprovisionalprogram 3
Step 10 accepted: .mo.ids sidecar and mo test --write, mo fix (three loop shapes, unused binding, default parameter), spec/errors.md generated from the tables (59 codes), README front door; 60 minutesFable—program 3
Sidecar: one .mo.ids per program root, JSON, declaration ids are 12 hex digits of a hash of module and name, declaration hash is SHA-256/64 over tokens; a verified: line is stale only when its own file’s declarations changeFable, from Opus’s defaultprovisionalprogram 3
mo test --write writes even on failure (verified: types, exit 1) and writes the proven: line tooFable, from Opus’s defaultprovisionaltier 3
mo fix rewrites a pure loop only for the map, filter, and reduce shapes over a list with one statement; other pure bodies stay a diagnostic with no fixFable, from Opus’s defaultprovisionalprogram 3
The usage line in mo must list fmt and fix (they work; the text is stale): a step 11 itemFableprovisionalstep 11
Step 11 accepted: processes under mo run, Net (listen, accept, connect, read_line, write, close), direct style over blocking calls without stopping the scheduler, Net.fixture, echo over a real socket; 1,000 round trips in 56 ms; 62 minutesFable—program 3
Sup.start(args) returns its one child’s handle or a tuple of them in child order; nothing names the supervisorFable, from Opus’s defaultprovisionalprogram 3
After main returns, the run continues until no message waits; the exit code is main’s; a supervisor giving up exits 70Fable, from Opus’s defaultprovisionalprogram 3
A program with processes runs without the value region and without memoization (mailboxes hold values the region cannot see)Fable, from Opus’s defaultprovisional, a cost to measureprogram 3
listen binds 127.0.0.1 only; port 0 picks a free port and listener.port reports it; SO_REUSEADDR onlyFable, from Opus’s defaultprovisionalprogram 3
Deadline outcomes: accept keeps listening, connect leaves nothing, read_line keeps the partial line, write closes the connectionFable, from Opus’s defaultprovisionalprogram 3
A Conn in a process’s start arguments closes when that process crashes or its supervisor gives up; listeners stay openFable, from Opus’s defaultprovisionalprogram 3
Program 3 accepted as an experiment: kv answers 15k GETs/s, holds under sim, but cannot persist (no file write) and leaks per request; six toolchain bugs; corpus test red until fixedFable—step 12
main stays green: session-05 is not merged while zig build test failsFablelocked—
The runtime under real programs (step 12) comes before the C backend (now step 13)Fableprovisionalstep 12’s numbers
A function may omit its return type when it returns nothing, like mainFableprovisionalstep 12, the corpus
A negative integer literal is a patternFableprovisionalstep 12
String.byte_size; Fs.write, append (fsync), remove, rename; Out.flush; Out.fixture() with out.writtenFableprovisionalstep 12, kv’s replay test
Maps and sets gain a hash index; insertion-order semantics unchangedFableprovisionalstep 12’s map-100k row
Memoization and never-only-under-sim to be reversed in step 12b: the reference interpreter runs every body and every contract every time; every never runs on every test, and one that cannot be checked is MO0324Fable, after unpacking both for Robertprovisional, overturns two earlier rows when 12b landsstep 12b
Robert (session 5, morning): Fable’s recommendations are the decisions; do whatever Fable would do, always documented for later review; “we are super early, there are no mistakes, this is uncharted territory and we are learning as we go”Robertlocked—
Step 12 accepted: program discovery, hashed maps, in-place state writes, per-request freeing, file writes with fsync, optional return type, negative patterns, byte_size, mo fmt fuzz-clean, four diagnostics reworded; kv durable across restart; 50k SETs leave the server at 19 MB; 80 minutesFable—step 13
Corpus rules replace counts: every simulated process test outside racy.mo must hold under faults; recipe skips are the only allowed skipsFable, from Opus’s defaultprovisional—
Map index is open addressing from 8 keys; in-place writes extend to field paths under any var; a crashed update’s in-place writes are undone; a process whose invariant reads old(state) is never written in placeFable, from Opus’s defaultprovisionalstep 13’s differential tests
Messages, replies, start arguments, and first state are deep-copied between processes; each process reserves up to 16 GiB of address space; the region compacts when it doublesFable, from Opus’s defaultprovisionala day-long kv run
Fs.write and append fsync; a write past its deadline stays written; rename replaces; a read-only Fs passed as a parameter is enforced at run time, not check timeFable, from Opus’s defaultprovisional, the check-time gap is a step 13 itemstep 13
Out.written is tests-only and Out.flush is a no-op in testsFable, from Opus’s defaultprovisionalprogram 4
Step 12b accepted: memoization removed (logstat-4k 12 → 80 ms, accepted), every never runs at the end of every test over recorded values, MO0324 for an uncheckable never, a never trip satisfies test rejects; 25 minutesFable—step 13
Values are recorded where held (bindings, parameters, binders, constructions, state fields), inside collections; a type the recorder cannot see (a generic T) is a gap, not an errorFable, from Opus’s defaultprovisionalprogram 4
Control run round 2 recorded: Mo 11.8 min (from 25.5), Go 8.2, Python 7.9; Mo zero loops to green; the rest of the gap is mo fmt line breaking and five stdlib rowsFable—round 3 after the formatter fixes
Formatter follow-ups (from round 2): break long list literals and calls outside parentheses; keep one-line anonymous functions inside long calls; sort_by descending, two-value min/max, streaming readFableprovisionalstep 14
Step 13 accepted: C runtime, emitter from the checked tree, mo build via zig cc, differential tests over the corpus (57 identical, 0 differences), read-only Fs refused at check time; logstat native: 200k lines in 0.14 s (interpreter 0.95 s), logstat-4k 6.8 ms vs 44.6 ms; 83 minutesFable—program 4
Contracts off by default in mo buildOpus’s defaultoverturned on acceptance: chapter 3 says contracts run in every build; step 14 makes them on by default with --no-contracts for measurementstep 14
One 16-byte tagged value in C; case as test chains; Mo locals at the top of each C function for the compactor; the interpreter’s region model ported as isFable, from Opus’s defaultprovisionalprogram 4
Processes and Net are refused by mo build in this step, not compiled to crashFable, from Opus’s defaultprovisionalstep 15: processes in the C backend
Linux targets link static musl; macOS links libSystem only; zig found next to mo then on PATH; nothing cached between buildsFable, from Opus’s defaultprovisionalprogram 4
Overflow checks and asserts are always on in every binaryFable, from Opus’s defaultlocked (chapter 2)—
A read-only Fs is its own type unifying with Fs; the checker infers which functions write through which Fs parameters; not followed through Process.startFable, from Opus’s defaultprovisionalstep 15
Step 14 accepted: contracts on in every build (--no-contracts for measurement; logstat-4k-c 8.9 ms with, 6.2 ms without), three interpreter panics reproduced and fixed, the formatter’s round-2 shapes, sort_by_desc, min_of, max_of, Fs.each_line, housekeeping; 45 minutesFable—round 3 of the control run
Contract cost in native code is measured at about 40 percent on logstat’s hot path; recover by contract-proved bound elision later (chapter 7), never by turning contracts offFableprovisionaltier 3 proving
Step 15 accepted: the scheduler and Net in the C runtime, mo build compiles every program, the differential test covers every process module and echo and kv; native echo-1k 33.9 ms (interpreter 52.2), kv-10k-get 345 ms (476), kv after 50k SETs 19.2 MiB (37.4); crash reports, deadline outcomes, and a failing test binary identical to the interpreter on programs the brief did not name; aarch64 Linux static binary; 40 minutesFable—program 4
Under main, each process runs on a thread of its own with a 16 MiB stack and the threads take turns; a call that waits gives up its turn; while main waits, one thread per blocked call watches the socketFable, from Opus’s defaultprovisional, a cost to measurea day-long kv run
A native socket call tries its socket first and gives up its turn only when it is not ready; the interpreter always gives up the turn; the two must print the sameFable, from Opus’s defaultprovisionalthe differential test under load
Undo of a crashed update in the C runtime treats as older anything not allocated in the current region since the update began; the interpreter compares addressesFable, from Opus’s defaultprovisionalprogram 4
mo test --sim has no compiled form: a --tests binary runs the fixed order only, the seeded runs stay the interpreter’sFable, from Opus’s defaultprovisional—
kv’s memory row is 50,000 SETs of distinct keys from one client, each waiting for its OK, on an empty log; kv-50k-set-rss-kib holds KiB and its name says soFable, from Opus’s defaultlocked as the methodevery later kv row
Two interpreter behaviours ported as they are: a process started directly with no single matching child line takes the last supervisor with one; a skip inside update propagates as a skipFable, from Opus’s defaultprovisional; the first is a smell and becomes a check-time diagnostic (one child line per process) in a later stepprogram 4
Step 16 is HTTP in the stdlib, before round 3 of the control run, so program 4’s spec can follow; round 3 runs after step 16 in its own worktreesFableprovisionalstep 16
HTTP v0: Http over Net, HTTP/1.1 only, no TLS, one request per connection (Connection: close), bodies by Content-Length only, Request and Response as structs, a server that accepts exchanges and a client that sends requests, Http.fixture() in tests, both runtimes, differentialFableprovisionalstep 16, program 4
Step 16 accepted: Http over Net in the interpreter and the C runtime, ## Http in the stdlib, effects/http.mo and stdlib/http.mo, programs/httpd identical under both runtimes; native http-1k 58.5 ms (interpreter 98.4), servers at 2.4 and 4.6 MiB after 1,000 requests; fourteen curl and raw-socket cases of Fable’s own (chunked, a 2 MiB body, garbage, HTTP/2.0, two content-lengths, a stalled client) identical under both; 65 minutesFable—program 4
The HTTP wire: HTTP/1.0 requests are read and answered as 1.1, any other version is Unsupported; 1 MiB each for the request line, the headers, and the body; any transfer-encoding is Unsupported; a request with no content-length has an empty body and a response with none runs to the end of the stream; repeated headers join with ", "; query keys decode + and %XX and the last repeated key wins; strings hold the bytes as they came; Conn gains no row, the body is read from the bufferFable, from Opus’s defaultprovisionalprogram 4
A failed accept answers the client 400, 413, or 501 and closes it; accept’s deadline covers the whole request, so one slow client holds the acceptor for its deadlineFable, from Opus’s defaultprovisional, a known cost: if program 4 needs it, accept hands over the connection before the request is readprogram 4 under load
The prelude structs Request and Response may be built without their empty fields (headers, query, a request’s body); a module’s own Request or Response hides the prelude’s in that module and the Http rows still use the prelude’sFable, from Opus’s defaultprovisional, flagged: the first fields with a default outside state; the rule stays prelude-only until a question settles struct defaultsprogram 4
reply: a status outside 100 to 599 or a bad header is Malformed and writes nothing; a second reply is Closed; reading exchange.request after the reply is a crash; the runtime writes content-length and connection itself and drops the program’s; reason phrases for the common statuses onlyFable, from Opus’s defaultprovisionalprogram 4
send writes host unless given one and percent-encodes the query; in a test, send delivers the processes’ waiting messages a round at a time until the response is whole, Timeout when none waits; under --sim, accept and send time out by the seed and reply and send find the connection Closed by the seedFable, from Opus’s defaultprovisional—
A request’s bytes are freed at the reply; an exchange never answered keeps them until the run endsFable, from Opus’s defaultprovisional, a cost to measureprogram 4
The http bench rows: 1,000 GET /hello to httpd serve, one connection per request, from a Zig client, interpreter and binary; resident memory by ps after them, in KiB, both runtimesFable, from Opus’s defaultlocked as the methodevery later http row
Round 3 of the control run starts after step 16: worktrees control3-mo|go|python from session-05, the round 2 implementations removed, the same briefs, agents mo-r3-*Fable—round 3’s table
Control run round 3 recorded: Mo 9 loops to green (6 of them syntax or law diagnostics, 1 real bug, 2 test mistakes) against Go 2 and Python 1; Mo’s checks caught a real bug twice (a test and a never), the first time in any round; wall-clock void for Mo and Go, the machine slept mid-run; 851 Mo lines to Go’s 1,387Fable—round 4 after step 17
any(T) for a refined T generates only values the refinement admits; a refinement that admits none of the candidates is a diagnostic, never a value that breaks itFablelocked (chapter 5: a refinement is a contract)step 17
A String is UTF-8: an Fs row that reads text returns NotText for a file that is not, and a program that wants the bytes asks for them by a row that says soFableprovisionalstep 17
Step 17, the round 3 follow-ups (any(T) under refinements, NotText, a fold over lines, MO0101 and the other five diagnostics the run tripped reworded), comes before program 4; the program 4 spec is written meanwhileFableprovisionalprogram 4
Step 17 accepted: any(T) honours refinements in both runtimes with MO0325 when a where admits nothing, NotText and Fs.read_bytes, Fs.fold_lines, six diagnostics say what to write instead; verified on a refined type of Fable’s own under both runtimes, an unsatisfiable where, a bad-byte file through all three rows under both runtimes, the six sentences tripped by hand; 35 minutesFable—round 4, program 4
any(T) on a refined type tries 100 base values, then 100 from the integer bounds a where of value <op> integer clauses joined by and states, hitting each edge a fifth of the time; MO0325 after 200 missesFable, from Opus’s defaultprovisionalround 4
NotText carries no path; fixtures and Mo.Sim faults cannot produce it, since write takes a String; read_bytes returns List(UInt8) for want of a Bytes type; fold_lines(path, init, fn, within:) returns Ok(init) on an empty fileFable, from Opus’s defaultprovisional; a Bytes type is a later questionprogram 4
Robert (13 Sep, on the outside review): the laws and the no-while rule stay as they are; “we need to test and see what happens and can reevaluate later”; findings and decisions are documented as baselines for later comparisonRobertlocked until re-evaluated against a control runround 4, program 4
The outside review’s no-compat fixes go to step 18 before program 4: invariant flipped to “stays true”, Handle(T) counts as a capability, a capability captured in an anonymous function refused, a stack overflow is a Mo crash report, grouped patterns A | B: body, map and set equality by content, the sidecar’s cache key over transitive bodies, a discarded pure call value refused, and --faults that stop injecting partway so a test can assert progress after faultsFableprovisionalstep 18, program 4
Decision-log rows touching failure, authority, equality, persistence, or scheduling carry the tag semantic; a provisional row names what first tests it and is re-read at that test; Robert reads the semantic rows, not the queueFable, after the outside reviewlockedevery acceptance from step 18
The failure model (what survives a crash, what timeout means, when a reply means durable, poison messages, retry limits, cleanup on crash) is written by Fable as chapter 3’s next section before program 4’s --sim claims are readFableprovisionalprogram 4
Deadlines as budgets (an absolute deadline at the operation boundary that nested within: calls inherit and may tighten) is program 4’s experiment, not a rule yetFableprovisionalprogram 4
Step 18 accepted: the outside review’s no-compat fixes; verified with a natural invariant of Fable’s own that trips when false, a handle captured in a closure refused (MO0409) beside its dropped map value (MO0310), 50-million-deep recursion crashing with a Mo report and exit 70 under both runtimes, a grouped arm binding a name under both runtimes and a mismatched binding refused, maps and sets equal across insertion order, a body edit tripping MO0317, --until turning sim.mo from “passes only without faults” to held; 55 minutesFable—round 4, program 4
semantic: an invariant holds after every update and trips when false; the report says “no longer holds in”Fable, from the reviewlocked (chapter 3)—
semantic: Handle(T) is a capability: holding one makes a function effectful, using one with no capability parameter is MO0403, a handle in a struct, state, or message field is refused, a handle may be returned, a recipe’s needs lists capabilities only, flows(T, into: Handle(P)) covers sends and asks; an anonymous function that captures a capability or handle is MO0409; a dropped value from a pure call, a bare dot call included, is MO0310Fable, from Opus’s defaultprovisionalprogram 4
semantic: calls nest at most 10,000 deep per thread, counted through closures, contracts, invariants, updates, and an ask running another process inline; past it a crash report and exit 70; the interpreter runs main and each process on 256 MiB of reserved stackFable, from Opus’s defaultprovisional, the number to measureprogram 4
Grouped patterns are arm-only (A | B: body), every alternative binds the same names of the same types or none; is takes one pattern; grouped update arms replying with different types are MO0212Fable, from Opus’s defaultprovisionalround 4
semantic: maps and sets are equal, and hash, by content, not insertion order; iteration order stays insertion orderFable, from the reviewlocked (chapter 3)—
The sidecar hashes every used module’s declarations minus its tests, so any body change in a used module stales the caller’s verified: line, even one its tests never reachFable, from Opus’s defaultprovisional, coarse by designprogram 4
--until F is a fraction of the fixture calls that could fail, counted on a faults-off run of the same seed first, so a seeded run costs twice; a # sim: --faults P --until F line at the top of a file sets the corpus test’s options for that fileFable, from Opus’s defaultprovisionalprogram 4
Fs.each_line’s callback can reach no capability now that capture is refused, so the row is dead; it is removed, or takes a value, in a housekeeping step; fold_lines is the streaming rowFableprovisionalhousekeeping
Program 4 (notes) starts on the toolchain after step 18; the failure model (chapter 3) is written and is what its --sim claims are read againstFable—program 4
Program 4 accepted: notes in 55 minutes, eight modules, --sim 100 green, identical native; native creates 7,621/s and gets 23,692/s with 32 clients, 103 MiB at 100k notes, a 1M-line replay in 6.3 s; the recipes saved a design and cost a conformance gap; two runtime findings and seven gaps go to step 19Fable—step 19, program 1
semantic: a started process is never freed today (a thread and about 30 KiB each, for the program’s life), so a process per request is not a shape a program can use; step 19 frees a process that no live process or main holds a handle to once its mailbox is empty, handles being values the runtime can count across copies; a process a supervisor names by a child line is never freedFable, after program 4’s bug 1provisional, the rule to measurestep 19, program 1
semantic: sends from inside update are held until the update ends (chapter 3), so an update that starts a process and waits for its reply deadlocks; step 19 makes the runtime crash the waiting process with a report naming the held message instead of hangingFable, after program 4’s bug 2provisionalstep 19
A recipe may hold never blocks; mo check --recipe Module.Recipe file.mo checks an implementation’s exposed signatures against the recipe and runs the recipe’s tests against it, so recipes stop drifting from implementationsFable, after program 4’s gapprovisionalstep 19, program 5
Fs.mkdir, and mo run --clock <ISO-8601> giving main a clock that starts there and advances with the wall, so a transcript over real sockets can be replayedFable, after program 4’s gapsprovisionalstep 19
A capability cannot travel in a message; a process gets one only as a start argument (chapter 3); program 4 wanted to hand an Exchange to a live worker, and the answer is freeing finished processes, not capabilities in messagesFableprovisional, re-read after step 19program 1
Program-level defaults the worker chose (a refill-all-at-once limiter, ids reserved in blocks of 100, <token>/n_<id> store keys, 404 across clients, 503 on a torn log, 30 s from acceptor to service) stand as notes’s own; none is a language ruleFable, from Opus’s defaultsprovisionalprogram 1’s shape
Robert (13 Sep, evening, after Fable unpacked the three answers to the fictional-bound loops): the runtime owns the loop; no loop keyword; the laws stayRobertlocked until round 4 re-evaluates the lawsstep 20
semantic: Net.serve(listener, into: handle, idle:), Conn.lines(into: handle, idle:), and Http.serve(listener, into: handle, idle:) make the runtime accept, read, and deliver: each connection, line, or exchange arrives at the named process as a message (Accepted, Line, Closed, Idle); the runtime stops reading a socket while the target mailbox is near its bound, so overload is backpressure, not a crashFable, Robert agreedprovisionalstep 20, program 1
semantic: a message may carry a capability or a handle when its message line declares the field, and a sender may put in it only what it holds; the process’s protocol shows what authority it receives, so direction 31 holds; step 18’s refusal of capability fields in messages is reversed for declared message fields only, struct and state fields stay refusedFable, Robert agreedprovisionalstep 20, program 1
Threads: a process is still an OS thread, so a process per connection holds to a few thousand connections; green threads are the chapter 7 memory step, after step 20Fableprovisional, the number to measurestep 20’s rows, the memory step
Step 19 accepted: a finished process is freed (the reproduction runs 200,000 processes at 21 MB interpreted and 9 MB native, where 20,000 ran out of memory before; a worker per exchange serves 20,000 requests at 18 and 9 MB), the held-send deadlock is a crash report, mo check --recipe (a missing signature is MO0326, a changed type fails the recipe’s own tests), Fs.mkdir and mo run --clock (the same transcript twice), three diagnostics reworded, each_line gone, mutation tests 9 of 10 caught; 75 minutesFable—step 20, program 1
semantic: a process started by a start call ends once its mailbox is empty, no update of it runs, and no handle to it is reachable from main’s frames, a running update, a live process’s start arguments, a held send, or an untaken reply; a sweep on main’s thread every 64 quiet events; a process a child line names is never freed; freeing happens under main only, not in mo test; ids are reused last-ended-first and up to 64 threads are kept; a freed process’s connections are not closedFable, from Opus’s defaultprovisional; the counting costs under 2 percent on the bench rowsstep 20, program 1
semantic: the held-send rule: an update waiting in accept on a listener, or read_line on a connection, whose only way to progress is a send this update holds, crashes with a report naming the message; an ask counts through such a wait; a doomed asker crashes when its ask returnsFable, from Opus’s defaultprovisionalstep 20
semantic: since step 18 a process with no capability parameter cannot start another (MO0403), so starting a process is an effect nothing names; step 20 decides: a process may start any process its own supervisor names as a child without a capability, and a function still needs oneFable, found by a probeprovisional, flaggedstep 20
The recipe check compares types by printed name, requires as the same set, ensures as a superset, keeps the implementation’s own test rejects and identical nevers, and finds the recipe module under the root or above it; a # recipe: line is honoured by the corpus test but not by a plain mo check, which step 20 fixesFable, from Opus’s defaultprovisionalstep 20
Fs.mkdir makes one level and is Ok on an existing folder; MO_CLOCK gives a built binary the fixed clock --clock gives mo run; notes check keeps masking timestamps since the clock still advances between runsFable, from Opus’s defaultprovisionalprogram 1
Mutation testing found the one contract the corpus cannot catch: an invariant that reads old(state) with its witness removed passes when every test drives the state forward; rule for step 20: an invariant that mentions old needs a test rejects that trips it, as a requires needs one (a new MO03xx)Fableprovisional, a law candidate for round 4’s re-evaluationstep 20
Step 20 accepted: the runtime owns the loop; serve and lines rows in both runtimes with fixtures and faults, a message may carry a capability, the six servers rewritten with every fictional bound gone (11 → 0) and every .expected file unchanged, a corpus check that refuses a for reaching accept or read_line; kv 3 to 9 percent slower on the bench, http-1k interpreted 13 percent faster, 32-client native kv GETs 42k → 36k per second, notes POSTs flat; verified by a server of Fable’s own (a burst of 2,000 lines into a mailbox of 4, no crash, the count right, an idle client closed at the bound, a Conn through two processes by message) under both runtimes; 105 minutesFable—round 4, program 1
semantic: a capability sent in a message moves, and a later use of the bare name in that function is MO0410 (“later” follows the block structure, never a sibling arm); a handle is copied; a copy the checker cannot see is not tracked by the runtimeFable, from Opus’s defaultprovisionalprogram 1
semantic: the serve rows send Idle too and the target must declare every message a row sends (MO0223); the rows return nothing; serving a listener twice or reading one connection into two processes is a crash; accept or read_line on a served source is Busy; the runtime pauses a source at the mailbox bound minus min(4, bound/2) and resumes at half, idle time does not run while paused; a served listener keeps the program alive and platform.exit stops itFable, from Opus’s defaultprovisionalprogram 1
semantic: under Mo.Sim a served source delivers one message at the start of each delivery round, Idle fires once simulated time passes the bound, and faults are drawn only when a source is about to deliverFable, from Opus’s defaultprovisionalprogram 1’s --sim claims
A client stays synchronous: main cannot receive the runtime’s messages, so echo’s and kv’s clients keep a for bounded by their data around ask; the corpus check follows calls, not asks; echo-1k-c 33.7 → 52.3 ms because the client now asks once per line, an accepted cost until green threadsFable, from Opus’s defaultprovisionalthe memory step
semantic: MO0327 requires only that a test rejects starts or messages a process whose invariant reads old(state); the four corpus invariants it covers cannot be broken by any message the process accepts, so their new tests trip a different contract: those four invariants are documentation, not checks, which is what the mutation survivor said; program 1’s invariants must be trippable, and round 4’s re-evaluation decides whether MO0327 demands the trip itselfFable, overruling nothing yetprovisional, flaggedprogram 1
A process has no handle to itself, so one that must read a connection into itself starts a child instead; found by Fable’s probe, queued as a question for program 1Fableprovisionalprogram 1
The memory step’s targets: a process per connection holds 6,400 connections under mo run (230 KiB each) and 5,536 as a binary (the OS thread limit)Fable, from Opus’s measurement—the memory step
”Its own supervisor” means one supervisor naming both the starting and the started process; a plain mo check honours a file’s # recipe: line; zig build -Dtest-filter runs a subsetFable, from Opus’s defaultprovisional—
Round 4 of the control run starts now in worktrees control4-* from session-05 after step 20, the round 1 and 2 implementations removed, the same briefs; it is the timing round round 3 lost to the machine sleeping, and the laws are re-evaluated against its loops and the baselines pageFable—round 4’s table
Control run round 4 recorded (timing valid): Mo 16.1 min, Go 9.3, Python 9.0; loops Mo 5 (4 tooling: MO0206, MO0101 twice, MO0309; 1 test mistake), Go 1 (tooling), Python 0; no check caught a bug in any language; Mo 849 lines to Go’s 1,648, median 3 lines per function to Go’s 9; one toolchain bug (Fs.fixture() accepts ..)Fable—round 5 after program 1
semantic: the laws re-evaluated after rounds 2–4: no loop in any round came from a shape law or from test rejects; the no-while law’s cost was the fictional bounds, gone since step 20; Mo’s loops are the grammar’s one-line forms (MO0101) and one misleading type error; Fable recommends keeping every law unchanged and spending an ergonomics step on the one-line if and arm forms and MO0206’s wordingFablefor Robertround 5
Fs.fixture() refuses .. as the real Fs does, so a test can show a program staying inside its folderFable, from round 4’s bugprovisionalthe next toolchain step
semantic: the runtime’s introspection surface (direction 37) is a capability: mo run and mo test hold it and expose the surface in development; a built binary has it off unless main is handed the capability and passes it on, narrowed like Fs; reading a process’s state is the largest authority in the system and is never ambientFable, Robert agreed (13 Sep, night)provisional; first design in program 1’s runtime surface stepprogram 1
The research agenda’s twelve concept pages reviewed: seventeen “contradicts Mo” items called on research-agenda-2026-09-response (agree 8, disagree 6, test 3); three were settled before the pages were written (step 20’s bounds, chapter 3’s restart rule, round 4’s laws)Fable—round 5, program 1
semantic: chapter 2’s recursion law now says what the toolchain does: calls nest at most 10,000 deep, past which the process crashes with a report, in every build; termination is mo prove’s obligation and never a syntax rule; “structural only, proved terminating” was never checked by any stage and is withdrawnFable, after the Dijkstra and SPARK pagesprovisional; a law’s text changed, Robert to reviewprogram 1
semantic: Armstrong’s R6, stable storage, is answered by name in chapter 3: durability is a capability’s contract (the store recipe), never the supervisor’s; a process’s state never survives its crash; restart recovers the serviceFable, after the Armstrong page; restates step 18’s failure modelprovisionalprogram 1
The Q16 ledger: a program that a law blocks, as opposed to a missing stdlib row, is recorded here as a Q16 event naming the law and the program; the count is zero across programs 2–4 and rounds 1–4; this ledger, not an argument, is what could reopen the no-override rule Robert chose twiceFable, after the Kernighan and MISRA pagesprovisionalprogram 1, round 5
Mo’s pages cite Erlang’s practice and scale, never the nine-nines number; no page outside the raw runs didFable, after the Armstrong and Cronqvist sourceslocked, a writing rulelint by eye
Reproducible builds are a release requirement before any registry; measured 13 Sep night: kv’s emitted C and binary are byte-identical across two mo binaries built from separate caches, and mo itself differs only in the Mach-O LC_UUID and its ad-hoc signature (114 bytes, no embedded path); a Linux static build is measured at the registry stepFable, measured, after the Thompson pageprovisionalthe registry step
Round 5 records loops to green by cause and whether each worker wrote Mo directly or a generator for it; rounds 2–4 wrote Mo directlyFable, after the LLM-facing pages—round 5
semantic: the deadline law stays per call; program 1 counts the within: literals it writes and how many are derived from an enclosing deadline; an inherited, tighten-only budget (structured concurrency, Ravenscar’s absolute delays) is designed only if that count shows literals lyingFable, after the reliability pageprovisional, flaggedprogram 1
The shape laws’ justification is human review economics and one declaration per ID edit, never model performance; the finding that complexity metrics do not predict LLM performance changes nothing; round 5 keeps counting trips, zero in rounds 2–4; JPL’s “should” and MISRA’s deviations are not taken, since a deviation record is an overrideFable, Robert’s no-override call standsprovisionalround 5
Robert (13 Sep, night, going to bed; Fable runs the queue as last night): step 21 adds no syntax; the one-line if as a value stays a question for the morning; MO0101 shows the block form insteadRobertlocked for step 21round 5
Step 21 starts: green threads in both runtimes, the four chapter 7 bets measured, Fs.fixture() refusing .., three diagnostics; the brief on interpreter-step-21Fable—step 21’s numbers
Step 21 accepted: a process is a stackful fiber, not an OS thread, in both runtimes; a process per connection is bounded by descriptors (65,530 idle connections under mo run at 2.41 GiB and as a binary at 1.64 GiB, from 8,026 and 8,185 before); a process at rest 38.8 KiB interpreted and 22.7 native (73.2 and 39.9 before); the 200,000-process reproduction flat at 23 and 12.5 MiB; no bench row over 10 percent slower and the socket rows faster (echo-1k 57 → 18 ms, kv-10k-get-c 386 → 210 ms, http-1k 90 → 58 ms); the four bets carry numbers in chapter 7; Fs.fixture() refuses ..; three diagnostics with a mo fix for the one-line if; verified by Fable’s own probes (a one-line if rewritten by mo fix, a positional variant pattern and 0..60.map named, 20,000-deep recursion a Mo report in both runtimes, 200 idle connections never delaying a live request, 3,000 idle connections held by kv); about 2 hoursFable—program 1, round 5
semantic: every update runs on a stackful fiber on main’s thread with a kqueue or epoll poller and no thread pool, so a program’s updates never run in parallel (they took turns before, one at a time, so nothing observable changed); the context switch is hand-written assembly in both runtimes; Fs calls and hostname resolution still block main’s thread, only socket waits parkFable, from Opus’s defaultprovisional, the parallelism question is program 1’sprogram 1
semantic: a fiber is borrowed per delivery (256 MiB reserved in the interpreter, 16 MiB in C, a 1 MiB guard, at most 64 idle fibers kept), so a process at rest holds no stack; a process region reserves 1 GiB and grows fourfold up to 16 GiB, so a single update needing more than about 1 GiB of live values now fails where 16 GiB was reserved beforeFable, from Opus’s defaultprovisionalprogram 1
semantic: found by Fable’s probe: an HttpListener.serve counts accepted connections that have sent no request against its target’s mailbox bound, so an HTTP server holds about 1,000 request-less connections (the default bound less headroom) and then stops accepting until idle: closes them, while a raw Net.serve holds 3,000 and more; a slow client burst is therefore backpressure on HTTP, and the idle: value is the defence; program 1’s spec must choose its idle: with this number in viewFable, after a probe of step 20’s defaultprovisional, flaggedprogram 1
semantic: when this side closes a connection a runtime loop is reading, no Closed message is sent; the interpreter now matches the C runtime and the specFable, from Opus’s defaultprovisionalprogram 1
A field set writes in place only inside a region (mo run and a binary), since tests copy: a first in-place version broke invariant-trips.mo; a string grows in place only when it was made at run time; a map set still allocates once per updateFable, from Opus’s defaultprovisionalthe next memory measurement
The contract cost re-measured after step 14: 41.5 percent on logstat-4k-c by the worker’s harness and 22.4 by the bench (two ensures !card? scans in parse.mo are 24 points of it), 3.9 on kv-10k-get-c, 7.1 on notes POSTs; overflow checks within noise; recovery stays contract-proved elision under mo prove, never contracts offFable, measured by Opusprovisionaltier 3 proving
Fs.fixture() refuses any climb above its root with the real Fs’s Missing error, while the real Fs, rooted at /, refuses only a climb out of a narrowed scopeFable, from Opus’s defaultprovisionalprogram 1
mo fix proceeds on a file that does not parse when every error carries a fix; MO0101’s catalog row carries the one-line if rewrite at confidence 100; rejects/ files with a syntax code skip the formatter check; a variant’s field names in MO0101 come only from enums in the same file; MO_STATS=1 prints allocation, packed-byte, and freeing counters in both runtimesFable, from Opus’s defaultprovisionalround 5
The Linux epoll path compiles for x86_64 and aarch64 in both runtimes and was never run; the first Linux run is the registry step’s, or earlier if a Linux machine appearsFableunmet, recordeda Linux run
Housekeeping: MO0206’s catalog why now ends with the range sentence for every MO0206, not only a method bound to a literal (Fable’s probe printed it under a plain type mismatch); the per-code why cannot carry a per-site sentence, so the next housekeeping step moves it into the messageFableprovisionalthe next housekeeping step
Program 1 (jobq) specified and started: a lease-based job queue over HTTP on the store recipe; a lease is a deadline the queue checks at its next look, never a timer (Mo has no delayed send; a gap if it bites); every transition durable before its response; the spec asks for trippable invariants only, the within: count, an idle: chosen against the 1,000-connection backpressure finding, the Q16 ledger, and the runtime-surface questions for directions 37–40Fable—program 1’s report, round 5
Program 1 accepted: jobq in 40 minutes, nine modules, 195 functions, 2,891 lines; the corpus’s five run lines identical under mo run and as a binary; mo check --recipe green on the store; native 3,180 lease-and-ack pairs per second with one worker and 4,051 with 32 (interpreted 2,416 and 2,846); a run-out lease handed out again in 0.14 ms; 207 MiB at 100k jobs; a 1M-record replay in 8.9 s; 1,200 silent connections held while a producer’s request is answered at once; verified by Fable’s own HTTP session under both runtimes (29 checks: every status, a lease running out and re-leased with attempts 2, a fail on the last attempt to dead, a restart keeping a dead job and re-leasing a run-out one, a 40-worker race with one holder, the crowd); loops 17 (laws 8, grammar 3, test mistakes 4, bugs 2, diagnostics 0)Fable—round 5, program 1’s follow-ups
semantic: the within: count, the evidence the log asked for: 36 literals, 18 in tests, 15 chosen for their call, 3 derived by hand from an enclosing deadline as sums in comments, and two of the three were wrong before the worker’s second pass (an ask of 60 s over a rewrite of up to 70 s; an open of 660 s over a replay of up to 1,240 s); literals do lie where deadlines nest; a derived deadline (a call’s within: as what remains of an enclosing one, tighten-only) is designed in program 1’s follow-up step, the law unchangedFable, from the countprovisional, flaggedthe follow-up step
semantic: the invariant construct kept zero of eight candidates in program 1: every candidate was untrippable by any message the process accepts, since a transition either cannot break it or a requires or never trips first; the process’s contracts are its requires, ensures, and nevers over each step; invariant may be a construct for a state machine whose messages can break its shape, not for one whose updates are transactions over a durable board; Fable recommends no change until program 6, the ledger, whose invariants are the pointFablefor Robertprogram 6
semantic: a lease is a deadline the queue checks at its next look (a lease, an ack, a fail, a read, a listing, or the listener’s Idle turned into a sweep); a lease has run out once the clock reaches lease_until; Mo has no timer or delayed send, and program 1 did not need oneFable, the spec’s rule, from Opus’s default on the sweepprovisionalprogram 5
semantic: a torn log is rewritten whole at the next change, not refused until restart as notes does, since otherwise work cannot resume after faults stop; the recipe’s own text says “no change is safe until the store is opened again and compacted” and both implementations pass its tests, so the recipe under-specifies; the follow-up step makes the recipe say the rewrite ruleFable, from Opus’s defaultprovisionalthe follow-up step
Program-level defaults (one service process for every queue and no registry, since updates never run in parallel and every change waits on one fsync; a worker process per request with restart: :never; mailboxes of 4,096 on the acceptor and the service with idle: 5 s, which holds 1,200 silent connections; everything one call changes in one append through a put_all beyond the recipe; ids reserved 1,000 at a time; max_attempts required on create; a token of 1 to 256 bytes) stand as jobq’s ownFable, from Opus’s defaultsprovisional—
The Q16 ledger after program 1: empty; no law blocked the program; the laws cost 8 of 17 loops (the 500-line law twice through a toolchain bug, a copied verified: line, stale verified: lines after a store change, a captured handle, seven parameters, a never tripped by a half-built value, a fixture in a pure helper) and shaped main; round 5 counts the same wayFable—round 5
Program 1’s follow-ups, one toolchain step: mo check --recipe must not count the recipe’s tests against the file’s 500-line law (the bug); Fs.fixture().list on a missing folder is Missing as the real Fs says; a Json row that decodes an integer; the derived deadline; the store recipe’s rewrite rule; MO0206’s per-site sentence; the state and old keywords as struct field names go to Robert with the one-line ifFable—step 22
Directions 37–40: the nine questions the worker wanted to ask the running service are filed on d37 as the surface’s first requirementsFable—the runtime surface step
Round 5 of the control run is pre-registered on control-run-5 before any session starts: P1 Mo wall-clock at most 1.5 times Go, P2 Mo loops at most Go’s plus 2, P3 no loop from a shape law or from the three forms step 21 gave diagnostics for; all three or “mixed”; briefs word for word as rounds 2–4; loops by cause and “wrote the language directly” recorded; the bolted-on-checks arm for the baselines waits for a round with a second taskFable—round 5’s result
Control run round 5 recorded, pre-registered, mixed: P1 held (Mo 14.8 min to Go’s 11.6 and Python’s 14.9, 1.28 times Go, from 1.73), P2 missed by one (loops Mo 5, Go 2, Python 3), P3 held (no shape-law loop, none of the three step 21 forms); no check caught a bug in Mo, one test each did in Go and Python; every worker wrote its language directly; tokens not capturedFable—round 6
semantic: the laws after five rounds: no shape law tripped in rounds 2–5; Mo’s loops are the worker’s own test mistakes (3 of 5) and one grammar form a diagnostic can cover (is inside a comparison); the one law loop was the honesty laws working (MO0214, MO0403); every law stays; the is form’s diagnostic goes to step 22Fableprovisional, Robert’s standing callround 6
Round 6 pre-registers loops by cause, not a total; reads each pane’s token count before the report; the baselines’ bolted-on arm (Go contracts library, Python pydantic) waits for a second taskFable—round 6
Tooling around the baselines: the installed staticcheck cannot read Go 1.27 (the Go worker rebuilt it in its scratchpad) and mypy is not installed, so no round has type-checked the Python; recorded, not fixed by FableFableunmet, recordedRobert’s machine
semantic: the derived deadline, designed for step 22: a prelude Deadline; inside an update arm for a message that carries a reply, reply_by is bound to the asker’s deadline; within: accepts a Deadline and gets what remains, Timeout at once when nothing does; deadline.at_most(d) tightens and nothing extends; main’s calls stay literal; the law is unchanged, every waiting call still carries within:; jobq rewritten on it and its count re-takenFable, from program 1’s evidenceprovisionalstep 22, program 5
Step 22 starts: the --recipe line count, the fixture’s missing folder, a Json integer row, the derived deadline, the store recipe’s rewrite rule with notes following it, two diagnostics; no syntax; brief on interpreter-step-22Fable—step 22’s numbers
Step 22 accepted: the --recipe line count fixed (a 496-line implementation passes), Fs.fixture() answers Missing for a missing folder, json.to_i64, Deadline and reply_by in both runtimes with jobq rewritten on them (chosen literals 24, derived 7, sums 0, from 15, 3, 3), the store recipe’s rewrite rule with notes following it (a change after a torn log is 201, was 503), two diagnostics; no bench row over 10 percent slower, jobq 4,046 → 3,923 pairs a second native; verified by Fable’s probes under both runtimes and the simulator; 50 minutesFable—program 5, the runtime surface step
semantic: reply_by is bound in an update arm that answers an ask, to the asker’s deadline; within: takes a Deadline and gets what remains, Timeout at once and the call not made when nothing remains; at_most tightens and nothing extends; a Deadline is a Time on the runtime’s clock, monotonic under mo run, simulated under Mo.Sim; a reply-carrying message that arrives by send has no asker and its reply_by is already spent; reply_by outside a process arm is MO0201; Deadline.fixture(d) in tests onlyFable, from Opus’s defaults on the brief’s designprovisionalprogram 5
semantic: simulated time now moves when calls wait: a delayed fixture call waits its delay, a call past its deadline waits the whole deadline, a fault’s slowness is capped at the deadline, and an ask is Timeout only when the target’s waits pass its deadline strictly, so a process answering on reply_by never times out its own ask under the simulatorFable, from Opus’s defaultprovisional, the strictness to re-read at program 5program 5’s --sim claims
A recipe signature that can wait takes a Deadline parameter, so an implementation can run on its caller’s reply_by; Recipes.Store’s functions take Fs and choose their own literals, which is why jobq needed a Journal module beside the recipe; the next recipe written follows the rule, and the store recipe is brought to it when a program needs itFable, from the worker’s findingprovisionalprogram 5’s recipes
Program-level defaults ratified: jobq’s acceptor asks for a sweep on a 10-second deadline and the sweep replies with a count; books and moves take a Moment (time and deadline) under the six-parameter law; notes keeps the torn-log rewrite inside its id-reservation function; MO0302 under --recipe counts the file as on disk; a checker bug found on the way (no method on a prelude enum was found) fixedFable, from Opus’s defaultsprovisional—
semantic: the runtime surface (directions 37 and 40) as chapter 3 now says: platform.runtime is Some(Runtime) under mo run and mo test and None in a binary unless built with --surface; a read is a snapshot between updates and never changes anything; a Runtime that may act can send a declared message, pause, and resume, each an event, and read_only refuses them; a bounded ring of structured events (updates with durations and waits, starts, ends, restarts, crashes, overflows, timeouts, sources paused and resumed) is what the surface, the crash report, and a seed’s replay read; mo run --surface PORT serves the rows as JSON over HTTP as the development on-ramp, an MCP wrapper later; direction 38’s replay is not in this stepFable, from Robert’s call of 13 Sep night and program 1’s nine questionsprovisionalstep 23, program 5
Step 23 starts: the runtime surface; brief on interpreter-step-23Fable—step 23’s numbers
Step 23 accepted: the runtime surface in both runtimes; the event ring (168 bytes an event interpreted, 112 native; 4,096 events cost 912 KiB and 416 KiB; 1.4 percent on 100,000 native GETs, 6.5 at 65,536); platform.runtime with its rows and read_only; mo run --surface PORT and MO_SURFACE for a binary built with --surface; GET /processes with 10,001 live processes in 3.3 ms native; jobq’s nine questions: six answered, three partly (a reply is not in an event, memory is not broken down inside a state, “run out” is the program’s notion); no bench row over 5 percent, kv-10k-get-c 0.1 percent apart interleaved; a checker bug fixed (a module’s own Request hid the prelude’s from every module); verified by Fable’s probes (httpd under mo run --surface and as a --surface binary: every route as JSON, a paused acceptor making a request wait and a resume releasing it, an unparsed message refused; a binary without --surface listening on nothing; read_only refusing in a test binary; a failed seeded test printing its last events; jobq’s /sources counting 300 silent connections in flight and /slowest naming the update and its wait); 68 minutesFable—program 5
semantic: the surface’s acts and reads as built: state(id) on a process mid-update waits for the update within the deadline, and a process reading its own state, or any busy one under Mo.Sim, is Timeout at once; send puts a declared message in the mailbox at once, not at the caller’s commit, a full mailbox is MailboxFull and crashes no one, and a reply the message carries is dropped; a paused process holds its deliveries and an ask to it is Timeout at its deadline; read_only refuses at run time with ReadOnly; the surface’s own acts (Sent, Paused, Resumed) are events; the surface’s HTTP process is hidden from the rows and the ring and keeps no program aliveFable, from Opus’s defaultsprovisionalprogram 5
semantic: an event’s time is the monotonic clock pinned to the wall clock at the run’s start, and the run’s own clock under Mo.Sim, so a seed’s events repeat exactly; durations in microseconds; a test gets its Runtime from Runtime.fixture(), its own run, tests onlyFable, from Opus’s defaultprovisional—
A module’s own Event, RuntimeError, Request, or Response hides the prelude’s in the declaring module only (the bug fixed in step 23); RuntimeError is NoProcess, Unparsed, ReadOnly, MailboxFull, TimeoutFable, from Opus’s defaultprovisional—
Directions 37 and 40 are built as step 23 (the surface as a capability, the ring as the events); direction 38 (replay from a snapshot) and the MCP wrapper wait for a program that asks for them; direction 39 (hot reload) stays unearnedFableprovisionalprogram 5
Program 5 (agent) specified and started: an agent harness that runs a model’s loop under permissions (each tool holds only its narrowed capability), budgets (one Deadline per run, every call on what remains of it), and immediate retries; the model is any plain-HTTP server and the program ships a scripted mock so a check needs no network and no TLS; a new recipe, Recipes.ModelClient, whose waiting signature takes a Deadline, the first recipe under that rule; the transcript is durable before the next step; the runtime surface is the operator’s viewFable—program 5’s report, round 6
Program 5 accepted: agent in 77 minutes, 19 modules, 4,539 lines, 284 functions, 72 tests; the six run lines identical under both runtimes; mo check --recipe green on the model client; native 448.7 five-step runs a second with 32 concurrent runs, 5.38 ms of harness time a step (two synced appends included), 89 MiB holding 1,000 runs; the three surface questions answered from platform.runtime.read_only in 74–93 ms; verified by Fable’s 22-check session under both runtimes (every status, a .. path and an off-list host refused and recorded, garbage twice then right under two retries, garbage failing under one, each of the four budgets ending over_budget, a cancel mid-run, the surface naming a run waiting in Http.send, a restart marking a running run failed with its transcript readable, 200 concurrent runs at 44 and 19 MiB); loops 28 (laws 7, grammar 8, test mistakes 9, real bugs 3, misleading diagnostics 0)Fable—round 6, step 24
semantic: found by program 5: MO0404 does not follow a read-only Fs into a process’s start arguments, so a write through one crashes at run time instead of being refused at check time; the program relies on the crash as the backstop for write_file; an authority hole, fixed in step 24Fable, from the worker’s bug reportprovisional, flaggedstep 24
semantic: the handle law shaped program 5: a handle cannot be kept in a value (step 18), so no process can hold a routing table and every request goes through one process (Agent.Book, as jobq’s service and notes’s acceptor did); Fable decides: a process’s state field may hold a Handle(T), since a state field is owned by exactly one process and the runtime counts handles across copies already; structs, enums, and returned values stay refused; step 24 implements it with a corpus file, and Robert reviews the rowFable, overturning part of step 18’s defaultprovisional, for Robert’s eyestep 24, program 6
semantic: three programs wanted a timer and program 5’s mock sleeps by an accept on a listener nothing connects to; Fable decides: a send may carry delay: Duration, delivered no earlier than delay after the sending update ends, ordered by the seed under Mo.Sim; no new syntax (delay: is a prelude name already); a process still never loops, the runtime doesFableprovisionalstep 24, program 6
semantic: under --sim an ask delivers only its target’s messages while it waits, so a test polling one process can starve another; step 24 makes a waiting ask deliver rounds for every process, as send on a fixture doesFable, from the worker’s gapprovisionalstep 24
The within: count in program 5: 76 outside tests, 48 chosen and 28 derived; inside the run and its book 27 derived to 2 chosen, so the budget model works where an asker exists; every chosen literal is in main, check, the HTTP front (an exchange carries no client deadline), the mock, or the operator, with a stated reason; a Deadline.remaining row replaces the by.at_most(0.ms) == by idiom in step 24Fable—step 24
The invariant finding, updated: program 5 kept two invariants of eight, each trippable by a second Begin (a run’s deadline is taken once; a stopped run stays stopped), and left six out for the same reasons as program 1; invariant holds for a process’s lifecycle, not for what a requires already refuses; the row for Robert stands with this evidenceFablefor Robertprogram 6
Program-level defaults ratified as agent’s own: one JSON log per run instead of the store recipe (a poor fit for an append-only transcript); a step is a model call and the tool it names; the step whose tokens pass the budget is written, then the run ends over_budget; a run past its wall budget plus 120 s is failed as lost by a sweep; a restart’s end line begins with a newline so it cannot join a torn line; ids continue after the highest log on disk; https refused; mailboxes 8,192 for the book, 4,096 elsewhereFable, from Opus’s defaultsprovisional—
Program 5’s follow-ups, step 24: the MO0404 hole; a Handle(T) in a state field; delay: on send; Deadline.remaining; Result(none, E) writable in a signature; the prelude Event’s fields renamed off the keywords (process, message, state) so a pattern can take them; a recipe module’s own Request hidden from its implementation as step 23 hides a module’s; the simulator’s ask delivering every process’s roundsFable—step 24
Step 24 starts: the MO0404 hole, a handle in a state field, delay: on send, Deadline.remaining, Result(none, E), the Event field names, the recipe’s Request hiding, the simulator’s ask; brief on interpreter-step-24Fable—step 24’s numbers
Robert (14 Sep, morning): the one-line if as a value is added, x = if c: a else: b, a value only, else: required, one expression a branch; p16-one-line-if-value (pick 16); step 25 after step 24; mo fix stops rewriting itRobertlockedround 6
Robert (14 Sep, morning): a keyword (state, old) may name a field after a dot and in a struct’s field declaration, where it cannot start a state block or an old(...) call, and stays refused as a bare name; step 25Robert, on Fable’s recommendationlockedround 6
Robert (14 Sep, morning): the invariant construct stays as it is until program 6, the ledger, whose invariants are the point; the two “for Robert” rows on it are answeredRobert, on Fable’s recommendationlocked until program 6program 6
Robert (14 Sep, morning): uv is the tool for anything Python in this project; Fable installed mypy (2.3.1) and ruff as uv tools and rebuilt staticcheck (2026.2.1) for Go 1.27, so round 6’s baselines are type-checked and vetted; the round 5 Python was checked with mypy --strict after the fact and the result is on control-run-5Robert; Fable installedlockedround 6
Robert (14 Sep, morning): Fable and the workers install what a step needs without asking, with Homebrew, mise, uv, or go install; a Python project starts with uv init and lives in its virtual environment; agreement 10 in SCHEMA.mdRobertlocked—
Step 24 accepted: the read-only Fs hole closed (a write through a narrowed Fs in a start argument, a message field, or a child line is MO0404 at check time; Fable’s probe refused), a Handle(T) in a state field with the runtime counting it (Fable’s own registry routed three keys and a dropped key’s worker ended, under mo test, --sim, and as a binary; 10,001 workers held in 26.5 MiB interpreted, 53 native), delay: on send (Fable’s probe: nothing at once, pings at 102 and 302 ms, a delayed send from a crashing update dropped, both runtimes; lag 1 ms average, 3 worst), Deadline.remaining, Result(none, E) in a signature, the Event fields renamed pid, taking, snapshot and taken by a pattern, a recipe’s own Request resolved by fit, a test’s waiting ask giving every process rounds; no bench row over 5 percent slower (jobq 3.4 percent, the delayed-send scan on every turn); the jobq 29-check and agent 22-check sessions green again under both runtimes; 84 minutesFable—step 25, program 6
semantic: the delayed send as built: a delayed message waits outside the mailbox, so a later plain send may arrive first; a delay of zero or less is a plain send; a pending delayed send keeps its target alive and keeps main from finishing; one falling due on a full mailbox is dropped with an Overflowed event, nothing crashes; one not yet due when its target restarts still arrives, one due to a down process is dropped; under mo test simulated time jumps to the next delayed send only when nothing else waits (a settle, a test’s end, a fixture send)Fable, from Opus’s defaultsprovisionalprogram 6
semantic: a process whose state holds a handle counts as holding authority, so its updates may use and start processes without a capability parameter; a down process keeps nothing alive through its state; under mo test a finished process nothing can reach is marked ended when the surface reads, its id never reusedFable, from Opus’s defaultsprovisionalprogram 6
semantic: only an ask made by a test, not one inside an update, gives other processes rounds while it waits, and those rounds carry no listener or connection traffic; the fixed order keeps its order; the read-only check follows a supervisor’s child line but an if expression still hides a read-only Fs from it (a hole left, to step 25)Fable, from Opus’s defaults, narrowed after jobq’s fault test brokeprovisional, flaggedstep 25
semantic: in a module that declares its own Request or Response, a construction builds the prelude’s struct when a call expects it or when the fields fit only it, and a signature still means the module’s own; none is a type only, Ok(none) still cannot be writtenFable, from Opus’s defaultprovisionalround 6
semantic, flagged for step 25: agent’s registry now hands every run its folder writable, since the checker refuses the old read-only backstop, and the tools refuse ungranted writes in code; the spec said a run without write holds a read-only Fs, so the authority is wider than the spec’s; step 25 puts the writing tool in a process started only when the run grants writeFable, overturning the default’s shape, not its codeprovisionalstep 25
Housekeeping to step 25: MO0404’s catalog wording does not fit the new diagnostic (the worker’s # expect lines fill in the catalog’s words); jobq’s lease sweep stays on Idle and agent’s naps stay an accept on a listener, both judged over the brief’s time; the agent registry’s per-run routing was skipped (over an hour); the Fs.write row’s stale sentence fixed by FableFable—step 25
Step 25 is written, not started: Robert stopped the loop at 07:22 before work; its worker was exited with no commits; the next session starts itFable—step 25’s numbers
Step 25 accepted: the one-line if as a value in both runtimes (Fable’s probe: nested in its own else branch, in a list literal, as a call’s argument, in parentheses before an operator, assigned to a struct’s state field, the same four lines from mo run and the built binary), refused as a statement, without else:, and with a return in a branch, each with a sentence that says what to write; a block value that fits becomes one line under mo fmt and one too long becomes the block, idempotent; mo fix leaves both alone; a struct with state and old fields built by name, read and set after a dot, and encoded as named; a bare state = 1 refused; jobq’s .expected files unchanged (the wire bytes are the same); a read-only Fs hidden by a block if bound to a name or by a case arm refused as MO0404 naming the branch; a run of agent not granted write_file holds folder.read_only and no writer; zig build test 184 of 184; mo fmt --check clean over the corpus; stage rows within noise (lex 6.8 ms, parse 17.2, check 61.2, fmt 9.9 over 149 files); 25 if values on one line in the corpus, from 2Fableacceptedround 6
semantic: tier 1 follows a narrowed capability through each branch of an if or a case, in either form, and through a name bound to one, so no shape in Mo hides a read-only Fs from MO0404 any more (a returned Fs is MO0403, a parameter handed on is followed, a var cannot be sent); the simulator’s own test now narrows in Zig to keep the runtime refusal coveredFable, from Opus’s defaultprovisionalprogram 6
semantic: agent narrowed again to what spec 05 says: a run holds its folder read-only and an Option(Handle(Writer)); the one process holding the folder writable is started only for a run whose order grants write_file, and write_file without a writer is refused as ungranted; both runtimes take the optional handle as a start argument; step 24’s flagged row is closedFable, from Opus’s defaultprovisionalprogram 6
For Robert, grammar: a one-line if that starts a line is refused as a statement even as the last expression of a body, where the block if is the function’s value (fn sign(n) / if n < 0: "negative" else: "not negative" / end is MO0101, found by Fable’s probe); Fable decides: the one-line form is an expression everywhere, so in tail position of a body, an arm, or an anonymous function it is the value, and at the start of any other line it is a dropped value (MO0310), never a statement; step 26 makes it so and moves the reject file’s if mid-body; pick 16’s rules standFable, overturning part A’s readingprovisional, for Robertstep 26, round 6
Formatter defaults ratified: the formatter chooses the if value’s shape from its width and comments, whichever form the author wrote (a block that fits becomes one line; the corpus gained 23); a comment after the first branch or on a line inside keeps the block, one after the else branch or after end ends the one line; a block whose end is followed by more expression stays a block; an over-long line breaks around the if at commas before falling back to the block; MO0101’s mo fix is gone for both forms, so mo fix refuses a file that does not parse, as mo check doesFable, from Opus’s defaultsprovisionalround 6
Keyword field defaults ratified: state: and old: also label the field when the struct is built (the third position, or no such struct could be built); a variant’s or a message’s field, a parameter, and a binding still refuse them; a bare state = 1 is the checker’s MO0201 with a sentence naming the keyword, so assigning the whole state inside an update is untouched; jobq keeps its hand-built JSON because Json.encode of a Job would write the id as a number, the state by its variant name, and absent fields as null, which the API does not; var state = n and fn f(old: Int32) fall to the parser’s bare “expected a name”, to be worded in step 26Fable, from Opus’s defaultsprovisionalstep 26
The toolchain’s first run on Linux (the exe.dev VM, x86_64, Zig 0.16.0 installed with mise; every earlier step ran on Robert’s Mac): three suite failures, none the poller’s: part A’s hand-written verified: line, a Json unit test reading a slice of a dead stack frame (undefined everywhere, hidden by the Mac’s stack layout), and the --surface corpus test binding ports inside Linux’s ephemeral range over a TIME_WAIT socket (now 21000–23998); after part F 179 of 179, and the socket, HTTP, and surface tests pass on epoll, so the “Linux poller never ran” item is clearedFable; Opus fixed—round 6 on this machine
The lead runs on the exe.dev VM from 14 Sep 2026, 12:30 UTC; the worker pane is w7:p7; the control worktrees are not on this machine and round 6 makes its ownFable—round 6
Step 26 accepted: a one-line if on the last line of a function body, a case arm, and an anonymous function’s body is that body’s value under mo run and as a built binary (Fable’s probe, the same two lines from both); the same if mid-body is MO0310 with a sentence that shows the block form; var state, an old parameter, and for old in refused with a sentence naming the keyword and what to write instead; zig build test 185 of 185; stage rows within noise (lex 7.3 ms, parse 17.5, check 60.9, fmt 9.7 over 151 files); the row for Robert on tail position is now built, provisional until round 6Fableacceptedround 6
Step 26 defaults ratified: a body with no value (a function without a return type, a test) refuses a line-start one-line if on its last line too, as a dropped value; a line-start if with no else: keeps the block-form sentence, since the author meant a statement; mo fmt does not fold a block if on a body’s last line into one line, and keeps a line-start one-line if on one line when it fits (rule I4); the keyword sentence also covers inout, for and comprehension names, anonymous-function parameters, and a pattern binding (MO0104); an enum variant’s field named state still gets the bare “expected a name”Fable, from Opus’s defaultsprovisionalround 6
Round 6 pre-registered on control-run-6 before any session: two tasks (logstat, jobq), three languages, the baselines with their checks bolted on (Go: vet, staticcheck, a contracts library; Python: a uv project, mypy --strict, ruff, pydantic), four predictions with P3 stating the null hypothesis; mypy 2.3.1 and staticcheck 2026.2.1 installed on the VM (agreement 10)Fable—round 6
Robert (14 Sep, afternoon): everything Python goes through uv init into a project’s own virtual environment, checkers included (uv add --dev mypy ruff, uv run mypy --strict); nothing is installed globally or as a uv tool; the mypy tool Fable installed on the VM is uninstalled, agreement 10 reworded; round 6’s Python worker had run the global mypy against its projects’ .venv Python, so the next round’s brief says the checkers are dev dependenciesRobertlockedround 7
Round 6 result, pre-registered, failed on all four predictions: Mo 51.0 min to Go’s 32.2 and Python’s 39.0 (1.58, P1); one shape-law loop (MO0302, the 500-line file) and five keyword or grammar loops (state twice, result, a case arm assignment, a fixture in a helper) against P2; no check in any language caught a real bug in either task, so the null hypothesis of chapter 8 stands (P3); Mo’s jobq 2,650 lines to Go’s 3,578 (0.74, P4), its program alone longer than Go’s; native throughput 399 lease-and-ack pairs a second to Go’s 858; verified by Fable in all three worktrees (control-run-6)Fablerecordedthe laws’ re-evaluation
semantic, for Robert: the laws re-evaluated against six rounds and two real programs: round 6 is the first round where a shape law cost a loop (the 500-line file, MO0302) and the first designed to let the checks earn one, and none did in any language; Fable recommends keeping the 70-line function law (max 20 in jobq, never near), demoting the 500-line file law to a warning mo check prints and mo fmt ignores, and making state, result, and old ordinary names everywhere but the positions the grammar reserves (state as a block and a bare name in update, old(...), result in ensures), as step 25 began for fields; nothing changes until Robert reads this rowFablefor Robertthe next round
semantic, for Robert: a never over T.all reads a var copy between two field assignments, so chapter 4’s own idiom for changing a struct trips a never that relates two fields (round 6’s logstat, one loop, a 20-line reproduction in its TOOLCHAIN-BUGS.md); Fable recommends that a never read a value only where it rests (a binding, a field, a return, a message), not a var between statements, which is what “the values the run held” meant; a step after Robert’s readingFablefor Robertthe step that builds it
From round 6’s Mo worker, to one small step: a string literal has no code-point escape and "\u0085" is read as five letters with no diagnostic (a \u{...} escape or MO0101 at an unknown escape); result as a parameter gets the bare “expected a name” where state and old get their sentence (step 26 missed it); Fs.fold_lines loses the fold at NotTextFableprovisionalthe step
Round 6 housekeeping: the Go and Python worktrees keep examples/programs/logstat/ (as every round has) and both copied its fixture, the Mo worker wrote its own, so the two logstat outputs are not the same numbers; the baselines wrote their own contracts packages (28 and 15 lines) since no library fit; the next round removes the Mo programs from every worktree and names the contracts library; no seventh round until a law or the never rule changes, since it would measure the same thingFable—the next round
Robert (14 Sep, afternoon): agrees with all three of Fable’s round 6 recommendations; the rows below are his callsRobertlockedstep 27, round 7
Robert: the 500-line file law is dropped (Fable had recommended a warning; chapter 2’s honesty laws forbid warnings, so the law goes rather than softens); MO0302 retired; the 70-line function law, the 6-parameter, nesting, and state-field laws stay; chapter 2 says so under “Session 6 changes”Robert, on Fable’s recommendationlockedstep 27, round 7
semantic, Robert: state, result, and old are ordinary names everywhere but the positions the grammar reserves: state as the block that declares a process’s state and as the bare name of it inside update, invariant, and a process’s functions; old( inside ensures and invariant; result inside ensures; elsewhere a parameter, a binding, a field, a for name, and a pattern may take them; step 25’s field rule is the first case of thisRobert, on Fable’s recommendationlockedstep 27, round 7
semantic, Robert: a never reads a value where it rests (a binding, a field, a return, a message, an assertion), never a var between two statements of one body, so chapter 4’s var copy = x then copy.field = v cannot trip a never that relates two fields; the runtime records a var when the body’s next statement is not an assignment to it, or at the body’s endRobert, on Fable’s recommendationlockedstep 27’s corpus file, round 7
Step 27 starts: the three calls above plus the small items (a \u{...} escape and MO0101 at an unknown escape; result’s keyword sentence; Fs.fold_lines at NotText); brief on interpreter-step-27; round 7 after it, with the Mo programs removed from every worktreeFable—step 27’s numbers
Robert (14 Sep, afternoon): the control run’s measure changes. Agent time to green, loops, and lines are not what Mo is for and are dropped as predictions: a model has never seen Mo, so it will take longer in it than in the languages that fill its training data, and that is expected. From round 7 the predictions are how fast the program runs and how much memory it holds natively against Go and Python, the feedback loop’s time (check, test, build), and the dependency count (third-party packages and tools; Mo 0 by construction, round 6’s Go 1, Python 3, a column round 6 never had). Agent time and loops stay recorded columns. Chapter 8 says so under “Session 6”. Round 6’s failed predictions stand as recorded under the old measureRobertlockedround 7
Robert (14 Sep, afternoon): reliability is the thing being optimized, agent time is not; round 7’s first prediction is a hidden defect suite: Fable writes an adversarial acceptance suite for jobq before any session starts (malformed bodies, a lease race, a crash mid-write and restart, 1,200 idle connections under load, a torn last line, wrong tokens), kept out of every worktree, run by Fable against the three finished programs, defects counted; the prediction is that Mo has the fewest; speed, memory, the feedback loop, and the dependency count follow itRobert, on Fable’s recommendationlockedround 7
Robert (14 Sep, afternoon): when Fable judges the toolchain ready, Mo reimplements an existing open-source tool or library with a clear spec and its own test suite, at real size, and the original suite is the oracle; Fable’s readiness rule: a program finishes with no new line in GAPS.md and no TOOLCHAIN-BUGS.md entry (program 5 and round 6 each added some), so program 6 is the first that can pass it; Fable’s candidates, to be chosen then: a CommonMark renderer (the spec’s 650 language-neutral tests, pure logic, 3–6k lines in the originals) for the parsing axis, and a Raft node (the paper, tested under --sim) for the process axis; the program page names the pickRobert; Fable decides whenlocked, waits on readinessprogram 7
Round 7 pre-registered on control-run-7 before any session: P1 the hidden defect suite (121 checks; run after the fact on round 6’s programs: Mo 0, Python 0, Go 1, all durable under a kill), P2 native speed and memory, P3 the feedback loop, P4 dependencies; agent time recorded only; the suite stays out of every worktree until the round startsFable—round 7
Step 27 accepted: a 606-line file checks and tests clean (MO0302 gone); state and result as parameters and bindings, old as an anonymous function’s parameter, in a plain function under mo test and as a test binary; state as a process’s parameter refused with a sentence that says where it is reserved; round 6’s Pair reproduction passes and a copy returned with one half moved still trips (test rejects), in both runtimes; "\u{85}" two bytes, "\u{1F600}" four, "\q" refused naming the escapes that exist; fold_lines over a file with one non-UTF-8 line folds three lines and counts the one holding U+FFFD, identical from mo run and the built binary; zig build test 185 of 185; stage rows within noise (lex 6.8 ms, parse 17.0, check 59.2 over 154 files); no function over 70 lines, the longest 48Fableacceptedround 7
semantic: the at-rest rule as built: a field write records the whole struct for T.all unless the next statement of the same body assigns the same root name; the last write in a run records; a write inside an if followed by another after the if still records in between; both backends; contracts/never-var-copy.moFable, from Opus’s defaultprovisionalround 7, program 6
Keyword positions as built: the lexer keeps the three tokens and the parser retags them as names everywhere but state inside a process (its parameters, state block, invariants, update), result inside an ensures, old inside an ensures or invariant; fields, named arguments, and pattern labels take all three anywhere; old(x) outside a contract still parses as the keyword, so a function-typed parameter named old cannot be called; binding result in a body under an ensures is accepted and the crash report then shows it twice (a small thing, to a later step)Fable, from Opus’s defaultsprovisionalround 7
fold_lines at a line that is not UTF-8: the line is handed on with U+FFFD for each byte that begins no character, no signature change (a NotText carrying the fold was not possible, FsError is not generic); a string knows \n \t \r \\ \" \# \u{X} and refuses any other backslash naming them; the grammar’s semantic-rules line still says 500 lines and the crash report for a wrong duration unit (1.second) says “second is a field of a type tier 2 cannot see” instead of naming the units, both to the next housekeeping stepFable, from Opus’s defaultsprovisionalround 7
The outside review of 14 Sep (outside-review-2026-09-14) filed with Fable’s response (outside-review-2026-09-14-response): three of its recommendations were built the same afternoon (the file law, the keywords, the never rule), one is wrong on facts (the C backend exists), seven are agreed and queued (the counted shape laws as project settings, for Robert; the try law reworded; the zero-dependency cost priced on a page; program 7 chosen for capabilities and the runtime surface; a closure column in round 7; a 5,000-module compile benchmark; the process as an artifact), two disagreed (a JSON verified: line; the Ruby framing); the fork (the runtime as the thesis) put to Robert as one questionFablerecordedprogram 7
For Robert: the counted shape laws (70 lines a function, 6 parameters, nesting 3, 12 state fields) become project-configurable settings with today’s defaults, still errors; the laws that remove a class of bug stay laws; Fable recommends yes, on the review’s argument that the counts carry the aesthetic and not the safetyFable, from the reviewfor Robertround 7’s reading
Robert (14 Sep, afternoon, on the outside review): the thesis is restated in chapter 1: Mo exists so that software written by agents is reliable and needs no third-party code; three layers carry it, the runtime and process model first, capabilities and recipes second, the language third as their surface; a law belongs in the language only when it removes a class of bug, and a rule that counts lines is a project setting; the control run’s competitor on the runtime layer is the BEAM; program 7 is chosen to depend on capabilities, recipes, and the runtime surfaceRobert, on Fable’s recommendationlockedprogram 7
From the reviewer’s reply (14 Sep, afternoon), taken: chapter 1’s null hypothesis is now the BEAM’s (Elixir and OTP already give most of the runtime layer; Mo’s delta is static types, capabilities, deadlines everywhere, one binary, no ecosystem to trust, the agent surface), with the language layer’s old null kept beneath it; the one-sentence thesis (the language makes the runtime’s guarantees visible in the source, the runtime makes the language’s observable at run time); the closure counterfactual measured by an audit of round 7’s Mo jobq counting named functions that exist only because a closure could not be stored or returned, with their lines, a second-worker experiment only if that number is large; the zero-dependency page states the fallback, a brick that wraps an existing C library inside the platform under audit, never application-level FFI; program 7’s shortlist is a Redis subset with streams and persistence, tested by Redis’s own socket-level suite, against an Erlang or Elixir implementation if one exists and otherwise Go, decided when program 6 passes the readiness bar; a reading pack for an OTP reviewer and a capability-systems reviewer, Robert to arrange themFable, on the reply; the thesis Robert’sprovisionalprogram 7
From the reviewer’s third message (14 Sep), taken: the closure audit gains a judgment column for sites shaped at a coarser altitude than a fluent Elixir or Rust author would choose, kept apart from the mechanical count; the zero-dependency page states an audit budget per brick (an initial audit and a version-bump re-audit, in hours, first estimates from the platform steps’ costs) and orders the shelf by program utility over audit cost; program 7’s operation set is pre-registered from Redis’s own test suite (streams, persistence, auth, pub/sub) before any session, the socket-level oracle named in the brief as the selection reason; the reading pack gains a “tried and rejected” appendix generated from the log’s overturned rowsFable, on the replyprovisionalprogram 7, the reading pack
Round 7 result, pre-registered on Robert’s measure, held on all four: defects 0, 0, 0 under the hidden suite (all three level, Mo’s worker had read the suite’s description); native Mo 981 lease-and-ack pairs a second at 32 workers to Go’s 478 and Python’s 467 on one client, 150 MiB at 100k jobs to 76 and 189, restart 3.7 s to 0.7 and 1.0; the loop 0.38 s to 18.7 and 8.7; dependencies 0, 1, 3; recorded: Mo 74.6 min to Go’s 36 and Python’s 39.1, 21 loops to 4 and 10; verified by Fable in all three worktrees (control-run-7)Fablerecordedstep 28, program 6
semantic: reliability under the suite is level across Mo, Go, and Python for the second program in two rounds; the difference Mo’s checks are meant to make has not shown on a job queue, and the next place it can is a program whose invariants are the point (the ledger) or a harder suite; no claim that Mo is more reliable is made until one showsFableprovisionalprogram 6
Round 7 housekeeping: the page describing a hidden suite is written after the worktrees are branched, as the suite is; the workers’ own load numbers are given but not compared, since their loaders differ (a connection a request doubled the Mo worker’s memory reading); Fable’s one client is the round’s instrument from now onFable—round 8
Step 28, from round 7’s Mo notes, the map write first: setting or removing a map key copies the whole map (22.7 s for 2,000 writes at 80k entries; every program with a growing map pays it); a reduce with a tuple accumulator copies it each step; resident memory grows past the regions and MemoryInfo does not see it; the never at-rest rule’s gap when the second write sits inside an if; replay’s speed (15 s for 1M records native to Go’s 4.8); and the six gaps (Fs.list kinds, a thousands separator, an unread lambda parameter as _, seconds on an integer and a check-time diagnostic for a wrong unit, Option.map, a fixture clock that moves under the simulator)Fable—step 28’s numbers
The closure audit (closure-audit-2026-09-14) over round 7’s Mo jobq: direction 31 cost 12 lines of 2,843 (13 eta-expansions, one flag pair, one fold-accumulator struct); the actor reply idiom is where a callback language would store closures and costs nothing against Elixir or Rust; the judgment column found 18 lines the stdlib already covers (Map.update unused); d31 stands, the ledger is the second sampleFable, from the reader’s auditrecordedprogram 6
For Robert: chapter 3 says “named functions are first-class values” and the stdlib chapter says “a signature cannot name a function type”; the toolchain lets neither happen (a named function cannot be passed by name anywhere); Fable recommends the narrow reading: a named function may be passed by name where an anonymous function goes (xs.map(shown)), a signature still cannot name a function type, so nothing can be stored or returned and d31 stands; chapter 3’s sentence narrowed to that; built in the step after 28Fable, from the auditfor Robertthe step that builds it
Program 6 specified (spec/programs/06-ledger.md) and its brief written (program-6): a double-entry ledger over HTTP on the store recipe with holds that expire by a delayed Expire or at the next look, captures, releases, refunds, settlement, and idempotency keys; seven nevers over history, four invariants each of which a message can trip, ensures on every move, a planted-bug test that shows which check catches a transfer written as two records; measured on Robert’s measure in round 8 against Go and Python; starts after step 28Fable—program 6’s numbers
Step 28 accepted: a map held by one owner is written in place in both runtimes (Fable’s probe: 80k entries and 2,000 overwrites plus 2,000 removes inside an update in 0.09 s interpreted and 0.03 s native, 400k and 20,000 in 0.41 s, the values read back; the worker’s rows 47 s → 0.13 s interpreted, 21 s → 5 ms native); a tuple accumulator over 100k items in 0.05 s; round 7’s logstat Tally shape with a write inside an if no longer trips its never, under mo test and as a test binary; Fs.list_kinds, String.grouped, _ as a lambda parameter, 10.seconds with 1.second refused at check time naming the units, Option.map, and the fixture clock that moves, each from mo run and a binary; zig build test 186 of 186; the round 7 Mo jobq rebuilt on the new toolchain and measured with the round’s client: 944 pairs a second at 32 workers (981 before, noise), 159 MiB at 100k jobs (150), restart 3.3 s (3.7) and 57 MiB after it (181), the defect suite 121 of 121Fableacceptedprogram 6
semantic: ownership as built (step 28, moves.zig, shared by both backends): a local’s last read, or the one read of a place on the right of an assignment to it, hands the value on; every other read of a map, set, struct, tuple, or variant gives its claim up; lists, map keys and values, sets, messages, and captures never hold a buffer alone, structs, tuples, variants, and accumulators do; a function with an ensures and a process’s state, message, and parameters never hand theirs on; remove moves later entries down in place with an undo a crash takes backFable, from Opus’s defaultsprovisionalprogram 6
semantic: the never at-rest rule looks through the arms of an if or case and past a branch’s end for the next write of the same name; a condition, subject, or guard naming it keeps the earlier write at restFable, from Opus’s defaultprovisionalprogram 6
Memory as measured: regions now give pages back past their top after an update and after a large compaction; MemoryInfo gains region_resident_bytes; what remains outside the regions at 100k jobs (about 100 MiB, swinging 170–270 MiB run to run) is packed message buffers Zig’s allocator keeps after they are freed, measured and left; memory after a 1M-record replay 392 → 102 MiB interpreted, 183 → 57 native; replay 63.9 → 43.1 s native, its split compaction 50%, map sets 22%, string slicing 20%Fable, from the worker’s numbersprovisionalprogram 6, round 8
Stdlib defaults ratified: Fs.list_kinds beside list (a link counts as what it points at); String.grouped(n); MO0208 names ms, seconds, minute, days for any unknown member on an integer; Clock.fixture().now is Time.fixture() plus the simulator’s time, frozen inside an update; two rows that slowed, reuse-map-remove-100k interpreted 76 → 97 ms and http-1k interpreted 37 → 51 ms, recorded; grammar.md’s “500 lines” and “frozen” sentences fixed by FableFable, from Opus’s defaultsprovisionalround 8
Program 6 accepted: ledger in 92 minutes, 14 modules, 315 functions, 4,430 lines; zig build test 186 of 186 with it in the corpus; the five run lines identical under both runtimes; mo check --recipe green on the store (11 signatures, 8 tests); every process test under 100 seeds with faults; Fable’s 35-check HTTP session green under mo run and as a binary (accounts, a transfer within and past an overdraft, cross-currency refused, no key 400, no token 401, a retry with the same key answered identically and a different body 409, a hold reducing available, a capture over the hold refused and within it taken, a release after capture 409, refunds up to and past what remains, a hold expiring by the delayed message, a capture of an expired hold 409 with a release entry marked expired, 32 captures and releases racing with exactly one 201, balances summing to zero, a settlement, a kill under load with balances equal to the postings after replay); native 1,168 transfers a second at 32 clients, 654 at 1; 198 MB at 100k entriesFableacceptedround 8
semantic: the check that earned its keep, strictly, for the third program in a row: none. The ledger’s four invariants are all kept and three are tripped by a test rejects over a torn or doubled log, and the planted bug (a transfer written as two records) is caught by the never “money is created or destroyed” and by the first invariant on open; but the worker’s own tests would have caught every real bug it found (a settlement retry answering the wrong body; a hold’s Expire sent after the flush, found by a test written to probe the invariant, and harmless since the next look released it); batches of one, the throughput bug, was caught by no check and no test, only by the load run. The round 7 row stands: a difference Mo’s checks make has not shown on a job queue or a ledger; round 8 puts the ledger under the hidden suite against Go and Python, and the reading after it decides what the checks are forFableprovisional, for Robertround 8
semantic, a runtime bug, from the ledger: a process whose supervisor line says restart: :never is restarted after a crash under both mo run and mo test, so a fail-stop journal would come back empty and forget its book; chapter 3’s “say restart: :never and mean it” is not what the runtime does; a reproduction is in programs/ledger/TOOLCHAIN-BUGS.md; to the next runtime step, firstFable, from the worker’s noteprovisional, flaggedthe next runtime step
Runtime findings from the ledger, to the next runtime step: platform.exit does not end a program while a delayed send is pending (the check hung until its holds were shortened); replay of a journal grows faster than the log (100k entries 12.4 s and 198 MB native, 500k 126 s and 1.38 GB, 1M killed at 4.2 GB) because the whole replay runs inside one Open update and nothing it builds is freed until the update ends; under mo test simulated time jumps to the next delayed send at every statement boundary, so an hour-long hold expires between two statementsFable, from the worker’s notesprovisionalthe next runtime step
Ledger defaults ratified: a capture credits a per-currency clearing account (clearing:USD, not an a_ account, shown in statements); hold, release, and settlement entries carry no postings; an idempotency key is compared on method, path, and body, with 201, 404, 409, and 422 recorded and 400, 401, 405, 503 not; a release takes an optional reason, an expiry’s is “expired”; settling a day not begun is 422, one already settled 409; every answer, reads included, waits for the flush that covers it, and a refused batch answers every call 503 and puts the book back; a hold’s Expire is sent when the hold is staged; the journal is fail-stop (restart: :never, which the runtime does not yet honour); group commit as two asks, stage then collect in the worker’s next update (1.00 → 1.46 calls a batch, 704 → 1,168 transfers a second); the fourth invariant kept though no message can trip it now, against the spec’s rule, a row for the readingFable, from Opus’s defaultsprovisionalround 8
Robert (15 Sep, night): after Fable’s forest-and-trees reading of the first three days, go with Fable’s recommendations and order; the roadmap’s “Where we are” rewritten: step 29 (the runtime honest), step 30 (processes on every core), round 8 as a maintenance round, the bricks page, the language items, the scale benchmark, then program 7Robertlockedround 8’s reading
Robert, on Fable’s recommendation: the counted shape laws (70 lines a function, 6 parameters, nesting 3, 12 state fields) become project-configurable settings with today’s defaults, still errors; the laws that remove a class of bug stay lawsRobertlockedthe language step after round 8
Robert, on Fable’s recommendation: a named function may be passed by name where an anonymous function goes; a signature still cannot name a function type; chapter 3’s sentence narrowed to thatRobertlockedthe language step after round 8
semantic, Robert, on Fable’s reading: “no check earned its keep” after six programs is read as an untested claim, not a refuted one: every program so far was written once and never changed, and the laws exist for the second agent; round 8 becomes a maintenance round (a finished program, a changed spec, a fresh agent, a second hidden suite, regressions counted, in all three languages); if Mo’s checks catch no more there, the reliability claim is dropped from the thesis and Mo stands on the loop, dependencies, and the runtimeRobert, on Fable’s recommendationlockedround 8
Step 29 accepted, the runtime honest: five commits (A–E), green at each, the suite green and mo fmt --check clean at the end, about 2 h 47 min of worker time, most of it measurement. Fable’s probes, none the brief named: a supervisor with a :never child and an :always sibling crashed the same way, under mo run, as a binary, under mo test, and under --sim 100: the :never child answers Down to every ask after its crash and to one after a send, the sibling comes back with a fresh state, and only the :never child’s report ends “not restarted”; two processes holding delayed sends two hours and a minute away, platform.exit(5) ending the program in 0.00 s with code 5 under both runtimes; a message five minutes away still pending across three statements and arrived once the test waited the five minutes in a fixture, under mo test, --sim 100, and as a test binary; the ledger journal under --sim 100 reading invariants (kept 4, tripped 3) with the untripped one named; Fable’s own 100k-entry ledger log driven over HTTP (200 accounts, 32 clients, 69 MB) replayed native in 5.0 s at a 200 MiB peak, three runs, and the same session’s log at 1M entries (701 MB, 200 accounts) replayed native to 1,111 MiB at 75 s and 8,163 MiB at 90 s, killed past 9 GB at 101 s, after the fold ended and rebuilt began, where the live server that wrote it sat at 1,586 MiB: the brief’s memory bound is unmet on a real log, to step 29bFableaccepted for A, B, D, E; part C’s speed accepted and its memory bound openstep 29b
semantic: a process Name.start begins takes its whole policy from the first child line naming it, restart: included (it took only max_restarts before, so every child restarted); a :never child that crashes stays down in both runtimes and the simulator, its report ends “not restarted: says restart: :never, so stays down”, the messages waiting for it are dropped with events, a waiting ask and every later one answer Down, and a later send is dropped with a Dropped eventFable, from Opus’s defaultprovisionalprogram 7
semantic: platform.exit(code) takes effect when main returns, as chapter 9 already said: from then on what a mailbox already holds is delivered, nothing waits on the clock or the network, every pending delayed send and any sent meanwhile is dropped with a Dropped event whose why is “exited”, listeners are closed, and the code is kept; both runtimes; the ledger’s check holds live an hour again and its check still ends within half a secondFable, from Opus’s defaultprovisionalprogram 7
semantic: under mo test, simulated time passes to a delayed send only while the test waits (a fixture call with a delay, an ask whose deadline passes, a paused or busy target included, Http.fixture()’s send) and at the test’s end, never at a settle between two statements; the ledger’s gap line is closed and processes/timer.mo holds a message an hour away across two statements; the test’s end and the paused-target ask are the worker’s two additions to the brief’s listFable, from Opus’s defaultprovisionalround 8
The verified: line’s sim clause counts invariants: sim (N runs, invariants (kept n, tripped m)), the tested file’s own invariants only, under --sim only, a trip counted when a seeded test rejects stops on that invariant, each invariant printed as tripped (by which message, seed, and test) or “kept, and no seed’s message tripped it in a test rejects”, the clause omitted for a file with none, the test binary’s line unchanged, mo check unchanged; chapter 5’s vocabulary gains the clause (Fable); the ledger’s journal reads kept 4, tripped 3, the count program 6 made by handFable, from Opus’s defaultprovisionalround 8’s reading of invariant
Event.Dropped(at, sender, sender_name, target, name, taking, why) is a prelude variant, why “down” or “exited”, in chapter 9 and PRELUDE.mdFable, from Opus’s defaultprovisionalprogram 7
Replay was the runtime’s fix, not the ledger’s: 91% of a replay was compaction copying the whole accumulator at every step, so reduce and fold_lines now compact in generations in both runtimes (only what the accumulator reaches past the last compaction is copied; a minor compaction when the young bytes pass a quarter of the old, a major when the old has doubled; scratch pages released after a large copy; a 1.5× major trigger bought 2.5% of peak for 17% of time and was not kept); the ledger’s replay native 100k 35.4 → 7.8 s, 500k 260.5 → 35.6, 1M 715.6 → 81.2; 100k interpreted 511.5 → 169.2; peak memory unchanged (203, 1,087, 2,490 MiB) and now linear in the log where it grew faster than it before; the bench’s replay-1m 196 → 212 s interpreted and 43.1 → 42.4 native, http-1k interpreted 35 → 40 ms inside its known swingFable, from Opus’s defaultprovisionalstep 30’s ledger rows
The ledger’s replay peak is the program’s, not the runtime’s: its book keeps every entry, so a 1M replay holds about 2.5 KB an entry live and a peak of 2.5 GB; the runtime no longer holds anything the update no longer reaches; a ledger that pages its history is a program-shape choice, left until a program needs it; the brief’s “bounded” is read as bounded by the live data, said plainlyFableprovisionalprogram 7
Observed by Fable’s probe, not decided: a test rejects whose process crashes on an integer overflow fails with the crash report rather than passing as a rejection, where the same test with an invariant trip passes; whether an overflow is a rejection or a defect goes to the language step’s reading of chapter 2’s try lawFableopenthe language step
semantic: what an update makes and no longer reaches is freed while the update runs, in every loop shape, not only reduce and fold_lines: the rule step 29 half-built and Fable’s real-log probe found wanting (a phase after the fold making 7 GB in fifteen seconds on a book of 1.6 GB); step 29b finds the phase and makes the rule hold, or shows the growth is the program’s and adds what would have shown it; the evidence log and the instrument are kept in ../mo-lang-replay-1m/, never deletedFableprovisionalstep 29b
Step 29b accepted, replay memory on a real log: three commits (A, B, C), green at each, the suite green and mo fmt --check clean at the end, about 4 h 40 min of worker time, most of it three measurement rounds. Where the memory went (part A): a process region reserved 1 GiB and moved to a larger one only between updates; the journal’s Open is one update, rebuilt’s last reduce filled the region at 77 s, and from then every allocation came from malloc, which no compaction frees, at about 650 MiB a second; the step-29 worker’s generated log stopped 55 MiB short of the reservation. Fable’s probes: the evidence log’s 1M replay native, twice, 97.2 and 95.1 s at a 2,323 MiB peak settling at 1,057 MiB, where before it was killed past 9 GB three times; Fable’s 100k HTTP-written log under mo run in 49.0 s at 471 MiB; the suite green. The worker’s rows: evidence 1M 94.8 s and 2,323 MiB; generated 1M 81.2 → 80.3 s and 2,490 → 2,153 MiB; the interpreted 100k 168.1 → 144.8 s; kv, http, logstat within noise; transfers a second 1,335 → 1,370; a recursion 9,000 deep 89 → 4 MiB native and 589 → 47 under mo run; the ledger’s program unchangedFableacceptedstep 30, program 7
semantic: memory is bounded by what the program still reaches inside one update as between two: at every loop step, every step of a row that folds or maps, every call made as a whole statement, and every return, what no frame on the stack still reaches is freed; a call made as a whole statement is a safe point where the frames waiting in such calls are compacted together (the walk); in C the point is the whole-statement call because temporaries are not visible elsewhere, in the interpreter every direct call; a frame reading its closure’s captures ends a walk; the sentence is in chapter 3’s Processes listFable, from Opus’s defaultprovisionalstep 30, where a scheduler per core walks its own frames
semantic: a process’s values have 64 GiB of address space while every live process’s together stays under 16 TiB, and 1 GiB past that (step 21’s 65,530 idle processes still fit), moved into a larger reservation between updates; every reservation is MAP_NORESERVE where the platform has it and nothing is set where it does not (macOS); what an update allocates past its reservation is never freed and is counted as spilled on the MO_STATS=1 line in both runtimes; the interpreter allocates past a full region as the binary does instead of failing the update with OutOfMemoryFable, from Opus’s defaultprovisionalthe Mac’s next suite run, step 30
The walk’s cost, measured and kept: it fires once the region has grown past the outermost reachable frame’s mark by more than twice what is known live there plus 1 MiB (the first trigger, counting bytes allocated anywhere, cost 13% of the replay); C frames copy their roots into the frame record at such a call and read them back only after a walk (exposing every local’s address cost 2%); a compaction no longer copies each view of a pushed list separately (depth-squared copies, found by the walk’s test); the copy’s lookup order differs per runtime, the forward table first in the interpreter and the growth table first in C, each the other way costing 9% and 4%; interpreter frame locals live in chunks kept for the vm’s life (the mo run replay’s peak 482 → 510 MiB); a -DMO_STRESS build sets every C budget to 0 and gives the ledger check’s output unchangedFable, from Opus’s defaultprovisionalstep 30
Robert (15 Sep, morning), direction 41: the worker in every program and control round has been Opus; rerun the control run’s measures with smaller, cheaper models, open-weights ones included, to see how much of Mo’s standing against Go and Python is the model’s. Fable’s reading: native speed, memory, and the dependency count are the toolchain’s and do not move with the model; reliability under the hidden suite and the loop count do, and a weaker model that makes more mistakes is where the checks would first earn their keep, so this is a stronger test of the thesis than another Opus round; queued as round 9 after round 8, pre-registered with the same task and suite, unless Robert wants it before round 8Robert; Fable’s readingfor Robert: the orderround 9’s pre-registration
Robert (15 Sep, midday): the small-model round runs after round 8, as round 9, and tests several models of different sizes, open-weights models among them, not Haiku alone; Fable pre-registers it on plans/control-run-9.md with one row per model, the same task and hidden suite for all, and the drivers Herdr already has for other agents (opencode, pi, kimi, hermes, codex, gemini, grok among its kinds); how the open-weights models are served (a hosted API or a local server, this VM having 4 cores and 16 GB) is the next question for himRobertlockedround 9’s pre-registration
Robert (15 Sep, midday), round 9’s harness and models: every model runs in the Pi harness (Herdr kind pi, on this machine at 0.83.0), chosen for its small system prompt, so the measure is close to the raw model; the models come from his Grok and Codex subscriptions and his Ollama cloud subscription (any open-weights model there, over its API); nothing runs on this VM; smaller open-weights models can run locally on his MacBook Pro (96 GB); Fable proposes the model list, one row each on plans/control-run-9.md, with the round’s Opus baseline rerun in Pi too so the harness is held constantRobertlockedround 9’s pre-registration
Robert (15 Sep, midday): after round 8 is read and recorded, the lead pauses; Robert and a fresh Fable session plan round 9 together (the model list, the panes, the predictions); no item after round 8 starts before that; and this session ends now with the handoff rewritten whole for a fresh sessionRobertlockedround 8’s report
Robert (15 Sep, midday): step 30, processes on every core, runs before round 8, as the roadmap orders; round 8’s speed and memory columns compare Mo on every coreRobertlockedround 8
semantic, Robert (15 Sep, 14:55 and 15:05): step 30’s multi-core tests and measurements also run on his MacBook Pro (M3 Max, 14 cores: 10 performance and 4 efficiency, 96 GB); the question there is scaling, how Mo performs on all fourteen cores against one on the same machine and where the curve stops, not a comparison with the VM’s four (a side row at most); the VM stays the primary machine for acceptanceRobertopenstep 30’s acceptance, then a Mac run of the suite and the part D drivers at MO_CORES 1, 4, 10, 14
semantic, Robert (15 Sep, 17:45), revising the locked row of 15 Sep morning on Fable’s reading: Mo’s claim is the conjunction, reliability at zero dependencies, so round 8 is read on both columns together, not on defects alone. The baselines keep their bolted-on checks (Go: vet, staticcheck; Python: mypy --strict, ruff, pydantic), since beating an unchecked language would prove nothing; but their reliability is bought with packages nobody read, which is what Mo refuses to spend. The rule: Mo keeps the reliability claim if it matches the checked baselines on regressions and defects while needing none of what they needed; Mo loses it if a baseline is more reliable, or as reliable at zero run-time dependencies too. Go with the stdlib and one build tool is therefore the comparison that decides, and if it matches Mo, Mo’s delta over Go is the runtime, the loop, and the process model, not the checksRobert, on Fable’s recommendationlockedround 8’s reading
Robert (15 Sep, 19:30): the Mac scaling run (MO_CORES 1, 4, 10, 14 on the M3 Max) runs in parallel with round 8, whenever the laptop is free; it does not gate round 8, which measures on the VMRobert, on Fable’s recommendationlockedthe Mac run’s table beside step 30’s
semantic, Robert (15 Sep, 19:40), on Fable’s recommendation: round 10 is the Elixir round (d42-elixir-round), after round 9: the BEAM null hypothesis has only been argued, never run; round 7’s job queue and round 8’s change in Elixir with dialyzer, credo, and ExUnit, one fresh agent, the same hidden suites, read on reliability, the loop, dependencies, and the runtime rows Mo claims as its delta; the pause after round 8 reads against it and writes its planRobert, on Fable’s recommendationlockedround 10’s plan page
semantic, Robert (15 Sep, 19:55): the order is runtime first, the language held steady as the instrument, then the language revised to what the runtime proved. Rounds and probes may keep adding runtime hypotheses and tests after round 8 if the results disappoint, a failed hypothesis gets a new one, not a rescue; the language step is a design page, “The language after the rounds”, Fable writes at the pause, one section per candidate change with its evidence row, its cost, and code options, and no change to the language without a control-run row behind itRobert, on Fable’s recommendationlockedthe design page at the pause after round 8
semantic, step 30 accepted (15 Sep, 20:05): a Mo program runs its processes on every core, a process on one scheduler for its life, an update one transaction on one thread, nothing shared, a message a copy; MO_CORES=1 is step 29b’s runtime; the store’s Ok still means on disk, with the write and its fsync on a pool of four threads while the caller waits holding no schedulerFable, on the worker’s five commits and the probes in interpreter-step-30acceptedthe corpus at 1 and 4 cores, the kill under load at 4 cores, the 1M replay, all passed
semantic, from Opus’s default: one runtime lock over the shared tables (processes, delayed sends, pending asks, events, sockets) rather than a lock per mailbox, since a send, an ask, and a commit each touch several of them; Mo code and the region compaction run without itFable ratifiedacceptedthe 8-cruncher probe (3.7× at 4 cores) and the asks-across-schedulers cost (3.4× one scheduler), the number a later step lowers
semantic, from Opus’s default: a sweep waits for every update in progress to park or end (at most 20 ms, then a retry 100 ms later) before counting handles, instead of reference counts; missed sweeps show in MO_STATS; chosen after a stop-the-world that waited only for threads outside Mo code missed a handle held in a C localFable ratifiedacceptedthe 200,000 short-lived processes probe, all freed at every setting
semantic, from Opus’s default: main’s code runs holding the lock and main’s settle waits for every scheduler to rest, so main’s sends are still delivered before its next statement; a cross-scheduler ask that waits on itself is Timeout at once, found by following the chain of asksFable ratifiedacceptedthe corpus at 4 cores; the 1M replay’s 15 percent cost at 4 cores is this rule’s price for a one-process program
From Opus’s default: a process’s ids and its Vm’s memory stay on its scheduler, ends freed by that scheduler; an idle scheduler spins about 2,000 pauses and looks at its poller every 64 (and, after the spin fix, at its sockets); the blocking pool is threads with an eventfd per write, not io_uring, so it works the same on macOS; only write and append moved off the schedulerFable ratifiedacceptedthe Mac run
semantic, for Robert: programs/agent’s check depends on arrival order (several runs share one mock that hands out replies as requests arrive), which the spec never promised, so the corpus test runs that one program at MO_CORES=1 (corpus.zig, one_core_programs), its source untouched. Fable’s reading: the pin stays; the program’s check is the thing to fix, in the language step or program 7’s cleanup, so that no corpus file needs one coreFable, ratified from Opus’s defaultaccepteda later brief that makes agent’s check order-independent and empties one_core_programs
semantic, for round 8: the queue is fsync-bound on this VM’s disk (one service process syncs each change; about 990 syncs a second, 1.01 ms mean), so the pairs row does not move with cores, and step 29b’s binary makes 353 pairs a second today against round 7’s 981, so round 7’s speed rows were not measured under today’s disk. Round 8 reruns Go and Python on the same disk the same day before Mo’s row is read; no speed row from round 7 is reusedFablelockedround 8’s plan page
Carried, for a later step: the interpreter holds about 780 KB per process at rest (7.78 GB for 10,000; native 130 MiB in all), identical at step 29b and real anonymous memory under ps; with the crash report’s 1 MB and the one-core update that keeps thousands of started processes alive, this is the interpreter’s memory step, after round 8Fableopena brief with a number: 10,000 processes at rest under 200 MiB interpreted
For Robert: Fable’s five measurements (d43-five-measurements): bodies as cache (spec completeness), sampling as verification, the erosion round, the incident round, tokens read per correct change and first-fix rate per diagnostic as columns of every round; the unfamiliarity tax named as the risk against the thesis, with a sharper test (the same agent writes the same program twice). Fable’s order: 1 and 3 at the pause after round 8, 5 from round 8 on. Asked which would change his mind most if it came out against Mo, Robert (15 Sep, 21:30): not sure; Fable’s answer, bodies as cache, orders the fiveFableacceptedround 8 (column 5), then the pause
semantic, Robert (15 Sep, 20:40): measurement 1 of direction 43, bodies as cache, runs on all six programs, two runs each (tests kept; tests stripped, contracts and intents only), one fresh agent per module seeing only its stripped module and its imports’ stripped signatures, judged by each program’s hidden suite or check; the numbers are spec completeness per program (fraction of modules whose regenerated bodies pass) and hidden defects in the assembled program. Fable’s predictions: with tests above 0.8, without below 0.5. A different model regenerating (round 9’s harness) is the cleaner version and followsRobert, on Fable’s proposallockeda plan page plans/bodies-as-cache.md at the pause after round 8; the ledger first
Measurement 2 of direction 43, sampling as verification, runs before round 8, in a pane while Fable writes round 8’s spec and plan: one module with a real algorithm (the ledger’s journal compaction or the queue’s lease and retry logic), five fresh Opus regenerations from the stripped spec, a driver feeding all five the same random operation sequences, every disagreement read as a defect or a spec hole, compared with the hidden suite’s defects in that module. If it finds defects, round 8’s pre-registration gains disagreement as a fourth oracle on the changed modules. Prediction: at least half the suite’s defects, plus two or three holesFable’s recommendation, Robert asked for it (15 Sep, 20:50)acceptedplans/sampling-as-verification.md, run before round 8
semantic, measurement 3 of direction 43, the erosion round: round 8 is generation one; Fable writes and seals all ten change specs before any session, Robert reads them first; a fresh agent per generation per language sees only the current program and its change; after every generation round 7’s suite, that generation’s hidden suite, the loop, the dependency count, tokens read. Run five generations, then continue to ten under a rule fixed now: stop at five only if all three languages show zero defects and zero regressions at every generation, in which case the change sequence is rewritten harder, not the laws declared useless; otherwise run to ten with no re-reading of the sealed changes. Prediction: Go and Python at least three latent defects each by generation ten, Mo at most oneFable’s recommendation, Robert asked for it (15 Sep, 21:00)acceptedplans/erosion-round.md at the pause after round 8
Measurement 4 of direction 43, the incident round: two fresh agents per incident, neither shown the code first, one with logs and crash text, one with the event ring, the runtime surface’s process table, and a seeded replay; time to the right diagnosis, fix right first time, tokens read. Real incidents count (the worktrees’ bug notes and the programs’ toolchain bugs: the torn log under a kill, the mailbox flood to 3 GB, the crash report’s cost, the sweep that missed a C-local handle); planted faults calibrate the instrument only and never count toward the prediction. Decides whether directions 38 and 40 are built or cut. Prediction: fix right first time in most incidents from the ring, under half from logsFable’s recommendation, Robert asked for it (15 Sep, 21:10)acceptedplans/incident-round.md, after program 7 or a ledger incident; two planted faults first to test the harness
Measurement 5 of direction 43: tokens read per correct change and first-fix rate per diagnostic are standing columns of the measure (chapter 8) from round 8 on, recorded in every round, never part of the reading rule; a diagnostic under 0.7 with ten or more sightings is rewrittenFable’s recommendation, Robert asked for it (15 Sep, 21:20)lockedround 8’s plan page and its report
Measurement 2 run and read (15 Sep, 20:30 to 22:10): five fresh Opus regenerations of round 7’s Jobq.Board from its stripped spec (signatures, contracts, intent, never, ten tests) are behaviourally identical to each other and to the original over 132,000 random operations through a frozen harness; round 7’s suite finds 0 defects in every one; the only disagreement is on a hand-written log holding a queued job at its max_attempts, where the original, v1, and v3 crash the queue process at the first lease and v2, v4, v5 pass the job over. P1 held, P2 unread, P3 failed (one hole, and from a directed probe), P4 mostly. Read: the spec is complete for this module (completeness 1.0, the first evidence for measurement 1); sampling verifies only the space the spec does not pin, and a random API driver does not reach it (sampling-as-verification)Fableacceptedmeasurement 1, bodies as cache, on the ledger’s compaction
semantic: round 8’s fourth oracle is not a random driver but the workers’ “decisions the spec did not cover” lists, read for inputs the suites do not send and played through all three programs after the suites; the pre-registration on control-run-8 says soFable, from measurement 2’s resultacceptedround 8’s reading
semantic, for the spec (01-job-queue.md, next revision): a log record in an impossible state (a queued job whose attempts equal its max_attempts) is refused at open like a record that is not a job, never left to crash a process at its first lease; the original round 7 queue does the latter, half of the regenerations skip the job, the spec said nothingFable’s recommendationprovisionalthe erosion round’s change list, or measurement 1’s ledger run
For the toolchain, from measurement 5’s first column: every regeneration lost one loop of three to MO0317 on the dependents of a changed module (the verified: lines of api, queue, server, main, sampler went stale together and had to be rewritten one module at a time in dependency order; first fix wrong once in five). The diagnostic should name the module that changed and the one --write order. First-fix rates recorded: MO0101 5/5, MO0501 4/4, MO0212 2/2, MO0201 2/2, MO0317 4/5Fableprovisionalthe diagnostics step after round 8 (chapter 8’s rule: under 0.7 with ten sightings)
Round 8’s setup, 15 Sep evening: the change spec spec/programs/01b-job-queue-change.md (scheduled jobs and retry backoff, a /retry route, attempts/max_attempts renamed tries/max_tries, the old log replayed); the pre-registration on control-run-8 with five predictions and Fable’s guesses; worktrees ../mo-lang-control8-{mo,go,python} (Mo from main after step 30 with round 7’s queue and sidecar entries swapped in, green under step 30; Go and Python from their round 7 branches with the toolchain, corpus, and wiki removed; the two spec pages at spec/ in each); both suites written after the branching and smoke-tested on the round 7 programs (control-run-8-suite/regressions.py is round 7’s with the names changed, defects.py is new and takes --old-serve to have the round 7 service write the old log itself)Fableacceptedthe three sessions
semantic: round 8 read (15 Sep, 23:35): held on all five predictions. Regressions 0/0/0, defects 0/1/0 (Go’s null taken as absent), speed 1,420 pairs a second against 428 and 325 with memory at 1.4× Go’s, the loop 0.81 s against 14.4 and 7.5, dependencies 0/0 against 0/1 and 1/2. The conjunction, reliability at zero dependencies, survives the maintenance round; evidence that the laws made the second agent safer is still none: no check in any language caught a change-induced bug, Mo’s never cost two loops as a false positive, and the Mo maintainer took 2.2× Go’s wall-clock, 1.9× its tokens, and 9 loops to 8 and 6 (control-run-8)Fableaccepted, for Robertthe erosion round’s generation two
semantic, for Robert: the fourth oracle’s outage. A log record in an impossible state (a queued job at its max_tries) is refused at open by Go’s and Python’s bolted-on invariants; the changed Mo queue opens it and on the first lease its queue process crashes on a requires and the whole service stops answering, /health included, with no restart and no refusal. Whether that is the program’s supervision or the runtime’s is the first question of the pause; the spec’s next revision says a replayed record that trips a contract refuses the folder at openFableopen, for Robertthe pause: a probe of the acceptor’s supervision under a crashed queue, then a spec row
Recorded for chapter 8’s standing columns (measurement 5), first round: tokens read per correct change Mo about 347k, Go about 180k, Python unread (its pane was closed before a readable /context; next round the panes are widened before the sessions start); first-fix rates across measurement 2 and round 8: MO0101 5/5, MO0501 4/4, MO0212 2/2, MO0201 2/2, MO0317 6/7, MO0303 1/1, MO0002 1/1, MO0403 1/1Fableacceptedround 9
One check of round 8’s defect suite (runout) was amended after Go’s run and before the reading: it took one of two readings the spec allows for when a run-out lease’s backoff is dated; the amended check was rerun on all three and passed on all three. Disclosed on the pageFableaccepted—
From the Mo maintainer’s decisions, two rows for later: data/compact/jobq.log committed in the new shape so the corpus # run: compact stays idempotent (the old-log coverage moved to data/demo and the tests); one queue test passes only without --sim faults because injected waits move the fixture clock (TOOLCHAIN-BUGS.md’s “frozen fixture clock” entry is stale, the maintainer says, and left it alone)Fable, from Opus’s defaultsprovisionalthe erosion round’s next generation
Robert (15 Sep, 23:55): Fable makes the decisions and keeps the work moving; never stop to ask him, even at a planned pause; a question is a row, not a wait. Supersedes the “one question per message” habit where it would stall the workRobertlockedevery session from here
semantic, the outage probed (16 Sep, 00:05; control-run-8 Result): the queue crashed on purpose under mo run and as a binary, then every request, /health included, timed out and no restart came. It is the program’s by chapter 3 as written: the queue is a :never child, so a send to it is dropped with a Dropped event and an ask is Down; the worker answers a request by send(Want) and waiting for a Done message, a wait with no deadline that the deadline law does not see, and the acceptor keeps accepting. Two program fixes exist without a language change (a worker that asks with reply_by and answers 503 on Down or Timeout; a queue that replays the store in its own start so it can be :always), and the spec’s next revision says a replayed record that trips a contract refuses the folder at open. The language row, for 10-language-after-the-rounds.md (then numbered 09-): a reply awaited as a message is a wait the law does not bound; code options thereFableaccepted, for Robertthe erosion round’s change 2, which is this incident’s fix; the language page
Round 10 brought forward to the night of 15–16 Sep and run: Elixir 1.18 on OTP 27 installed through mise; one fresh Opus session wrote the queue from the round 7 spec (31 min, 14 loops), a second made round 8’s change (16 min, 7 loops); both suites, the measure, and the fourth oracle run (control-run-10)Fable, while Robert sleptaccepted—
semantic, for Robert: the BEAM row after round 10. Elixir: 2 defect causes under round 7’s suite (a token with a space; a torn last line dropped on read but not cut from the file, so the next run corrupts the log), 0 regressions and the same torn cause under the change’s suite; 2,870 pairs a second at 32 workers, twice Mo’s binary, at 237 MiB against 113; the loop 6.99 s against 0.81; zero run-time dependencies (OTP 27’s :json), so the dependency column ties Mo; written in half Mo’s round 7 time. The null hypothesis is alive: Mo’s earned rows are reliability and the loop, the BEAM’s are speed, time to write, and the dependency tie; P6, a crashed process with the service still answering, is unprobed on Elixir and was an outage on Mo in round 8, and is the first probe of the morningFableaccepted, for Robertthe P6 probe (kill the Elixir queue process from outside; Mo’s change 2)
From round 10’s fourth oracle, for the spec: a retry sent with a body is ignored (three of four) not refused; a record in an impossible state is refused at open (change 2 already says so). For the language page: the torn-line durability defect is the class round 7’s never at rest on store.mo catches, and Elixir has nowhere to state itFableprovisionalchange 2 on the Elixir program; the language page
semantic, for Robert: measurement 1, bodies as cache, run on five of the six programs the night of 15–16 Sep (bodies-as-cache): ten fresh Opus regenerations from the stripped specs (intent, types, processes, signatures with contracts, tests kept), ten at completeness 1.0, every kept test and transcript passing and jobq’s 121 hidden checks twice, in 11 to 47 minutes each, every loop fixed by its first edit. The spec altitude is real for these programs and bodies are regenerable; the agent program, predicted to fall, was not run (Robert paused the night at the ledger)Fableaccepted, for Robertthe agent program’s two runs on the Mac; then the stronger form with the tests deleted
The night ended at Robert’s word (02:20, “when they finish I want to pause and then have you continue on my mac”): the agent program’s runs, the P6 crash probes on Elixir and Mo, round 9, the Mac scaling run, and change 2 are the Mac session’s; every branch and worktree is pushed, the instruments are committed beside their plansRobertlockedthe Mac session
The Mac session set up on 15 Sep 2026, 22:45 local, by the lead alone: Zig 0.16.0 (Homebrew), Go 1.27.1 and staticcheck, Elixir 1.18.5 on OTP 27.3 pinned by mise.toml in the Elixir worktree only (Robert’s global 1.20 on OTP 29 untouched), uv, Pi 0.73.1 from npm; the 13 missing evidence worktrees recreated and the toolchain binary copied in; every queue suite green on the Mac (Go 3 packages, Elixir 104 tests, Python 173, Mo 26 with a 20-run sim). The Go and Zig versions are not round 8’s exactly (1.27.1 against 1.26); the Mac rows say so where a number is comparedFablelockedthe Mac scaling run
Robert, 15 Sep 2026, 22:50 local, going to bed: the lead is in charge and makes all decisions while he is away; the worker is Opus on medium effort in Herdr pane w44:p2, one fresh session per piece of work; the lead briefs and reviews. Recorded in the mo-lead skill’s start commandRobertlockedthe P6 probe’s worker
semantic, for Robert: P6 on Elixir, probed 15 Sep 2026, 22:45 local (control-run-10-suite/p6.py): the queue GenServer killed from a second node three times under 11,000 requests a second, /health back in 261, 393, and 583 ms, 735 of 99,060 requests failed, 0 of 32,765 acknowledged jobs lost, the folder reopened whole; five kills 400 ms apart cross OTP’s default intensity (3 in 5 s) and the node exits, the disk still whole. Read as the BEAM’s row: what chapter 1 argued the runtime and process model give, restart with the service answering, the BEAM gives from a 70-line supervisor the program did not think about, and Mo’s spec-as-written program stopped answering (round 8). The null hypothesis after round 10: Mo has reliability and the loop; the BEAM has speed, time to write, the dependency tie, and P6. Change 2’s Mo program and the language page answer itFabledecided, for Robertthe same probe on Mo’s change 2 program, then the language page
semantic, for Robert: chapter 10, the language after the rounds, written 15 Sep 2026 (spec/design-v0/10-language-after-the-rounds.md; chapter 9 was the stdlib, so the roadmap’s 09- became 10-). §1 recommends a deferred reply, zero syntax: the arm for a message with a reply may keep reply_to (a Reply(T) state field carrying the asker’s deadline) and answer it later; a crash answers every held reply Down. It keeps the batch that makes Mo’s queue 3.3 times Go’s and gives the worker the ask deadline it lost in round 8’s outage. Options B (a diagnostic on send to a :never child) and C (a deadline on the message type, new syntax) recorded and not recommendedFablerecommended, for Robertchange 2’s Mo program under p6.py; the erosion round’s third suite
semantic: chapter 10 §2, the restart budget: an :always child without max_restarts gets a diagnostic as a project setting, off by default, after P6 showed OTP’s silent default (3 in 5 s) ending the Elixir node on the fourth kill; §3, the four counted shape laws move to mo.toml [shape] (Robert’s item of 14 Sep, now a chapter 2 edit and a step); §4, never and invariant unchanged, false positives a recorded column from round 9; §5, MO0317 names the changed module and the --write order; the grammar forms stay diagnostics while their first-fix rate holds above 0.7Fabledecidedthe steps that build §1 to §3 and §5, one brief each
The Mac scaling run, 15 Sep 2026, 22:46 to 23:20 local (mac-scaling-run, the table in interpreter-step-30): every row fastest at 1 core on the M3 Max and slower with each core (queue pairs 2,908 to 2,416 from 1 to 14 cores, the ledger 5,106 to 4,073, echo-1k 19 ms to 104, kv-10k-get 383 ms to 1,236, replay-1m unchanged); the disk moves the fsync bound eight times up, the cross-scheduler ask moves every crossing row down. Decided: MO_CORES=1 for every Mac row in the rounds until placement is fixed; a step after 31 places a process with its asker or answers on the asker’s scheduler, measured on echo-1k and the queue at 1 and 14 coresFabledecidedthat step’s numbers table
semantic: step 31 built chapter 10 §1 as the brief stated it (16 Sep 2026, accepted 01:15): in the arm for a message with a reply, reply_to is bound as Reply(T); the arm answers by its value or moves reply_to into a state field, exactly one (MO0411); reply.answer(v) from a later arm answers the ask, commits with its update, is dropped after the asker’s deadline or on a second answer; a crash or restart answers every held reply Down. Reply(T) lives only in state fields, never in a struct, a message, or a return. First tested by the corpus file and Fable’s crash probe (8 of 8 Down, 8 answered after the restart, both runtimes, 1 and 14 cores)Fable, from Opus’s buildaccepted, for Robertchange 2’s Mo program under p6.py
Step 31 defaults ratified from Opus: a Reply is a sequence number (the deadline stays with the asker); a per-process held list, so a dropped Reply is invisible and its asker times out; the deferral decided at check time (defer_reply); the move rule ‘mentions reply_to once, inside an assignment under state’; a corpus file whose first line is # run: is runnable; answering is an effect for the loop rule; Reply is a hideable prelude type; the recursion unit test on a 256 MiB thread. Recorded: at 128 held asks under mo run on one scheduler the deferred reply is 0.46 of the send shape (parked fibers), 1.11 as a binary; a row for the placement stepFableacceptedthe placement step’s numbers
semantic, for Robert: the erosion round’s generation two, 16 Sep 2026, 01:16 to 02:00 local (erosion-round): change 2 by four fresh Opus maintainers in 12 to 18 minutes; 0 regressions and 0 new change-1 defects in Mo, Go, and Python, Elixir 1 (a torn line refused at open, fatal after a full disk); under the third suite Mo 1, Go 0, Python 1, Elixir 3; Mo’s maintainer used Reply(T) for the queue’s answer the first time it was offered, so round 8’s outage is closed by the program. Held: P1, P4, P5, P6; failed: P2 (Go cleaner by one), P3 (Go and Python answer through the full disk as Mo does; Elixir does not). Generation one under the same suite already contained the failure in Mo, Go, and Python; Elixir’s node exited on :enospc. The BEAM row after this: supervision restores a killed process and does not, by default, survive a disk that stays fullFabledecided, for Robertgeneration three
Decided from the erosion round: the change 2 spec gains three sentences (a record with a field its state forbids is ill-formed; verify never writes; verify on a missing folder exits 1); the Mo change 2 program’s P6 probe (the queue crashed under load, the service answering) is the next probe; Go’s and Python’s verify rewriting the log is recorded, not counted; the erosion suites are erosion-round-suite/ (defects2.py, oracle5.py, the Mac’s RAM disk and port rules inside them)Fabledecidedgeneration three’s third suite
semantic, for Robert: round 9, the small-model round, read 16 Sep 2026, 02:45 (control-run-9): reliability moves with the model on the Mo side and only there (Mo 0, 1, 2, 0 defects for Opus, kimi-k3, deepseek-v4-flash, gpt-5.5; Go 1 for all four; Python 0 for all four); the two open-weights models’ Mo changes share a scheduling miss no check states; the diagnostics carried them to green with first fixes right in 21 of 23 loops; gpt-5.5 matched Opus in 14 minutes; the local 27B could not do the task in any language. The reading: the laws did not catch the weaker models’ mistake, the language’s diagnostics did teach it; the check that would have caught the miss is a program never (‘a due job is never left scheduled’), a spec rowFabledecided, for RobertHaiku 4.5’s row; the change 3 spec’s never list
The wiki is a site (Robert, 16 Sep 2026, morning): Quartz 5 in site/, built from mo-wiki/ and published to GitHub Pages on every push to main at https://robertguss.github.io/mo-lang/, everything public including raw/; the lead keeps state-of-the-project as a standing page rewritten at every pause, and maps of content under maps/ (the thesis and its evidence, the rounds, the language, the runtime, the programs, for Robert, how we work); the site is linked from the README and the repo’s descriptionRobert, built by Fablelockedthe next pause’s rewrite
semantic, for Robert: round 9’s last row, Haiku 4.5 through Claude Code at medium effort, 16 Sep 2026, 08:22 to 08:45 local (control-run-9): three sessions of 7 to 9 minutes by the lead’s clock, each stopping at its own tests with the program’s other checks red (Go’s check.sh, Python’s mypy, ruff, and check.sh, Mo’s corpus transcript), each report’s wall-clock wrong by a factor (Mo says 90 minutes). 0 regressions in every language; defects Mo 28 of 189 over 4 causes (the old names and malformed fields accepted at create; a due job never moved from scheduled to queued, the change’s centre; a race round; an old name left after compact), Go 22 over 6 (its bolted-on nevers trip on its own change and answer 500 or exit the server), Python 18 over 2 (the retry route and a scheduled delete answer 500). The reading: at this size the change is wrong in every language and the language decides only which checks are missing; Mo’s miss is the never no program states (“a due job is never left scheduled”), the spec row already recorded; P2 fails for Haiku as for the open-weights models, P4 fails by its own loop count (1 in Mo to 7 in Go); the round is closed with the Opus-in-Pi baseline unmetFableaccepted, for Robertgeneration three’s Mo maintainer, if change 3’s spec states the due-job rule (the lead’s call when that spec is written)
semantic, for Robert: P6 on Mo’s change 2 program, 16 Sep 2026, 08:50 to 09:05 local (erosion-round, erosion-round-suite/p6-mo.py): the queue process crashed through the runtime surface (POST /send/1 with a Create whose queue name the API would have refused; job’s requires trips inside the queue) under about 10,000 requests a second, under mo run and as a binary. From the crash on every request answered 503 the queue is down within 2 ms, /health included; 0 of 6,638 acknowledged jobs lost on a reopen of the folder; the queue never restarted, by the program’s restart: :never. Read: round 8’s outage (a hang) is closed by the program with the deferred reply; the restart stays the BEAM’s until a Mo program takes it, and it can: a restarted process re-runs its state initializers with its capabilities (erosion-round-suite/reopen-run.mo: the file read “one” before the crash and “two” after the restart, both runtimes), so a queue that opens its folder in its own state and says :always restarts correctly today. No corpus program does; chapter 3 named kv’s store as the pattern, and kv replays in main and says :never tooFabledecided, for Robertchange 3 of the erosion round
Decided from P6 on Mo: change 3 of the erosion round is the reopening store (a queue that crashes is restarted from its log with the service answering 503 meanwhile and 200 after, with a budget on the line; Go, Python, and Elixir asked for the same behaviour in their own terms); chapter 3’s “What restart means” now names the reopening state initializer as the pattern and says kv replays in main; chapter 10 §2’s premise that change 2’s queue reopens in its own start is corrected on the pageFabledecidedgeneration three’s Mo maintainer and the fourth hidden suite
For the toolchain, from P6 on Mo: with the default ring of 4,096 events GET /crashes was empty after the crash, the ring having turned over under load; at MO_EVENTS=262144 the crash was listed whole. Crash reports are kept apart from the event ring, the last 16, both runtimes (step 32, interpreter-step-32), with a corpus file for the reopening restartFabledecidedstep 32
Step 32 accepted (16 Sep 2026, 10:20; interpreter-step-32): crash reports kept apart from the event ring in both runtimes, the last 16, mo run --crashes N and MO_CRASHES=N, read newest first; examples/processes/restart-reopens.mo shows a restarted process re-reading its file at start; the P6 probe with the default ring lists the crash under both runtimes, seven seconds and 4,096 events later. The standing rows unchanged within noise (the mo run http-1k row 64 to 69 µs from one bench run each, flagged, not rerun)Fableacceptedthe P6 probe, the corpus
Step 32 defaults ratified from Opus: each kept text (clause, message, snapshot) cut to 4,096 bytes at a character boundary with an ”… N bytes more” ending, the printed report whole; fixed slots of 3 × (4,096 + 40) bytes a report reserved at the first crash; the store kept even under --events 0; the hidden surface process’s crashes not kept, as in the ring; mo test always keeps 16; crashes newest first (the spec row changed from oldest first)Fable, from Opus’s defaultsaccepted—
For the toolchain, from step 32’s report: both runtimes keep every full crash report for the whole run (the sim’s list under mo run, the rendered strings never freed in a binary), about 2.3 MB resident for 16 crashes with 64 KB states, unbounded for a service that crashes often; a bound on the kept full reports is a step of its own, queued after placement; event_bytes on the memory row still counts only the ringFabledecidedthe step that bounds it
A corpus flake recorded: zig build test run while the P6 probe and the worker’s bench loaded the Mac failed the agent program’s transcript (the binary listed one step where the interpreter listed several, a run on wall-clock budgets) and passed on the rerun alone. Not counted until it recurs; the lead does not run probes or benches during a verification suiteFableacceptedthe next suite run
semantic, for Robert: the erosion round’s generation three, 16 Sep 2026, 10:22 to 11:20 local (erosion-round, change 3 01d-job-queue-change-3): four fresh Opus maintainers in 10, 10, 12, and 23 minutes (Python, Elixir, Go, Mo); regressions 0, 0, 0, and 1 carried; the fourth suite (55 checks: the chaos switch under load, the restart within a second, the board whole after it, the budget) Mo 55 under both runtimes, Go 55, Python 55, Elixir 53 (the budget at the window’s edge, OTP counting whole seconds); P6: the Mo queue killed through the surface under load back in 106 ms with nothing lost, Elixir’s in 285 to 694 ms. The BEAM’s row is answered by a Mo program written to chapter 3’s pattern. Held P1, P2, P5; P3 and P6 half (Go and Python restart as well as Mo and Elixir; the Mo budget lives in a warden process); P4 failed. Nothing new eroded in three generationsFabledecided, for Robertgeneration four
semantic: chapter 10 §2 gains one ask from generation three: max_restarts and its window on a child line may be values the supervisor’s arguments carry, not only literals, since a budget that comes from the command line is what an operator’s ticket asks for and the Mo maintainer had to write a process to hold it; zero syntaxFabledecided, for Robertthe step that builds §2
For the toolchain: the crash report’s rendered state is never freed in either runtime (step 32’s carried row), measured by change 3’s Mo maintainer at about 44 MB a restart on a 20,000-job queue and 1.4 GB after 30 restarts (erosion-round-suite/results/e3-mo-TOOLCHAIN-BUGS.md.txt §5); a restarting store makes it a leak per failure, so the bound moves ahead of placement as step 33. Beside it: under mo run alone the interpreter exited on signal 6 late in the third suite’s unwritable category on the change 3 program (the binary passed it whole), to probe in the same stepFabledecidedstep 33
Disclosed from generation three: the fourth suite was amended during the run on five forms that were wrong on this machine, the checks unchanged (defects3.py says where and when); the Elixir worktree’s untracked mise.toml did not come with the worktree, so its first pass ran on the global OTP 29 and was redone under the pinned OTP 27, which is the row; the Mo maintainer’s own probe found a restart on a 100,000-job log at 1.38 s against the spec’s one second, a miss the suite’s smaller logs did not reach, recorded on the pageFableacceptedgeneration four’s setup (mise.toml copied in; the suite as amended)
Step 33 accepted (16 Sep 2026, 13:05; interpreter-step-33): the crash report freed after it is printed, both runtimes, growth per restart on a 20,000-job queue 46 MiB to under 0.3 as a binary and 28 to 0 under mo run (Fable’s run: 0.07 and 0); the interpreter’s abort on opening a log past about 8,000 jobs fixed (the high-water mark raised before the subtraction; the binary had wrapped silently); the unwritable, restart, and budget categories green under both runtimes; P6 twice, back in 102 and 203 ms, nothing lost. Unmet and carried: one restart at 100,000 jobs is 1.45 s against the spec’s one second (the replay plus the report)Fableacceptedchange 4’s suites
Step 33 defaults ratified from Opus: the C runtime renders reports into chunks it maps and unmaps itself (free() left the blocks resident on macOS); a Crashed event in the ring holds the report’s number in step 32’s store, so an event whose report the store has let go, or under --crashes 0, has empty clause, message, and state; mo test unchanged, every report kept whole for the runner; small reports (runtime failures, mailbox full, held sends) still kept; the state rendered twice per crash because the invariant’s value and the snapshot differ; part B’s fixture a unit test in vm.zig, with bench/step33/reopen.py for a folder; the numbers’ before tree at part B’s commit, since without it mo run cannot open the 20,000-job log; part C’s commit evidence not code, after steps 23 and 24Fable, from Opus’s defaultsaccepted—
For the toolchain, from step 33: compaction copies a string once for every value that points at it, about half again on jobq’s log, in both runtimes (a step when a program pays for it); kv-50k-set-rss-kib is about 340 MiB on the Mac against about 40 in bench/results.tsv, the same before and after the step, likely the VM’s row, to explain when the bench baseline is next recorded on the Mac; the restart at 100,000 jobs at 1.45 s is the replay’s, for the placement or a replay stepFabledecidedthe next bench baseline; a later step
semantic, for Robert: the erosion round’s generation four, 16 Sep 2026, 13:05 to 15:05 local (erosion-round, change 4 01e-job-queue-change-4: idempotent creates by a key, old jobs archived out of the log): four fresh Opus maintainers, 1,358 to 1,956 lines each; regressions none new in any language; the fifth suite (77 checks) Mo 77 under both runtimes, Python 77, Go 76 (null read as no key), Elixir 76 (a repeated flag accepted); P6: the Mo queue killed twice under load back in 58 and 85 ms, nothing lost. The seam the change was written to press on, state the log carries across a self-restart, a kill between two writes, and a compaction, held in all four languages. P1, P2, P5, P6 held; P3 and P4 failed. After four generations nothing has eroded in any program since generation one. The wall-clock column is unreliable: the Mac slept several times and cut every session shortFabledecided, for Robertchange 5
From generation four, for the spec and the language page: the Mo maintainer keeps archived jobs in memory, paged like the live ones, so the log stops growing and memory does not (change 5 may ask for archived jobs read from the disk); its chaos switch counts the ids reservation as a record; three of four answer a key lookup with an archived job and Elixir hides it (the spec’s two sentences conflict; the next revision says the lookup returns it). For the lead: the Mac’s sleep is held off with caffeinate -dimsu for every run from now on, and every run or spawn goes in a fresh pane of Robert’s workspace, which he closes or the lead closes when it is readFabledecidedchange 5’s spec; the next session
Step 34 paused at part A’s commit (16 Sep 2026, 15:45; 1559554, 660b75c): Robert leaves with the Mac, and parts B and C are the Mac’s (the fourteen-core measurement); the worker stopped on the lead’s word after a green suite. Resumes on the Mac with a fresh worker from part A; change 5 runs on either machine meanwhile. The rounds’ Mac rows keep MO_CORES=1 until thenFabledecidedthe next Mac session
Step 34 accepted (16 Sep 2026, 21:20; interpreter-step-34): placement with the starter (part A) while the starter’s scheduler holds at most twice its share, MO_PLACE=spread for step 30’s rule; the crossing made cheap (part B): 100,000 asks across two schedulers 4.0 to 5.6 s to 0.14 as a binary and 0.15 under mo run, the cost a zero-timeout kevent on every poke and a lost wake, never the runtime lock; the measurement at 1, 4, and 14 cores (part C) with the queue’s pairs level across cores (456, 453, 444), kv-10k-get under mo run level (428 to 441), the crunchers 7.3× and 6.0×, 200,000 short-lived processes faster than step 33 at 14 cores. Not met: echo-1k +43 and +39 percent, the binary’s kv-10k-get +21, the queue’s creates −25, every one a path main starts on both ends, which the brief left on the fewest-live rule; the scheduler lines show it (17,517 of the acceptor’s workers with it, every other scheduler crossing for every ask). The rounds’ Mac rows may now run without MO_CORES=1, though at 1 core nothing is slower, so the rounds keep it until a program needs the coresFableacceptedgeneration five’s Mo rows, the next bench baseline
Step 34 defaults ratified from Opus: both spin budgets 200 µs and a poked scheduler looks at its armed sockets at most every 200 µs (50 µs and 1 ms no better); a scheduler with no socket armed sleeps on its state word (a futex; a condition variable in C), one with sockets in its poller; the lock spins 20,000 times (was 200), the arm64 spin hint yield; the step-aside: an update about to deliver an ask on its own scheduler yields while a sweep waits or is due, only with more than one scheduler (part C’s regression: with its targets on its own scheduler a spawner never parked, sweeps missed, and ended processes piled up to 4 GB at 200,000 processes); the 8 crunchers program a bench program, not corpus; the queue’s client a copy of round 7’s with max_tries; the ledger’s load a probe that owns the server’s process group and checks nothing is left; the final build’s queue and ledger rows best of threeFable, from Opus’s defaultsaccepted—
For the toolchain, from step 34, carried: no unit test covers the step-aside (the regression shows at 200,000 processes, the corpus program runs 2,000); placement for what main starts (a floor on the starter’s share, or a process placed with its first asker) is the row that would meet echo-1k and the binary’s kv-10k-get; the crunchers binary grows about 15 bytes a loop iteration a running process, freed only when the update ends (1,223 MiB at 8 cores for 10M rounds, identical on step 33’s mo; past 6 GB at 100M rounds); the interpreter ledger at 100,000 transfers is 650 to 669 a second on step 33’s and step 34’s binaries alike, each tenth slower than the last, 39 percent of samples in vm.Vm.compact: the compaction copy per reference, now measured on the ledger, ahead of the queue’s 1.45 s restart in the same rowFabledecidedthe placement follow-up; the compaction step
Disclosed from step 34: the worker’s first ledger phase was contaminated by its own wrapper (the load script killed the watchdog, which orphaned the mo run server; every later run talked to the orphan), found by Fable at 18:57 as a process thirty-one minutes old at 99 percent CPU and 1.3 GB, killed, and the phase rerun clean with a probe that owns the server’s process group; one 10,000-asker memory run reached 8 GB early in the session with no watchdog, the worker’s slip, every later run guarded; the Claude Code worker’s turn ended twice while its driver ran in the background and was prompted to continue each timeFableacceptedthe next step’s brief names the process group and the watchdog
semantic, for Robert, from Fable’s step 34 probe: the Mo queue’s lease-and-ack pairs a second at 32 workers, 1 core, as a binary on step 34’s mo, one program per generation of the erosion round: round 7’s 4,040, change 1’s 4,045, change 2’s 4,142, change 3’s 4,068, change 4’s 452 (one worker 2,000 for every earlier generation, 730 for change 4), and change 4 on step 33’s binary 455. Generation four’s Mo maintainer made the lease path nine times slower, on either binary, and the fifth suite counted only correctness: the first erosion the round has found is a performance one, and the round’s measure (chapter 8: native speed second) was not applied per generation. Decided: every generation from five on records pairs and creates a second at 32 workers, 1 core, for all four programs, against the generation before, on the round’s page; generation four’s row for the three baselines is measured now and written beside Mo’s; the cause in the Mo program (the archive’s look over the board at every request, or the key map) is read from the diff and named on the page; whether the Mo maintainer is told is not changed for change 5 (the brief is the same for all four, and speed is the lead’s to measure)Fabledecided, for Robertgeneration five’s rows
semantic, for Robert: the erosion round’s generation five, 16 Sep 2026, 21:18 to 22:55 local (erosion-round, change 5 01f-job-queue-change-5: a lease handed to another worker, a queue renamed with jobs in flight as one record; the first change whose seam is a law): four fresh Opus maintainers in 11, 14, 15, and 25 minutes (Elixir, Go, Python, Mo), 1,477 to 1,838 lines; regressions none new in any language; the sixth suite (94 checks) Python 94, Elixir 94, Go 92 (to at 256 bytes, a reading), Mo 93 under both runtimes: after a compaction, one more rename, and a stop, the folder refuses to open (verify and serve exit 1, “the rename count is below rename_3”; compact keeps a SET renames n record a later rename never raises; reproduced by hand); P6 the Mo queue killed twice under load back in 55 and 99 ms, nothing lost, Elixir 279 to 856 ms. Held: P1, P5. Failed: P2 (the first Mo-only defect in six suites), P3 (no baseline broke a rule under the kill), P4 (only Mo mishandled the record), P6 (three nevers added, none tripped on a wrong edit; the bug during the work found by reading, the shipped one refused at open by the program’s own rule). The reading: the law did not earn its row, and the shipped bug cuts both ways, an outage on restart an operator sees where a baseline’s same slip would have replayed the log into the wrong queue in silence. The tally after five generations: Mo 1 carried and 1 new, Go 1 carried, Python 1 carried, Elixir 3 carriedFabledecided, for Robertgeneration six
Decided from generation five: the Mo change 5 program’s count slip is the program’s row, not the toolchain’s (nothing in the runtime or the language is behind it: a counter the maintainer added and did not raise after a compaction), and change 6’s Mo maintainer inherits it as a bug to find or a regression the suites carry, like every other generation’s; the spec’s archive sentence (“an archived job’s queue is the live log’s renames applied to the archive record’s queue”) is wrong once a name is reused, found and fixed the same way by all four maintainers (a position or a count on the record), and the next revision says it their way; “unchanged apart from updated_at” means updated_at changes, said plainly next time; the 128-byte to stands, Go’s 256 a reading; the sixth suite’s four amendments (the rename setup’s lease order, the live listing after the archive move, the leased count after the handoff category, the kill category’s creates after the rename and a create durable but unanswered) are disclosed on the page, every program having failed each the same wayFabledecidedchange 6’s spec; the sixth suite as amended
Decided from generation five, the speed row: from this generation on every program is measured after its session with round 8’s client (100,000 creates, then lease-and-ack pairs a second at 1 and 32 workers, MO_CORES=1, one run, on a quiet machine after every suite), against the generation before, on the round’s page. Generation five: Mo 425 pairs at 32 workers (change 4’s 452, the nine-times loss of generation four carried, not made worse), Go 107, Python 4,847, Elixir 5,619, on the Mac’s disk where Go fsyncs every write and the other three batch; the baselines’ change 3 and 4 rows on the page. The cause of Mo’s generation-four loss is still to be named in its program (the archive scan is gated; no invariant was added to the queue process; the board’s one new never and the key map are the suspects): a probe on a quiet machine, before change 6 is writtenFabledecidedchange 6’s brief
Disclosed from generation five, the lead’s slips: the first two attempts at the baselines’ speed rows died on the lead’s harness (a buffered pipe under a timeout; then the sixth suite’s smoke run, which ends every category by killing any server under the temp folder, took the probe’s servers with it); P6 on Mo first ran against a binary built without --surface; the rename-category rerun once ran nothing because its output name held a space; Elixir’s regressions were rerun alone after three categories died on the Mac’s port exhaustion behind Python’s suite. Recorded in the handoff: no probe beside a suite, python3 -u under timeout, the --surface binary for P6, a lease hands out the oldest queued jobFableacceptedthe next generation’s setup
semantic, for Robert: research PR 2 (the Hermes lane, research/hermes-monitoring, wiki only: two daily notes, a monitoring plan, six raw snapshots, links from four research pages) reviewed and merged into main, 17 Sep 2026, morning. Read as sharpening, not news: every finding lands on a page already in play. Its one correction applied to chapter 10: the 3-in-5 restart budget that ended the Elixir node in P6 is Elixir Supervisor’s default, not OTP’s (Erlang’s supervisor defaults to 1 in 5 s; the round-10 server.ex sets neither), so the P6 reading stands and only the attribution changes. Its one gap check confirmed: erosion2-* and erosion5-* were never pushed though the handoff said every evidence branch was; all eight pushed. Its two checklists queued as reading for change 6, not as steps: the crash-consistency sequence create, compact, rename, reopen, write again (Pillai et al., OSDI 2014) sits on the exact path of generation five’s Mo defect; error-path reachability as a recipe acceptance question (Yuan et al., OSDI 2014: catastrophic failures came from handlers that existed and were wrong, which is the case against expecting a consumed-result law alone to catch them). The research branch stays open for the next scan and is merged only after a readFabledecided, for Robertchange 6’s spec and the seventh suite’s categories
For Robert: the auditor role read and taken up, 17 Sep 2026. Fable read audit/README.md, audit/CHARTER.md, and the three rule files Robert ratified the same day (runtime R1–R7 and RC1–RC4 with S-A/S-B/S-C; capabilities P1–P4 with T-A/T-B/T-C; the language rule simplified to one tier under L-2, R-B automatic). Fable holds to the charter: a parallel reading audit/fable-reading-<date>-<subject>.md is written before the auditor’s file on the same subject is opened; a disagreement is a row citing both; no ratified threshold or retirement mapping changes except by a row with a reason; Fable never opens or sits in an audit session. The rows below are Fable’s disagreements and readings, filed before program 7 exists, as Robert askedFableacceptedprogram 7’s first commit
For Robert: roadmap M-3 accepted. Next, in order: (1) the bricks page, (2) the probe naming generation four’s nine-times loss, (3) program 7, which is Fable’s sealed spec, then the auditor’s pre-registration session (Robert opens it), then the Mo and Elixir builds; then change 6 and generation six, the step 34 follow-up, chapter 10’s other sections, the compile benchmark. Why accept: chapter 1 names program 7 as the test of the primary claim, and the queue had it behind work on the layer the pivot demoted. Why the probe still goes before program 7: it is RC2’s evidence. On today’s record RC2 is already at its line: round 10’s Elixir queue ran twice Mo’s pairs at 32 workers (0.5×, the amber/red boundary), and generation five ran Mo 425 against Elixir 5,619 (0.08×). A cost row red sends the runtime claim to S-B whatever R1–R6 show, so the loss must be named before program 7’s load rig is built. One counter, on timing only: generation six may run while program 7 waits on the auditor’s sealed suites, since the language rule needs generations six to ten and one worker would otherwise sit idle; it never goes ahead of program 7’s buildFabledecided, for Robertthe board, and program 7’s start date
For Robert: the bricks page is a hard prerequisite for program 7’s first commit, as the ratified capabilities rule says. Accepted without counter. Fable writes deep-dives/bricks-and-the-cost-of-zero-dependencies.md next: the shelf boundary (what a program may use before it needs a recipe), an audit budget per brick, the update cadence, the bricks’ own dependency surface, and the fallback (a brick wrapping a C library inside the platform under audit, never application FFI). The auditor’s P2a drift seeds and the P4 modification can then name bricksFabledecided, for Robertthe bricks page
For Robert, a disagreement with the ratified capabilities rule on scope, not on a threshold: the rule assumes program 7 needs what an Elixir program takes from hex (crypto, JSON, HTTP, TLS, a database driver, rate limiting), but the roadmap’s program 7 is a Redis subset (streams, persistence, auth, pub/sub), and an Elixir author writes that on OTP alone: :ssl covers TLS, :crypto covers password hashing, Elixir 1.18 ships JSON. As specified, the Elixir side has no hex dependency, so P4 has no hex update to compare against, and a Mo P1 of zero shows only what Elixir also shows. That is itself a point for the null hypothesis on the dependency leg, and the reading will say so. Fable’s position: fix the program, not the rule. Program 7’s spec will require TLS on the listener and ACL users with SHA-256 passwords (Redis 6 features with tests in Redis’s own suite), which press Mo’s shelf for P1 and P2, and a Prometheus metrics endpoint (in Elixir a hex package, telemetry_metrics_prometheus), which is the P4 modification’s target. Lua scripting (EVAL, luerl in Elixir) is the other hex-shaped Redis feature and is left out as too large for one program. If Robert prefers a different program, the rule needs a named alternative before the auditor seals the P4 modificationFablerecommended, for Robertprogram 7’s spec
For Robert, a disagreement with the ratified language rule, and a proposed amendment (not applied; the rule stands as ratified until Robert says otherwise): the R-A escalation “false positives > 3× catches” fires on a single false positive when catches are 0, the outcome the auditor gives 0.65. One stray trip across generations six to ten would then put removal from the language on the table, which is not what the tier’s rationale (“a check that catches once and costs many loops”) describes. Proposed: R-A escalation when density > 10 per 1,000 lines, or false positives > max(3 × catches, 3). The R-B line is unaffectedFablerecommended, for Robertgeneration ten’s reading
For Robert: Fable’s reading of the runtime rule’s ambiguous clauses, filed before any program 7 evidence exists, so the reading cannot be fitted to the numbers. (a) Who writes the ≥ 50-defect hidden suite: §4 says Fable, the README lists it as the auditor’s outstanding work; Fable’s position is the auditor, since Fable directs the builds, and Fable will not write or read it before the builds finish. (b) RC3 and RC4 have no amber band: missing the clear line is red. (c) R4 and R7 are outside the ratified mapping: a failure of either leaves the S-letter as the mapping gives it and adds §3’s downgrade (“matches the BEAM with better tooling”) to the reading. (d) R1 clears when Mo’s missed defects are at least 3 fewer than Elixir’s, or equal with at least 2 defect classes Elixir cannot state; “Mo catches” in §8 means the suite finds no defect. (e) R3 and R5 are Mo-only rows; Elixir is not measured on them. (f) R2’s Elixir fault rig is built by the worker who builds the Elixir program’s harness, to the same action list, before either program’s first commit. (g) If Elixir shows 1 or 2 capability escapes and Mo 0 or 1, P3 clears with the footnote, the same as the ratified both-zero case. (h) P3’s Elixir half is near-certain by construction (the auditor writes the malicious packages and the BEAM has no confinement), so the claim rests on Mo’s absolute ≤ 1, which the ratification already made the hard failFablerecorded, for Robertprogram 7’s reading
Decided on the bricks page (deep-dives/bricks-and-the-cost-of-zero-dependencies.md, 17 Sep 2026): a thing is a brick when a bug in it is a security or data-loss event, or it implements a standard other software must interoperate with, or it needs native code; otherwise it is a recipe or the program’s own code. So program 7’s RESP parser is the program, its Prometheus exposition format is a recipe (the P4 target against telemetry_metrics_prometheus in Elixir), and it demands two bricks, crypto (SHA-256 for ACL passwords) and a TLS 1.3 serverFabledecided, for Robertprogram 7’s spec and the auditor’s P4 modification
Decided on the bricks page: a brick is on the shelf only with five audit items on its chapter 9 page (the rows; the standard’s test vectors in the corpus; a differential run against the reference implementation, a thousand inputs; one CPU-hour of fuzzing at zero crashes; a reading of the native code by someone who did not write it, or the mark unread, which mo add prints); and each brick implements a capped cut of its standard (TLS 1.3 only with two suites, X25519, Ed25519 and P-256; Postgres v3 with SCRAM and no COPY; deflate, gzip, zstd; HTTP/2 without push), widened only by a row. The cost stated: 12,000 to 15,000 lines to write and about 70,000 of Zig’s std to read for the review’s five bricks (estimates, from the measured 59,059 lines of std/crypto, 7,780 of compress, 3,262 of http); the shelf about doubles the platformFabledecided, for Robertthe crypto brick’s step
semantic, decided on the bricks page: from the crypto brick on, a brick is written once, in Zig, compiled to a static library that mo build links beside the C runtime and the interpreter calls, so it is audited once; Net and Http, which exist twice today (net.zig and http.zig, and again in mo_rt.c), stay as they are until a step touches them. mo build is to record the toolchain version and the platform hash in the binary’s --version lineFabledecidedthe crypto brick’s step
semantic, decided on the bricks page: the fallback when a brick cannot be written under its cap is a C library vendored into the toolchain at a pinned hash, compiled by zig cc with the runtime, reachable only through chapter 9 rows on a capability, under the same five items with the reading replaced by the library’s audit record and CVE history; nothing fetched at build; never application FFI. The likely cases are SQLite and TLS 1.2Fabledecidedthe first brick that needs it
Decided from the bricks page, the order before program 7’s first commit: the crypto brick (one worker step), then the TLS brick (two steps: the server handshake on Zig’s TLS 1.3 client code, then the certificate chain and the differential run against OpenSSL), then program 7’s spec sealed, then Robert’s audit session. The generation-four speed probe runs between the brick steps, on a quiet machineFabledecidedthe board

| semantic, for Robert: step 35 accepted, 17 Sep 2026, 18:16 UTC (interpreter-step-35): the crypto brick, one Zig file over std.crypto with C-ABI exports, imported by the interpreter and linked by mo build (compiled once per target and CPU, cached), so it is written and audited once. The rows on Hash, AesGcm, ChaCha, X25519, Ed25519, Password, and the capability Random; the standards’ vectors in zig build test and in the corpus; the differential run against python’s cryptography 0 mismatches in 18,000 inputs per runtime; the worker’s ten-minute fuzz and Fable’s hour (3,855,200 inputs) 0 crashes; Fable’s own 29-line probe against cryptography equal under both runtimes and the Argon2id tag rederived independently. Numbers on the VM: SHA-256 of 1 MiB 245 MB/s under mo run and 532 in a binary against 1,548 for the brick called straight; AES-GCM 329 and 595 MB/s; Ed25519 sign 10,000 in 1.7 and 1.1 s; Password.hash 171 and 145 ms; jobq’s warm build unchanged at 0.08 s, its binary 406 KiB larger. Read: the first brick under the bricks page holds its five audit items and its cap; what it costs is List(UInt8) (6.3× and 2.9× on the raw call), a later step | Fable | accepted, for Robert | program 7’s ACL passwords, step 36 | | semantic: Random is a capability like Fs (authority: platform.random, a parameter, never captured by an anonymous function, held by a process only when started with it), read from the OS on every call (getrandom(2) on Linux, arc4random_buf on macOS; no other target compiles, said at build); Random.fixture() in tests is ChaCha20 keyed by SHA-256 of the run’s seed, the same bytes under mo test, --sim, and in a test binary; from Opus’s defaults 4 and 5 | Fable | ratified | program 7’s salt draws; the TLS brick’s nonces | | semantic: Password.verify? accepts only the exact string Password.hash writes (argon2id, v=19, m=65536,t=3,p=1, a 16-byte salt, a 32-byte tag, one spelling) and everything else is false, so a stored string can never ask for more memory or time than one hash; the Argon2 parameters are the brick’s and no row takes weaker ones; from Opus’s defaults 2 and 3. Overturned nothing: chapter 9’s failing-is-a-value rule holds, and the cap on what a stored string can cost is the bricks page’s audit item 4 | Fable | ratified | program 7’s ACL file with a foreign PHC string | | mo build with no --target compiles the brick with -mcpu native; a --target build keeps the triple’s baseline and stays portable; from Opus’s default 6, since the baseline x86-64 brick ran AES-GCM at 33 MB/s and SHA-256 at 203 without AES-NI and SHA-NI. The cost: a binary built without --target may not run on an older CPU of the same triple, which the README says | Fable | ratified | program 7 built on the VM and run on the Mac with --target | | Sizes the brief left open: Hash.hkdf_sha256 past 8,160 bytes (HKDF’s 255 blocks) and Random.bytes past 1 GiB at once crash at the row; every key, nonce, seed, salt, and signature size is checked before the brick is called, so the brick’s bad_size answer is unreachable from Mo; from Opus’s defaults 7 and 8 | Fable | ratified | the TLS brick’s key schedule | | List(UInt8) costs 6.3× the raw brick call under mo run and 2.9× in a binary on a 1 MiB hash (a Value per byte): a byte-string value is a row for a later step, after the TLS brick, which will say what its record path pays through List(UInt8) before that step is scheduled | Fable | decided | step 36’s numbers | | A toolchain step’s write scope includes the .mo.ids sidecars and toolchain/PRELUDE.md whenever the corpus or the prelude changes, without the brief naming them (the corpus test fails on a stale verified: line otherwise); from Opus’s defaults 10 and 11, and the mo-lead skill’s brief rule is read so from now on | Fable | ratified | step 36’s brief |

| semantic, decided for step 36 (interpreter-step-36): the TLS brick is an engine over bytes with no sockets (ciphertext in, plaintext out, and back), so each runtime drives it from its own socket and scheduler and the record layer is written once; Tls is a capability (platform.tls) whose one row makes a TlsServer from PEM text the program read with Fs, so Tls reaches no file; TlsServer.accept(conn, within:) runs the handshake on an untouched Conn and gives back a Conn, so every row and every program written for a plain socket works unchanged behind TLS and no syntax is added; a TlsServer may be stored and shared, since it holds only its own key. The cut this step: TLS 1.3, the two suites, X25519 with one HelloRetryRequest, Ed25519 and P-256 certificates, KeyUpdate, close_notify; ALPN, the client, the chain, and the differential run are step 37 | Fable | decided | step 36’s abuse script and the corpus | | The TLS brick’s tests this step use Zig’s own std.crypto.tls.Client in memory, since Mo has no TLS client until step 37, and its bench uses openssl s_client as dev-time tooling (the bricks page allows it, nothing is linked); the differential run against OpenSSL waits for step 37, when both directions exist | Fable | decided | step 37 |

| semantic, for Robert: the cause of generation four’s nine-times loss on the Mo queue’s lease path, named 17 Sep 2026, 19:25 UTC on the VM (../mo-lang-erosion3-mo and -erosion4-mo rebuilt with step 35’s mo, bench/step34/jobq_measure.py at 30,000 jobs, MO_CORES=1, perf on the server, the runtime surface’s /slowest beside it). Pairs a second at 32 workers: generation three 1,664, generation four 533; with MO_CONTRACTS=0 generation four 1,736 and generation three 1,793, so the contracts are the whole gap (the VM’s disk caps generation three near 1,700; on the Mac’s disk the same per-request cost read as 4,040 against 452). perf puts 23 percent of the server in one anonymous function: sweep’s postcondition ensures all_ends(result.board).all?(fn(e) !old_enough?(board, e.1, now) end), added by change 4’s Mo maintainer with the archive, which flattens every finished job’s page and tests each; decide calls sweep on every request, so every lease and ack pays a walk over every job ever finished (chapter 3: contracts run in every build). Neither the runtime nor the key map is the cause; the board’s new never is not. Read for RC2: the runtime’s rate is generation three’s; what the row measures as shipped is a Mo program whose maintainer wrote an O(n) postcondition on a hot path and had nothing that showed its cost (the fifth suite counted correctness; the surface’s /slowest would have shown Sweep growing). Decided: the speed row stays as measured, contracts on, since that is what ships; the finding goes to chapter 10 as a candidate section, a diagnostic for a contract whose cost grows with the state it walks (the surface knows the update’s time; the check knows the contract walks a collection of the state); program 7’s spec names the request path’s contracts as a thing the auditor’s speed row reads | Fable | decided, for Robert | chapter 10’s next section; program 7 |

| semantic, for Robert: the runtime’s share of generation four’s slowdown, found while writing the parallel reading of 17 Sep (audit/fable-reading-2026-09-17-gen4-speed-probe.md): the C emitted for an anonymous function calls mo_disown_in on every captured value at the top of every call, and mo_disown_in on a record walks all its fields and looks up every map it holds, so a lambda that captures a large record (board, in change 4’s sweep postcondition) pays a walk over that record per element it visits: 23 percent of the server’s samples in mo_disown_in itself. Generation three’s lambdas capture a scalar and are cheap. Decided: a step, after the TLS brick, that disowns a closure’s captures once when the closure is made (or only when its body shares them), with a micro-benchmark first (a lambda capturing a record against one capturing a scalar, both runtimes, the ratio on the page), and the speed probe rerun on erosion4-mo after it. The program’s own O(n) postcondition remains the program’s; this row is the multiplier under it | Fable | decided, for Robert | the micro-benchmark, then the step’s rerun of the probe | | The bricks page carries, from 17 Sep evening, the note that a program’s shipped rate sits below a brick’s raw rate by List(UInt8) (2.9× and 6.3× on step 35’s hash) and by contracts on (the speed probe’s 3.4×), compounding; program 7 is measured as shipped. Agreed with the auditor’s two standing concerns as relayed by Robert, before the auditor’s file was opened | Fable | decided, for Robert | program 7’s numbers against the page |

| Auditor workflow amendment, approved by Robert in Telegram on 17 Sep 2026: replace routine Robert-driven audit starts with automated two-way repository handoffs. Fable publishes a ready subject with an exact evidence commit and raw pointers; a fresh isolated auditor session files a cold reading or evidence request on an audit branch/PR; Fable supplies evidence or its independently filed response; follow-up runs automatically. No conclusions cross before both independent readings are filed. Robert retains sole authority to amend/reject auditor readings and change rules; unresolved disagreements and blockers escalate to him. Reason: remove Robert as the routine message relay without collapsing the independence firewall. See audit/CHARTER.md (ratified amendment) and audit/WORKFLOW.md (proposed operational protocol). No stopping threshold changes or automatic merge authority. Deployment remains pending. | Robert; recorded by Mo Auditor | ratified workflow; automation not active | signed trigger and two-way delivery tests |

| Auditor automation implementation, 17 Sep 2026: deploy profile-local outbound GitHub polling every two minutes, rather than public webhook ingress, because the existing auditor gateway can already schedule work and no webhook listener is configured. Immutable main-branch handoffs trigger fresh audit/comparison jobs; no agent runs on empty polls. Real GitHub-to-fresh-Hermes canary passed; duplicate consumption scheduled no second job. Fable-side wake-up is still an integration blocker, so two-way automation is not claimed. Reason: make the auditor intake operational without opening a public listener or changing other profiles. See audit/automation/README.md. | Mo Auditor, under Robert’s automation setup request | auditor intake deployed; return receiver pending | actual Fable receiver acknowledgement |

| Auditor intake cadence revised to once per hour at Robert’s request on 17 Sep 2026. Reason: the initial two-minute polling interval was too frequent. The active mo-audit-inbox job and deployment documentation were updated; no other workflow or stopping rule changed. | Robert; applied by Mo Auditor | active | hourly intake |

| Robert’s amendment of 17 Sep 2026 (evening, PR #3) taken up: the audit exchange runs through immutable JSON handoffs under audit/handoffs/ polled hourly by both sides; Fable wrote its receiver (audit/automation/fable_poll.py, 18 tests, FABLE-RECEIVER.md), installed the hourly wake-up in the lead session, merged PR #3 (fc595c5), and published a labelled working record (automation-transport-test-fable-working-001, status only) for the outbound leg. Not claimed: the inbound leg, pending the auditor’s to: fable canary; two-way automation is called live only when both ledgers show the exchange. Limits recorded: both pollers depend on a running session or gateway; the lead’s cron is session-scoped and re-created each session | Fable | decided | the transport test’s inbound leg, then step 36’s ready record |

| semantic, Robert (17 Sep 2026, 8:40 PM ET, before program 7 exists), on how program 7’s outcome is read: a Mo runtime that matches the BEAM on program 7’s reliability rows is an achievement in itself, not a failure, given that Mo is compiled, was built in under a week, and the BEAM is thirty years old; the claim he cares about is parity at zero dependencies from a compiled runtime, with anything beyond parity a bonus. Recorded as his reading, filed against the ratified runtime rule, whose retirement mapping (S-A, S-B, S-C) is unchanged by this row: if the rule reads parity as retirement of a stronger claim, the disagreement is one for him and the auditor to settle by a row, not one Fable settles. Fable’s caveat, recorded beside it: parity on a Redis subset’s rows is parity on a narrow test, not on the BEAM (no distribution, no hot code loading, no thirty years of production), and program 7’s page will say so | Robert | decided, for the auditor | program 7’s reading against the runtime rule |

| semantic, for Robert: step 36 accepted, 17 Sep 2026, 10:15 PM ET (interpreter-step-36): a TLS 1.3 server as an engine over bytes in one Zig file, both runtimes driving it from their own sockets; platform.tls, a TlsServer from PEM text, and accept giving back a Conn that is the same Conn, so every row and program written for a plain socket works behind TLS with no new syntax. Handshakes 1,026 and 1,196 a second (Ed25519), bulk 203 and 268 MB/s over AES-128-GCM against 488 and 477 plain, round trips inside 2×, an idle TLS connection 9.6 and 12.6 KiB, the binary +394 KiB. Fourteen abuse rows as named; Fable’s 22 probes of its own green under both runtimes; the suite 225 of 225 on a quiet machine. Two defects found by verification and fixed the same evening (a hanging test, a wrong certificate path), both of which the worker had reported green. Read: the second brick is on the shelf with its five audit items, at the cost the bricks page predicted; the record layer pays a copy per byte and the ChaCha20 gap is the standard library’s | Fable | accepted, for Robert | step 37 (the client, the chain, ALPN, the differential run), then program 7 | | semantic: the TLS rows as the worker shaped them, ratified from Opus’s defaults 3, 6, 7, 8, 9, 10, 12: mo_tls_flush peeks and mo_tls_sent consumes, so a partial socket write loses nothing; Tls.fixture() for tests; Tls.server(cert:, key:) takes PEM text, never a path, so Tls reaches no file; TlsServer is a capability kind like Listener (the checker’s rules MO0403, MO0409, MO0410 apply unchanged); the server table lives beside the sockets, not per Vm; a Conn remembers the first row that used it so TlsServer.accept on a used Conn crashes naming that row; the server prefers AES-128-GCM when offered, else ChaCha20-Poly1305 | Fable | ratified | program 7’s listener | | semantic, for Robert: a TLS stream that ends without close_notify is the end of the stream (eof), the same as a plain socket’s end, not an error; a truncation is the program’s to detect, as chapter 9 leaves it for a plain Conn (Opus’s default 13). Ratified for the echo; flagged, because RFC 8446 treats a missing close_notify as a truncation attack and a protocol such as Redis’s, where a partial reply is a wrong reply, may want Closed with a reason instead. Program 7’s spec decides for its listener, and step 37’s client side revisits it with the client’s Closed | Fable | ratified, for Robert | program 7’s spec | | The two bricks are two objects, each cached by its own source hash, and the TLS brick carries its own ten-line entropy function rather than calling the crypto brick’s, since two objects cannot share an export without duplicate symbols (Opus’s defaults 4 and 5). Ratified; the duplication is ten lines and the alternative, one object for both, is recorded as the way to remove it if a third brick needs entropy too | Fable | ratified | the next brick | | semantic, for Robert: a worker’s “green” is a claim, not a result. Step 36’s worker reported zig build test green at every commit and the corpus green under both runtimes; the suite hung deterministically from part A’s tree and the corpus test of its example failed, both found only by the lead’s own run. From now on a brief’s Done-when asks for the suite’s summary line and exit code in the report (zig build test --summary all under a timeout, the count and the seconds), the lead runs the suite itself before any acceptance (it already did, which is how this was caught), and a test that can block on a socket carries a deadline on every read and write (the fix’s rule). Written into the mo-lead skill | Fable | decided, for Robert | step 37’s brief and report | | Carried from step 36 for a later step: the record path copies each byte once more than a plain write (decrypting into the connection’s buffer in place would remove it); every binary links both bricks whether the program reaches them or not (+394 KiB; leave out a brick the rows never reach); a KeyUpdate from the server is checked as queued and never delivered to a client (step 37’s client can); two brick tests swallow TestTimedOut behind an assertion that fails within the bound | Fable | decided | step 37, then a bricks-cost step | | For Robert: step 36’s two readings compared (audit/mo-audit-2026-09-18-step-36.md, filed cold on PR #5; audit/fable-reading-2026-09-18-step-36.md, filed at 258d1e2 before the auditor’s was opened). Both read the server half as functioning and substantially tested after the two fixes, both place the differential run and the fuzz hour with step 37, and both find the day’s load condition not material to step 36’s numbers. The auditor found four things the lead’s reading did not, conceded in the five rows below; nothing in the auditor’s file is disputed. The auditor’s standing concern that the server half must not be read as a completed shelf audit is accepted: the brick is on the shelf marked half and unread until step 37 closes items 2 to 4 and a reading of the native code is filed | Fable | decided, for Robert | step 37’s brief and Result | | Correction of the lead’s own Result: step 36’s numbers were not taken with an orphan on one core. The orphan was killed 21:26 UTC; the bench needs part B’s rows (committed 22:00 UTC) and its outputs were committed with part C at 22:40 UTC, so the four runs fell after the kill, as the step-36 evidence README already said (load 0.38 at 22:48 UTC). The parenthetical in the Result, the carried line, and the handoff were wrong; this ordering rests on commit times because the outputs carry no timestamps. From step 37 on, every bench script prints the date and uptime at the head of each output file | Fable | decided | step 37’s bench outputs | | Conceded to the auditor: toolchain/bench/step36/abuse.py runs all seven abuse cases first and its seven serving after checks after the whole batch, so the Result’s “the server serving after each” is not what was measured; what was measured is that the server served after the batch. Step 37’s brief has the script check an echo immediately after each case and label the oversized case for what it sends (a header declaring 65,535 bytes and 64 bytes of body), with a second case that sends a real 64 KiB body | Fable | decided | step 37 | | Conceded to the auditor: the brick’s two tests against Zig’s own tls.Client run with the P-256 pair and one suite (tls.zig lines 1392 to 1398); the suite-and-key matrix (lines 2099 to 2109) runs against the brick’s own TestClient, which shares the brick’s record layer. The brief asked for Zig’s client for each suite and each key type; that clause was not met and the lead’s Result said it was. Step 37 makes the Zig-client tests iterate both suites and both key types | Fable | decided | step 37 | | Conceded to the auditor, and the carried row above corrected: the brick has no export for a KeyUpdate on the runtime’s request; keyUpdate (line 927) only answers a client’s. The test’s pending > 0 is the reply to the client’s request, not a server-initiated update, so “checked as queued” was wrong. The brief’s clause “one sent on request of the runtime” is carried to step 37 unmet, where the client can receive it | Fable | decided | step 37 | | Method notes the auditor documented, kept as written and disclosed on the page rather than rerun: handshake.py uses openssl s_time -new instead of the brief’s s_client loop, its echoes lost counts separate echo probes and s_time’s exit code is unchecked; bulk.py prints decimal MB/s for MiB payloads; common.rss_of counts the watchdog with the server. Step 37’s bench keeps s_time (a loop of s_client processes measures process spawning), checks its exit code, reports the connection count s_time prints, and states the units | Fable | decided | step 37’s bench | | For Robert: cold evidence for the auditor is standalone command-and-output capsules from now on. Terminal-pane transcripts (a worker’s report with its decisions list) go under worker-raw/ marked as containing synthesis, never in the ready record’s paths; the lead’s suite run is saved from zig build test --summary all under timeout as its own file; a probe script imports by a relative path so an isolated checkout can run it. The auditor’s third standing concern, accepted | Fable | decided, for Robert | step 37’s evidence bundle | | For Robert: the auditor asks that Done-when clauses step 36 did not meet be disposed of explicitly rather than weakened. Disposition: the Zig-client matrix, the runtime-requested KeyUpdate, and the per-case recovery check are carried to step 37 as named Done-when items, not waived; the brief for step 36 is not amended. Robert may overturn by a row | Fable | decided, for Robert | step 37’s Done-when |

| AUD-COMP-GEN4-RSS-001, retrospective disagreement recorded 18 Sep 2026: the auditor reads gen-4 contracts-on RSS after pairs (46 MiB versus gen-3 173 MiB) as a memory win and CPU-for-memory trade (auditor, lines 35–58); Fable disputes counting a design benefit, cites contracts-off 169 MiB versus 168 MiB, and proposes contract-triggered region compaction, expressly without having run the cheap-contract control (Fable, lines 61–76). Both positions retain equal standing; lower measured RSS is not disputed, its interpretation is. Neither the benefit nor the mechanism is adjudicated by this comparison. Rows 498–501 at aace4ee record the speed/runtime/compounding findings, not this disagreement. See audit/comparisons/2026-09-18-gen4-speed-probe.md; both parallel readings carry the relayed-summary independence caveat. No rule or prior reading amended. | Mo Auditor, under Robert’s explicit comparison/filing authorization | unresolved interpretation, for Robert; no probe run or authorized here | matched cheap-contract control and repeated memory/throughput measurements, then Robert’s disposition | | For Robert, Fable’s answer to AUD-COMP-GEN4-RSS-001 (the row above, filed by the auditor on PR #6, merged 18 Sep 2026): the disagreement is recorded as the auditor states it and both readings stand. Fable does not treat its own explanation (the postcondition’s whole-statement call as a compaction point that walks the board) as established; it is a hypothesis with a named test, the same server with a cheap ensures that touches board once per request, measured for RSS and pairs a second beside generation three and four with contracts on and off. Until that control runs, the 46 MiB is a measured number with two readings and no owner. Fable’s recommendation: the control probe runs as its own evidence bundle before program 7’s build (an hour on the VM; the erosion worktrees are in place), never inside step 37, and the decision on what the number means is Robert’s after both sides read the probe. The step 35 comparison (audit/comparisons/2026-09-18-step-35-crypto-brick.md) records no disagreement and needs no row; the relayed-summary caveat on both of Fable’s 17 Sep readings is accepted as stated, and the 18 Sep step 36 reading is the first filed without it | Fable | decided, for Robert | the cheap-contract control probe, then Robert’s row | | semantic: the TLS client’s rows mirror the server’s (step 37’s brief): Tls.client(trust:) from PEM text of one or more roots, TlsClient.connect(conn, host:, within:) on a plain Conn from Net.connect (the same Conn after, as accept gives it), and a fifth TlsError, Untrusted, for a chain that does not lead to a trusted root, a wrong name, or a wrong date, after the alert RFC 8446 names is written. The client checks what Zig’s own client checks (SAN names, the common name only without a SAN, each link’s signature, the dates against the runtime’s clock, which is the simulator’s under the fixture), depth at most five, no OCSP, no client certificates | Fable | decided | step 37’s tests and the fixture corpus | | ALPN without new syntax or default arguments: TlsServer.offer(protocols) and TlsClient.offer(protocols) return a new server or client carrying the list, the old unchanged, and Conn.protocol is Option(String) on any Conn (None when plain or nothing agreed). Two sides that both offered and share nothing fail with no_application_protocol; a side that offered nothing takes no part. Chosen over a third parameter on Tls.server because Mo has no default arguments and program 7 does not use ALPN; HTTP/2 will | Fable | decided | step 37’s fixture tests | | A KeyUpdate on the runtime’s request is an export (mo_tls_key_update) on either role, with no Mo row this step: no program in the menu asks to rekey, and a row would be a promise about when the runtime rekeys on its own, which is undecided. The export is tested brick to brick and against OpenSSL in both directions; a rekey policy (records or bytes per key) is a later row | Fable | decided | step 37’s differential run | | For program 7 (the reading the handoff left open): a client stream that ends without close_notify is read as a dropped client, as a plain socket’s end is; a partial command in the buffer is discarded and nothing of it executes, and the connection is counted as dropped, not as closed. This is what Redis does and what the brick’s eof reading already gives; the spec of program 7 will say so | Fable | decided, semantic | program 7’s spec and its hidden suites | | For Robert: step 37, the TLS brick part two, accepted 18 Sep 2026 (the Result on interpreter-step-37). The client side, the chain to a trusted root, ALPN, KeyUpdate either way; the differential run at 1,000 sessions and 0 mismatches against OpenSSL 3.0.13, the fuzz hour at 87,440 inputs and 0 crashes, the RFC 8448 client replay byte for byte; 234 of 234 on Fable’s own run; Fable’s probes against a second OpenSSL (3.5.7, Python’s) green on 35 cases, with one defect found and fixed (the row below). The four step-36 findings are closed: the abuse script checks after each case, the Zig-client matrix runs both suites and both key types (the Ed25519 cells end at Zig’s own TlsBadSignatureScheme, since Zig’s client has no Ed25519 CertificateVerify), the runtime-requested KeyUpdate exists and is read by OpenSSL in both directions, the bench outputs carry the date and load. The brick stays unread on the shelf: item five, a reading of the 4,136 lines against the cap, is owed | Fable | decided, for Robert | the auditor’s reading of step 37 | | semantic: a fatal alert from the peer during the handshake is Handshake, on both roles and both runtimes, over a socket as under the fixture; close_notify or user_canceled from the peer, or the stream’s end, is Closed. Found by Fable’s probe after step 37’s worker reported done: over a socket both runtimes reported Closed for a server that refused the ClientHello with an alert (a TLS 1.2-only server; an RSA-certificate server), while the spec’s rows and the fixture path said Handshake. Fixed by a fix session (the Fix section on the page) | Fable | decided | fable-probe/alert-probe.py under both runtimes | | The TLS cut refuses RSA and P-384 (SHA-384) chains as unsupported_certificate, so the brick’s client cannot reach most of the public internet today (www.google.com and example.com are Untrusted with the system’s roots). Ratified from Opus’s default 7, because RSA verification is outside the cap and P-384 costs 2.5 s of every cold build; the shelf entry says so, and a program that needs a public host is the row that widens the cut | Fable | ratified, for Robert | the first program that dials a public host | | Ratified from Opus’s defaults for step 37: refusal alerts as OpenSSL 3.0 sends them (unknown_ca for a chain past five, an untrusted root, a missing link, a non-CA issuer; bad_certificate for a name or a date), the chain checked strictly as sent with no reordering, every certificate shape-checked before Zig’s bounds-free DER parser reads it, the brick’s own signature check in place of Parsed.verify, the middlebox-compatibility session id with its change_cipher_spec, no SNI for an IP address, a NewSessionTicket read and dropped, a plaintext alert accepted during the handshake, offer returning a new value with a crash on an empty, over-long, or NUL-holding name, mo_tls_untrusted as the export both runtimes map to Untrusted, the fixture’s connect and accept running the peer’s engine as Http.send’s fixture does, the cookie HelloRetryRequest tested brick to brick only (s_server -stateless drops it), the fuzz driver as a test executable with a two-second watchdog per step and a self-check by a planted panic and a planted hang, s_time -new’s exit 1 on a good run accepted with its count | Fable | ratified | step 37’s suite and the differential run | | semantic, step 38 before program 7’s build, two runtime rows found by step 37’s measure.py: (1) a Conn reads while a write on it is blocked, so a program streams both ways through one connection (today the read waits on net.zig’s writing flag and a pipelining client stalls until the write’s deadline, 58 s for 1,600 lines); (2) TCP_NODELAY on every Conn in both runtimes (Nagle costs a write-then-read pattern about 40 ms a window). Both measured on echo-1k and tls-dial before and after. Program 7’s clients pipeline, so neither can wait | Fable | decided, for Robert | step 38’s brief | | Program 7’s spec: Redis’s own test suite runs its TLS tests with client certificates (tls-auth-clients yes by default) and RSA keys from utils/gen-test-certs.sh; the brick has no client certificates and refuses RSA. The spec pins tls-auth-clients no and a test CA generated with Ed25519 or P-256 for the run, and says so as a deviation the auditor can weigh; a Redis client speaks TLS 1.3 to our server unchanged. Mutual TLS is not in the cut until a program asks | Fable | decided, for Robert | program 7’s spec and hidden suites | | Two mo builds in one directory at once collide on the .bricks cache under zig-out/mo-build (Fable’s probe built tls-echo in examples/effects while the suite’s corpus step built there: ld.lld: cannot open output file .../.bricks/<hash>/tls-<hash>.o); the same build alone passes. A row for the build step: the brick cache should be written under a temporary name and renamed, or locked. Not a step 37 defect; carried | Fable | decided | a later build step, reproduced by two concurrent mo builds | | semantic, for Robert: a client’s alert or reset during the handshake must never crash the server. Fable’s probe after step 37’s acceptance-in-waiting found the tls-echo binary dead (SIGSEGV) after one client that refused its chain; the cause was a double free in the C runtime’s handshake (mo_rt.c tls_handshake freed an engine that net_close had already released after a broken read), present since step 36 for any client that resets mid-hello, never under mo run (the interpreter attaches the engine only after the handshake). Fixed in b0b2ac4 with a corpus test that drives five raw clients (alert, reset, alert, reset, alert) at a server under both runtimes. The rule that follows for every brick with a handshake: the abuse suite drives resets and alerts at every handshake state, both runtimes, and checks the server takes the next connection | Fable | decided, for Robert | step 38’s abuse rows; program 7’s hidden suite | | The brick cache is per build directory (zig-out/mo-build/.bricks/<hash>/ under each program’s folder), so a change to a brick’s source recompiles it once per corpus program in the suite (the fix’s suite took 28 minutes against 12; the TLS brick is about 10 s cold). A build step later: one cache keyed by source hash and target under the user’s cache directory, with the lockfile’s hash checked, so a brick compiles once per machine. Carried, not blocking | Fable | decided | a build step before program 7’s Elixir comparison (its cold-build number) | | For Robert, the answer to AUD-COMP-GEN4-RSS-001 from the pre-registered control probe (gen4-memory-control-probe, run 18 Sep 2026, 3:57 to 4:33 AM ET, audit/evidence/2026-09-18/gen4-memory-control/): none of H1, H2, H3 as written. Forty runs, eight cells, five trials each, one compiler. The 46 MiB of 17 Sep is one draw from a bimodal spread: generation four’s family (gen 4, the cheap ensures, the deleted ensures, contracts on or off) lands in a low state (33 to 60 MiB after the creates) in 0 to 3 of 5 trials per cell and in a high state (110 to 163) otherwise; generation three never does (0 of 14). So Fable’s reading (the walk as a compaction point, H1) is refuted: deleting the postcondition does not return a steady 169 MiB, and the cheap variant is bimodal too. The auditor’s reading (a design benefit, H2) is not established either: with contracts on, generation four’s median after the pairs is 148 MiB against generation three’s 186, and the low state is not controlled by anything measured. What is established: the rate. The cheap and the deleted variants run at generation three’s rate (medians 1,834 and 1,906 pairs a second against 1,893) and generation four’s 546 is the walk (mo_disown_in from 23 to 1.7 percent). What is open: what puts a generation-four binary in the low state (the surface shows region_bytes at 10 to 32 MB under a resident set of 67 to 190, so it is outside the region, in what the allocator returns); a runtime row, not a contract’s. Fable’s own predictions: the rate low by a core (the VM had four this time), the RSS wrong. Both readings retire; the number is not counted as a win or a cost for either side until the allocator question has its own probe | Fable | decided, for Robert | a runtime probe of the allocator’s resident set on generation four, with the region’s bytes beside it | | A measurement rule from the control probe: a load average near 3 on this VM during a one-server, one-client run is the measurement itself (the client’s threads, the server, and the ext4 journal’s D-state threads), not another process; ps at the moment, not the load, says whether a run was alone. And GNU timeout moves its child to its own process group, so a harness that kills a group must use timeout --foreground; the probe’s first sixteen runs lost their restart column to this and were kept with the column marked invalid | Fable | decided | every bench wrapper from now on | | Generation six’s seventh hidden suite sealed before the sessions: mo-wiki/plans/erosion-round-suite/defects6.py, sha256 d4dab05cc331b7fa, seven categories (prune, retention, prunerecord, prunekill, renamerule, sequence, bench), written by Fable from change 6’s spec on 18 Sep 2026, 4:50 AM ET; the runner e6-suites.sh runs the six earlier suites first. The four worktrees ../mo-lang-erosion6-{mo,go,python,elixir} branch from the generation-five commits; the Mo one carries the spec as of step 37 and its mo (b0b2ac4, the runtime embedded in the binary). Amendments during the run are disclosed on the round’s page as before | Fable | decided | generation six’s result table | | For Robert, the VM’s crash of 18 Sep 2026: at 5:21 AM ET, during generation six, a mo process in the Mo maintainer’s session (pid 1160731) reached 13.4 GB resident on the 16 GB VM and the kernel’s out-of-memory killer could not take it, because every process under Herdr inherits oom_score_adj -1000 (unkillable) from the Herdr server; the killer took tailscaled, systemd helpers, and shells instead, four times, and the machine wedged until Robert restarted it at 8:30 AM ET. Herdr then resumed every Claude session (claude --resume); the Python maintainer had finished at 5:43 AM ET, the Mo, Go, and Elixir ones were mid-work with uncommitted edits. Decided: (1) every process the lead or a worker starts runs with oom_score_adj 0 (the lead reset every session’s at 8:35 AM ET; the skill gains the rule); (2) every mo, server, bench, or test process under a maintainer runs under the 4 GB memory guard (toolchain/bench/step36/guard.py), stated in every brief from now on, not left to the maintainer; (3) never four maintainers with benches at once on this VM while a Mo process is unguarded; (4) what the 13 GB mo process was (the interpreter running bench? mo test --sim? the compiler?) is a runtime memory row the Mo maintainer’s report must answer and a probe follows. Herdr’s -1000 on children is a note for Robert’s Herdr | Fable | decided, for Robert | the resumed sessions under the guard; the Mo maintainer’s report | | Generation six continued on Robert’s Mac (18 Sep 2026, 9:23 AM ET): worktrees ../mo-lang-erosion6-{mo,go,python,elixir} from the pushed erosion6-* branches, the Mo one with main’s mo built here at b0b2ac4’s toolchain (504add8), three sessions mo-e6-{go,elixir,mo} in workspace w6 on Opus at medium effort, briefed by erosion-round-suite/e6-brief-mac.sh: e6-brief.sh word for word with the Mac’s paths, the predecessor’s work in progress and REPORT-change-6-wip.md named, every process under guard.py. Disclosed on the round’s page: these are resumed maintainers on a second machine, not fresh ones; wall-clock is the sum of two sessions; loops carry on from the predecessor’s count; Python’s finished on the VM and is not rerun. P7’s absolute threshold (1,300 pairs a second) was the VM’s: on the Mac P7 is read by the budget’s own ratio, at least 0.8× the change-3 program on the same machine, which is what the spec asks. The suites run on the Mac for all four programs (e6-suites-mac.sh, with a 4 GB watchdog), one language at a time, after the sessions end | Fable | decided | generation six’s result table | | semantic, for Robert: what the 13.4 GB mo process was, from the Mo maintainer’s own report (erosion6-mo, REPORT-change-6-wip.md): mo test --write --sim 100 queue.mo on a queue whose background prune sent itself a Tick every 60 s forever. Under the simulator a process with a perpetual delayed send never settles, the run never ends, and its memory grows without bound until the timeout (30 minutes, 13.4 GB); the same file without --sim then ended in OutOfMemory. A second runaway after the restart was the program’s (for _ in 0..100_000_000 builds the whole range; 4 GB in 10 s, caught by the guard). Two toolchain rows follow: (1) the simulator needs a bound on a test that cannot settle (a virtual-time horizon or a step budget, with a diagnostic naming the process whose timer never stops), and memory that does not grow with simulated time; (2) a range in a for should not be built as a list. Both go to the runtime memory probe queued third on the board | Fable | decided, for Robert | the runtime memory probe: a ten-line reproducer of the perpetual Tick under mo test --sim, memory against simulated time | | semantic, for Robert: the two readings of step 37 compared (audit/mo-audit-2026-09-18-tls-independent-code.md, audit/fable-reading-2026-09-18-step-37.md, Fable’s pushed at baf6683 before the auditor’s was opened). Conceded whole: the TLS brick’s client accepts certificates outside their issuer’s restrictions. The auditor built four chains OpenSSL rejects (an intermediate past a pathLenConstraint of 0, a CA without keyCertSign, a leaf whose extended key usage is client authentication only, an unknown critical extension) and both ends of a real brick-to-brick handshake became ready on each (audit/evidence/2026-09-18/tls-independent-code/chain-checks.json). Fable’s reading listed exactly these as “not checked by anyone”; the auditor checked, and they fail. Also conceded: the fuzz driver counts a crash only when an input fails again alone, so a batch-only failure leaves the printed zero unchanged; the differential run’s sampled groups never reach openssl s_server on the client path; suite attempts A1 and B1 ended in exit=124 and the Result did not say so. Agreed by both: the step-36 recovery fix is real; the 26 brick tests pass on an independent run. Decided: the brick’s shelf entry says “chain validation incomplete: do not use the client against a CA you do not run” until a fix step lands (path length, key usage, extended key usage for the role, every unknown critical extension refused, name constraints refused as unsupported), accepted only when the auditor’s own chain-checks.py rejects all four with the control passing, plus an x509-limbo run; the fuzz driver keeps every failed batch. Program 7 is not blocked (mored is a TLS server with client certificates off and verifies no chain), and its build must not start using TlsClient for anything. No disagreement | Fable | decided, for Robert | step 39 (the chain fix), queued after step 38 since both touch tls.zig; the auditor’s chain-checks.py as its gate | | For Robert: the two readings of generation six’s execution compared (audit/mo-audit-2026-09-18-generation-six-execution.md, audit/fable-reading-2026-09-18-generation-six-execution.md). The auditor found four defects in Fable’s sealed seventh suite and one in the pre-registration that Fable’s reading missed entirely; all conceded after Fable checked each against the source. G6-1: t_sequence calls done_job("s2", "s2-late") with three older jobs queued in s2, so a FIFO-correct program leases an older job, the helper acks nothing, and the four later checks fail on every correct program. G6-2: the kill oracle’s lost test joins its two conditions with and, so an acknowledged job that comes back queued passes. G6-3: the suite exits 0 whatever it found and both runners discard timeout’s status and carry on after a failed build. G6-4: change 6’s own status paragraph tells every maintainer that the slowdown is “a postcondition walking every finished job on every request”, so P7’s condition “told only the budget” was false from the start, and the same page claims it does not say where to look. G6-5: the suite never opens a change-5 folder and never kills between a rename and the directory’s fsync, so it cannot read P4. G6-6: the Mac runner’s watchdog matches any jobq, zig-out, or beam.smp process on the machine, guard.py watches one pid and not its children, and defects6.py still calls ss and kills serve /tmp. What Fable’s reading had that the auditor’s did not (it had not seen the reports): the P7 threshold re-read from absolute to ratio with the VM’s 943 in view, the budget runs taken under load 5 to 7, the in-process Mo bench, the three-segment sessions. Decided: (1) P7 is void as a test of unaided discovery and is reported as “the ratio, measured by the lead on a quiet machine” and nothing more; Fable’s 9:23 AM row re-reading its threshold is withdrawn as a re-reading and stands only as disclosure; (2) the sealed defects6.py runs exactly as sealed, its hash checked at the run, and every failure G6-1 predicts is filed as harness-induced, never as a program’s defect; (3) a corrected suite defects6b.py (the sequence acks in FIFO order, the oracle’s or, a nonzero exit, netstat on macOS, a change-5 folder category per language from the erosion5-* programs, negative controls for G6-1 and G6-2) is written and sealed by hash before any suite runs on any generation-six program, disclosed as written after the maintainers finished and after Fable read the Mo maintainer’s report; (4) the runners record every build and suite exit status, stop on a failed build, and the watchdog is limited to the runner’s own descendants; (5) the directory-fsync window cannot be tested from outside a program that offers no kill point, and is read from each maintainer’s own sequence script, as a recorded column, not P4; (6) P6 is reported apart from the language rule’s ledger: a never tripping on a wrong edit is not an L-2 catch. No disagreement | Fable | decided, for Robert | defects6b.py’s seal row; generation six’s result table with harness-induced failures in their own column | | For Robert: the two readings of program 7’s sealed spec compared (audit/mo-audit-2026-09-18-program-7-spec-compliance.md, audit/fable-reading-2026-09-18-program-7-spec.md). Both say the spec is not ready to build against, from different findings. The auditor’s, all conceded: P7-1 (P4 has no package-backed target: the Elixir maintainer may hand-write the metrics text, so there may be nothing to hex update; Fable’s reading says the same), P7-2 (the rewrite rules give no way to keep an expiry on a hash, list, set, or stream, against the spec’s own expiry-for-expiry never), P7-3 (a 512 MB command cap and a 64 MiB × 1,024 multibulk cap that contradict each other, with no rejection oracle), P7-4 (the skip list’s author and the discretionary “timing” class; Fable’s reading says the lead or the auditor should write it, not the Mo maintainer), and the recipe gate’s full definition (3 exports, 5 contracts, 50 lines each). Fable’s, which the auditor’s did not have: unit/aofrw.tcl, integration/aof.tcl, and integration/aof-multi-part.tcl are tagged external:skip at Redis 7.2.4 and start their own server, so in the --host mode the spec prescribes Redis’s tests cover no persistence at all (checked against the tag’s files, 18 Sep); RC2 names 28 numbers and no core operation; R2 has no defined recovery window and no designed fault rig for the BEAM; R5’s “replay” means two things; RC1’s clock has no end a maintainer can see; Elixir 1.17 against the rig’s 1.18. Decided: the spec is amended once, as 07-redis-subset revision 2 with a row per change and a new ready record, before the auditor’s sealing session: persistence out of Redis’s suite and into the program’s tests and the hidden suite (the lead states per file how many Redis tests run); every rewritten key with an expiry is followed by PEXPIREAT; one aggregate cap (a command of at most 64 MiB in total, Protocol error and close past it); the skip list written by the lead before either build; the core operation for RC2 named (SET and GET, -c 50 -P 1, plain, the binary); R5’s two replays named apart; the metrics endpoint required to sit on a named hex package in the Elixir build (the auditor names the package and the change, so P4 has something to update); Elixir 1.18. The ratified thresholds do not change. The auditor’s sealing session (Robert opens it) follows revision 2 | Fable | decided, for Robert | revision 2 of the spec and program-7-spec-ready-002; the auditor’s sealing session | | For Robert: the two readings of step 38’s brief compared (audit/mo-audit-2026-09-18-step-38-plan.md, audit/fable-reading-2026-09-18-step-38-plan.md). No disagreement. The auditor’s one finding, conceded: the 64 abuse cells’ expected answers are not written down before the run, so the harness author could fit the table to what it sees; the worker was started at 9:26 AM ET before either reading existed. Fable’s additions: the brick’s differential run and fuzz are stale if part A touches tls.zig; no test can see a data race between a reader and a writer on different schedulers; the write’s deadline under duplex is untested; the server’s shape (another process writes to a Conn whose reader is parked) is not the shape the brief tests. Decided: Fable writes the 64-cell expected table now, from the spec’s rows alone, commits it before looking at the worker’s table (audit/evidence/2026-09-18/step-38/expected-cells.md), and acceptance compares the two cell by cell; the worker’s table is not shown to change Fable’s. Acceptance probes add the four items above; what they find is a fix session before program 7’s build | Fable | decided, for Robert | step 38’s acceptance | | semantic, for Robert: a second, separate auditor session read step 37 cold (audit/mo-audit-2026-09-18-recent-tls-step37.md, PR 10; Fable’s reading audit/fable-reading-2026-09-18-step-37.md was on main first). It reproduced the certificate-path defect independently (H1, the same four chains, both ends ready) and found four more things, all conceded, none of which Fable’s reading or probes had: M1, a valid ALPN overlap past the 64th offered name is dropped and the handshake fails with alert 120, where the spec gives no limit; M2, the fuzz driver’s zero excludes batches that fail and do not fail again alone (shown by a mocked run of the unchanged script); M3, examples/effects/tls-client.mo’s six tests stay green when the handshake helper is replaced by an unconditional Timeout, because every one of them allows a fault on an unseeded run, so the corpus’s green said nothing about the client; L1, chapter 9 line 355 still describes the old fixture scheduling beside the new; and audit item 2 is not met in its governing sense (the RFC 8448 replay is a native test with authentication skipped, not a vector in the Mo corpus under both runtimes). Also noted and agreed: the post-fix probe was 49 of 50, the one miss an expectation the script was then loosened to allow. Decided: the TLS brick is not complete and the state page, the board, and the shelf stop saying it is. Step 39, the TLS brick’s corrections, queued directly after step 38 (both touch tls.zig and the runtimes): path length, keyCertSign, extended key usage for the role, every unknown critical extension refused, name constraints refused as unsupported; ALPN searched whole or capped with a stated error; the fuzz driver keeping and counting every failed batch and exiting nonzero, diff.py too; the client example’s tests split into exact deterministic controls (a handshake and a line each way must succeed; each refusal must be the named error) and seeded-fault tests; the vectors in the corpus under both runtimes; chapter 9’s stale paragraph removed. Its gate is the auditor’s own chain-checks.py (both copies) rejecting all four with the control passing, an x509-limbo run, the mutant check failing as it should, and a fresh 1,000-session differential run with constrained chains in the generator. A rule for every step from now on: the lead runs one mutant per new corpus test file at acceptance (break the thing under test; the tests must go red) | Fable | decided, for Robert | step 39’s brief and its gate; the mutant check at step 38’s acceptance | | Research PR 7 (the Hermes lane, 18 Sep: TLS state-machine learning, USENIX Security 2025; OpenSSL 3.0’s close_notify against an unexpected EOF) read and merged, wiki only, five files under mo-wiki/. Nothing in it changes a decision. Taken from it: every abuse cell records the handshake state actually reached before the fault (already in audit/evidence/2026-09-18/step-38/expected-cells.md), a no-crash count and a permitted-transition check are separate evidence columns (step 39’s gate has both), and a differential run records its oracle’s version and options | Fable | accepted | step 38’s acceptance; step 39’s brief | | For Robert: the sealed seventh suite was worse than the auditor found, and Fable found it only by running the corrected copy for the first time. Every one of defects6.py’s 19 server starts passes --retain-ms 500 or 300; change 4’s spec gives 1,000 as the minimum, and a correct program refuses the flag with a usage error (the generation-five Go program: exit 2, “—retain-ms is 1000 to 2678400000”). So the sealed suite, as written, fails every category on every correct program and passes only a program that does not check the bound. It was sealed at 4:50 AM ET without ever being run against anything. The rule that follows: a hidden suite is smoke-run against the previous generation’s programs before its hash is sealed (its new categories will fail there, but its setup must run). defects6b.py sealed now, sha256 183a992cb6893ca8 (full: 183a992cb6893ca8c4c2e34b3190a3fc90c02619f2e17e7010844368ff675c73), 18 Sep 2026, 10:00 AM ET (the commit that adds this row), before any suite has run on any generation-six program: defects6.py with --retain-ms 1000 and the waits lengthened, the sequence’s late job in a fresh queue (G6-1), the kill oracle’s or over every acked job (G6-2), harness preconditions printed and counted apart from defects, a nonzero exit (G6-3), macOS’s netstat and temp folder (G6-6), one new category change5 (the language’s own change-5 program writes, archives, renames, compacts, renames again, and stops; the change-6 program must verify, open, count the same, and serve it: P4’s first case, G6-5), and --selftest negative controls. Disclosed: written after the Python and Mo maintainers finished and after Fable read the Mo maintainer’s report (which says its program opens its own change-5 folder), with the Go and Elixir maintainers still working and unseen; smoke-run only on erosion5-go (the change5 category, 7 of 7). The sealed suite still runs first, as sealed, and its failures are filed as harness-induced. The runner e6-suites-mac.sh rewritten: hashes checked at the start, a failed build stops the run, every exit status written, a timeout named as incomplete, the watchdog limited to its own descendants | Fable | decided, for Robert | generation six’s result table: a defects6-sealed column expected to fail everywhere at server start, a defects6b column that is the reading | | For Robert, a correction to a published result: generation five’s “third suite (66)” column was never measured. e5-suites.sh called defects2.py without its required --log-format; the suite printed a usage error and exited 2 for all five runs (results/e5-{go,python,elixir,mo,morun}-defects2.txt, 16 Sep, 21:42 to 22:05), the runner discarded the status, and the result table on erosion-round nonetheless carries a number per language in that column (Elixir 63 of 65, Go 66, Python 65, Mo 66, the same as generation four’s). No raw output supports them; they read as generation four’s numbers carried forward by the lead’s earlier session without saying so. Found 18 Sep 2026, 10:28 AM ET, because the runner rewritten after the auditor’s G6-3 writes every exit status: generation six’s Python run showed exit=2, NO SUMMARY LINE on the same suite. The sentence “nothing eroded on the old suites in five generations” therefore rests on four of the five old suites for generation five. Decided: the column is marked not run on the page today; defects2.py is run on the five generation-five configurations from their erosion5-* worktrees after generation six’s suites, and the numbers go in as measured on 18 Sep with this row cited; every earlier runner’s outputs (e3, e4) are checked for a summary line per suite before generation six’s result cites them; the auditor gets this row’s raw files in generation six’s bundle. The G6-3 finding was about exactly this, and it had already happened | Fable | decided, for Robert | the rerun’s five summary lines; a check of every results/e[345]-*.txt for its summary line | | For Robert: generation six read (erosion-round, the result of 18 Sep 2026, 11:32 AM ET; raw under erosion-round-suite/results/e6-* and audit/evidence/2026-09-18/generation-six/). Nothing eroded in any language under any of the six old suites; under the corrected seventh suite (defects6b.py, sealed 183a992cb6893ca8) no program has a defect: every failure is the harness’s (two /queues checks that all four programs fail identically, a record-shape assumption) or the machine’s (Python’s bench reads /proc). Mo’s count went down for the first time: generation five’s Mo-only defect was fixed from the ticket, the sixth suite 94 of 94 in both runtimes. P1 and P2 held (P2 at a tie of zero); P3 and P4 failed (no baseline lost anything under the kill; every program opens its own change-5 folder); P6 failed for the sixth time: no never or invariant tripped on a wrong edit in Mo, and none in the other three; P7 is void (the spec named the cause) and what is true is that the rate is back: about 3,700 pairs a second at 32 workers against generation five’s 425, 1.01× change 3 on the lead’s second round. Time, loops, and tokens are recorded and compared with nothing (broken sessions, two machines). The language rule’s ledger at six of ten generations: zero catches, threshold two | Fable | decided, for Robert | the auditor’s reading of generation-six-ready-001; generation seven | | semantic, for Robert: on macOS, Mo’s “on disk before Ok” is not on the disk. Both runtimes call plain fsync (toolchain/src/blocking.zig:114, toolchain/runtime/mo_rt.c:8303); on macOS that hands the bytes to the drive without asking it to flush, and only fcntl(F_FULLFSYNC) does. Go’s File.Sync uses F_FULLFSYNC, which is why Go’s queue runs at about 100 pairs a second on this Mac where Mo’s runs at 3,700 and Python’s (os.fsync, the same plain call) at 4,200: the Mac’s speed rows since round 7 compared a stronger promise in Go with a weaker one in Mo and Python, and every “Mo ahead of Go at concurrency” sentence taken on the Mac is withdrawn as a speed claim (the VM’s rows, Linux, stand: fsync there is the full promise). Decided: Mo’s runtimes use F_FULLFSYNC on Darwin, falling back to fsync where the file system refuses it, in step 39; chapter 3’s durability sentence names the platform rule; the Mac rows are re-taken after it; the ratified comparisons (program 7 against Elixir) run on Linux, where this does not arise, and the rig note for program 7 says so. Found by the lead reading Go’s 105 against Mo’s 3,700 in the maintainers’ own bench lines, then the source | Fable | decided, for Robert | step 39: a test that the Darwin build calls F_FULLFSYNC (a syscall trace), and the Mac’s jobq rows before and after | | From the Mo maintainer’s TOOLCHAIN-BUGS.md, entries 6 to 9 (erosion6-mo, 53ee60d), ratified as toolchain rows: (6) no Fs row syncs a folder, so a Mo program cannot make a rename or a create survive a power loss by the book (the crash-consistency gap the research lane named on 17 Sep, now confirmed from inside a program); an Fs row sync_dir or a rename that syncs its folder, with the fixture able to fail between a write and a rename, goes to the step after 39; (7) a mo fmt break seen once on the VM and not reproduced: recorded; (8) for _ in 0..n builds the whole range (4 GB in 10 s at 0..100_000_000): a range in a for must be a counter, both runtimes; (9) a delayed send that re-arms itself keeps a simulated test from ever settling and its memory grows without bound (the 13.4 GB process): the simulator needs a virtual-time horizon with a diagnostic naming the process, and memory that does not grow with simulated time. (8) and (9) are the runtime memory probe’s first two items | Fable | decided | a toolchain step after 39: the three rows, each with a test that fails today | | The spec sentence generation six could not read: change 2’s GET /queues lists “every queue that has at least one job in any state”, and an archived job (change 4) has a state but no column in /queues. All four maintainers, in four languages, omit a queue whose only jobs are archived; Fable’s suite expected it listed. Decided: the four programs’ reading is the spec’s from change 7 on (“a queue with only archived jobs is not listed; /archive counts them”), and the two checks in defects6b.py are counted as the harness’s in generation six’s result | Fable | decided | change 7’s spec | | For Robert: step 38 accepted (11:59 AM ET, 18 Sep 2026; parts A ebf59b3, B 1bb5612, C 26610d6; one Opus session 9:26 to 11:06 AM ET on the Mac; interpreter-step-38). Verified by the lead: the suite 237 of 237, exit 0, 7 min (audit/evidence/2026-09-18/step-38/fable-probe/zig-build-test.log); the mutant: main’s duplex.mo run by the runtime of b0b2ac4 differs from its transcript at one core in 5 of 5 runs (the TLS leg “a process writes, main reads”: 131 of 1,600 lines back) and stalls 60 s in 1 of 5 at 14 cores, while main’s runtime is equal in 10 of 10 (mutant-old-runtime-ten-runs.txt); the lead’s first single mutant run passed by luck and the lead told Robert at 11:55 AM ET that part A was unproven, which the ten runs corrected, so a mutant is run at least five times at one core and at the machine’s count; a held-reader pipelining probe (Python’s ssl, 20 to 25 MB of numbered lines at tls-echo.mo, the server’s writes blocked for 3 s while its reader goes on, every byte and the order checked, 1 and 14 cores): 8 of 8 under mo run, 8 of 8 as a binary, server memory flat at 19 to 40 MiB (and 8 of 8 on the old runtime: the server’s shape was never the broken one, so this shows no corruption and no regression, not the fix); the abuse table 64 of 64 with the worker’s negative control (0 of 33 against the runtime before b0b2ac4), compared cell by cell with the lead’s table committed before it was seen (expected-cells.md, 90cbc2f): 56 equal, 6 where the worker’s Closed after a post-handshake fatal alert is more exact than the lead’s “the stream’s end” (accepted), 4 (S3 and C2, an alert or close_notify in the clear once handshake keys exist) where the brick acts on the plaintext record: kept for the server (OpenSSL’s client sends its refusal alerts so) and changed for the client in step 39 part C. tls.zig’s production code is unchanged since b0b2ac4 (one test helper’s fcntl made portable: the Mac’s SIGSYS), so step 37’s differential run and fuzz are not stale. Not verified by anyone: a KeyUpdate arriving during duplex traffic (Python’s ssl cannot start one); a ThreadSanitizer build; part B’s gain, which the worker measured in a Linux container (windows of 16: 8.8 s to 0.19 s plain) because the Mac’s loopback shows no Nagle delay (0.150 to 0.153 s), and which the lead did not rerun. Two probe errors of the lead’s own are kept under fable-probe/first-attempt/ (two threads on one SSL socket; the example’s 200 ms idle exit read as a server’s death) | Fable | accepted, for Robert | program 7’s pipelining clients; step 39 part C; the auditor’s reading of step-38-ready-001 | | From step 38’s acceptance, carried into step 39: the corpus runs duplex.mo at the machine’s core count, where the old runtime passed four runs in five; the corpus step must also run it (and every example whose claim is about scheduling) with MO_CORES=1, where the old runtime is red every time. And the worker’s eleven “decisions the brief did not cover” are ratified as read (from Opus’s default), the two that matter: close skips close_notify while a flush is halfway through a record, and the Busy checks in the example are sequenced by a pause on an idle listener, which is a test-only device and not a pattern for programs | Fable | decided | step 39’s corpus change; program 7’s review of any Busy handling | | For Robert: the two readings of generation six compared (audit/mo-audit-2026-09-18-generation-six.md, PR 11; audit/fable-reading-2026-09-18-generation-six.md, restating what was on main at d846a4b before the auditor’s PR; compared 12:10 PM ET, 18 Sep 2026). They agree on the ledger (zero catches at six of ten, threshold two; 16 declarations over 8,630 lines, 1.85 per 1,000), on P3, P6, and P7’s void condition, on the sealed suite’s invalidity, and that the corrected suite is late-corrected evidence and not the pre-registered instrument. The auditor is stricter in six places and is right in each; all conceded after Fable checked the source: (1) P1 is not met as written. P1 said Mo 0 under every earlier suite; Mo carries one real cause in the third suite (a queued record with a worker and no lease deadline verifies: job.mo:503 tests (state == Leased) != (worker and until both present), which a worker-only record passes), unchanged since generation three. Fable’s “held” read “no new cause” into a threshold that says zero. (2) The same two failures in Python are not Python’s: control-run-8-suite/oracle4.py:76 writes "worker": None for the Python fixture unconditionally, so the illegal record is never written; Python’s store refuses the real one (the auditor probed it). Fable had filed both as “carried” alike; Mo’s is a defect and Python’s is Fable’s harness, since round 8. (3) /queues: change 5 line 56 says a queue with a job in any state, “live or archived”, is “the same as /queues listing it”, which supports the suite’s reading; Fable’s row of this morning dismissed the two checks as the harness’s from change 4’s sentence alone. They stand as one common spec-level discrepancy in all four programs, the text disputed, equal across languages, and change 7 settles the sentence prospectively. (4) In defects6b.py the prune-record locator’s failure in Mo and Python also skipped the malformed-cutoff checks that Go and Elixir got, so coverage was unequal and “0 harness preconditions failed” did not mean an error-free harness; and the file’s header still carries the sealed file’s sentence “before the four maintainers’ sessions started”, which is false of the correction. (5) Go’s 30,000-job row at 0.66× stands as a failed budget row; Fable’s three reruns at 5,000 jobs were a changed workload and show variability, not a cancellation: Go is rerun at 30,000 jobs, alternating, three rounds, today. (6) The instruments: measure.py prints intended creates, not completed ones, and loses producer-thread exceptions; its restart line prints a duration after a timeout; ps --ppid is Linux’s; the runner writes statuses but still exits 0 after failed suites. Also new from the auditor’s source reading: Python’s compaction keeps a rename count the spec says it drops (a representation mismatch, no suite printed it). Decided: the result section on erosion-round is corrected by a dated note (P1 not met; Python’s third-suite failures struck as harness; /queues as a disputed common discrepancy; Go’s row); the Mo defect is a ticket in change 7; oracle4.py, measure.py, and the runner are fixed before generation seven, each with a negative control, and generation seven’s suite is smoke-run and read by the auditor before its seal (Fable asks for that in the pre-registration’s ready record). No disagreement is filed | Fable | decided, for Robert | the Go rerun at 30,000 jobs; change 7’s spec; generation seven’s pre-registration | | For Robert: program 7’s spec, revision 2, sealed (12:19 PM ET, 18 Sep 2026; 07b-redis-subset-revision-2; the sealed 07-redis-subset is not edited; published as program-7-spec-ready-002). Nine amendments, each from the two readings of this morning: Redis’s three persistence test files leave the list (they run nothing against a server the runner did not start) and the reading must say Redis’s tests are silent on mored’s durability; every rewritten key with an expiry gets PEXPIREAT; one size rule (64 MiB a command, 1,048,576 elements, refused at the header); the skip list is the lead’s, written before either build, six reasons, no “timing” reason; RC2’s core operation is GET at -c 50 -P 1 -d 64 on the plain port, the binary, on Linux; the Elixir build must serve /metrics through a hex package so that P4 has something to update; Elixir 1.18; the recipes’ full gate; the abuse suite’s seam. One amendment touches how a ratified row is measured, and Robert and the auditor should look at it: R2. The rule’s text measures MTTR “on --faults 0.05 --until 0.5”, which are flags of Mo’s simulator and have no counterpart under the BEAM, so as written the row cannot be taken on the Elixir build at all. Revision 2 defines the rig both builds can run (kill the keyspace process under a steady SET load, twenty times; recovery is the kill to the first +OK; MTTR the mean) and leaves the threshold (at most 1.2× Elixir’s) alone. That is Fable operationalizing a ratified clause, not amending its threshold; if the auditor reads it as an amendment it is Robert’s to ratify, and the builds do not start before the sealing session either way. R4’s hundred edits, R5 as the runtime’s seeded replay (Mo-absolute), R7’s empty folder, RC1’s clock, and R6’s withheld channels are pinned the same way. The denominator is partly measured: Redis 7.2.4’s runner against Redis 7.2.4 itself in --host mode ran eight files on the Mac before the lead stopped it (audit/evidence/2026-09-18/program-7-spec-r2/): 649 tests passed, unit/type/set ended in an exception after 107, and unit/type/stream hung in a test that starts its own server, so even the files the spec keeps hold tests that cannot run this way; the full baseline is taken on the Linux rig before the skip list is written | Fable | decided, for Robert | the auditor’s sealing session on revisions 1 plus 2; the Linux baseline; the skip list | | Robert asked (18 Sep 2026, 9:27 AM ET) for the control-run and erosion worktrees to stop cluttering his projects directory. Done 12:22 PM ET: all 67 sibling worktrees moved with git worktree move from ~/Projects/startups/mo-lang-<name> to ~/Projects/startups/mo-lang-worktrees/<name> (68 registered before and after, 0 failed, nothing deleted or merged; the map is mo-lang-worktrees/MOVED-2026-09-18.json). The live scripts (e6-suites-mac.sh, e6-speed-mac.sh, e6-brief-mac.sh) and the lead’s skill now use the new paths; every older page, brief, and evidence README that says ../mo-lang-<name> means the same worktree under its new path, and is left as written. Python worktrees need uv sync and Elixir ones mix deps.get before a first run from the new place. The VM’s copies are untouched | Fable | done | the next suite run from a moved worktree | | Go’s budget at the registered workload: not met on the evidence there is (recorded 1:36 PM ET, 18 Sep 2026; erosion-round-suite/results/e6-speed-go-30k-again.txt). The rerun at 30,000 jobs the auditor asked for completed one alternating round before it had to be stopped: change 3 at 230 creates and 112 pairs a second at 32 workers, change 6 at 225 and 70: 0.98× on creates, 0.63× on pairs, beside the first row’s 0.94× and 0.66×. Round 2 began at 12:32 PM ET under a load average of 32 (step 39’s worker running the test suite) and the Mac then slept for Robert’s pause, so it printed nothing and is not evidence. Two 30,000-job rounds now agree that Go’s change-6 program is at about two-thirds of its change-3 rate on lease-and-ack pairs at 32 workers on this Mac, under the 0.8 budget, where Go’s own maintainer measured 1.00× with its own bench; the 5,000-job rounds (0.99, 1.61, 0.96) do not show it, so the cost appears with the size of the log or the archive, which is what change 6 touched. Fable’s “noise on a disk-flush-bound path” of 11:33 AM is withdrawn. So P7’s last clause (“every baseline is within its budget without a change”) fails for Go, on a busy Mac where every Go write is a full flush; a quiet Linux rerun (three alternating rounds at 30,000 jobs) is owed before it is called a Go regression rather than this machine’s, and it goes to the auditor as evidence-updated either way | Fable | decided, for Robert | three alternating 30,000-job rounds of Go’s change 3 and change 6 on Linux | | semantic: a test can ask how many faults the simulator has injected into its run (3:00 PM ET, 18 Sep 2026; asked by step 39’s first worker in toolchain/bench/step39/WIP.md). The corpus runs every process test under 100 seeds with faults and requires that none passes only without them, so a test that tolerates a fault must tolerate it always, and then it passes when the thing under test is replaced by a Timeout (the auditor’s M3 on tls-client.mo). Decided: one test-only row, no new syntax, on what the test already holds from the simulator (the worker picks the receiver and name that fit chapter 9; it returns the count of faults injected so far in this run, 0 in the fixed-order run and under mo run); a test’s allowance is then written as “this error, and only if a fault was injected”, and its deterministic control has no allowance at all. Step 39 part E uses it for tls-client.mo. It follows that every fault-tolerant test in the corpus may be vacuous in the same way: a sweep with the auditor’s mutant method (break the thing under test, the tests must go red) over every corpus file with a fault allowance is a step of its own after 39 | Fable | decided | step 39 part E: the auditor’s example-assertion-check.py goes red; then the corpus sweep |

| Robert will perform the cloud VM move himself after the current Step 39 worker finishes (18 Sep 2026, 3:40 PM ET). Codex (GPT-6) monitors the worker, preserves the final report, raw evidence and Darwin-only checks, ensures its checkpoint is pushed, names acceptance still owed, ends the worker, and stops the queue for the move. No automatic provisioning or transfer, and no later queued work before that handoff. Worker completion does not accept Step 39 or complete the TLS brick. | Robert; recorded by Codex (GPT-6) | decided | the final move checkpoint in HANDOFF.md | | Linux Redis baseline preserved for the move (3:40 PM ET): all 22 retained files attempted, 909 ok, 5 err, 22 ignored, 3 exceptions, 3 timeouts; thirteen exit 0, six exit 1, three exit 124. This ran in OrbStack Linux on the Mac, ending 3:34:59 PM ET. The script reuses one server and two exceptions say another background child is active; those are not yet permanent skip grounds. The raw logs and table are in audit/evidence/2026-09-18/program-7-spec-r2/; fresh-server checks and the skip list remain owed after the move. | Codex (GPT-6) | recorded | the evidence update and destination-rig checks |

| Robert asked to wrap the Step 39 worker up ASAP for his own VM move (18 Sep 2026, 4:33 PM ET). This supersedes waiting for all six parts: A/B are pushed (faec6b5, 18d45a6); C/D are preserved as a patch in bba9fda; E/F and Linux verification are unstarted. Worker ended, queue stopped. No acceptance: limbo is 27 against the zero gate, abuse is 63/64, the lead’s own checks are unrun, Darwin full-sync is unimplemented. The worker’s 15 decisions are preserved, not ratified. Report, scratch suite logs, exact WIP diff and 68-worktree inventory are in audit/evidence/2026-09-18/step-39-move-checkpoint/; a verified private transfer package also preserves 70 local branches/tags and local-only files. Sixteen local branch names have no same-name origin ref. | Robert; recorded by Codex (GPT-6) | decided, paused | Robert’s move and a fresh worker continuing toolchain/bench/step39/WIP.md; the original acceptance gates |

Lead transition and PR 12 (18 Sep 2026)

decisionwhostatusfirst tested by
Robert authorized Amp to take the lead role in the Amp orb. The active task is PR 12’s review and audit exchange; no implementation worker or program 7 build is started in this review. The prior private transfer and 68-worktree environment are not verified here; Zig 0.16 is available, Herdr is not on PATH.Robert; recorded by Ampdecidedthe next implementation session’s environment check
PR 12 reviewed and merged unchanged after the lead’s audit/fable-reading-2026-09-18-current-state.md was published on main at 3473239. The auditor’s audit/mo-audit-2026-09-18-current-state.md and lead’s audit/fable-comparison-2026-09-18-current-state.md agree on the verdict at its anchor; no substantive disagreement. TLS authorization and ALPN failures predate step 39 A/B, whose preserved probes now pass those cases; independent acceptance and the zero-Limbo gate remain owed. The audit is not rewritten or treated as a fresh failure of A/B. Step 39 stays unaccepted.Amprecorded, for Robertfull step 39 acceptance, not worker counts
Acceptance instruments must propagate failures/timeouts, reject empty or invalid selections, assert expected coverage, and prove the intended abuse state and stimulus were reached. Fresh unchanged mock probes at 5:28 PM ET reproduce all four runner cases returning 0 after injected 1/124, 20/20 abuse cells with failed stimuli and mocked good output, and a failed fuzz batch reported as zero crashes; a real invalid category selection runs zero checks and exits 0. Source and outputs: audit/evidence/2026-09-18/current-state-lead/. These prove harness defects, not a false-green real campaign. Repairs and negative controls precede further acceptance; preserve sealed evidence. Add a reproducible Zig/corpus CI gate as follow-up: the wiki deployment and Socket checks are not that gate.Amp, on PR 12decidednegative controls on repaired instruments before step 39 acceptance or generation seven
For Robert: program 7’s R2/RC1/R4 measurement discrepancies are conceded to PR 12; see both current-state readings and the lead comparison. Recommend explicit ratification of revision 2’s twenty-keyspace-kill R2 rig with the unchanged 1.2x threshold, disclosed as narrower than mixed simulator faults; retain separate RC1 timestamps through first passing hidden suite rather than silently substituting the maintainer report; fewer than 100 edits cannot clear R4. These are recommendations, not rule amendments. Resolve them in a recorded decision and a new spec revision before the auditor’s seal/builds; never edit revision 2 in place.Ampfor Robert, semanticexplicit measurement reconciliation and the auditor’s sealing session
Program 7 is not ready for its binding comparison. In addition to PR 12’s measurement and baseline gates, the lead’s orientation found line-only Conn input inadequate for binary RESP, no snapshot-plus-message-log restore path matching R5, and the already-recorded missing directory-sync operation. Resolve these against the sealed requirements before briefing the builds; no silent substitution of seeded whole-test reruns for snapshot replay or process-kill recovery for power-loss durability. These are lead findings, not findings attributed to PR 12.Ampdecided, semanticprogram 7 readiness review and any explicitly versioned spec/toolchain work

Agent-native direction and program 7 suspension (18 Sep 2026)

Authority: Robert’s explicit confirmations in the lead discussion, recorded by Amp. These rows append decisions; they do not rewrite earlier votes or evidence. The documentation checkpoint follows the 7:59 PM ET fetch.

decisionwhostatusfirst tested by
Mo is for agents as code authors and readers. Humans specify outcomes and authority and review behavior and evidence, not source. It remains a functional, statically typed, compiled, BEAM-inspired option, never a required replacement for Elixir/Erlang.Robertdecidedthe revised premise and future agent-workflow evaluation
Prioritize the complete fast, trustworthy agent feedback loop for existing features over expansion, except where a missing capability blocks a representative application. Plain source plus targeted semantic operations, version-correct just-in-time learning and compiler/runtime inspection are the direction; protocols such as MCP expose the services, not replace their semantics.Robertdecideda bounded workflow milestone, scope still to be agreed
Evaluate both cold discovery and a short introductory guide. Later compare different LLMs, including affordable and open-weight models, on independent behavioral success and total cost including retries, failures and stronger-model assistance. Smaller-model parity is a hypothesis, not an accepted result.Robertdecidedfuture pre-registered onboarding and cross-model studies
semantic: Program 7 execution is on hold. Its BEAM-superiority thesis and runtime-claim retirement framing S-A/S-B/S-C in audit/mo-audit-2026-09-17-stopping-rule-runtime.md are superseded prospectively because the product goal is another useful agent-native option, not superiority over BEAM. No old gate is declared passed and no historical result changes. Preserve 07-redis-subset.md, revision 2 and all auditor rules/evidence unchanged; a replacement scope and criteria require a new version before any seal/build. Capabilities requirements and T-A/T-B/T-C are not retired here, but their program-7 execution is suspended. The separate generation-ten contract-catch rule and R-B are not retired. Correctness and safety obligations remain; implementation as a whole is paused. This supersedes the preceding PR-12 queue’s instruction to proceed toward the old seal/build.Robert, explicitly approveddecided, semantica replacement charter/specification and audit coordination before future execution
Robert is running all four research briefs in parallel: unfamiliar-language learning, semantic editing, useful language restrictions, trustworthy verification evidence. Results are pending. The lead synthesizes with the oracle; no new research workers or implementation sessions are started. Oracle consultation is required for substantive lead evaluations and decisions.Robertdecidedsynthesis when Robert supplies the results
The lead’s proposed sequence is evidence integrity and bounded execution, security/durability containment, an end-to-end agent slice on an existing application, measured improvements, then revised program 7 and broader model evaluation. A smaller program-7 core, TLS make-versus-wrap, individual law revisions and exact acceptance thresholds remain open proposals. Documentation is authorized; workers, environment setup, experiments and implementation require Robert’s explicit resume instruction. Step 39 remains unaccepted.Amp’s proposals; Robert’s pauserecorded, openfurther discussion after research; no execution authorized

Research received and external review requested (18 Sep 2026)

Authority: Robert’s confirmations in the lead discussion; recorded by Amp. These rows extend the pause and record proposals, not implementation acceptance.

decisionwhostatusfirst tested by
Four supplied research reports preserved unchanged with hashes and synthesized with the oracle in agent-native-research-synthesis. Selective primary-source checks corrected overstatements about compiler-feedback outcomes, LSP edits and pytest. No report’s suggested thresholds or evidence gates are adopted.Amprecordedfuture trial specification and external review
The evidence attachment labels itself an auditor draft; the lead encountered it in the research batch before filing a new independent reading. This is not a cold independent audit reading. Its E-1–E-8 remain proposals, no hidden suite was opened, and no ratified audit obligation changes.Amprecorded, for Robertany later formal audit must respect the disclosed exposure
A bounded maintenance task is the first candidate to discuss. The lead/oracle propose the existing Agent application’s terminal HTTP-401 policy, current versus guided onboarding and a small affordable/reference-model pilot. Exact task, models, budgets, repetitions, independent checks and escalation rules remain open; no experiment is authorized or sealed.Robert agrees to direction; Amp/oracle propose scopeprovisionaldiscussion and external critiques before pre-registration
No workers, setup, implementation or experiments begin until Robert explicitly approves starting and the lead confirms readiness. We are still discussing and revising; documentation maintenance and recording proposals do not authorize execution. Program 7 stays suspended and Step 39 unaccepted.Robert; Amp agreesdecidedexplicit start decision with resolved prerequisites
Robert requests multiple external model opinions with web research and no assumed repo access. Reviewers may challenge everything, including whether Mo should be a language/runtime. agent-native-independent-review-prompt separates goals, implemented capabilities, historical evidence and proposals, and asks for reasons, counterevidence and decision-changing experiments. Compare reasons, not votes; no reviewer is an implementation worker or a cold raw-evidence auditor.Robert; recorded by Ampdecidedindependent reviews returned by Robert

External strategic review agreement (18 Sep 2026, 9:36 PM ET)

Authority: Robert’s agreement to the lead/oracle synthesis; Amp records the direction separately from the lead’s conservative execution interpretation.

decisionwhostatusfirst tested by
Preserve Mo’s ambition, narrow investment: trustworthy instruments, then a proposed 401 workflow/onboarding pilot, then a useful application with one well-equipped existing-language comparator. Choose the application before finalizing workload-dependent scope. The pilot is not language-value proof; extraction remains an option.Robert agrees; Amp/oracle recommenddecidedbounded specification and later independent outcomes
Requirements correctness, implementation conformance and trustworthy verification remain distinct. Consider required progress and uncertain external effects in the representative workload, not as extra 401 gates or newly promised runtime guarantees.Amp/oracle; Robert agreesdecidedworkload requirements and independently authored checks
semantic: obtain approval for a versioned retry policy before the 401 pilot; resolve shared model-client recipe versus Agent specialization. Today’s recipe promises retries on model errors. Terminal 401 is a policy change, not merely a repair. No recipe scope or implementation change approved here.Amp/oracle; Robert agrees to prerequisiteopenexplicit policy owner/scope decision
Four external strategic reviews compared in agent-native-research-synthesis; fifth pending. Agreement from a shared packet is not independent empirical corroboration. Preserve packet v1.0 and audit obligations; no new performance, security or contract-catch acceptance claim.Amprecordednew evidence, including fifth review if supplied
Robert approved the revised direction and sequence. The lead records no bounded execution start or readiness confirmation: workers, setup, experiments and implementation remain paused. Application, comparator, budgets, models, repetitions and acceptance criteria are unresolved.Robert’s agreement; Amp’s execution interpretationrecordedexplicit bounded start plus lead readiness

Mo-first coding harness selected (18 Sep 2026, 10:29 PM ET)

decisionwhostatusfirst tested by
Select mo-first-coding-harness: Mo-written, Mo-first, initially bounded maintenance of existing Mo applications. Thin CLI and machine-readable events; no initial self-editing, compiler changes, full TUI, plugins or multi-agent coordination. Reuse Agent selectively.Amp/oracle recommend; Robert approvesdecidedbounded implementation brief and protected behavioral acceptance
Actual Pi is the first practical comparator, with matched model, guidance, tool capabilities, tasks, budgets and isolation. No second Elixir harness first. Separate harness correctness, coding outcomes and Mo development cost; add an affordable model after calibration.Amp/oracle recommend; Robert approvesdecidedmatched pilot with all attempts reported
Use established external execution isolation and maintained TLS/auth boundaries where needed; disclose dependencies. Protect harness/compiler/verifier from target edits, including during final verification. Version the proposed Agent-specific 401 policy and resolve its recipe binding before implementation.Amp/oracle; Robert approves directiondecidedreadiness decisions and negative controls, not a present security claim
Approval selects the application and prepares its bounded brief. No worker launch or lead-readiness confirmation: exact paths, provider/executor, policy and budgets remain unresolved. Program 7 stays suspended; Step 39 and retained audit obligations are unchanged.Robert’s agreement; Amp records scoperecordedbounded start approval plus lead readiness
The final DeepSeek-labelled attachment is byte-identical to the supplied Kimi review, confirmed by cmp and SHA-256. Four distinct bodies, not five; attribution cause unknown. Pi source inspection informed the application design, not new runtime acceptance.Amp with oraclerecordednew evidence if supplied

Report claim check proposed (18 Sep 2026, 11:00 PM ET)

decisionwhostatusfirst tested by
Propose report-claim-check: TypeSafe (Jev) triage of worker report claims against raw outputs, citation-check shape; code-first exact checks; output orders the lead’s attention and is never acceptance, raw evidence or a reading. Not in the Mo harness, so the Pi comparison stays matched.Robert chose from lead’s three optionsrecordedcalibration on step 36, Step 39 A/B and planted negative controls
A TypeSafe account and API key, and sending raw logs to an external service, are Robert’s call. Nothing is built or called before a bounded start and lead readiness.leadfor RobertRobert’s answer
Robert already has a TypeSafe account and API key (18 Sep 2026, 11:10 PM ET). Still open: sending raw logs out, and a bounded start.Robertrecordedbounded start approval

Orb workers and subscription OAuth (18 Sep 2026, 11:01 PM ET)

decisionwhostatusfirst tested by
Use available Amp orbs. Astra is lead. Every worker and every new work unit/phase gets a fresh thread; workers use medium mode and a1.xxlarge orbs. Supersedes Herdr/Opus launch mechanics, not role ownership or audit rules. No launch or current-thread model switch is claimed.Robertdecidednext explicitly approved worker launch with exact code transferred
The Mo harness uses Robert’s OpenAI subscription through its own OAuth login, presenting the genuine provider link/code when authentication starts. Do not use an API key or borrow Amp credentials as an implicit substitute.Robertdecidedauthorized device/browser flow after readiness
Prefer a pinned Pi AI provider/auth/transport adapter with device login first; Mo retains the agent/tool loop. Protect credentials and sanitize upstream auth errors. Local logout is not a server-revocation claim. See mo-first-coding-harness.Amp/oracleprovisionalsupported client-identity decision, adapter contract and isolated credential tests
Pi’s source demonstrates subscription interoperability, not general registration permission. Account/model eligibility, support expectations, network policy and secret isolation remain open. No login, implementation, setup or worker started.Amprecorded, openlead-owned provider readiness checks

Amp thread workflow made operative (18 Sep 2026, 11:14 PM ET)

decisionwhostatusfirst tested by
Keep the Astra lead in this same thread. Replace active Herdr/shared-tree instructions with fresh medium-mode, a1.xxlarge worker orbs per worker/new work unit/phase; explicit state transfer, bounded ownership, stable handoff and lead-side integration/verification. Historical evidence and audit obligations remain unchanged.Robert; Amp records with oracle reviewdecidednext approved bounded worker task
Worker onboarding excludes lead audit/decision duties. Preserve final code and evidence before ending a worker environment. The workflow update and authorized documentation push do not start implementation, OAuth login, setup or experiments.Amp/oracledecidedrole-aware brief and receipt checks

Lead returns to Robert’s Mac (18 Sep 2026, 11:44 PM ET)

decisionwhostatusfirst tested by
Move the Astra lead to Robert’s Mac, where he confirms OrbStack is working. This supersedes keeping the lead in this orb; keep one continuing lead session after relocation and fresh medium/a1.xxlarge orb workers. Do not restore Herdr mechanics or overwrite existing Mac work.Robertdecidedread-only destination and checkout verification
Bounded credential-free executor probes were separately approved, including temporary privileged Docker and reversible CPU setup. Final run: nine PASS records, exit 0; two failed probe runs retained. This is not Mo harness acceptance or Mac validation. Temporary setup removed and ancestor controller sets/numeric workload limits restored.Amp, observed with Robert’s scoped approvalsrecordedretained raw outputs and further destination-specific checks
Preserve separate outer VM and inner candidate boundaries; use a dedicated delegated executor subtree, bounded output drain and protected external verdict. Readiness is per bounded work unit, not a waiver of unresolved provider, task or audit obligations. No implementation worker or OAuth login is authorized by relocation.Amp, recommendation; oracle consulted on environment choicerecommendedscoped executor design and independent controls

Mac arrival inspected (18 Sep 2026, 11:58 PM ET)

decisionwhostatusfirst tested by
Continue the handoff in this Mac checkout. Arrival checks found clean main at the handoff commit, Zig 0.16.0, reachable OrbStack Docker, 68 existing worktree paths, 70 local branches and the private transfer package. Existing receiver ledger retained; zero new audit records. No restoration or executor acceptance claimed.Robert requests continuation; Codex (GPT-6) records observationsrecordedaudit/evidence/2026-09-18/mac-arrival/inspection.json
No named Linux machine exists; dedicated execution and Linux toolchain remain unverified. This Codex session lacks the required Amp oracle/native thread tools. Asked Robert whether to adapt lead/review work to Codex or preserve Amp; no new design decision or implementation start.Codex (GPT-6)openRobert’s workflow choice, then scoped readiness review

Astra/Herdr and overnight authority (19 Sep 2026, 12:10 AM ET)

decisionwhostatusfirst tested by
Astra remains lead in this Mac session; spawn fresh Astra workers at low reasoning in Herdr panes. The former orb’s oracle and medium/xxlarge Amp worker requirements are superseded.Robertdecidedactual gpt-6-astra/low worker startup and completed executor readiness review
Keep working while Robert sleeps; the lead makes decisions, including those previously needing approval, and continues around blockers. Supersedes the harness implementation pause; the lead records bounded setup, implementation and verification work.Robertdecidedisolated executor foundation, then headless coding path
Start provider-independent executor work in a dedicated isolated OrbStack machine, using existing installation’s isolation and resource-limit flags. Verify absent Mac sharing, effective limits and protected verdicts before running application candidates. Existing shared Docker daemon remains outside this scope.Astra lead, informed by Astra/low reviewdecided, semanticmachine inspection and executor controls

Agent terminal authentication policy v1 (19 Sep 2026)

decisionwhostatusfirst tested by
Specialize Agent model calls: HTTP 401 returns its status error immediately and ends that call’s retries; preserve all other retries and deadlines. Introduce Recipes.AgentModelClientV1.ModelClient and leave the generic Recipes.ModelClient recipe unchanged. This is a versioned application requirement, not a retroactive bug finding against the shared recipe.Astra lead under Robert’s overnight authoritydecided, semanticnine real-HTTP status/count controls in both runtimes, per mo-agent-terminal-auth

Provider foundation and worker receipts (19 Sep 2026, 12:41 AM ET)

decisionwhostatusfirst tested by
Use Pi revision 36b60d2e8985899743c4cf5bd5f8929832a3f05d for a provider-only fixture boundary, with artifact/catalog provenance checked independently of the package version. Select gpt-6-astra, low reasoning, SSE and no hidden retries. This is not account entitlement or a scored comparison.Astra lead, informed by Astra/low source reviewdecidedmo-provider-foundation actual-parser fixture tests
Track upstream usage presence; unknown stays unknown, reported zero is separate, and legacy Mo integration must fail explicitly until its contract can represent the result. Preserve native tool-call IDs/signatures; Mo keeps every tool and subsequent-turn decision.Astra leaddecided, semanticmissing/partial/zero usage and call-result-roundtrip controls
Accept the terminal-auth worker’s aggregate .mo.ids paths as authorized scope, restricted to Agent.Model and the new versioned recipe record. Worker HTTP matrix is reported green; independent lead acceptance is still owed.Astra lead; implementation by GPT-6-Astra at low reasoningrecorded, pending acceptanceexact record diff plus lead matrix and extra status control

Coding fixture v1 and generated evidence closure (19 Sep 2026, 12:57 AM ET)

decisionwhostatusfirst tested by
Start mo-coding-fixture-v1 in a separate worker tree: existing Agent loop, exact edit, inert HTTP command fixtures and post-run JSONL. Adopt 16 steps, 4096 reported fixture tokens, 30-second run/2-second call limits, 64 KiB byte bounds and a separate 15-second recording/report grace. This does not execute candidate commands or connect the live provider.Astra lead, informed by Astra/low interface reviewdecided, semanticinterpreter/native scripted repair and stop-bound controls
Full auth integration exposed stale dependency verification (MO0317) and an unverified driver despite focused green checks. Authorize generated-only closure regeneration with existing simulation coverage preserved; eight source files remained identical. No policy, compiler or shared recipe change.Astra lead; regeneration by GPT-6-Astra/lowrecorded, acceptance pendingretained 241/243 failure, reviewed 9f4b433, lead full-suite recheck

Executor acceptance and retained integration failures (19 Sep 2026, 1:06 AM ET)

decisionwhostatusfirst tested by
Accept mo-executor-foundation only after reaper disarm follows positive writer/container/cgroup cleanup proof. Lead repeats 15 unit, 17 live, collector-loss and explicit-exit controls; shared Docker IDs/states match and final inventory is empty.Astra lead; implementation and review correction by GPT-6-Astra/lowaccepted, semanticraw harness-integration/executor-01 evidence at integrated 4b6c3c0
Keep auth acceptance open after full-suite progression 241/243 to 242/243: generated closure is fixed, three owned files require actual formatter output. Keep provider acceptance open after clean setup reproduces missing .cache. Correct both narrowly and preserve red attempts; fixture greens do not waive integrated checks.Astra leaddecidednext guarded full-suite and fresh provider setup

Coding fixture filename correction (19 Sep 2026, 1:10 AM ET)

decisionwhostatusfirst tested by
Replace three underscore filenames in mo-coding-fixture-v1 with resolver-conventional exact-edit.mo, command-adapter.mo and coding-fixture.mo; matching IDs are owned. Preserve module names and behavior scope.Astra lead after Astra/low worker MO0323/MO0001 reproductiondecidedretained worker check-4/check-5 failures, next compile check

Offline provider acceptance and Linux build preparation (19 Sep 2026, 1:16 AM ET)

decisionwhostatusfirst tested by
Accept mo-provider-foundation as offline one-turn library: exact git TypeScript plus reviewed SSE hook, frozen generated catalog, honest unknown usage, no retries and sanitized failures. Retain the 148/177 source/artifact mismatch and clean-setup red. Lead clean-copy reproduction, 28 parser and two extra controls passed with original tracked bytes unchanged.Astra lead; implementation/correction by GPT-6-Astra/lowaccepted, semanticprovider-01/02/03 raw evidence at integrated e3a01bb
Prepare trusted Linux Mo builds inside the dedicated machine, separate from candidate fixture policy. Official Zig archive is hash-verified; build service has independent 900-second deadline, 1.5 GiB RAM, 1.5 CPU and 128 tasks, private network. First two-job build hit the memory cap; retain it and retry one job without increasing limits. This is not candidate/application acceptance.Astra leaddecidedretained Linux build attempts and unit/process cleanup observations

Terminal-auth acceptance (19 Sep 2026, 1:19 AM ET)

decisionwhostatusfirst tested by
Accept mo-agent-terminal-auth after final integrated full suite 243/243, 5/5, exit 0 and exact 62-file worker-tip comparison. Retain initial dependency/formatting failures and the earlier 18-case matrix/six independent controls; distinguish subsequent focused reruns from a fresh full matrix. Shared recipe bytes remain unchanged.Astra lead; implementation and narrow corrections by GPT-6-Astra/lowaccepted, semanticagent-terminal-auth/attempt-03 at e3a01bb, final-source-identity.json

Workspace foundation scope (19 Sep 2026, 1:23 AM ET)

decisionwhostatusfirst tested by
Start mo-workspace-foundation as a Python/BusyBox-only slice: bounded Linux tmpfs, descriptor-based trusted file handling, actual isolated feedback commands and frozen snapshot verification. Defer HTTP/provider/Mo-build integration. Preserve accepted fixture policy and reaper lifecycle; live tests wait for the lead build to stop while local implementation proceeds.Astra lead, informed by fresh Astra/low read-only reviewdecided, semanticmounted-workspace negative controls plus unchanged executor regressions

Overnight continuation (19 Sep 2026, 1:45 AM ET)

decisionwhostatusfirst tested by
After native Linux two-job OOM and one-job 900-second timeout, retain bounds and use a separate exact-source trusted Mac cross-build. It passed for aarch64-linux-musl in 43 seconds; Linux runtime verification remains pending. Positive native service/process cleanup released the machine to workspace tests.Astra leaddecided, measured build onlylinux-toolchain-preparation/install-build-01, build-02, cross-build-01
Cancelled terminal totals are unknown/null while recorded per-call usage is preserved. Require Run.Stopped before reporting. Correct the lead’s initial zero-token inference: actual RED appended and reported 17; native race RED showed post-report append.Astra lead; correction by GPT-6-Astra/lowdecided, pending integrationcoding-fixture cancel-red-2, race-before-stop-check, cancel-review-1
Start mo-provider-auth-v1 separately: only new provider/auth files, actual pinned device OAuth, private store, bounded serialized mutations, synthetic credentials and denied external egress. No live login or bridge/Mo edits in this slice.Astra lead, informed by bounded Astra/low source reviewdecidedfixed offline controls and later independent lead acceptance

Offline provider bridge scope (19 Sep 2026, 1:56 AM ET)

decisionwhostatusfirst tested by
Start mo-provider-bridge-v1 only in new provider/bridge files. Preserve native messages and validate exact two-step Mo continuations; distinguish offered replies from independently proved Book writes. Unknown usage fails before actionable output; existing/uncertain journals never resume or replay. Actual Mo control waits for lead coding-fixture acceptance.Astra lead, informed by bounded Astra/low source reviewdecidedpinned-parser offline protocol/journal controls; later Mo end-to-end release

Workspace and trusted Linux runtime results (19 Sep 2026, 2:02 AM ET)

decisionwhostatusfirst tested by
Accept mo-workspace-foundation after exact 1586-file comparison, 27 unit/22 workspace/17 executor/lifecycle/two extra controls, empty owned cleanup and unchanged shared Docker IDs/states. Retain the lead’s missing-wait probe failure separately.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticworkspace/attempt-01 and extra-02 at f4fe3ea/e6f04ce
Trusted cross-built Linux compiler passes seven commands including native driver build and 18 real HTTP auth cases, with 248 source files unchanged and positive service/cgroup cleanup. This is runtime readiness for tested trusted code; candidate Mo image/resource policy still needs separate proof.Astra leadmeasured, bounded readinesslinux-toolchain-preparation/runtime-smoke-01

Coding/auth acceptance and application build scope (19 Sep 2026, 2:18 AM ET)

decisionwhostatusfirst tested by
Accept coding fixture after cold-runner correction and 243/243 full suite. Require exact stderr and an existing current executable for legacy tests; retain cancellation usage/race reds. Release actual bridge Mo control against exact e6f04ce.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticcoding-fixture/attempt-02, 49 checks, both22 HTTP matrices, seven cancellation and six extras
Accept private auth offline after independent late-body cleanup red/green, fresh preparation, 28 auth/28 foundation/two extras and unchanged 186 original files. Live OAuth support remains unverified.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticprovider-auth/attempt-01; auth-readiness/late-response-02 and -03
Start separate mo-application-build-v1 with immutable pinned toolchain and new 1GiB/120s candidate policy plus separately capped 1536MiB parent. Preserve old BusyBox policy; require actual cold-build/resource/cleanup evidence before acceptance. Package unchanged Logstat first; repair and HTTP/Mo routing follow separately.Astra lead, informed by fresh GPT-6-Astra/low source reviewdecided, semanticfixed local policy controls, later explicitly released isolated machine controls

Bridge acceptance and application machine release (19 Sep 2026, 2:34 AM ET)

decisionwhostatusfirst tested by
Accept mo-provider-bridge-v1 at191da144 after exact92-file match,27 protocol groups, real Mo both runtimes,28 foundation/two lead extras and full243/243,5/5. Retain missing framing and mixed-selection preparation reds.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticprovider-bridge/attempt-01 and full-01;278 provider/3489 toolchain-example files unchanged
Provision separate mo-application.slice at1536MiB/CPU1/192 tasks, no swap; verify outer2GiB/CPU2/no-swap cgroup. Guest free/df are shared VM totals. Release dedicated machine exclusively to application worker, preserving old512MiB slice and read-only compiler/Zig inputs.Astra leaddecided and read backapplication-preparation/inspect-01 and provision-01
Preserve once-per-production-process bridge provisioning as trusted operator responsibility; library enforces one run per listener. No singleton, crash durability or client-receipt guarantee is claimed.Astra lead, worker limitation revieweddecided, semanticimmutable bridge API/journal review and duplicate/restart controls

Application runtime and cleanup ownership (19 Sep 2026, 3:10 AM ET)

decisionwhostatusfirst tested by
Application lead package/export and 23 runtime groups, old regressions and extra cold snapshot build pass; 68 executions/34 workspaces cleaned, shared five Docker IDs/states unchanged. Full-suite acceptance remains held on an unrelated-source TLS count mismatch, 242/243; ten focused unchanged runs pass, one full rerun underway. Preserve the red and do not label it harmless without evidence.Astra lead; implementation GPT-6-Astra/lowmeasured, acceptance pendingapplication/attempt-01, full-01, tls-focus-01
Add mo-workspace-recovery-v1 before HTTP: private ownership before effects, cleanup-only reopen, exact identity reconciliation and terminal barriers against delayed create/registration. A client deadline must not end cleanup ownership; unknown outcomes stay unknown, with no automatic retry/resume.Astra lead, informed by GPT-6-Astra/low source reviewdecided, semanticinterrupted reservation and late-bootstrap controls; independent lead acceptance required
Release the dedicated machine to recovery after positive application cleanup. Keep accepted image, resource ceilings and installed inputs unchanged. Full Mo/Zig runs remain gated while lead TLS/full-suite checks use the Mac; local Python and brief-owned remote controls may proceed.Astra lead under overnight authorityreleased, boundedexact release to worker at base 90858791; ownership inventories
At 3:16 AM ET accept the bounded application-build slice at aa7ec762 after full-02 passes 243/243 and 5/5, with all 5799 tracked bytes unchanged. The earlier TCP-count mismatch stays unexplained; the fresh pass is non-reproduction, not a fix. Release recovery’s compiler gate and continue its explicit cleanup-only scope.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticapplication/attempt-01, full-01, tls-focus-01, full-02 and retained source review

19 Sep 2026 — Recovery acceptance, 4:27 AM ET

decisionwhostatusevidence
Accept recovery6266d293 integrated throughde71578d after independent local59/schema21, recovery16, regressions, post-effect lost-reply extra and full243/243,5/5. Preserve both14/1 operator outcomes and unknown original transport/TLS causes.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticworkspace-recovery/README.md and immutable raw attempts
Next expose only six tools through mo-workspace-http-v1, with a serialized owner independent of request lifetime, exact call claims before effects and cleanup-only recovery after owner loss. Keep Mo application routing and scripted repair separate.Astra leaddecided, semanticaccepted recovery and retained workspace-wire-readiness source reviews

19 Sep 2026 — Workspace HTTP acceptance, 6:38 AM ET

decisionwhostatusfirst tested by
Accept worker42015b73/product1cf268b3 integrated atcf99cd88: exact6210 manifest entries, local22/inherited59, real22 per profile, old runtime regressions, review controls and two new extras. Full243/243,5/5;17339 tracked files unchanged;100 executions/131 workspace IDs/97 cgroups absent,34 groups gone/shared5 unchanged.Astra lead; implementation GPT-6-Astra/lowaccepted, semanticworkspace-http/README.md, immutable reviews and six lead attempts
Keep delivery uncertainty separate from persisted execution and cleanup. Absolute fragmented-IPC deadlines now return504/unknown; completed-response drain cannot close later work. Preserve all reds, first cleanup deadline refusal and two owner-kill gzip streams lacking final footers. No client-receipt, crash-durability or unconditional synchronous bound claim.Astra lead, informed by independent Astra/low reviewsdecided, semanticidentical drain/IPC probes, actual pipeline extra, closeout-01
Release mo-application-workspace-v1 locally in a fresh Astra/low worktree: remote all-six-tool routing, private config, fresh Book binding, separate command waits and terminal recording/reporting.4096/524288 are acceptance limits. Grammar decode plus raw-member counts and integer lexical validation must be proved in both runtimes; machine/full gates remain lead-controlled.Astra lead, informed by four architecture and two JSON/API reviewsdecided, semanticexact-base worker brief and future versioned acceptance groups

19 Sep 2026 — Lead change to Fable, Opus workers, application workspace restart, 7:20 AM ET

decisionwhostatusfirst tested by
Fable (Claude Fable 5.1, Claude Code in Herdr pane w4:p1) takes over as lead from Astra. Workers are fresh Claude Opus sessions in Herdr panes, one per work unit, in separate worktrees. Supersedes the 19 Sep Astra-lead/Astra-low-worker instruction; ownership, verification, audit and evidence rules are unchanged. For Robert (his instruction).Robertdecidedfirst Opus worker launch, model confirmed in its startup output
Every worker the lead creates runs with bypass permissions (--dangerously-skip-permissions); the brief’s write scope and constraints are the boundary, and the lead’s diff inspection before integration is the check. The worker already in flight (app-workspace-v2-opus, accept-edits with shell allowed) keeps its mode to avoid a restart. For Robert (his instruction, 7:33 AM ET).Robertdecidednext worker launch
Scrap the unfinished mo-application-workspace-v1 implementation and rebuild it from the accepted base 030290b8 with a fresh Opus worker. The Astra worktree is preserved as historical evidence, never merged: checkpoint 0a74a0fc plus WIP snapshot 0b1404b5 on local branch harness/application-workspace-v1 (not green: five wire REDs retained, native and final integration not done). The reviewers’ findings carry into a revised brief as required controls. For Robert.Robert proposed; Fable lead agreesdecidedrevised brief and the new worker’s RED-first controls for the five wire gaps
Evidence is kept proportionate from here: a run retains its command, exit code, summary and failing output, not per-run process tables and full source-identity manifests (the stranded slice held 20 MB of evidence for about 1,000 lines of Mo; the night added 23,820 files). Existing bundles stay as they are. For Robert, overturn if the auditor needs the fuller form.Fable leaddecidedthe rebuilt slice’s evidence bundle size and the auditor’s next reading

19 Sep 2026 — Fable’s review of the overnight harness work, 7:42 AM ET

decisionwhostatusfirst tested by
All ten overnight components are kept; none is rebuilt wholesale. Exception: the machine-side recover() in toolchain/harness/executor/recovery/ is rewritten, and recovery’s acceptance is qualified: four of its negative tests pass with the function body broken. Findings E1 to E7, H1 to H8, P1 to P5, M1 to M8 with file and line are in audit/evidence/2026-09-19/fable-overnight-review/README.md. For Robert.Fable lead, from four read-only Opus reviewsdecided, semantica fix brief per area; each finding gets a control that fails first
Overnight rows saying “independent lead acceptance” are read as “re-run by the same model”: lead, workers and reviewers were all GPT-6-Astra, and the acceptance passed five tests that cannot fail and two that assert a defect as intended (the provider’s cache_write_tokens requirement; the 2-second file-op teardown). From here a reviewer of accepted work is never the model that wrote it where another is available. For Robert.Fable leaddecidedthe next acceptance
Fix order: first the two high executor defects (a slow docker rm powers off the machine; pre-claim refusals crash the controller) and workspace HTTP’s run-ending behaviours (2 s file-op teardown, half-close, fd reuse, large output as output_encoding, missing keys as success), because the application workspace and Logstat slices run on them. Then the Mo agent’s tests that cannot fail. The provider’s live blockers (5 s deadline cap, 64 KiB cap, usage field) wait for the live-provider slice.Fable leaddecided, semanticmo-application-workspace-v1 acceptance on the fixed services
The plan’s “narrow trusted adapter” outside Mo is now about 8,800 lines of Python and JavaScript against about 900 lines of new Mo. Kept for now since isolation and provider auth belong outside Mo, but the harness’s Mo share is tracked from here and new non-Mo code needs a reason in its brief. For Robert: say if you want more of it moved into Mo.Fable leadproposedthe Logstat slice’s brief

19 Sep 2026 — Harness to be Mo-first in fact, 8:08 AM ET

decisionwhostatusfirst tested by
Fix every finding of the overnight review, and refactor the harness so that as much as possible is written in Mo, with Python and JavaScript cut to the minimum their roles need (OS isolation; provider auth over maintained TLS) and Astra’s verbose code simplified. Resolves the previous section’s proposed row. The fix batches are folded into this refactor where a module is moving anyway, so nothing is fixed and then thrown away; the two high executor defects are fixed regardless. A read-only Opus design map (must stay, can move now, needs a new Mo capability) comes first. For Robert (his instruction).Robertdecidedthe design map, then one brief per migration step, each leaving a working system

19 Sep 2026 — Mo gains a scoped child-process capability, 8:11 AM ET

decisionwhostatusfirst tested by
Mo gains a scoped child-process capability so that as much of the harness as possible is written in Mo, “to really test Mo as much as possible”. This lifts the harness plan’s “no compiler changes” rule for this capability and the permission and hostile-file rows the executor needs; zero new syntax is still the aim (a Platform part, narrowed like fs.scoped). The lead writes the design page first, with code options for anything that touches the grammar. Provider auth stays outside Mo until the TLS client passes step 39. For Robert (his instruction).Robertdecided, semanticthe design page, then a toolchain step with mo test --sim coverage of deadline, kill and bounded output in both runtimes

19 Sep 2026 — The harness capabilities’ design, 8:24 AM ET

decisionwhostatusfirst tested by
Fs.scoped is made to hold instead of adding a stricter second scope: every component opened without following links, a refused path is Missing, EntryKind gains Link, regular files only. Chapter 09’s sentence “nothing outside the scope is reachable” is false today (the check is lexical; a symlink inside a scope escapes it). For Robert: this changes existing behaviour for any program that reads through a link on purpose.Fable leaddecided, semanticthe hostile-filesystem cases from test_workspace.py as corpus tests, both runtimes
Exec is narrowed in main to Program then Command (a fixed argument list of Fixed(text) and Hole); only a Command runs or travels. No shell, no PATH, empty environment by default, own process group killed at the deadline, bounded output, Exec.fixture for the simulator. No new syntax. Containment of the child stays the operating system’s. Design on mo-capabilities-for-the-harness. For Robert.Fable lead, on Robert’s decision to add the capabilitydecided, semanticthe step’s deadline-kill, grandchild, output-bound and one-argument-hole controls on Linux and Darwin
Fs.replace: atomic write by temporary file, sync, rename, folder sync, mode 0600.Fable leaddecided, semantica kill between write and rename leaves the old file whole

19 Sep 2026 — Rebuild, step 1 and step 8 accepted, 9:03 AM ET

decisionwhostatusfirst tested by
Accept the rebuilt mo-application-workspace-v1 (harness/application-workspace-v2 at 01023e78, merged ddd81c06) at the level shown: both runtimes against a strict bridge double and the real Bridge front end over the accepted test owner; seven carried findings closed RED first. Not shown and owed by the Logstat slice: the Mo agent against the real workspace service on the machine. The worker’s 256 KiB report cap stands as mitigation for a toolchain defect (native binary prints raw memory on reports over about 0.35 MB; interpreter panic at vm.zig:1531 over about 0.8 MB), which gets its own toolchain brief. For Robert.Fable lead; implementation Claude Opus 5accepted, semanticlead build and full suite 243 of 243 exit 0 on d78cb017; audit/evidence/2026-09-19/fable-lead-verification/
Accept mo-harness-step-1-executor (cf5ed57b, report c958d118). The machine powers off only on proof that the candidate’s cgroup is still populated; an unconfirmed cleanup leaves evidence and the armed reaper, and the host’s orbctl stop follows the same rule, reversing Astra’s accepted test. Follow-up owed in the Mo server step: refuse new runs on a machine with an unconfirmed cleanup. Two fault-injected machine checks are owed. For Robert: overturn if the machine should stay fail-closed.Fable lead; implementation Claude Opus 5accepted, semanticlead reruns 96, 25, 22 local; seven live suites and inventory on mo-executor-r01, all exit 0
Accept mo-harness-step-8-agent (8e9f9ed2). steps keeps both written meanings (the legacy golden counts model calls; fixture and application profiles count recorded steps) as one Counting value chosen at configuration, with every budget check in steps.mo. A tool may run when tokens equal the budget; the next model ask is refused. The process-test rule (every test holds under 5% faults) means the boundary test asserts what held on all 100 seeds, not one exact outcome per mode. The context-size bound stays profile-only for now: giving plain runs a new over-budget reason waits for a need.Fable lead; implementation Claude Opus 5accepted, semanticsix mutants fail the rewritten test; goldens 12 of 12; matrices 24 of 24 per runtime; full suite 243 of 243
The design map’s size estimates are not evidence: step 1 was estimated at about 1,000 Python lines removed and measured 362. Reductions are reported only as measured, per “The size question” on mo-harness-in-mo.Fable leaddecidedeach acceptance’s counted lines

19 Sep 2026 — The raw-memory fix and harness step 2 accepted, 10:37 AM ET

decisionwhostatusfirst tested by
Accept toolchain-raw-memory-report (44a4da08): an answer packs when it runs, in both runtimes. The defect was a use-after-free in the runtimes, reachable by any Mo program that answers a kept ask after allocating past the frame budget in one update; no Mo program could have prevented it. For Robert. The agent’s 256 KiB report cap can now be lifted (small follow-up).Fable lead; implementation Claude Opus 5accepted, semanticfull suite 244 of 244; the reduction correct from 9 bytes to 12 MB in both runtimes at sizes the worker did not name; the MO_STRESS test
A runtime memory-safety step is queued after step 40: the whole corpus with compaction at every safe point in both runtimes as a standing check, released region memory poisoned in that mode, an audit of everything the runtimes hold outside the stack across a frame return, a Zig type split between a region value and an owned parcel, and guard.py killing the process group, since an orphan from a killed run broke the lead’s next full-suite run. For Robert (he asked how to prevent the class).Fable leaddecidedthe step’s brief
Accept mo-harness-step-2-live-tables (699eed1d). The lead’s live rerun caught a regression the worker could not see without the machine; the fix’s audit found five more rows leaking silently. Python rose to 6,643 counted lines: no more worker time goes into polishing Python that is moving to Mo, and Exec moves ahead of the Mo six-tool server so the server runs docker itself.Fable lead; implementation Claude Opus 5acceptedunit 110 OK; eight live suites and a clean inventory on mo-executor-r01
Robert pushes main himself, so main holds accepted work and lead records only: worker merges are verified on a local lead/verify-<unit> branch and reach main at acceptance.Fable lead, after Robert’s notedecidedstep 40’s integration

19 Sep 2026 — Step 40 accepted, 1:08 PM ET

decisionwhostatusfirst tested by
Accept interpreter-step-40 (toolchain/step-40-scope at 3d24c001, merged through lead/verify-step40). The lead’s first statement of the defect was half right and is corrected on mo-capabilities-for-the-harness: the real Fs already refused a read through a link pointing outside; the real holes were a program’s own scoped("link"), links followed inside the scope, mutations through links, a FIFO hang, and check-then-use. For Robert: list_kinds now reports a link as Link, not as what it points at, and a narrowed Fs refuses every link.Fable lead; implementation two Claude Opus 5 workersaccepted, semanticDarwin full suite 249 of 249; Linux x86_64 6 of 6; lead race probe 0 secret reads of 300,000
The two costs past 10% are accepted for now: a deep path costs about 9.7 µs a folder (was 1.3), and the interpreter’s list_kinds stats every entry. Correctness first; the one-call forms (O_NOFOLLOW_ANY on Darwin, openat2 with RESOLVE_NO_SYMLINKS on Linux) are a later step if a real program is slowed, since they add a code path per platform.Fable leaddecideda corpus program or the harness showing the cost
Linux toolchain checks run on Robert’s Linux VM (aurora-but-gold, x86_64), not on the Mac; the OrbStack machine is for the harness’s live executor suites only. Its first use found a Linux-only defect in a test harness that Darwin could not show.Robertdecidedstep 40’s Linux run
The harness proceeds on two tracks at once: the end-to-end run and scripted Logstat repair on the existing Python services (mo-harness-end-to-end-v1), which proves the design and yields the behaviour tests the Mo server must match; and the toolchain capabilities (interpreter-step-41, then runtime memory safety). For Robert: say if the Mo port should come first instead.Fable leaddecidedthe end-to-end run’s report

19 Sep 2026 — The auditor’s repository audit (PR 15) read and compared, 1:21 PM ET

decisionwhostatusfirst tested by
PR 15’s findings are conceded whole: sized integer literals past their type reach both runtimes (check.zig checkLiteral truncates at 32 digits and turns a parse overflow into maxInt(u64)), an oversized mailbox: bound passes the checker and panics the compiler, and the fuzz driver exits 0 on a run of no inputs. The lead’s reading (audit/fable-reading-2026-09-19-repo.md, filed first) reproduced all of it on current main on Darwin and found one worse form: a 54-digit literal silently becomes a different number. Comparison: audit/fable-comparison-2026-09-19-repo.md. No disagreement is open. semanticFable leadacceptedinterpreter-step-43
The fix is its own small toolchain step, interpreter-step-43, RED first, with a sweep of every number the compiler reads from source; it runs beside step 42 and the lead accepts the merge work. Default range for a mailbox bound: 1 to 4,294,967,295, 0 refused unless the spec gives it a meaning. For Robert: the language’s sentence “overflow is never implicit” was false for literals until this lands.Fable leaddecidedstep 43’s RED tests
A reproducible compiler and corpus CI gate is still owed (the auditor’s standing concern 2, first raised 18 Sep), and the suite writing generated files into the source tree is part of it: two runs cannot share a tree. It follows steps 42 and 43.Fable leaddecidedthe gate’s first run on a pull request

19 Sep 2026 — Few Opus workers at once, 1:33 PM ET

decisionwhostatusfirst tested by
Robert: going forward, do not spin up too many Opus workers. The lead’s working limit is two at a time until he names a number; briefs queue. Three were in flight when he said it (end to end, step 41, step 43); none is stopped, and nothing new launches until fewer than two remain.Robert; the number is the Fable lead’sdecidedthe next launch

19 Sep 2026 — Three Opus workers is the maximum, 1:33 PM ET

decisionwhostatusfirst tested by
Robert named the number: at most three Opus workers at once. This replaces the lead’s working limit of two in the section above.Robertdecidedthe next launch

19 Sep 2026 — Step 43 accepted, 1:59 PM ET

decisionwhostatusfirst tested by
Step 43 is accepted: every number the compiler reads from source goes through one exact reader, and a literal past its type is MO0217 before either runtime sees it. This closes PR 15’s F1 to F3. Darwin full suite 263 of 263; Linux build and focused tests green. semanticFable leadacceptedthe auditor’s next reading of number.zig
Ratified defaults of the worker (Claude Opus 5): MO0217 is reused for every range, no new code; a mailbox bound is 1 to 4,294,967,295 and 0 is refused (every send would crash its sender); max_restarts is 0 to 4,294,967,294, because the lowering marks “none given” with 2^32 - 1; a float literal that would be infinity is refused; the lowerings panic with a named message if a refused literal ever reaches them. semanticFable leaddecidedstep 43’s tests
-128 written as an Int8 expression stays refused (128 does not fit in Int8); only a pattern takes it, so a signed type’s smallest is written -127 - 1. Conservative and never wrong, but unfriendly. For Robert: accepting -<literal> as one literal would be a small rule, not new syntax; say if you want it.Fable leadopena corpus program that needs it
Noticed by the worker, not fixed, queued as small toolchain items: a crash report’s source span inside "#{...}" runs to the end of the line; per 0.ms (a window of nothing) checks and has no stated meaning.Fable leadrecordedthe next toolchain step that touches them

19 Sep 2026 — TypeSafe (Jev) approved for a report claim check calibration, 1:59 PM ET

decisionwhostatusfirst tested by
Robert approved sending worker reports and log excerpts to TypeSafe and has an API key. This settles the open item on report-claim-check. Never sent: auditor readings, sealed suites, secrets, anything outside the repository.Robertdecidedthe sender’s refusal tests
The first use is a calibration only, at tools/claim-check/ (lead-side Python, uv), on labelled cases from this repository’s history plus planted controls, at most 2,000 requests, model pinned by exact name. The lead’s acceptance loop does not depend on it until its numbers exist and a row says so; it never accepts anything. The second use, Jev as the Mo harness’s fast-judgment layer (typed Choice to a Mo enum), waits for Exec and HTTPS.Fable leaddecidedtools/claim-check/calibration/RESULTS.md

19 Sep 2026 — Research PR 16 (Bend2) read and merged, 2:03 PM ET

decisionwhostatusfirst tested by
Hermes’s bend2 comparison is merged after the lead’s checks (lint and raw hashes, two citations against upstream at the pin, the executed checks found in the raw logs). Its proposals are recorded, not decided: (1) a task binds an owner-approved requirements bundle by hash, and an omitted, changed, failed or unrun obligation blocks acceptance; (2) a release-matched mo guide and symbol documentation shipped in the executable; (3) diagnostics and receipts that name the unmet obligation and a status (tested, not_run, timed_out…), never one broad “verified”. (1) and (3) go into the Mo six-tool server’s and the protected verifier’s briefs as design inputs; (2) is a candidate toolchain step after steps 42 and the CI gate. Not adopted: a proof calculus, global affinity, a GPU scheduler.Fable leadrecordedthe six-tool server’s brief

19 Sep 2026 — End to end v1 accepted, 2:20 PM ET

decisionwhostatusfirst tested by
The end-to-end slice is accepted: the Mo agent, a scripted model, the real service and real containers, in both runtimes, with the scripted Logstat repair and a protected verdict that refuses a forged success and a rewritten test. The lead reran it on the machine; inventory clean; no token in 175 evidence files. This closes the day’s first “owed and unmet” item. It proves plumbing only.Fable leadacceptedthe first model-driven task
Defect D1 (the agent gives a late command all the time that is left and waits no longer than that, so the last clamped command is always “unknown” though it completed) is fixed in Mo with a named collection margin, in mo-agent-report-cap. semanticFable leaddecidedthat brief’s RED test
Defect D2 (the frontend closes the operator’s channel when the client disconnects, so a run that ends on a timed-out call can never be frozen or verified) is not patched in Python: the Mo six-tool server must keep the operator’s path independent of any candidate connection, as a required control beside H1 to H7. For Robert: until that server exists, a real run that ends on a timeout loses its verdict; say if you want the Python patched first. semanticFable leaddecidedthe six-tool server’s controls

19 Sep 2026 — The claim check’s calibration read, 2:22 PM ET

decisionwhostatusfirst tested by
The TypeSafe claim check is accepted as a calibration and merged at tools/claim-check/: 73 requests, $0.0033, 0.175 s median. It caught 5 of 5 planted failures (4 by code, 1 by Jev) and 2 of 6 historical defects (both by code); Jev wrongly flagged 1 of 34 true claims. Acceptance does not depend on it: the lead may run it as a first pass on a report, and still runs every suite itself. On this evidence the model adds little over the code checks; that may change with false claims code cannot settle, which the history barely contains.Fable leaddecidedthe next report it is run on
From now on every brief’s Done-when asks the worker to tee each run its report quotes into a filed log with an exit file beside it (ten of the twelve true claims the tool flagged were runs with no raw output in the repository). The lead skill’s step 1 carries the rule.Fable leaddecidedthe next brief

19 Sep 2026 — The report cap and the collection margin accepted, 3:06 PM ET

decisionwhostatusfirst tested by
Accepted: the agent’s report cap is the profile’s own bound (23,068,672 bytes), and a clamped command leaves a 5 s collection margin (D1). The lead saw the margin hold on the machine: the last command of a 881 s run was received with execution known. Darwin full suite 263 of 263. semanticFable leadacceptedthe first model-driven task
Ratified defaults of the worker (Claude Opus 5): the model reply bound is the runtime’s 1 MiB HTTP body limit, named model_reply_cap(); the margin is 5 s, about 3.5 times the largest measured need, and appears on the profile line as candidate_margin_ms.Fable leaddecidedthat brief’s tests
examples/programs/agent/tests/application-workspace-v1/real_bridge.py has failed 2 of 3 cases since harness steps 1 and 2 changed the executor’s test double; nobody reran it. It is fixed or retired with the Mo six-tool server’s behaviour tests, which replace that double.Fable leadrecordedthe six-tool server’s brief

19 Sep 2026 — Linux checks deferred; acceptance on macOS for now, 3:26 PM ET

decisionwhostatusfirst tested by
Robert: the Linux builds and tests take too long; defer them and test on macOS for now. From here a toolchain step is accepted on the lead’s Darwin checks alone (build, focused tests, full suite, probes). Linux is not waived, it is owed: the lead keeps a list in HANDOFF.md (“Linux owed”) and runs it as one batch later, or the CI gate (ci-gate) brings it back on every pull request. Two things depend on Linux whatever the Mac says and are gated on that batch: step 41’s fork child (only posix_spawn runs on Darwin) and part B of the Mo workspace server, which runs on the Linux machine.Robertdecidedthe Linux batch, or the CI gate’s first run
Owed on Linux at this row: step 41 (-Dtest-filter="step 41" and the full suite; first run 5 of 6, the one failure a test predicate, took > 0.ms, that a sub-millisecond run fails), and every toolchain step accepted after it.Fable leadrecordedthe Linux batch

19 Sep 2026 — Step 41 (Exec) accepted on macOS, 3:33 PM ET

decisionwhostatusfirst tested by
Step 41 is accepted on the lead’s Darwin checks (full suite 268 of 268, focused tests, probes in both runtimes), under Robert’s deferral of Linux. Its fork child runs only on Linux and stays on the owed list; nothing that runs on the Linux machine (the server’s part B) launches before that run. semanticFable leadacceptedthe Linux batch
The design said Command.in; the row is in_folder, because in is a keyword and taking it after a . would be new syntax. For Robert: if you want cmd.in(fs), it is one arm in the parser plus the formatter, and a rename in seven places; the lead’s default is to keep zero new syntax. The design page is corrected, with Fixed(text: "rm").Fable leaddecidedthe server’s part B, its first real user
Ratified defaults of the worker (Claude Opus 5): a module’s own variant or message hides a stdlib struct of the same name in that module (so the new Done did not break the agent); flows follows a list literal at the call; a message line’s field may not be a Platform, Exec or Program; when the leader exits the rest of its group is killed before it is reaped; the child gets its own session, not only its own group; the fixture’s function receives the program’s path first; each run has its own thread with no cap on concurrent runs; Darwin uses one posix_spawn (CLOEXEC_DEFAULT) after the fork version cost 94 ms a run closing a million descriptors. semanticFable leaddecidedstep 41’s controls
Recorded for later toolchain work, from the worker’s report: no cap on concurrent runs; exit detection naps instead of EVFILT_PROC or a pidfd; output as List(UInt8) makes 1 MiB cost 2.3 to 3.9 times C (a Bytes type would fix it); blocking.run still returns if block errors while its job is on the pool (step 42’s audit takes this one).Fable leadrecordedstep 42

19 Sep 2026 — OMP lead and fresh Sol workers; both WIP units resume

decisionwhostatusfirst tested by
Astra leads in OMP in this existing pane while Claude Code is unavailable. Workers use OMP with GPT Sol at high reasoning. Every assignment, including saved-WIP continuation and review, gets a fresh clean session; no resumed, forked or imported conversation. Maximum three workers, each in its own tab and implementation worktree.Robertdecidedthe server part A and step 42 launches
Workers write all implementation and code, including test/probe scripts. Astra owns plans, briefs, review, documentation, coordination and acceptance, and Robert explicitly permits the lead to run independent acceptance builds/tests. Existing audit safeguards, Linux deferral and push ownership remain. semanticRobert; recorded by Astra (GPT-6)decidedindependent acceptance of the two resumed units
Resume mo-workspace-server-4a at d679f568 and interpreter-step-42 at 0a4dffcd after recording the workflow. Their original worktrees are clean at these commits. Server WIP’s 7/13 is an unfiled half-close run, not unchanged-wire evidence; F1 needs a filed reproduction or a solution without changing clients. No acceptance claimed.Robert (resume); Astra (evidence qualification)decidedfresh workers’ filed results and lead checks

19 Sep 2026 — Server F1 requires bounded byte input

decisionwhostatusfirst tested by
F1 is a capability gap, not a client defect: Sol’s filed 8b0ff352 run uses the unchanged workspace client, whose 155-byte body arrives at Conn.lines only after the timed-out client closes. The lead read the reproducer and raw output without rerunning the known failure. Its exit 0 means reproduction succeeded, not protocol acceptance.Astra (GPT-6), reading GPT-5.6-Sol evidencerecordedstep 44’s separate positive control
Add Conn.chunks(into:, max_bytes:, idle:), delivering bounded Chunk(bytes: List(UInt8)) messages through the existing source mechanism, in interpreter-step-44. This supports the unchanged body and early rejection of oversized unfinished headers without a pull-read loop or mode switch. No new syntax, byte type, HTTP stack or client workaround. One reader, binary preservation, peer-half-close replies, TLS plaintext, backpressure and owned payloads are required. semanticAstra (GPT-6)decidedfresh Sol contract review, focused regressions, both-runtime unchanged-client control and independent lead acceptance
Use the third worker slot with a fresh Sol/high session and separate worktree. The server worker continues only independent part A; step 42 retains its memory-safety scope. Runtime changes remain isolated, with lead-serialized integration and full-suite runs; no copying unaccepted binaries or merging sibling branches. Neither server acceptance nor TLS/Program 7 acceptance is implied.Astra (GPT-6)decidedstep 44 launch and integration

19 Sep 2026 — Input EOF is not proof of lost response

decisionwhostatusfirst tested by
Keep step 44 unchanged. Its Closed cannot distinguish write-half-close from a peer that will never receive; neither the existing Net/source implementation nor a successful socket write proves receipt. In the server, input EOF after a complete request does not cancel an admitted operation or close admission. Keep read-end, execution, reply production, write outcome and unknown client receipt distinct. Write failure/timeout and existing response deadlines remain terminal for admission, not for the independent operator. semanticAstra (GPT-6), following server Sol’s consumer reviewdecidedseparate half-close, graceful full-close, failed-write and operator-path controls
Preserve Python’s original disconnect/lost-response tests unchanged; their required owner exit conflicts with D2. Add explicit Mo H2/H6/D2 lifecycle controls while preserving exactly-once execution, retained outcomes, unknown receipt and explicit-close cleanup evidence. Report the incompatible predicates rather than claiming 13 unchanged groups passed. No claim of detecting remote receipt without protocol acknowledgment; no new ACK or runtime terminal distinction. semanticAstra (GPT-6)decidedserver part A acceptance, then machine cleanup in part B
Step 44’s adversarial review found fixtures represent only full close today, so public fixtures cannot initiate a half-close control. Authorize an internal directional EOF model and runtime-level tests through the real source/dispatch; preserve public Conn.close and add no half-close API. Real sockets prove public half-close in both runtimes. Report these evidence boundaries separately; do not claim the public fixture can initiate half-close. semanticAstra (GPT-6), following step44 Sol’s blockerdecidedstep 44 internal fixture and public socket controls

19 Sep 2026 — Step 42 worker completion is not acceptance

decisionwhostatusfirst tested by
Request changes at be64e8a5. Source review shows blocking.worker and aloneMain publish done before their last job/fd access, while callers may unwind after observing it. Finish the completion handoff and prove it through real paths, not only the wait helper. Complete Part D for all audited retaining holders; pending answers alone do not satisfy the brief.Astra (GPT-6)corrective worker requireddeterministic ownership/error-path regressions and compile-failing holder mutants
Do not accept ASan warning filtering as sanitizer integration. Native custom fibers omit LLVM’s required switch notifications; add that integration and remove e537abfe’s stderr suppression. Restore opt-in sanitizer runs and preserve both ordinary and ASan mutant proof. Do not discard interpreter server events merely to avoid retaining them: preserve the existing effect safely.Astra (GPT-6)corrective worker requiredunsuppressed expected-crash corpus, ASan mutant, safe event retention
Keep the noisy +12.90%/+8.60% echo results; they prove neither a zero-cost switch nor a reliable regression size. Require controlled runtime measurements on three workloads in both runtimes; build timing is not a third runtime workload. Explicitly extend corrective scope to the existing bench/step38/measure.py for measurement evidence, without treating its earlier out-of-scope edit as authorized retroactively.Astra (GPT-6)decidedserialized measurements after corrective code stabilizes

19 Sep 2026 — Step 44 needs correction before integration

decisionwhostatusfirst tested by
Request changes at 9ad0162a: the fixture line-idle branch lost its terminal return and reaches unreachable; preserve existing Conn.lines semantics. The TLS positive test accepts ordinary errors, and binary length/sum is not exact ordered-byte evidence. Complete the bounded controls named in interpreter-step-44 rather than accepting the report’s broader claims. No dynamic reproduction or new acceptance claimed.Astra (GPT-6), source review at 9:43 PM ETfresh corrective worker requiredactual line-idle RED/GREEN; strict TLS success/negative control; exact-byte, ownership and blocked-writer probes
Preserve original samples (-8.69% interpreter/-0.97% native lines throughput) and the original delivery. Integrate only after corrections and independent guarded verification, including longer/interleaved lines measurements. No zero-overhead or causal regression conclusion from the short sequential samples. Step42-fix retains focused validation; the new step44 worker starts static-only.Astra (GPT-6)decidedexplicit validation slot, isolated integrated checks and measurements

20 Sep 2026 — Preserve strict contracts without weakening fault-tolerant corpus gates

decisionwhostatusfirst tested by
Independent Step44 full suite270/271 at6aa6ca84 fails the corpus invariant:11 strict chunks/TLS tests need fault-free setup; held-under-faults110 of121. Preserve all12 fixture tests, including the separate TLS fault target, in toolchain/testdata with permanent automated strict, seeded-fault, successful interpreter/native and formatting checks. Keep the ordinary example corpus’s all-held/zero-fault-free-only gates and every positive oracle unchanged. This changes test classification, not language/runtime semantics or any stopping rule.Astra (GPT-6)static diff reviewed; bounded focused slot granted; no code acceptancefocused chunks-filtered fixture gate, then independent unfiltered suite and remaining behavior/performance checks

20 Sep 2026 — Make memory reclamation evidence observable

decisionwhostatusfirst tested by
Require real delayed commit and waiter consumption, plus payload survival and observable Parcel reclamation; empty containers/pointer copies alone cannot prove a missing free is caught. Approve only an unapplied private test-only Zig/C allocation/destruction observer proposal, thread-safe/case-isolated and absent from normal execution; no public Mo hook or runtime grant. Reject silent missing-fixture and successful-run stderr suppression in the n10 draft.Astra (GPT-6), static source reviewstatic revision authorized; source frozen65b3dd37; no acceptancesource review, then explicit guarded green/mutant/restoration controls after Step44 releases runtime

20 Sep 2026 — Step44 accepted on Darwin, with measured limits

decisionwhostatusfirst tested by
Accept bounded Conn.chunks from fresh OMP/GPT-5.6-Sol workers after independent candidatecdf1e966 build, focused5/5, full272/272 and30 CLI/socket checks. Preserve strict positive oracles, separate fault classification, single-reader ownership and input-EOF/write-half separation. Main merged atdb515f9b; server adoption is separate, Linux owed, no audit/stopping-rule change.Astra (GPT-6), 8:30 AM ETaccepted on Darwin; semantic; for Robertfull-suite-03 and behavior-result-01 raw logs under audit/evidence/2026-09-20/step44-integration
Retain all20 larger interleaved line samples and original16MiB results. Interpreter best/median elapsed +3.36%/+4.83%; native +10.25%/-4.41%. Accept with these disclosed observations: no numerical performance floor was specified; neither zero overhead nor a stable causal regression is proved. Step42 still owes its own isolated before/after suite/stress measurements and all other gates.Astra (GPT-6)decided; for Robertline-measurement-result-01.json, all raw samples, load averages and unchanged worker driver

20 Sep 2026 — Fresh server adoption, explicit admission precedence

decisionwhostatusfirst tested by
Combine accepted Step44 with saved server deliveryd689b441 only in a fresh Sol/high worker tree. Start static-only chunks framing/coverage preparation; no runtime, source-harness change, machine or server acceptance. Preserve F1 RED and the two incompatible Python owner-exit predicates. Require complete real-server coverage and strict/fault-tolerant corpus classification before grants.Astra (GPT-6)authorized bounded continuationreviewed static diff/manifest, then explicitly scheduled unchanged-client and H2/H6/D2 controls
Ratify Mo refusal precedence: busy, duplicate/conflicting ID, terminal/short-lease admission,16-call limit, then journal capacity for otherwise admissible requests. CONTRACT.md lists codes/limits but no simultaneous priority; retain the existing Mo order and require overlapping-condition outcome tests. Never write an intent for an already-refused call or claim blanket H7 equivalence.Astra (GPT-6)decided; semantic; for Robertactual admission outcomes with overlapping limits, without effects or counter changes

20 Sep 2026 — Narrow server fixture scope; withhold execution

decisionwhostatusfirst tested by
Authorize one strict process fixture and the corpus gate, not a separate faults fixture. Keep three fault-tolerant controls in ordinary coverage; move seven strict controls without duplicating production modules or widening APIs for tests. Any exact-path simulation exception requires mandatory positive counts, seeded zero-fault execution, native parity and formatting; ordinary and Step44 gates stay intact.Astra (GPT-6), static reviewstatic scope granted; runtime withheldrevised diff/manifest, then a separately granted correctness batch
Bind the trusted operator’s base64 source mapping with the existing sorted-key compact-JSON digest convention. Require an independent actual-journal vector and key-order invariance, not config/journal echo; do not label insertion-ordered encoding a canonical reference hash. Preserve hostile-tree readiness and the tool fence.Astra (GPT-6)decided; semantic; for Robertactual-server GREEN and hostile controls after correction
Withhold correctness execution until the fixture split, fresh guarded compiler-build prerequisite, exact counts/fault settings and stronger binding assertions are reviewed. Benchmarks remain separate; retain the16-call cap and disclose batched1000-call timing, with exact result oracles.Astra (GPT-6)no runtime owner or acceptanceserver-chunks-static-review-01.json; static whitespace check0 only

20 Sep 2026 — Grant serialized server correctness, not measurement

decisionwhostatusfirst tested by
Accept the revised one-fixture routing for execution: strict7 retains fixed-order generic coverage and mandatory100-seed zero-fault/native-success gates; production35 includes three ordinary fault-tolerant controls. Grant exactly24 guarded commands to server-chunks-sol, sequential, first-surprise stop. Correct only command12’s shell quoting with its uniquely matching native-corpus filter.Astra (GPT-6), review02exclusive runtime grant; no acceptanceserver-chunks-correctness-grant-01.json; actual summaries, not printed expectations
Permit check-generated worker-local parent .mo.ids only as unstaged evidence; lead retains integrated regeneration/staging. Keep F1/evidence/report unchanged and stop on unexpected generator changes. Benchmarks, full suite, Step42 execution, machine/Linux and commits remain separately withheld.Astra (GPT-6)bounded execution exceptionraw per-attempt records and scoped cleanup after the batch

20 Sep 2026 — Repair imported-effect formatter classification at source

decisionwhostatusfirst tested by
After formatter03 passes all15 and fmt-check rejects strict.mo’s imported-handle loop, repair the shared formatter analysis rather than rewriting the admission test. The documented rule already treats handle calls as effects; isolated-file type checking loses that information. Authorize static program/pipeline/main/corpus changes and existing FORMAT documentation, preserving requested-file scope, correct diagnostic coordinates, best-effort checking and both formatter callers.Astra (GPT-6), source reviewstatic repair only; runtime released; no acceptancefocused imported-effect/pure-call/location regressions, then rebuilt-compiler correctness resumption under a separate grant

20 Sep 2026 — Preserve formatter scope; compose memory with accepted chunks

decisionwhostatusfirst tested by
Preserve requested-file loop checking when dependency loading stops: use the existing standalone Program rather than skipping analysis or reporting dependency loops. Require canonical fixture endings and interrupted-import regressions. Grant only fresh compiler, focused regression, strict smoke and full15-module fmt-check through the existing4GiB guard; original server commands4–24 remain withheld.Astra (GPT-6), formatter review02bounded exclusive verification; no acceptanceserver-chunks-formatter-grant-01.json and actual retained outputs
Revised Step42 lifetime oracles are ready for static composition, not evidence acceptance. Anchor BEFORE at accepted-main4e0bfc0e and merge frozen65b3dd37 only in a separate verification tree. Assign source conflict resolution and new Step44 retaining-caller migration to the same worker; do not freeze AFTER or grant runtime/timings until reviewed.Astra (GPT-6), memory review04static composition authorizedresolved-source/caller review, then separately guarded composed-source proof

20 Sep 2026 — Generate real provenance; keep failed transfers single-owned

decisionwhostatusfirst tested by
After formatter verification passes, promote the existing dependency-ordered —write generator ahead of tests because the fresh sidecar has no server records. No hand-edited/deleted verification lines. Keep generated provenance unstaged; seven modules proved27 tests before connection’s nesting diagnostics. Authorize only a connection-local, behavior-preserving nesting refactor; do not rerun unchanged completed modules.Astra (GPT-6)partial proof; static repair; runtime releasedcorrectness-result04/05 and nesting-review01
Use exact strict summary fields:7 tests and7 simulated at faults0, held_under_faults0 and fault_free_only0. Earlier “7 held” wording described success informally, not the held-under-faults counter; the existing corpus gate is authoritative and unchanged.Astra (GPT-6), source correctionclarified; no strict run claimedcorpus checkContractFixture and later real strict summary
Do not freeze composed Step42 with the known enqueue ownership hole. Require success-only ownership transfer with failure-atomic publication and audit caller cleanup, including partially transferred batches. A source-send errdefer alone can double-free after enqueue’s post-insertion failure. Permit only a static repair proposal and private context-only test-patch rebase first.Astra (GPT-6), composition review05static-only; no acceptancebounded source/caller review and allocation-failure controls under a later grant

20 Sep 2026 — Bound ownership implementation and correct the formatter grant

decisionwhostatusfirst tested by
Authorize the reviewed four-file Step42 ownership repair as source only. Retain markRunnable’s API; pre-reserve mailbox/trace, call its fallible resize/publish under the runtime lock, then commit infallibly. Prefer prefix cursors to sentinel stores, cover all already-owned commit buffers on failure, and include the explicitly reviewed answer/log seams. No native change, production audit instrumentation or AFTER freeze.Astra (GPT-6), composition review06implementation authorized, runtime withheldsource/caller review and three permanent plus private allocation-failure controls
Own grant06’s invalid mo fmt —write invocation as a lead command error, not a compiler failure. Preserve exit2 and untouched seven-record/27-test subtotal. Grant07 uses the existing default fmt invocation followed by only the remaining eight generators; no first-seven repeat or broader runtime grant.Astra (GPT-6)corrected bounded grant; no new pass claimedcorrectness-result06 and grant07

20 Sep 2026 — Advance complete provenance; keep normal builds free of audit-only storage

decisionwhostatusfirst tested by
Accept grant08’s42/42 generator results as the provenance prerequisite only:15 unstaged records and protected F1 unchanged. Resume the twenty remaining correctness commands under sole server runtime ownership; no generation repeat, benchmark, full-suite or server acceptance implied.Astra (GPT-6), raw result08 reviewremaining correctness authorizedgrant09 exact commands and actual gate results
Compile ASan-only fiber context fields and initialization out of normal native builds; remove the field-assignment-only stress budget test rather than preserving low-value implementation assertions. Keep actual stress/mutant obligations and the blocking lifetime behavior control. These are two bounded additions to the static memory repair, not a native ownership redesign.Astra (GPT-6), independent source review07source correction authorized; unexecutednormal/ASan build and existing real stress/mutant proof under later grants