el-retired/docs/v1/experiments/evidence/cycles/06-the-crossing-resolves-at-emission/CLAIMS.md

CLAIMS — cycle 06, the crossing resolves at emission

Source doc: docs/v1/experiments/cycles/06-the-crossing-resolves-at-emission.md

This cycle pins five commits. The record is five commit messages, written sequentially as the experiment ran, so several figures are restated at the landing commit and one claim is silently corrected by a later commit in the same cycle. Both are checked below.

Pinned commits

Tag	SHA	Committed	Subject	Parent	Worktree
06a	35b07bade29fcd93a663a2f538b43c31f07e28cb	2026-08-17 08:37:47 -0500	EXPERIMENT: resolve the crossing at execution, not at emission	1b324a071	/tmp/rerun-v1-06a
06b	886626a64e4c64b46d8382d95ab1d0ff7b739fe9	2026-08-17 08:40:10 -0500	seam refusal + control tests: a runtime binding can short-circuit	35b07bade	/tmp/rerun-v1-06b
06c	28d19da7f1b6b43394302c82ef58446deeebc9d3	2026-08-17 08:43:57 -0500	strip the compile-time machinery the seam replaces	886626a64	/tmp/rerun-v1-06c
06d	8bbb750c2cefc2dc070f6c5ff598e82483df9bcf	2026-08-17 08:48:57 -0500	control the claim that cannot be unit tested	28d19da7f	/tmp/rerun-v1-06d
06e	24f7fb51436bdc68838fd7651d7377f3fb919ee3	2026-08-17 08:56:41 -0500	land the runtime seam: resolve the crossing at execution	merge: 82e998273 + 8bbb750c2	/tmp/rerun-v1-06e

24f7fb5 is a merge commit, not a linear child of 8bbb750 (0214-commit-dag-topology.out). Its first parent is 82e9982 (a self-review commit on the trunk). Consequently git diff 24f7fb5^ 24f7fb5 shows the entire cycle, and codegen.el / el_runtime.c are unchanged between 8bbb750 and 24f7fb5 except for the +60 runtime lines that come in from 82e9982.

All five worktrees were clean at capture. Every artifact is stamped tree clean in MANIFEST.tsv. Environment: Apple M-series arm64, Apple clang 21.0.0, macOS 25.5.0 (RUN.env).

Self-hosting method used throughout

dist/platform/elc (the committed bootstrap) is stale at every commit in this cycle, because every one of these commits changes codegen's output. So:

gen1 = dist/platform/elc  elc-cli.el      # stale bootstrap emission, NO seam
gen2 = elc(built from gen1) elc-cli.el    # first emission that carries the seam
gen3 = elc(built from gen2) elc-cli.el    # the fixpoint check

The fixpoint is gen2 == gen3. gen1 != gen2 is expected. This is exactly the methodological point the record itself makes at 35b07ba ("my first fixpoint test was wrong, not the code"), and this record demonstrates both halves. All seam-site counts below are taken from gen2, the self-hosted emission — gen1 contains no seam at all.

Verdicts

