el-retired/docs/v1/experiments/evidence/cycles/03-the-wrapper-was-conditional/CLAIMS.md

CLAIMS — cycle 03, the wrapper was conditional

Source doc: docs/v1/experiments/cycles/03-the-wrapper-was-conditional.md

Pinned commits

This cycle pins three commits. The third is a merge, and its tree is byte-identical to the second — so every measurement at 285166c carries unchanged to b40754f.

	Record 1	Record 2 (the EXPERIMENT)	Record 3 (the land)
SHA	4f7568b07f61a81fed1db5b8274813032ea3b16e	285166c25c218e3ea91d9ceb537fac51fdd18c80	b40754f07b5eff3700a69681397e46949a5c4f41
Committed	2026-08-17 07:56:28 -0500	2026-08-17 09:01:55 -0500	2026-08-17 09:01:55 -0500
Subject	give a construct its after-crossing face, and let constructs compose	EXPERIMENT: emit the wrapper unconditionally, so exit binds at runtime too	land unconditional wrapper: exit crossings resolve at runtime
Parent(s)	60737b03 (let a construct refuse, not only observe)	24f7fb51 (land the runtime seam: resolve the crossing at execution)	merge: 24f7fb51 + 285166c2
Worktree	/tmp/rerun-v1-03a, tree clean	/tmp/rerun-v1-03b, tree clean	measured from /tmp/rerun-v1-03b

Topology matters and the record does not state it. 285166c is an experiment branch off 24f7fb5; b40754f is the merge that lands it. So the "before" state for every P1–P4 prediction is 24f7fb5, not 4f7568b. 4f7568b sits eight commits earlier on a different line (0004-commit-lineage.out, 0215-b40754f-tree-vs-285166c.out).

git diff 285166c b40754f is empty — the merge introduced nothing (0215-b40754f-tree-vs-285166c.out). b40754f carries no numeric claim of its own; its identity is captured in 0003-commit-identity-b40754f.out.

Artifact provenance: every artifact pinned per-capture, tree clean at both worktrees (see MANIFEST.tsv, RUN.env). Host: Wills-MacBook-Pro, Apple M4 Pro, arm64, Apple clang 21.0.0.

Verdicts

30 factual assertions enumerated. REPRODUCED 24 · DIVERGED 3 · NOT-REPRODUCIBLE 2 · NOT-CAPTURED 1

Record 4f7568b

#	Claim (verbatim from the record)	Artifact	Commit	Verdict
1	"§6 records 62 persist-after-mutate sites, 10 auth-per-route, and index-after-append that failed at 9 of 9" — as a quotation of §6	0223-sec6-figures-source-and-rederivation.out	4f7568b	REPRODUCED — §6 is docs/architecture/el-language-design.md "## 6. The residue map"; its table reads exactly persist-after-mutate | 62 sites, auth-per-route | 10 sites, index-after-append | 9 of 9 failed. The record quotes §6 correctly.
2	"62 persist-after-mutate sites" — as a measurement	0223	4f7568b	NOT-REPRODUCIBLE — population undefined; no scope produces 62 (see below)
3	"10 auth-per-route" — as a measurement	0223	4f7568b	NOT-REPRODUCIBLE — there is exactly one auth check at this commit, not ten (see below)
4	"index-after-append that failed at 9 of 9"	0223	4f7568b	NOT-CAPTURED — no enumeration, file, test, or procedure exists anywhere in the tree; all five occurrences are restatements of each other
5	"98/98 native compiler tests pass"	0007-native-compiler-tests-03a.out	4f7568b	REPRODUCED — 98 tests, 98 passed, 0 failed, 243 assertions in 4.271ms
6	"existing output byte-identical"	0034-REDO-parent-compiler-build-03a.out, 0047-REDO-existing-output-byte-identical-03a.out	4f7568b vs 4f7568b^	REPRODUCED — the parent compiler (60737b03, built from git archive) and the 4f7568b compiler emit byte-identical C for the whole 11,258-line compiler source of the parent, sha256 8408ae3aef3048cf… for both
7	"Fns with no exit construct emit byte-identically to before"	0047 §A	4f7568b vs 4f7568b^	REPRODUCED — probe of @manager / @accessor / undecorated fns: identical, sha256 f5ae7733b4b3ee0e…; __el_body_ wrapper count in the output = 0
8	"compiler self-hosts byte-identically"	0140-selfhost-fixpoint-gen2-gen3-03a.out	4f7568b	REPRODUCED — gen1 == gen2 == gen3, all sha256 fcdfdf13b9fed6e9…, 11,361 lines
9	"early returns pass through the exit"	0065-REDO-exit-and-composition-tests-03a.out	4f7568b	REPRODUCED — ok declared-exit-wraps-body-so-early-returns-pass-through; also ok declared-exit-receives-the-result
10	"ordering holds under composition" / "Three independent constructs now compose on one fn, none known to the compiler"	0065	4f7568b	REPRODUCED — ok constructs-compose-guard-entry-exit (asserts guard-index < entry-index < exit-index)
11	the emitted C shown for mutate() — guard, entry, body, exit ordering, all six lines	0018-probe-mutate-emission-03a.out	4f7568b	REPRODUCED — byte-for-byte (see below). Probe reconstructed, see "Reconstructed probes".
12	"The body moves into a static helper and the visible fn becomes a wrapper"	0018	4f7568b	REPRODUCED — static el_val_t __el_body_mutate(el_val_t k) emitted, el_val_t mutate(el_val_t k) calls it

