## 01What we established

El is a concept-oriented language — the first, and intended as the last, because every other family is oriented toward a representation of a concept rather than the concept. Procedures, objects, functions, predicates are the shapes concepts get flattened into. Once the primitive is the concept, there is no further rung.

Everything here is El. The engram is an El program, the soul is El, `elp` is El, ingest is El. Which gives the load-bearing consequence:

> A concept with no home in El does not disappear. It becomes C, or it becomes a convention.

Both are measurable, and both were measured. As C: 20,504 lines of `el_runtime.c` — 2.3× the entire self-hosting language it serves (9,089 lines), ~47% of it engram code that has its own six sibling files. As convention, from `language.md` §18.0 — "these are not four problems, they are one absence, four times":

Concern | Fragments | The convention it became
--- | --- | ---
Process identity | 0 guards | "check nothing is already running first"
Configuration | 20 env vars | "remember the right default here"
Durability | 62 call sites | "after you mutate, remember to persist"
Request auth | 10 per-route | "check the token in this handler too"
Index-after-append | 9 of 9 failed | "after you append, remember to index"

The last row is the strongest evidence available about what this class of convention is worth: it failed at 100% of its sites.

## 02The decomposition axis

Not by file, module, or subsystem. By faculty.

Every defect fought in the last day resolves to a faculty rather than a bug, and each one leaked out of El into something else — into C, into a Swift binary, into a shell script with a curl timeout, into a convention nobody performs.

Faculty | State | Measured | Where it leaked to
--- | --- | --- | ---
Ingest take in | dead | 2 min → 0 nodes | separate process, uploads bytes over HTTP to a process with direct fs access; 5 functions where there is 1
Recall remember | dead | own definition ranked 8th | lexical substring scan; empty on 23 of 24 multi-token queries
Transduce perceive | dead | 1 node, 0 edges | intake flattens signal to a point; `realized:false`; caller must declare the modality
Think reason | dead | direction [0,0,0,…] | null gradient from any anchor, any faculty, byte-identical; confidence at the uninformed prior
Realize express | partial | 13-word vocabulary | organ was 939 lines of Swift beside the language; voice read from a file path
Body substrate | partial | CC 356 / 1,626 lines | `engram_activate_inner` — recall itself, with 356 unexamined paths
Persist endure | live | 100% embedded | works; every signal placed in geometry at intake, 13,562 of 13,562

Stated plainly: it cannot take in, cannot remember, cannot perceive, cannot reason, and barely speaks. These were filed as tickets against a repository. They are faculties of the thing the repository is.

## 03The ordering principle

El's compiler is written in El. Every concept the language gains, the compiler can then be written in — so the tool improves the tool, and the fixpoint (stage2 ≡ stage3, byte-identical) makes each turn provable rather than hopeful. The verifier answers in 2.9s.

Which means the ordering criterion is not size of payoff:

> Order by leverage on the next iteration. Which concept, added to El, most increases the ability to add the following one?

In a recursive system that dominates immediate value — a small early gain that compounds beats a large one that doesn't. It also bounds itself correctly: unbounded in depth, bounded in rate, because nothing lands that the compiler and the fixpoint have not passed.

## 04Open — for the whiteboard

What does a declaration bind to?If `cat` names a region rather than a struct — one that shifts and completes against the engram and the neighbouring code — then what is written at the declaration site, and what is resolved at use? This is the centre of the whole thing and it is not specified anywhere yet.
Is "the type checker" a type checker at all?§2.3 records annotations as parsed and skipped, and every codegen hazard is downstream of that — `+` dispatching on AST node kind, `==` lowering to `str_eq` unless both operand names are in an int-name set. But if a declaration names a region, checking is asking whether the geometry supports the use. That is grounding, not unification. Naming this wrong builds the wrong thing.
Is the faculty list above right?Seven were derived from what broke. Derived-from-failure is a biased sample — it finds what is loud, not what is missing. What faculty is absent entirely and therefore never failed?
Which concept has the highest leverage on the next turn?Candidates so far: the prologue/epilogue seam (§19.3 names it as the prerequisite and its stated blocker has expired — it would collapse 62 + 10 convention sites); `protocol`/`impl` (the absence that produced five ingest functions); and the resolution question above. These are not equal and the criterion in §03 should decide it, not preference.
What is the seam that makes cognition non-optional?"Use the ops" is itself a convention — present in context every turn, enforced by nothing, and it failed at ~100% of sites in a full session. A stronger instruction is still a convention. What makes reasoning-outside-Neuron fail, the way `@manager` makes `dharma_emit` outside the boundary a compile error rather than a lint?

Working surface, not a design document. The design is what we put on it. Everything above is either measured or quoted from `lang/spec/language.md`; nothing is inferred and presented as fact.