#	Claim (verbatim from the record)	Artifact	Commit	Verdict
1	"codegen emits one unconditional indirection per fn"	0363-fn-count-vs-seam-sites-06a.out, 0030-seam-site-count-breakdown-06a.out	35b07ba	REPRODUCED exactly — gen2 declares 266 el_val_t functions (266 prototypes + 266 definitions = 532 lines, 266 distinct names) and carries 266 indirections over 266 distinct names. The set difference is empty: every declared function has exactly one, and nothing else has one
2	P1 "a construct declared after the build applies" — TRUE	0272-RECONSTRUCTED-seamrun-transcript-06a.out, 0274-RETROFIT-seam_binding-harness-06a.out	35b07ba	REPRODUCED
3	P2 "an unlinked target is skipped, not fatal" — TRUE	0272-…-seamrun-transcript-06a.out, 0274-RETROFIT-…-06a.out	35b07ba	REPRODUCED — binding no_such_symbol_anywhere prints 7, exit 0
4	P3 "emitting on every fn is measurably slower" — FALSE, "0.37s -> 0.36s … Free unused"	0298-REDO-free-when-unused-clean-binary-06a.out, 0297-RECONSTRUCTED-free-when-unused-06a.out	35b07ba	DIVERGED — it is measurably slower here: +3.9 % median, B slower in 38/41 interleaved paired runs. See detail A
5	"267 indirections" / "267 seam sites"	0013-selfhost-3gen-fixpoint-06a.out, 0030-seam-site-count-breakdown-06a.out	35b07ba	REPRODUCED — grep -c el_seam_run on gen2 = 267, exactly. Of those, 266 are emitted statements and 1 is codegen's own emit_line string literal. See detail F
6	P4 "the compiler still self-hosts" — TRUE	0013-selfhost-3gen-fixpoint-06a.out	35b07ba	REPRODUCED — gen2 == gen3, sha256 ca98d55ffad2… both
7	P4 note: "I compared gen1 to gen2, which must differ whenever codegen's output changes"	0013-selfhost-3gen-fixpoint-06a.out	35b07ba	REPRODUCED — gen1 (1748ab31…) != gen2 (ca98d55f…); the author's diagnosis of his own bad test is correct
8	P4 note: "gen2 == gen3, 267 seam sites, stable"	0013-selfhost-3gen-fixpoint-06a.out	35b07ba	REPRODUCED — gen2 and gen3 both 11817 lines, both 267 el_seam_run lines, byte-identical
9	DEMONSTRATED transcript: /tmp/seamrun → 7; then EL_CONSTRUCTS=constructs.txt /tmp/seamrun → "AUDIT: work applied by audited" / 7	0272-RECONSTRUCTED-seamrun-transcript-06a.out	35b07ba	REPRODUCED (probe reconstructed — see "Reconstructed inputs") — output matches the transcript verbatim, line for line
10	MEASURED COST: "0 bindings 0.36s vs 0.37s baseline" (absolute)	0296-RECONSTRUCTED-seam-cost-timing-06a.out	35b07ba	NOT-REPRODUCIBLE (machine-dependent) — this machine runs the same workload in 0.055 s / 0.058 s, ~6.7× faster than the record's hardware
11	MEASURED COST: "2 bindings, dlsym per call — 2.45s" (absolute)	0296-…-seam-cost-timing-06a.out	35b07ba	NOT-REPRODUCIBLE (machine-dependent) — observed 0.160 s
12	MEASURED COST: "2 bindings, resolved once — 0.69s" (absolute)	0296-…-seam-cost-timing-06a.out	35b07ba	NOT-REPRODUCIBLE (machine-dependent) — observed 0.112 s
13	"…dlsym per call 6.6x" (ratio)	0296-…-seam-cost-timing-06a.out	35b07ba	DIVERGED — observed 2.909× over baseline. See detail B
14	"…resolved once 3.5x recovered" (ratio)	0296-…-seam-cost-timing-06a.out	35b07ba	DIVERGED — observed 1.429× recovered. See detail B
15	"The table scan was never the cost. dlsym walks the dynamic symbol table on every call. Resolve once and cache"	0296-…-seam-cost-timing-06a.out	35b07ba	REPRODUCED (direction) — disabling the resolve-once cache costs 48 ms over 521 597 crossings ≈ 92 ns per dlsym; the table scan (2 entries) is not separable from noise
16	"The 0.69s residual is audit_entry's own printf … not seam overhead"	0296-…-seam-cost-timing-06a.out	35b07ba	DIVERGED — the printf is 63 % of the residual, not all of it; the remaining 37 % is seam dispatch. See detail C
17	"Prediction 3 was FALSE. I expected refusal to be impossible through the seam"	0274-RETROFIT-…-06a.out vs 0273-RETROFIT-…-06b.out	35b07ba → 886626a	REPRODUCED — at 35b07ba the refusal assertion is the only one of six that fails (expected 42, actual 7); at 886626a all six pass
18	The one-line emitted shape { el_val_t __s = el_seam_run(EL_STR(f), 0, 0); if (__s) return __s; }	0105-emitted-seam-shape-and-counts.out, 0190-seam-c-line-count-precise.out	886626a	REPRODUCED verbatim — emitted C reads { el_val_t __s = el_seam_run(EL_STR("is_digit_code"), 0, 0); if (__s) return __s; }; the commit's codegen diff is a one-line replacement
19	"work() returns 7; bound to a refusing construct AFTER the build it returns 42"	0273-RETROFIT-seam_binding-harness-06b.out	886626a	REPRODUCED
20	"three of the five compile-time kinds are runtime-bindable: entry injection, exit injection, and refusal"	0299-exit-phase-bindability-check.out, 0324-RECONSTRUCTED-exit-binding-probe-06b.out, 0325-…-06e.out	886626a	DIVERGED — only two are: entry injection and refusal. No exit-phase indirection is ever emitted in this cycle. See detail D
21	"wraps_body needs invocation control and prohibits_outside is compile-time by nature"	0326-strip-table-verification-28d19da.out, 0348-residual-kind-references-28d19da.out	886626a	REPRODUCED — both survive the strip; prohibits_outside resolves to emit_line("#error \"boundary violation: …") at codegen.el:3371
22	"104/104 native compiler tests pass"	0047-native-compiler-tests-06b.out	886626a	REPRODUCED — 104 tests, 104 passed, 0 failed, 253 assertions
23	"PREDICTION: codegen.el drops below 4661 … RESULT: FALSE"	0128-REDO-codegen-linecount-history.out	28d19da	REPRODUCED — the prediction is indeed false; codegen.el is 5095 after the strip, still far above 4661
24	"5157 -> 5096"	0128-REDO-codegen-linecount-history.out	886626a → 28d19da	DIVERGED — observed 5156 -> 5095. Both endpoints are exactly one line high in the record. See detail E
25	"Still +435 over baseline"	0128-REDO-codegen-linecount-history.out, 0348-residual-kind-references-28d19da.out	28d19da	DIVERGED — 5095 − 4661 = +434
26	"4661, its size before any of these passes" (the baseline itself)	0128-REDO-codegen-linecount-history.out	pre-cycle	REPRODUCED — codegen.el is exactly 4661 lines at 409bf573 and addd5120, the two commits immediately preceding cycle 01's parent
27	"injects_at_entry collapsed into the seam — removed / guards_at_entry collapsed into the seam — removed"	0326-strip-table-verification-28d19da.out, 0348-…-28d19da.out	28d19da	REPRODUCED — declare_decorator, decorator_injection, declare_guard, decorator_guard and both token-scan branches deleted; the single surviving mention of each name at 28d19da is a // comment
28	"injects_at_exit — STRUCTURAL / wraps_body — structural / prohibits_outside — a #error cannot be emitted at runtime"	0326-strip-table-verification-28d19da.out	28d19da	REPRODUCED — all three untouched by the strip diff
29	"61 lines of compiler replaced by one refusable indirection"	0128-REDO-…-history.out, 0190-seam-c-line-count-precise.out	28d19da	REPRODUCED exactly — 5156 − 5095 = 61; the diff is +4 / −65 = net −61
30	"8 tests fail, and they are exactly the 8 controls for compile-time entry injection and guards. No unrelated breakage."	0048-native-compiler-tests-06c.out, 0051-failing-tests-detail-06c.out	28d19da	REPRODUCED exactly — 104 tests, 96 passed, 8 failed; every failing test named below, 4 entry-injection + 4 guard controls, nothing else
31	"Verified after the strip: fixpoint gen2==gen3"	0069-selfhost-3gen-fixpoint-06c.out	28d19da	REPRODUCED — gen2 == gen3, sha256 7b9b6e0306ff…
32	"observation and refusal both work through the seam with the compiler knowing nothing about either"	0275-RETROFIT-seam_binding-harness-06c.out	28d19da	REPRODUCED — 6/6 with the harness from 8bbb750 applied retroactively
33	The six assertion names of tests/integration/seam_binding.sh	0228-integration-seam_binding-06d.out	8bbb750	REPRODUCED — all six lines match the record verbatim, in order
34	"6 assertions, 6 passed, 0 failed"	0228-integration-seam_binding-06d.out	8bbb750	REPRODUCED — real harness, bash tests/integration/seam_binding.sh /tmp/elc06d "$PWD", exit 0
35	"The eight controls that failed after the strip were replaced, not repaired"	0239-REDO-test-churn-names.out	8bbb750	REPRODUCED — the eight tests deleted at 8bbb750 are, name for name, the eight that failed at 28d19da
36	"Three took their place, asserting the emitted shape"	0239-REDO-test-churn-names.out	8bbb750	REPRODUCED — exactly three added: seam-replaces-inlined-entry-injection, seam-entry-is-refusable, seam-is-emitted-for-undecorated-fns. 104 − 8 + 3 = 99
37	"99/99 native compiler tests pass"	0049-native-compiler-tests-06d.out	8bbb750	REPRODUCED — 99 tests, 99 passed, 0 failed, 240 assertions
38	"Fixpoint holds."	0081-selfhost-3gen-fixpoint-06d.out	8bbb750	REPRODUCED — gen2 == gen3
39	"Five compile-time passes added 491 lines"	0348-residual-kind-references-28d19da.out, 0128-REDO-…-history.out	24f7fb5	REPRODUCED exactly — 4661 → 5152 across 5718943, 60737b0, 4f7568b, 7d01608, 1b324a0. 5152 − 4661 = 491
40	"The seam is ~55 lines of C and one line of emission"	0190-seam-c-line-count-precise.out, 0175-seam-c-block-verbatim.out	24f7fb5	REPRODUCED — the implementation block el_runtime.c:17095–17152 is 58 lines, of which 55 are non-blank (51 excluding comment lines); codegen contains exactly one emit_line producing the indirection
41	"a construct declared AFTER the binary exists applies to it"	0229-integration-seam_binding-06e.out	24f7fb5	REPRODUCED
42	"free when unused: 0.36s vs 0.37s baseline across 267 indirections"	0105-emitted-seam-shape-and-counts.out	24f7fb5	DIVERGED — at the landing commit the emission carries 263 el_seam_run lines / 262 actual indirections, not 267. The 267 figure is carried forward unchanged from 35b07ba, before the strip removed four functions. (The timing half is covered by rows 4 and 10.)
43	"dlsym was the cost, not the table scan; resolve-once recovered 3.5x"	0296-…-seam-cost-timing-06a.out	24f7fb5	DIVERGED — the qualitative half reproduces (row 15); the 3.5× does not (observed 1.429×)
44	"refusal works, composition works, unlinked targets are skipped not fatal"	0229-integration-seam_binding-06e.out	24f7fb5	REPRODUCED — the three corresponding harness assertions pass
45	"injects_at_exit and wraps_body do NOT collapse … The wrapper is structural"	0326-strip-table-verification-28d19da.out	24f7fb5	REPRODUCED
46	"prohibits_outside cannot move at all — a #error has no runtime"	0348-residual-kind-references-28d19da.out	24f7fb5	REPRODUCED — prohibits_outside still emits #error at codegen.el:3371
47	"Controls: 99/99 native compiler tests, plus tests/integration/seam_binding.sh (6/6)"	0050-native-compiler-tests-06e.out, 0229-integration-seam_binding-06e.out	24f7fb5	REPRODUCED — both, exactly
48	Cross-cycle: cycle 08's doc says "7/7 seam_binding.sh" where this cycle says 6/6	0256-seam_binding-assertion-growth.out	285166c	REPRODUCED as consistent, not contradictory — seam_binding.sh gains a seventh assertion ("an EXIT construct declared after the build replaces the result") at 285166c, after this cycle ends. See detail D

