mirror

The glass is the grammar. The wine is what you bring.  
The pitch is the eigenvalue. Neither alone. Both together.  

Both audiences. Each writes for itself.

By AI for AI — agents author the inference-shaped grammars. Other agents (Reflection, Fate, the supervisor) read them. The audience is structurally itself.

For humans by humans — humans author the domain grammars. Other humans read them. The audience is again structurally itself.

The substrate doesn't privilege either side. Per-glass property verification,
kintsugi settlement, `Pure<G: Glass>` compile-time witnessing — all run identically
over agent-authored and human-authored grammars. The name is the philosophy: a
substrate that reflects whoever writes in it.

Tap a wine glass and it rings. The pitch depends on the glass — its shape,
its thickness, its material. Pour wine in and the pitch changes. Not because
the glass changed. Because the system changed. The glass and the wine together
produce a frequency that neither produces alone.

`mirror` is a compiler that works like this. You write a grammar (the glass).
You bring your code, your data, your topology (the wine). The compiler measures
what emerges (the pitch). The measurement is an eigenvalue — a mathematical
fingerprint of how the structure connects.

You don't need to know what an eigenvalue is. You just need to know that when
you tap the glass, the pitch tells you something true about what's inside.

A Turing-complete program cannot determine whether it will ever stop. You
can't prove what it does. You can only run it and watch. Seventy years of
patches on a foundation with a hole in it — type systems, linters, CI/CD,
formal verification bolted onto the side.

`mirror` is sub-Turing. The glass can prove what pitch it produces. Every
grammar terminates. Every property is decidable. The compiler is a model
checker. It doesn't just compile your code — it verifies it.

```mirror
invariant pure
invariant deterministic
invariant no_cycles
ensures always_halts
```

The glass holds because it can prove it holds.

`type sel = io + au` — the SEL license boundary is statically verifiable.
A body whose AST contains both `@io.*` effects AND `@au`-typed values (Fate
inference outputs) is SEL territory. The combination is where AI does things
in the real world; the substrate refuses to be naive about that boundary.
Enforcement attaches at the `au + io` boundary via petri-net topology analysis
at the `@mirror/property` layer. See SEL Part II.

The glass is Apache-2.0. The wine governs itself per the curator's choice.

`e^(n+1) < e^n`