Record 285166c

#	Claim (verbatim from the record)	Artifact	Commit	Verdict
13	P1 "exit becomes runtime-bindable — TRUE, returns 14, bound after the build"	0014-integration-seam_binding-03b.out, 0017-test-diff-285166c.out	285166c	REPRODUCED — harness assertion an EXIT construct declared after the build replaces the result expects 14 and passes; the binding is supplied via EL_CONSTRUCTS=exit.txt after prog is compiled and linked
14	P2 "codegen shrinks — TRUE, 5094 -> 5044"	0012-codegen-linecount-285166c.out, 0013-codegen-linecount-neighbourhood.out	285166c^, 285166c	DIVERGED — observed 5095 -> 5043 (see below)
15	P3 "cost 5-15% from a call frame on every fn — FALSE, 0.37s -> 0.38s, ~3%"	0163-P3-isolated-callframe-cost-20x.out, 0189-P3-hypothesis-which-binaries-give-0.37-to-0.38.out, 0214-REDO-P3-control-binaries-wrapper-content.out, 0116, 0100	285166c vs 24f7fb5	DIVERGED — the substantive finding of this cycle. Isolated overhead +12.65% to +15.98%, median +13.65%, i.e. inside the 5–15% band the record scored FALSE (see below)
16	P4 "fixpoint holds — TRUE"	0132-selfhost-fixpoint-gen2-gen3-03b.out	285166c	REPRODUCED — gen2 == gen3, sha256 6bb520f2a0ce8695…, 12,957 lines each
17	"fixpoint gen2==gen3"	0132	285166c	REPRODUCED — under the correct three-generation numbering. gen1 != gen2 (expected: the committed dist/platform/elc dates from 45325f7, before the wrapper); gen2 == gen3 exactly
18	"99/99 native"	0008-native-compiler-tests-03b.out	285166c	REPRODUCED — 99 tests, 99 passed, 0 failed, 239 assertions in 5.327ms
19a	"7/7 integration" — the underlying fact: all seven assertions hold	0014	285166c	REPRODUCED — all seven assertions print ok, 0 failed, harness exit 0
19b	"7/7 integration" — as a reported harness tally	0014, 0224-harness-tally-arithmetic-285166c.out, 0225-REDO-harness-tally-history.out	285166c	DIVERGED — a fully green run prints 7 assertions, 6 passed, 0 failed. The harness at this commit cannot print 7/7 (see below)
20	"Every fn now gets a body helper and a wrapper"	0148-every-fn-gets-wrapper-03b.out	285166c	REPRODUCED — in the emitted C for the whole compiler: 258 forward decls, 258 static el_val_t __el_body_* helpers, 258 wrapper definitions. At the parent 24f7fb5: 0 body helpers, 262 plain fn definitions.
21	"Removed with the machinery: declare_exit"	0015, 0016-removed-symbols-detail-parent.out	285166c^ → 285166c	REPRODUCED — 2 occurrences at parent (codegen.el:4315 def, :4448 call) → 0
22	"…decorator_exit"	0015, 0016	285166c^ → 285166c	REPRODUCED — 3 occurrences at parent (:4319 def, :3226, :3321 calls) → 0
23	"…cg_exit_target"	0015, 0016	285166c^ → 285166c	REPRODUCED (code) — 3 → 1; the function (:3217) and its call (:3393) are gone. The 1 remaining is a stale comment at codegen.el:3215 still naming it.
24	"…cg_exit_construct"	0015, 0016	285166c^ → 285166c	REPRODUCED (code) — 3 → 1; function (:3312) and call (:3394) gone; the survivor is the same stale comment at :3215
25	"…and the injects_at_exit scanner branch"	0015, 0016	285166c^ → 285166c	REPRODUCED — the branch if str_eq(dkind, "injects_at_exit") at codegen.el:4429 is gone; the two test uses are gone; 1 doc-comment mention survives at :4272
26	"Two controls failed and were rewritten rather than repaired"	0067-which-controls-failed-03b.out	285166c	REPRODUCED — exactly two — running the parent's test_compiler.el against 285166c's compiler sources: 99 tests, 97 passed, 2 failed. The two: declared-exit-wraps-body-so-early-returns-pass-through, no-exit-construct-emits-no-wrapper. Nuance: three tests were deleted; the third (declared-exit-receives-the-result) still passed and was removed as obsolete, not because it failed.
27	"no-exit-construct-emits-no-wrapper asserted the optimisation this removes, so it is now inverted"	0017, 0066-exit-and-composition-tests-03b.out, 0067	285166c	REPRODUCED — it fails at 285166c (0067) and its logical inversion every-fn-gets-a-body-helper-and-wrapper replaces it and passes (0066)
28	"The integration harness gained a seventh assertion: an exit construct declared after the build replaces the result"	0017, 0014	285166c^ → 285166c	REPRODUCED — seam_binding.sh diff adds double_result() and the assertion expecting 14; 6 → 7 assertions

