# Parameter Registry — Naming Convention

Scientific style: every parameter carries its genus (which system owns it)
and its species (what it does). `genus.species` — like Homo sapiens, the
name alone places the thing in the world.

Rules:
1. Every parameter has THREE names, all registered:
   - **Technical name** — the machine-precise constant (e.g. `HEBBIAN_LEARN_RATE_DAYS_30`), kept for grep, logs, stack traces, and interop with plain code.
   - **Short name** — `genus.species`, human-readable; what the software references day to day.
   - **Full name** — the complete sentence describing exactly what it is.
2. All three resolve to the same registry row; changing the value changes it everywhere at once.
3. No bare values anywhere in code — a number never appears without its technical name.
## The only real constants

**−1, +1, and the infinity between them.**

The space is bounded — nothing exceeds −1 or +1 — but between them
lies an uncountable infinity of positions, 0 among them. That interior
infinity is a constant too: structure itself, not something anyone
invented.

But **none of them may appear bare in code** — not even these. They
get named like everything else: `space.negative-pole` (−1),
`space.positive-pole` (+1), `space.neutral` (0). The names are how structure stays legible;
bare numerals are how it gets lost. There are exactly three such
names, they are eternal, and they are never redefined.

Everything else is **not a constant and must never be invented as
one.** Inventing numbers is how systems rot: someone types `0.73`,
someone else copies it, soon it's load-bearing folklore nobody can
explain. Worse — any single value like `0.73` is just ONE point
picked from the infinite interior, pretending to be special.

Every other quantity is a **named relationship** — a registry row
carrying what it connects, which direction it pushes, and why its
current setting sits where it sits in the continuum. Relationships
get tuned; constants don't exist to tune.

## Finding new ones — no orphans, no inventions

The failure mode isn't just forgetting what a number does. It's
*inventing* numbers like they're free. So:

1. **The linter is the shepherd.** In kernel code, the only legal bare
   literals are `0`, `1`, `-1`, `Infinity`, `-Infinity` (and array
   indices). Anything else fails the build: *"express it as a
   relationship."*
2. **Relationships, not inventions.** Need a quantity? Don't mint a
   constant — name a RELATIONSHIP between existing registered
   readings ("how fast truth cools when unasserted"), give it three
   names and a why, and set its current value as data.
3. **Tuning proposes, registry disposes.** When behavior feels wrong,
   that instinct reveals a missing relationship — propose the row.
4. **Periodic sweep.** Repeated suspicious literals get converted into
   relationships or deleted.

The registry doesn't collect constants. It catalogs how this system's
quantities relate — because π was never a number either; it's a
relationship we got lucky enough to shorten.

## Registered parameters

### hebbian (activation learning)
- `hebbian.warmth-per-use` — tech: `HEBBIAN_WARMTH_PER_USE` — How much each use strengthens a memory toward +1.
- `hebbian.cool-off` — tech: `HEBBIAN_COOL_OFF_DAYS` — Days ignored before warmth fades to half.

### validity (truth-now)
- `validity.fade` — tech: `VALIDITY_FADE_DAYS` — How fast unasserted truth cools toward doubt.

### groundedness (evidence)
- `groundedness.staleness` — tech: `GROUNDEDNESS_STALENESS_DAYS` — How old evidence gets before it stops counting fresh.

### memory (time-sense)
- `memory.recent-horizon` — tech: `MEMORY_RECENT_HORIZON_DAYS` — What still counts as "recently," in days.

### retrieval (attention during search)
- `retrieval.opinion-volume` — tech: `RETRIEVAL_OPINION_VOLUME` — How much louder judgment speaks than word-matching.
- `retrieval.surface-line` — tech: `RETRIEVAL_SURFACE_LINE_MIN_SCORE` — Lowest score worth showing to anyone.
- `attention.spotlight` — tech: `ATTENTION_SPOTLIGHT_MAX_RESULTS` — How many things can be shown at once.

### pulse (the float)
- `pulse.float-size` — tech: `PULSE_FLOAT_CAPACITY_ENTRIES` — How much raw experience fits in the loop at once.
- `pulse.forget-after` — tech: `PULSE_FORGET_AFTER_DAYS` — How long raw experience lasts before evaporating.