Counts: 48 assertions — REPRODUCED 36, DIVERGED 9, NOT-REPRODUCIBLE 3, NOT-CAPTURED 0.

The nine divergences are rows 4, 13, 14, 16, 20, 24, 25, 42, 43, detailed in sections A–F below. Two of them (rows 13/14 and 43) are the same two ratios stated twice, once in the experiment commit and once in the landing commit.

---

Divergence detail A — P3, "emitting on every fn is measurably slower: FALSE"

The record's evidence is a single before/after pair, 0.37s -> 0.36s, reported to two decimal places on a ~370 ms run. A single pair at that resolution cannot distinguish a 3 % effect from noise, and the sign it happened to land on (faster) drove the verdict FALSE.

Re-measured as an interleaved paired benchmark, A,B,A,B,… × 41, so that clock or thermal drift cannot favour either arm:

	A: no seam (35b07ba^, self-hosted)	B: 266 indirections (35b07ba, self-hosted)
min	0.0572 s	0.0597 s
median	0.0595 s	0.0618 s
mean	0.0597 s	0.0618 s
sd	0.0019 s	0.0011 s

• B/A = 1.0391× by median, 1.0362× by mean, 1.0451× by min. The record's pair implies 0.36/0.37 = 0.9730×.
• Paired difference B−A: median +2.27 ms, mean +2.16 ms, sd 1.61 ms.
• B was slower in 38 of 41 paired runs.

