David’s latest frozen drop — I-13 Studio v0.15 P0, the name he gives the whole instrument: “The Compound and compIle 13.” A working compiler that talks back — it lexes, validates, lowers and runs its own language on a real WebAssembly VM in the browser — wrapped in the honesty apparatus that measures, and refuses to overstate, what it has proven. The most trustworthy thing in the package is that its own rubric will not call it a pass.
Read every bit and audited this session: 3 deep readers + 3 adversarial “spheres” (overclaim hunt, a prover that ran v0.14 vs v0.15 on identical source, an independence skeptic). Every LIT stamp below is tied to something re-run here — candidate sha256 f645f9b4…, corpus 1.6.0 5ec0e09d….
WHAT THE COMPOUND IS studio + harness + corpus + contract
“The Compound” names the whole instrument — it is not a symbol in the code (a grep over the tree returns 0 hits); it is David’s word for four parts that ship frozen together:
◆ STUDIO — a self-contained browser app (i13-suite-v0.15.html) that lexes, parses, self-verifies, lowers, validates and executes I-13, launched by a trivial Python static server that does no computation of its own. ·
◆ HARNESS — the benchmark runner, the “external” verifier, and a build chain where each build_i13_v0NN.py is a surgical single-defect patch on the previous .pyz. ·
◆ CORPUS — 96 frozen public cases plus differentials and a non-canonical diagnostic supplement. ·
◆ CONTRACT — I13-BC-1.0, a sealed rubric (its own SHA in FREEZE_SEAL.json) that grades the candidate and, by construction, can never rate a self-graded run as passing.
THE LIVE PIPELINE — source becomes an 8.5 KB WASM VM it really runs · LITheadless Node re-run this session
The whole compiler lives in the HTML. Source → tokens (byte-accurate char & UTF-8 spans) → AST (recursive descent, scope & return rules enforced at parse time) → a self-verifier that re-slices every span to prove offsets round-trip and honestly lists what it does not cover (types, termination, arithmetic semantics) → I13WasmVM3.compile() lowers to 24-byte op records + 16-byte func records written into WASM linear memory at base 16384 → i13_validate_program (an abstract stack-height / liveness proof) → i13_vm_exec_program, a real tagged-value stack machine with 64-deep call frames and a trace ring buffer.
The embedded module is genuine WebAssembly: magic \x00asm, 8,505 bytes, 0 imports, 31 exports. A headless Node run against the actual module executed sumdown(5) and read these back from the WASM’s own counters (not synthesised in JS):
8505
WASM bytes · 0 imports
6
native frame depth
123
VM steps
9
native calls
29
ENTER/CALL/RET/HALT events
4
validator regions
The UI reads that one real run: the Execution Map’s green “hot” edges are functions that actually appeared as CALL events; the frame tower is a per-depth digest of the trace, not an animation. Two honest edges: the shipped module self-names i13_cortex_vm_v03.wasm and exports no GFX (the v04 C reference in the tree is a larger superset that is not the one running); and the studio’s “Cortex” six-rule gate calls real WASM but over 4-of-6 pinned inputs, so it essentially always reads PASS on ordinary code — real machinery, near-constant verdict.
THE GRADE IS A GATE, NOT A SCORE why 81% + every P0 green = INCOMPLETE · LITrecomputed this session
The benchmark grades the frozen v0.15 at a weighted 81.167% — and still stamps it INCOMPLETE. That is not a rounding shame; it is a precedence rule. The grade order is INVALID → INCOMPLETE → FAIL → CONDITIONAL → PASS, and the instant required evidence is missing, the grader refuses to even ask whether the score cleared 95%. The one class at 0/48 — separated holdouts, the independent set a self-grader cannot see — is exactly the one that would catch the grader fooling itself. Press to recompute from the real class table, then try to buy your way to COMPLETE:
Even with every provable class maxed, the ceiling is 85% while holdouts stay absent — and the gate stays INCOMPLETE regardless of score, because independence is L0 (self-eval) and the holdout class is empty. You cannot reach COMPLETE with public-test points; you reach it by producing the evidence you do not yet have.
THE DIFFERENTIAL SPINE — one fix per version proven at its terminal link · LITran v0.14 vs v0.15
Each build patches the previous .pyz for exactly one defect: P0-K is fixed at version 0.(K+3), the predecessor fails the target’s cases, the fix passes them. That is the corpus’s own thesis — a claim earns its keep only against the version that lacked it. The terminal link (P0-012, static function arity mismatch) was proven live this session: v0.14 has no arity check, so a wrong-arity call silently reaches the VM boundary; v0.15 rejects it with a typed {line,col} CompileError before the WASM VM ever runs. Toggle the two shipped engines on the same source (outputs captured from a headless Node harness this session):
Verifier corroboration: P0-012 predecessor-to-fix public 2/6 → 6/6 (v0.14’s two passes are the accept-controls), typed-coordinate diagnostic 0/4 → 4/4. The one honest break in the spine: P0-011 was already rejected before v0.14 (v0.14 only upgraded the throw to a typed error), so it carries no predecessor-fails differential and is scored PREEXISTING_PASS — which is precisely why the differential class is 11/12, not 12/12. The spine is real at this link; it is not asserted uniformly clean across all twelve.
THE INDEPENDENCE BOUNDARY — the grader is the graded the honest wrinkle behind “external” · AMBERself-eval L0
The harness README and canonical grade are exemplary — they lead with INCOMPLETE / 81.167% / L0, disclose holdout 0/48, and print “Do not call the suite complete until L1 holdouts satisfy the contract.” The interactive studio makes no benchmark claim at all (grep of its engine: 0 hits for “12/12”, “official”, “INCOMPLETE”). But three edges are worth naming plainly, because the corpus rewards catching them:
the word “external” oversells: verify_i13_v015.py re-executes the candidate’s own compiler and own embedded WASM against a 96-case corpus that ships in the same directory — one author wrote both the engine and the answer key, so a shared wrong assumption passes the test while the behaviour is wrong. The runner stamps itself L0_SELF_VERIFIED; the grade’s evaluator is literally I13-STUDIO-SELF-EVAL. A separate process is not an independent oracle. ·
two studio-facing surfaces (README, STATUS) print “External verifier: 15/15 PASS” with no adjacent L0 caveat, and the studio README says “INCOMPLETE” zero times — the one place a casual reader could mistake a scoped public-target pass for a passing benchmark. ·
the bundle is named …COMPLETE… though every scoring doc says INCOMPLETE — “complete” means the full package, but in a bare directory listing the token collides with the contract term. ·
the documented Verify command itself crashes on a stock Windows console (cp1252 vs the π inside the studio HTML) and only reaches 15/15 with UTF-8 forced — reproduced here, disclosed nowhere in the prose. Fittingly, the drop’s own next target is P1-001: UTF-8 integrity.
None of these is a false claim — the numbers are all real and independently reproduced. They are the soft edges of an otherwise scrupulous honesty, and the fold keeps them visible the same way the harness keeps its own INCOMPLETE visible.
WHAT IT HAS EARNED vs WHAT IT HASN’T the ledger, never laundered
LIT · earned
The studio genuinely runs: real compile → validate → execute on a real 8.5 KB zero-import WASM VM with genuine recursion. The verifier reproduces 15/15 to the exact SHAs. Public conformance 96/96, false-positive controls 24/24, 48/48 valid mutants killed, reproducibility 9/9. The P0-012 differential is real to the token.
AMBER · self-graded
The 81.167% is a real deterministic number — but a self-produced L0 assessment, not an independent result. The Cortex gate reads PASS on constant-pinned inputs.
OPEN · not earned
0 of 48 separated holdouts authored, 12 of 60 required mutants never written, P1 evidence not started, no independence above L0, 0 Terminal-Bench tasks (and “official” framing is prohibited). 23 missing-evidence items — the reason the grade is forced to INCOMPLETE.
The verdict, in the drop’s own voice: 81.167% with every public P0 case green is still INCOMPLETE, because the contract decides INCOMPLETE before it looks at the score. A high number on an unfinished evidence surface is not a near-pass — it is an incomplete measurement. And the refusal to say otherwise, printed by the package about itself, is the most trustworthy thing in it.