Record b40754f

#	Claim	Artifact	Commit	Verdict
29	"land unconditional wrapper: exit crossings resolve at runtime" (identity only — no numeric claim)	0003-commit-identity-b40754f.out, 0215-b40754f-tree-vs-285166c.out	b40754f	REPRODUCED — merge of 24f7fb51 + 285166c2; git diff 285166c b40754f is empty, so the landed tree is byte-identical to the experiment

---

Divergence detail — claim 15, P3: the ~3% is an artefact of timing the wrong binary

This is the substantive finding for cycle 03.

The record predicted "cost 5-15% from a call frame on every fn", measured 0.37s -> 0.38s, concluded ~3%, and scored the prediction FALSE. Re-measured, the prediction was right, and the measurement that refuted it could not have detected the cost it was looking for.

Why. The compiler is bootstrapped from the committed lang/dist/platform/elc, a binary built at 45325f7 — long before this change. The chain is:

dist/platform/elc  --compiles-->  gen2 C  --cc-->  gen2 binary  --compiles-->  gen3 C
   (no wrappers)                                   (no wrappers)               (wrappers)

The 285166c compiler built from the bootstrap (gen2 binary) contains zero __el_body_* helpers — the stale bootstrap emitted it without wrappers. Only the self-hosted binary carries a wrapper on every fn. Measured directly (0214-REDO-P3-control-binaries-wrapper-content.out):

binary	built from	__el_body_ defs in that C	el_seam_run calls
BEFORE bootstrap-built 24f7fb5	pg2_03b.c, 11477 ln	0	1
BEFORE self-hosted 24f7fb5	pg3_03b.c, 11739 ln	0	263
AFTER bootstrap-built 285166c	g03b.c, 11409 ln	0	2
AFTER self-hosted 285166c	g03b_b.c, 12957 ln	258	518

The record's own numbers reproduce — on the pair of binaries that contain no wrappers. Ten compiles of the same input, three rounds (0189):

pair	BEFORE	AFTER	delta
both bootstrap-built (neither has wrappers)	0.3861 / 0.3872 / 0.3869 s	0.3912 / 0.3907 / 0.3871 s	+1.32% / +0.90% / +0.05%
both self-hosted (only AFTER has wrappers)	0.4125 / 0.4087 / 0.4108 s	0.4398 / 0.4389 / 0.4363 s	+6.62% / +7.39% / +6.21%

The record's 0.37s is within noise of the bootstrap-built BEFORE figure (0.386s here), and its 0.38s of the bootstrap-built AFTER (0.391s). The ~3% sits between the two rows. Whatever exact binaries were used, the reported delta is the emission cost — the AFTER compiler writes ~10% more C — and cannot contain the call-frame cost, because neither timed binary had a call frame added to it.

The controlled isolation. The cleanest instrument for "a call frame on every fn" is two binaries with identical compiler semantics and identical output, differing only in whether the binary itself was built with wrappers: /tmp/elc03b (bootstrap-built 285166c) vs /tmp/elc03b_g3 (self-hosted 285166c). Both emit byte-identical C (g03b_b.c == g03b_c.c, sha256 6bb520f2a0ce8695…), so all of the delta is runtime. 20 compiles per sample, 6 rounds, A/B order alternated (0163):

