log v1 experiments: nineteen cycles, organised by the method that produced them

cycles/    one file per Ishikawa -> scientific method -> Six Sigma loop, named
           for the DEFECT not the fix, carrying the commit record as written at
           the time
findings/  what the cycles produced, cross-cut: live bugs, architecture answers,
           and defects in my own measurement

The organising finding is that predictions which came back FALSE produced every
significant result. Eleven of sixty-one failed, and those eleven found: that the
arity table was not drifted but 40% incomplete; that the AST traversal is
irreducible and only rules and judgments move; that guards could refuse through
the seam after all; and that routing el_bin_lookup through the gate did NOT fix
the SIGSEGV, because the fallback strlen was the hazard -- a wrong fix I would
otherwise have shipped as verified.

One cycle was run without committing predictions first and had to be discarded
as rigged. It is kept, in full, as 18-async-half-expressible.md.

docs/v1/experiments/cycles/10-a-second-copy-of-the-header.md

@@ -0,0 +1,54 @@
+# a second copy of the header
+
+One `Ishikawa → scientific method → Six Sigma` loop. The record below is the
+commit message as written at the time, before the outcome was known to anyone
+reading this file.
+
+## Record — `9cc6040`
+
+```
+EXPERIMENT: derive arity from the runtime's own declarations
+
+codegen.el carried builtin_arity(): 344 lines, 300 entries, a hand-maintained
+second copy of el_runtime.h.
+
+PREDICTIONS AND RESULTS
+  P1 the table duplicates the header                     TRUE   243 shared names
+  P2 they have already drifted                           FALSE  ZERO drift. The
+                                                                duplicate had been
+                                                                maintained correctly.
+  P3 codegen can emit call-arity relations               TRUE
+  P4 the check becomes a query against the header        TRUE
+  P5 codegen drops to roughly baseline                   TRUE   4903 -> 4512,
+                                                                149 BELOW the 4661
+                                                                it started at
+
+P2 being false is the better result: the table was not WRONG, it was
+INCOMPLETE. 110 functions the runtime declares had no entry, so calling them
+with the wrong argument count produced no El-level diagnostic at all. Measured:
+the old compiler reports 0 arity errors for __http_do_map_to_file(1); the query
+reports "takes 5 arguments, called with 1".
+
+Deriving from the header fixes coverage AND makes drift impossible by
+construction. 503 signatures, versus 300 entries maintained by hand.
+
+THREE DEFECTS IN MY OWN CHECKER, each found by running it rather than reading it
+  1. El names and C names differ -- `println` is `__println`. 60 of 500 decls
+     carry the prefix and codegen owns the mapping; the old table carried both
+     keys. One rule covers all 60.
+  2. Multi-line declarations parsed as zero params, so the checker reported
+     "takes 0" for a function taking 5. A diagnostic with the wrong number in it
+     is worse than none -- the same shape as the stale caller attribution in the
+     previous pass.
+  3. Fixing (2) by joining lines dropped 500 signatures to 334, because a
+     declaration preceded by a comment no longer started its record. Comments
+     are stripped first now.
+
+98/98 native, 5/5 arity_query.sh, fixpoint ok.
+```
+
+## Record — `d9e301b`
+
+```
+land arity-from-header: the runtime declares its own surface
+```