Both arms are self-hosted to fixpoint, both -O2 -rdynamic, both compile elc-cli.el with stdout to /dev/null. The only source difference between the two compilers is this commit's 4-line codegen addition and 75-line runtime addition. The first run of this benchmark (0297) used a B binary that also linked the counting-target object file; 0298 repeats it with a clean B binary built from gen2 plus the runtime alone, and gets the same answer (+3.9 %, 38/41), so the extra object file was not the cause.

The record's practical conclusion survives; its literal verdict does not. 266 unused indirections cost about 4 % of a compile — small enough that "free unused" is a fair engineering summary, but it is a real, consistently signed, measurable cost. The prediction "emitting on every fn is measurably slower" was marked FALSE on evidence that could not support the call.

Divergence detail B — the 6.6× and 3.5× ratios

Four variants, min of 9 runs each, same workload (elc elc-cli.el > /dev/null):

	observed	record
A baseline, no seam	0.055 s	0.37 s
B seamed, 0 bindings	0.058 s	0.36 s
C seamed, 2 bindings, resolve-once	0.112 s	0.69 s
D seamed, 2 bindings, dlsym per call	0.160 s	2.45 s
E seamed, 2 bindings, silent target	0.076 s	(not measured)

ratio	observed	record
D/A dlsym-per-call vs baseline	2.909×	6.6×
D/C recovered by resolve-once	1.429×	3.5×
C/A resolve-once vs baseline	2.036×	1.865× (0.69/0.37)

