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/05-the-emitter-discards-what-it-knows.md

@@ -0,0 +1,48 @@
+# the emitter discards what it knows
+
+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 — `a5af871`
+
+```
+EXPERIMENT: let the compiler write down what it already knows
+
+HYPOTHESIS: attribution is redundant for static structure. Codegen sees every
+construct-to-function relation at emission time and discards it, so the only
+way to learn the structure back is to run the program and read what it
+reported. That is instrumentation compensating for erasure.
+
+PREDICTIONS, committed before running:
+  1 derivable at compile time with no runtime call     expected TRUE
+  2 complete for guards and exits (invisible today)    expected TRUE
+  3 answers it for code that has never executed        expected TRUE
+  4 deterministic                                      expected TRUE
+  5 makes the entry beat redundant                     expected FALSE
+
+RESULT: 5/5 as predicted. From a program that was never executed:
+
+  authenticate guards_at_entry login    my_auth
+  durable      injects_at_exit  save    persist_now
+  authenticate guards_at_entry critical my_auth
+  durable      injects_at_exit  critical persist_now
+  manager      injects_at_entry critical engram_boundary_beat
+
+Prediction 5 held: the relation records that a boundary COULD be crossed, the
+beat records that it WAS. They are different facts and neither replaces the
+other.
+
+CONSEQUENCE, and it undercuts the first pass on iteration-1: construct identity
+was available at compile time all along. With relations recorded at build, the
+runtime needs only the function name and attribution becomes a join rather than
+a payload. The counter-argument is that the payload is self-describing while
+the file must be pinned to the artifact or the two drift and attribution is
+silently lost — which is the same conclusion as "compile against a manifold
+revision and record the revision in the artifact", reached from the other side.
+
+Written to a file rather than the engram on purpose: a compile that consults a
+manifold produces different output from identical source at different times.
+The file is content-addressed; the engram ingests it. Determinism preserved,
+mechanism proven.
+```