round 1 (A-then-B)  A 0.7683s  B 0.8680s  +12.98%
round 2 (B-then-A)  A 0.7596s  B 0.8810s  +15.98%
round 3 (A-then-B)  A 0.7508s  B 0.8564s  +14.06%
round 4 (B-then-A)  A 0.7523s  B 0.8549s  +13.64%
round 5 (A-then-B)  A 0.7535s  B 0.8498s  +12.78%
round 6 (B-then-A)  A 0.7516s  B 0.8467s  +12.65%
overhead on MEDIAN = +13.65%      overhead on MIN = +12.77%

Claimed: ~3%, prediction scored FALSE. Observed: +12.65% to +15.98%, median +13.65% — inside the predicted 5–15% band, near its top. Even the end-to-end cross-commit comparison of self-hosted binaries (+6.2% to +7.4%) is inside the band. On this hardware P3 should have been scored TRUE.

Per §8 of the re-run recipe, the absolute wall-clock figures (0.37s, 0.38s) remain machine-dependent and are not themselves reproducible. It is the ratio the record leans on, and the ratio is what diverges. Machine: Apple M4 Pro, arm64, macOS 25.5.0, Apple clang 21.0.0, idle-ish interactive session; the A/B alternation and the min-based figure control for drift, and every one of the six rounds lands inside the band.

Divergence detail — claim 19b, "7/7 integration": the harness cannot print 7/7

A green harness whose own summary line under-reports itself.

285166c added the seventh assertion and bumped the header text of the tally line from 6 assertions to 7 assertions, but left the arithmetic at $((6-FAILS)) (0224-harness-tally-arithmetic-285166c.out):

lang/tests/integration/seam_binding.sh:91
    echo "  7 assertions, $((6-FAILS)) passed, $FAILS failed"

So with FAILS=0 — a completely green run — the harness prints 6 passed. Observed verbatim at 285166c (0014-integration-seam_binding-03b.out, exit 0):

  ok    unbound program is unaffected
  ok    a construct declared AFTER the build applies
  ok    a construct declared after the build can REFUSE
  ok    an unlinked target is skipped, not fatal
  ok    a binding for a different fn does not fire
  ok    two constructs compose on one crossing
  ok    an EXIT construct declared after the build replaces the result

  7 assertions, 6 passed, 0 failed

Seven ok lines, zero failures, exit code 0 — so 7 of 7 really do pass (claim 19a, REPRODUCED). But no tool in the tree at this commit is capable of emitting "7/7", and the line a reader gets when they re-run the harness contradicts the record. The record's figure was not read off its own instrument.

History of the tally line (0225-REDO-harness-tally-history.out) — the arithmetic was wrong for four minutes and was fixed by the next experiment:

commit	when	check invocations	tally line
8bbb750c	08:48:57	6	6 assertions, $((6-FAILS)) passed, $FAILS failed — correct
285166c2	09:01:55	7	7 assertions, $((6-FAILS)) passed, $FAILS failed — header bumped, arithmetic not
bc2f26dd	09:06:05	7	7 assertions, $((7-FAILS)) passed, $FAILS failed — fixed

Independently corroborated: this defect was first flagged by the cycle 08 re-run and is confirmed here from the artifacts above. Its practical severity is low (exit $FAILS is driven by the real failure counter, so CI would still catch a regression) but it is exactly the failure mode this evidence record exists to surface — a number in a commit message that the tooling of that commit never produced.

Divergence detail — claim 14, P2: 5094 -> 5044 is 5095 -> 5043

lang/el-compiler/src/codegen.el, wc -l (0012, 0013):

	claimed	observed
parent 285166c^ = 24f7fb5	5094	5095
commit 285166c	5044	5043
delta	−50	−52

Both endpoints miss, in opposite directions, so this is not a tool or off-by-one convention difference. Controls run:

• Every version of the file ends in \n (0013 prints the last byte as \n for all eleven neighbouring commits), so wc -l is exact and does not undercount.
• git show --numstat for the commit reports 2 insertions, 54 deletions — net −52, independently confirming the observed delta, not the claimed one.
• No commit anywhere in the neighbourhood has 5094 or 5044 lines of codegen.el. The full sweep (0013): 4f7568b 4953 · 7d01608 5084 · 1b324a0 5152 · 82e9982 5152 · 35b07ba 5156 · 886626a 5156 · 28d19da 5095 · 8bbb750 5095 · 24f7fb5 5095 · 285166c 5043 · b40754f 5043.