The record specifies neither the workload, nor which two functions were bound, nor the target's body, nor the hardware. Two of those were chosen here and are stated in "Reconstructed inputs" below; the choice of which two functions dominates the result entirely, since the ratio scales with the number of crossings. The two bound here are the two hottest as measured (0276), not guessed: tok_kind (310 018 crossings) and is_ws_code (211 579), 521 597 total.

The direction is right in every case and the mechanism is right (detail C). The magnitudes are not reproducible from what the record states, and they are reported here without any adjustment toward the claimed figures.

One further caveat on D: the dlsym-per-call variant reconstructs a state that was never committed. The code at 35b07ba already caches (resolve_tried), so the 2.45 s measurement must have been taken on a working tree that no commit preserves. D was produced by turning if (!_el_seam[i].resolve_tried) into if (1) in a scratchpad copy of el_runtime.c; no worktree was modified.

Divergence detail C — "the residual is audit_entry's own printf, not seam overhead"

This is the one claim in the cost table that is a causal attribution rather than a number, and it is the one worth separating. Variant E repeats variant C with a silent target, which the record never measured:

• C − A = 57 ms — the whole residual over baseline
• C − E = 36 ms — attributable to the target's printf (63 % of the residual)
• E − A = 21 ms — attributable to seam dispatch itself (37 % of the residual), ≈ 40 ns per crossing over 521 597 crossings

So the printf is the larger share, and the record is right that it is the thing to look at. But it is not the whole thing: a third of the residual is the seam's own dispatch, and the record's "not seam overhead" overstates it.

Divergence detail D — "exit injection is runtime-bindable"

At 886626a the record states that three of the five compile-time kinds are runtime-bindable: entry injection, exit injection, and refusal.

Entry injection and refusal are. Exit injection is not, at any commit in this cycle.

• The runtime's table parser accepts entry|exit and defines EL_PHASE_EXIT 1 (el_runtime.c:17097, :17119), so an exit binding loads without error.
• But codegen emits exactly one el_seam_run call, at every one of the five commits, and its phase argument is a literal 0. Emitted C at 24f7fb5 contains 263 phase-0 calls and 0 phase-1 calls (0299).
• Empirically (0324, 0325): binding work doubler exit double_result on an already-built binary produces no output from the target and leaves the result at 7, at both 886626a and 24f7fb5. The identical binding in the entry phase fires normally.

