kill: purge old-paradigm dist/platform binaries from tree

The generated C, amalgams, vendored runtime pins, and compiled binaries
from the Claude Code era are removed from the worktree. The El sources
survive; this tree is now source-only for the first-principles rebuild.

Per Principal direction 2026-08-19.

docs/v1/experiments/evidence/cycles/18-async-half-expressible/CLAIMS.md

@@ -0,0 +1,135 @@
+# CLAIMS — cycle 18, async — half expressible, and the cycle that was dogma
+
+Source doc: `docs/v1/experiments/cycles/18-async-half-expressible.md`
+
+This cycle is unusual: the doc already carries a chain-of-custody note stating
+that its original artifacts were destroyed and that it was **rerun, not
+reconstructed**. The verdicts below respect that. Where the original artifact is
+gone the verdict is NOT-CAPTURED, and the replication is graded separately.
+
+## Pinned commits
+
+| role | sha | subject |
+|---|---|---|
+| replication landed (system under test) | `511db25230c69b9484ece39ed4131d3920b16596` | rerun cycle 18 rather than reconstruct it |
+| original measurement | — | **no commit.** The C stub lived in `/tmp` and was destroyed with the session worktrees |
+
+`511db252` is the only commit that has ever contained
+`lang/tests/integration/async_future.sh` or
+`lang/tests/integration/fixtures/future.c`.
+
+## Verdicts
+
+| # | claim | artifact | commit | verdict |
+|---|---|---|---|---|
+| A1 | the first attempt was dogma: `pthread_join` immediately after `pthread_create`, and the test printed the word `DEFERRED` itself | — | — | **NOT-CAPTURED** (artifact destroyed; the doc says so) |
+| A2 | second run, 4/4: `[18 us] wrap RETURNS`, `[29 us] body START`, `caller continues, got 0`, `[50176 us] body END (computed 42)` | — | — | **NOT-CAPTURED** (artifact destroyed; the doc says so) |
+| A3 | the caller got **0, not 42** on the second run | — | — | **NOT-CAPTURED** |
+| A4 | the fixture now lives at `lang/tests/integration/fixtures/future.c` and the harness at `lang/tests/integration/async_future.sh` | `0002`, repo tree at `511db252` | `511db252` | REPRODUCED |
+| A5 | **6/6** on the replication harness | `0002-async-future-harness-6-assertions.out` | `511db252` | REPRODUCED (exact) |
+| A6 | follow-on P1: `el_val_t` already carries tagged heap objects — **5 magic tags exist** | `0003-P1-five-magic-tags.out` | `511db252` | REPRODUCED (exact) |
+| A7 | follow-on P2/P3: a future is one more; the caller awaits and gets **42** | `0005-P2P3-bound-run-interleaving.out` | `511db252` | REPRODUCED |
+| A8 | follow-on P4: **ZERO compiler changes** — runtime C plus one binding | `0004`, `0005` | `511db252` | REPRODUCED |
+| A9 | P1/P2 of the second run: the caller proceeds while the body runs; interleaving is observable in timestamps | `0005` | `511db252` | REPRODUCED |
+| A10 | follow-on P5: the unbound path still works — **FALSE, SIGSEGV** | — | — | **NOT-CAPTURED** (see note) |
+| A11 | the compiler builds at `511db252` | `0001-build-gen1-511db252.out` | `511db252` | REPRODUCED |
+
+## A5 — the replication, 6/6
+
+`0002`, harness run against the compiler built from `511db252`:
+
+```
+  ok    unbound: no construct, synchronous, correct result
+  ok    unbound: el_await on a non-future passes through, no crash
+  ok    bound: does not crash
+  ok    bound: the awaited result is correct
+  ok    bound: the caller continues BEFORE the body finishes
+  ok    bound: the wrap returns in under 10ms while the body takes 50ms
+
+  6 assertions, 6 passed, 0 failed
+```
+
+Exit 0. The harness's own header states it is a replication and not a blind
+test — the outcomes were known before it was written — and that grading is
+carried forward here unchanged.
+
+## A8 / A9 — zero compiler changes, demonstrated
+
+The same El source (`fixtures/probe.el`), compiled by the stock `elc`, run twice
+against the same binary.
+
+Unbound — no construct file, synchronous (`0004`):
+
+```
+CALLER_CONTINUED
+RESULT 42
+```
+
+Bound — `EL_CONSTRUCTS=c.txt` containing `work async wrap defer` (`0005`):
+
+```
+WRAP_RETURNED 12
+CALLER_CONTINUED
+BODY_START 20
+BODY_END 55034
+RESULT 42
+```
+
+Same compiler, same emitted C, same binary; deferral appears only because a
+construct was bound after the build. The wrap returns at **12 µs** while the
+body finishes at **55 034 µs**, and `CALLER_CONTINUED` precedes `BODY_END` —
+the caller demonstrably proceeds while the body runs. The record's own numbers
+were 18 µs / 29 µs / 50 176 µs; the shape matches and the magnitudes are
+consistent (the body sleeps 50 ms by construction).
+
+`RESULT 42` is the follow-on P3: with a future as one more tagged heap object,
+the caller awaits and gets the real value.
+
+## A6 — five tags, and a future would be the sixth
+
+`0003`, over `el_runtime.c` and `el_runtime.h` at `511db252`:
+
+```
+#define EL_MAGIC_BIN
+#define EL_MAGIC_GEOM
+#define EL_MAGIC_LIST
+#define EL_MAGIC_MAP
+#define EL_MAGIC_MFLD
+
+count: 5
+```
+
+and `fixtures/future.c` adds `#define EL_MAGIC_FUT 0xE1F07000u` in the fixture,
+not in the compiler.
+
+## A10 — why the SIGSEGV is NOT-CAPTURED
+
+Follow-on P5 records that the first `el_await` read `->magic` off an unvalidated
+slot and segfaulted on the unbound path. That version was never committed. The
+committed `future.c` carries the repair and a comment naming the defect:
+
+```c
+el_val_t el_await(el_val_t h){
+    if (h < 0x10000) return h;                 /* small ints / low addresses */
+    if (h & 0x7)     return h;                 /* malloc returns 8-aligned   */
+    ElFuture* f = (ElFuture*)(intptr_t)h;
+    if (f->magic != EL_MAGIC_FUT) return h;    /* safe to read now */
+```
+
+so the harness's second assertion ("unbound: `el_await` on a non-future passes
+through, no crash") passes today. The historical failure has no artifact and one
+was not manufactured. The *class* it belongs to is independently reproduced in
+cycle 19 (`0005-P6-sha256-hex-50000-exit-code.out`, exit 139), which is the
+cycle P5 opened.
+
+## Provenance notes
+
+All artifacts from `/tmp/rerun-v1b-18`, a dedicated worktree at `511db252`, with
+`capture.sh` invoked by absolute path from inside it. **No DIRTY-TREE flags in
+this cycle.**
+
+Three of this cycle's claims (A1, A2, A3) rest on a file that no longer exists.
+They are recorded as NOT-CAPTURED. Producing a `/tmp` C stub today and dating it
+to 2026-08-17 would be fabrication with a fresh timestamp; the doc's own
+chain-of-custody note already says as much, and this re-run does not go behind
+it.