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