# 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.