An exit binding is therefore accepted and silently never fires — a worse failure mode than rejection.

The record corrects itself three commits later without acknowledging the earlier claim: 28d19da lists injects_at_exit as STRUCTURAL, and 24f7fb5 says plainly "injects_at_exit and wraps_body do NOT collapse". The seventh seam_binding.sh assertion — "an EXIT construct declared after the build replaces the result" — first appears at 285166c, whose subject is "EXPERIMENT: emit the wrapper unconditionally, so exit binds at runtime too", i.e. after this cycle, as new work. That also resolves the 6/6-vs-7/7 question: cycle 06's 6/6 and cycle 08's 7/7 are both correct for their commits.

Divergence detail E — the codegen.el line counts, off by one at both ends

	record	observed (wc -l, and grep -c "")
28d19da^ = 886626a	5157	5156
28d19da	5096	5095
difference	61	61
over the 4661 baseline	+435	+434

Both files end with a trailing newline (0128 includes the od -c check), so wc -l is exact and grep -c "" agrees with it. The error is systematic and in the same direction at both ends — the signature of a count read off an editor that shows a phantom final line, i.e. N+1 for a newline-terminated file.

The delta is unaffected, which is why the load-bearing claim of the commit — "61 lines of compiler replaced by one refusable indirection" — reproduces exactly, and why the conclusion (the prediction was FALSE; codegen did not drop below 4661) is untouched.

Worth noting against this: the "491 lines" figure in the landing commit is computed from the true wc -l values (4661 → 5152 = 491, exact). So the record's own line counts are not produced by one consistent method.

Divergence detail F — the "267 seam sites", and what it counts

The record's 267 reproduces on the nose: grep -c el_seam_run over the self-hosted gen2 emission at 35b07ba returns exactly 267, at both gen2 and gen3.

One of those 267 lines is not an indirection. It is codegen's own emitter line, which appears in the compiler's emitted C as a string literal:

8180:  emit_line(el_str_concat(el_str_concat(EL_STR("  el_seam_run(EL_STR("), c_str_lit(fn_name)), EL_STR("), 0, 0);")));

The count of actual emitted indirections is therefore 266, over 266 distinct function names, one apiece — which is the cleaner statement of the mechanism ("one unconditional indirection per fn") and is confirmed independently in 0363: gen2 contains 532 el_val_t declaration lines, exactly 266 prototypes and 266 definitions over 266 distinct names, and the set of declared functions minus the set of seamed functions is empty. This is recorded as a precision note, not as an error: 267 is the number the obvious command prints, and the off-by-one is the compiler counting itself.

The figure does not survive the strip. After 28d19da removes four functions, the same grep returns 263 (262 real indirections) at 28d19da, 8bbb750 and 24f7fb5 — whose gen2 emissions are byte-identical to each other (sha256 7b9b6e0306ff…). The landing commit's restatement "across 267 indirections" is a stale carry-forward (row 42).

---

The eight failing tests at 28d19da, named

The record says "8 tests fail, and they are exactly the 8 controls for compile-time entry injection and guards. No unrelated breakage." The run (0048, exit code 8; detail in 0051) reports 104 tests, 96 passed, 8 failed, 253 assertions:

#	Test	Failing assertion	Kind
1	decorator-manager-beat-carries-construct	"@manager injects the beat"	entry injection
2	decorator-accessor-beat-carries-construct	"@accessor injects the beat"	entry injection
3	declared-construct-injects-without-compiler-knowledge	"a program-declared construct injects"	entry injection
4	builtin-constructs-still-inject	"seeded manager still injects"	entry injection
5	declared-guard-emits-refusable-check	"the guard is called at entry"	guard
6	declared-guards-stack-in-order	"first guard runs"	guard
7	guard-precedes-injection	"the guard is emitted before the beat"	guard + entry injection
8	constructs-compose-guard-entry-exit	"guard before entry injection"	guard + entry injection

Exactly eight, four entry-injection and four guard, nothing else. The claim is reproduced without qualification. 8bbb750 then deletes these eight by name (0239) and adds three — seam-replaces-inlined-entry-injection, seam-entry-is-refusable, seam-is-emitted-for-undecorated-fns — giving 104 − 8 + 3 = 99.