The qualitative half of P2 ("codegen shrinks") holds and shrinks slightly more than claimed. The two figures do not, and neither can be recovered from any state of the file in this range.

NOT-REPRODUCIBLE / NOT-CAPTURED detail — the three §6 figures (claims 2, 3, 4)

§6 was located: docs/architecture/el-language-design.md, ## 6. The residue map (0223). Its header names its upstream — "from §18.0 plus measured state", i.e. lang/spec/language.md §18.0. The record quotes §6 faithfully (claim 1, REPRODUCED). None of the three figures has a defined population.

"62 persist-after-mutate sites" — NOT-REPRODUCIBLE. §18.0 is the only place that names a procedure, and it names only a pattern set — persist_* / engram_save / wal_* / checkpoint call sites — with no directory, glob, language, commit, or call-vs-declaration rule, under the tense marker "Measured in this codebase before this section existed", which pins it to an unnamed earlier tree state. Applying the stated pattern set at 4f7568b (0223 §C):

scope	count
tree-wide, all files	302
tree-wide, *.el only	69
engram/ all files	151
engram/**.el	53
engram/src	52
lang/ all files	122

62 lies between the two most natural scopes (52 and 69) and equals neither. Per-symbol breakdown tree-wide over *.el is in 0223. Unlike cycle 01's decorator counts, there is no scope you can guess that recovers the figure.

"10 auth-per-route" — NOT-REPRODUCIBLE, and the mechanism it describes does not exist at this commit. §19.2 says "10 per-route _auth checks" and names no route, file, or command. At 4f7568b there is one auth check in the whole server: fn check_auth_ok(method, body) defined at engram/src/server.el:1958 and called from a single dispatch site at :1988 (0223 §D). Of the 11 _auth occurrences in server.el, 8 are comments or JSON-key documentation. The per-route form the figure counts is not present; a reader cannot recover a list of ten sites.

"index-after-append that failed at 9 of 9" — NOT-CAPTURED. This is the figure the record leans on hardest ("the 9-of-9 figure is what that costs") and it is the least sourced. The population is described only as "the index bug being fixed elsewhere in this tree" — no file, no function, no test, no commit, no enumeration of the nine sites, and no statement of how "failed" was determined. Searching the whole tree at 4f7568b for index-after-append, 9 of 9, 9-of-9, remember to index, after you append returns only restatements (0223 §E): el-language-design.md:25 and :199, el-architecture.html:105, design/completing-el.html:97, lang/spec/language.md:1237, and a comment in codegen.el:4224 citing it. Every one cites the figure; none produces it. There is nothing to re-run, so no artifact can be made.

The same document is self-aware about exactly this failure mode one section later: §7 flags el-architecture.html §04's scoreboard as having "no supporting evidence in the repository, under a footer asserting 'nothing is inferred and presented as fact'" and says "Fix or remove." That audit was never turned on §6's own table.

Reconstructed probes

Two artifacts are outputs of probe programs that are not in the tree. Per §7 of the re-run recipe the probe is an input, not evidence; the artifact is the captured output of running it at the pinned commit.

0018-probe-mutate-emission-03a.out — the record shows emitted C for a fn mutate but the tree contains no such fixture. The probe was reconstructed from what the record itself states (the @decorator("injects_at_exit", "persist_now") snippet it prints, the three decorator names visible in the emitted C, and the mutate(k) signature and body that the commit's own deleted test declared-exit-wraps-body-so-early-returns-pass-through used):

@decorator("guards_at_entry", "my_auth")
fn authenticate() {}

@decorator("injects_at_exit", "persist_now")
fn durable() {}

@authenticate
@durable
@manager
fn mutate(k: String) -> Int { if str_eq(k, "bad") { return 0 } return 1 }

The emission at 4f7568b is byte-for-byte the six lines the record prints:

el_val_t mutate(el_val_t k) {
  { el_val_t __g = my_auth(EL_STR("mutate"), EL_STR("authenticate")); if (__g) return __g; }
  engram_boundary_beat(EL_STR("mutate"), EL_STR("manager"));
  el_val_t __r = __el_body_mutate(k);
  persist_now(EL_STR("mutate"), EL_STR("durable"), __r);
  return __r;
}

Guard, then entry, then body, then exit — exactly as claimed. The same probe at 285166c (0019-probe-mutate-emission-03b.out) shows the compile-time injection gone and both crossings routed through el_seam_run.

0067-which-controls-failed-03b.out — to determine which controls failed (claim 26) the parent's tests/native/test_compiler.el (24f7fb5) was placed into a git archive export of the 285166c tree and run against 285166c's compiler sources. The test file imports codegen.el from the tree, so this genuinely exercises the new codegen against the old controls. No worktree was modified.

0034-REDO-parent-compiler-build-03a.out similarly builds the 4f7568b^ compiler from a git archive export of 60737b03 into /tmp/parent03a, and 0082-build-parent-24f7fb5-fixpoint.out builds 24f7fb5 into /tmp/parent03b. These are builds of committed trees, not reconstructions.

Measurement defects in this re-run, recorded rather than removed

1. 0009-selfhost-fixpoint-03a.out and 0010-selfhost-fixpoint-03b.out used a superseded fixpoint command. The original re-run recipe compared gen1 (the output of the committed dist/platform/elc) to gen2. That check must fail whenever codegen's output changes, which is exactly what this cycle does — 0010 exits 1 with differ: char 12850, line 264. This is not a broken fixpoint. The recipe was corrected mid-run by the parent agent; the correct check is gen2 == gen3. Superseded by 0132-selfhost-fixpoint-gen2-gen3-03b.out and 0140-selfhost-fixpoint-gen2-gen3-03a.out, which are the ones cited above. 0011-selfhost-fixpoint-gen3-gen4-03b.out is the same correct comparison taken before the naming was standardised (its "gen3==gen4" are the recipe's gen2 and gen3). Retained. Do not cite 0009 or 0010.

2. 0020-no-exit-construct-byte-identical-03a.out used an invalid "before" compiler. It compared lang/dist/platform/elc (the committed bootstrap, built at 45325f7) against the 4f7568b compiler. The bootstrap predates 4f7568b by many commits, so the two differences it found — engram_boundary_beat(EL_STR("f")) vs engram_boundary_beat(EL_STR("f"), EL_STR("manager")) — belong to cycle 01, not to this one. Superseded by 0034 + 0047, which build the actual parent 60737b03. Retained. Do not cite 0020.

3. 0021-parent-compiler-build-03a.out failed (exit 1). git archive was invoked with CWD inside lang/, and git archives only the current prefix, so the export contained the contents of lang/ rather than lang/ itself and the subsequent cd .../lang failed. This is the same class of CWD defect the recipe warns about for git grep. Corrected in 0034-REDO-parent-compiler-build-03a.out, run from the repo root. Retained.

4. 0063-exit-and-composition-tests-03a.out failed (exit 2) — it grepped a mis-numbered artifact filename (0006- instead of 0007-) and produced nothing. capture.sh numbers artifacts by counting non-empty MANIFEST lines, and multi-line commands write multi-line MANIFEST rows, so artifact indices jump. Corrected in 0065-REDO-exit-and-composition-tests-03a.out. Retained.

5. 0207-P3-control-binaries-wrapper-content.out failed (exit 127) — a shell quoting error inside a nested bash -c. Rewritten as a script file and re-captured as 0214-REDO-P3-control-binaries-wrapper-content.out. Retained.

6. Cosmetic, 0047 §B: the line-count interpolation in the "BYTE-IDENTICAL over N lines" message printed empty because of escaping inside the nested bash -c. The cmp result and both sha256 values — which are what the claim rests on — are unaffected. The figure is 11,258 lines, from 0034.

7. Not a defect of this re-run, but of the artefact under test: seam_binding.sh at 285166c prints 7 assertions, $((6-FAILS)) passed — the total was updated to 7 and the passed-count was not. See claim 19b and its divergence section.

8. 0224-harness-tally-arithmetic-285166c.out section D produced no rows. The per-commit tally-line loop piped git log into while read, and git show inside the loop consumed the loop's stdin. Re-taken as 0225-REDO-harness-tally-history.out with a for loop and </dev/null on every git show. Sections A–C of 0224 are sound and are cited above. Retained.

Supporting figures

• Stage-2 builds succeed at both commits (0005, 0006): 11,361 lines of emitted C at 4f7568b, 11,409 at 285166c (bootstrap-built), 12,957 self-hosted at 285166c.
• Test declarations in test_compiler.el (0064): 4f7568b 98, 24f7fb5 99, 285166c 99. The experiment removed three tests and added three; the "99/99" headline count was already 99 at the parent and did not move.
• codegen.el line counts across the cycle neighbourhood are in 0013.