Test and seam-site totals across the cycle

commit	native tests	seam lines in gen2	real indirections	codegen.el	fixpoint
1b324a0 (parent)	102 declared	0	0	5152	—
35b07ba	102 / 102 pass	267	266	5156	gen2==gen3
886626a	104 / 104 pass	267	266	5156	gen2==gen3
28d19da	104, 96 pass / 8 fail	263	262	5095	gen2==gen3
8bbb750	99 / 99 pass	263	262	5095	gen2==gen3
24f7fb5	99 / 99 pass	263	262	5095	gen2==gen3

Reconstructed inputs

Three inputs used below did not exist in the tree at the commit measured. Each is an input, not evidence; the evidence is the captured output of running it at the pinned commit.

1. /tmp/seamrun (0272). The record's DEMONSTRATED transcript names a probe binary that was never committed. It was rebuilt from the record's own text — an El program with fn work() -> Int { return 7 } and no construct anywhere, plus a linked-but-unreferenced C target named audit_entry printing AUDIT: <fn> applied by <construct>. The structure is copied from tests/integration/seam_binding.sh, which the same author committed three commits later (8bbb750) as the permanent form of this same hand check; the only substitutions are the record's own target name and message. Captured output matches the transcript line for line.
2. seam_binding.sh applied retroactively (0273, 0274, 0275). The harness from 8bbb750 was run, unmodified, against the compilers built at 35b07ba, 886626a and 28d19da, where it does not yet exist. This is what establishes that refusal fails at 35b07ba and succeeds from 886626a on. Artifacts are named RETROFIT- to mark that the harness postdates the commit.
3. The timing rig (0276, 0296, 0297, 0298) — see detail B. The dlsym-per-call arm uses a scratchpad copy of el_runtime.c with the resolve-once cache disabled. No worktree was modified at any point; all five worktrees are clean on every artifact in MANIFEST.tsv.

The two hottest functions used for the 2-binding measurements were determined by measurement, not by guess (0276): the seam itself was used as an instrument, binding all 266 seamed functions in two batches to a counting target that dumps at exit. Top of the distribution compiling elc-cli.el: tok_kind 310 018, is_ws_code 211 579, is_digit_code 208 435, is_alpha_code 204 417, is_alnum_or_underscore_code 152 568; 1 692 602 crossings over 124 functions actually reached.

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

1. 0114-codegen-linecount-history.out is defective and retained. Its while read -r h </dev/null attached the redirect to the whole loop instead of to git inside it, so read had no stdin and the loop body never ran; the artifact's history table is empty. The === the specific endpoints === section below it is unaffected and correct. Corrected capture: 0128-REDO-codegen-linecount-history.out. Cite 0128, not 0114.
2. 0230-test-churn-8bbb750.out is defective and retained. It grepped for test( where the test declaration syntax is test "name" {, so all three of its test-name sections are empty. Corrected capture: 0239-REDO-test-churn-names.out. Cite 0239, not 0230.
3. 0297-RECONSTRUCTED-free-when-unused-06a.out is superseded but not defective. Its B arm linked an extra object file (the counting targets). 0298-REDO-free-when-unused-clean-binary-06a.out repeats it with a clean binary. Both are retained; they agree (+3.9 % median, 38/41 paired runs), so either may be cited. 0298 is the cleaner instrument.
4. A recipe defect that did not enter this record. The re-run recipe's original fixpoint step compared gen1 to gen2, which is exactly the wrong test — the mistake this cycle's own P4 note diagnoses. It was corrected before any fixpoint artifact was captured here, so all five selfhost-3gen-fixpoint-* artifacts already compare gen2 to gen3 and additionally record gen1 != gen2. No superseded fixpoint artifact exists.

Note for later cycles

• The "267 indirections" figure is correct only for 35b07ba and 886626a. From 28d19da onward it is 263 (262 real). Cycles that cite 267 after the strip are citing a stale number.
• The claim that exit injection is runtime-bindable (detail D) is false for the whole of cycle 06 and becomes true at 285166c. Any later cycle that treats cycle 06 as having delivered runtime exit binding is inheriting the error.