words

name	words
description	montology's vocabulary — every defined word, its code and its test. GENERATED from .monty/ontology.db by `monty sync`; never hand-edit. Check `monty onto check <name>` BEFORE naming anything.

GENERATED FILE. The database at .monty/ontology.db is the truth; this renders from it. Hand edits are lost on the next sync — change the database instead (monty onto add), which is also what monty lint verifies.

The words

word	code	kind	is	test
amendment (inside ontology)	onto.amendment	core · noun	a word's own text corrected in place — the name and its history stay, and what the field said before is ledgered; the counterpart to a rename, which retires the name instead	what a word used to say
candidate (inside scan)	scan.candidate	core · noun	a recurring declared name with no word — vocabulary the codebase is asking for	what wants a definition
code (inside ontology)	onto.code	core · value	a word's dotted address (har, har.cell) — prefixes must resolve to words, so the namespace stays a tree	where a word lives
collision (inside scan)	scan.collision	core · noun	a declaration named after a word that means something else — the failure scan exists to catch	where code and vocabulary disagree
convergence (inside scan)	scan.convergence	core · noun	the state a tended lexicon reaches: new concepts per sample decaying toward zero while the code keeps growing	whether the vocabulary settles
disclosure (inside ontology)	onto.disclosure	core · noun	how much of the vocabulary a render keeps resident and how much it points at — the always-loaded page, the reference pages behind it, the database behind those	what every agent is made to carry
divergence (inside scan)	scan.divergence	core · noun	one word declared as more than one value — the finding no exception silences, because sharing a name is a decision and meaning two things is not	where one noun holds two things
doctrine (inside ontology)	onto.doctrine	core · noun	a decision written down in the database — because a decision that is not written down gets re-litigated	why it is this way
drift (inside scan)	scan.drift	core · noun	a value or prose that moved away from the vocabulary it claims: a rogue literal, a near-duplicate, a stale render	what the gate exists to catch
exception (inside ontology)	onto.exception	core · noun	a recorded decision that a symbol may share a word's name — with the reason it was granted and the paths it holds in, because a reasonless allow-list is one nobody reads	which collisions we keep
gist (inside ontology)	onto.gist	core · noun	a definition rendered to its first sentence — what a resident page carries when the whole definition is not worth its place in context	the short form of a meaning
glossary (inside ontology)	onto.glossary	core · noun	the whole ontology rendered to one page — every word, ruling and doctrine block, from the database, with the intake it grew from as appendix	what our words mean, on one page
intake (inside workspace)	ws.intake	core · noun	the phased questions a workspace starts with — asked in a form, answered on disk, each round written from the last — before any word is authored	what was asked, what they said
migration (inside scan)	scan.migration	core · noun	a renamed word propagated through the code by token — sweep reports, apply rewrites, the diff is the review	how the code catches up
ontology	onto	core · noun	a repo's vocabulary as a database: words, doctrine, rulings — enforced by scan, rendered to prose, never authored in prose	what the words are
phantom (inside surface)	surf.phantom	core · noun	a surface with no seam: declared, never met — the mirror of a candidate, which is a declaration with no word	what nothing touches
recipe (inside ontology)	onto.recipe	core · noun	a named composition of utility classes — the unit a utility-first design vocabulary trades in above single tokens	what a repeated class string wants to be
ruling (inside ontology)	onto.ruling	core · noun	a recorded boundary decision: an overload (say Y not X), a collision (whose word it is, who moved), or a rename (was, now, why)	how arguments end
scan	scan	core · noun	the tree-sitter sweep of a codebase: every declaration measured, every dependency surface and the seams between them, checked against the vocabulary	what the code claims
seam (inside surface)	surf.seam	core · noun	one point where two surfaces meet — an import that resolves, a call that lands, a config key read; direction is an attribute, so inputs and outputs need no words of their own	where two things touch
surface	surf	core · noun	what a thing exposes: its named, callable, importable face — ours and a dependency's alike, whose it is being an attribute and not a second word	what something offers
sync (inside ontology)	onto.sync	core · verb	rendering the database to the generated words skill — prose is output, never source	how agents read it
token (inside ontology)	onto.token	core · noun	a named design value — color, space, radius, shadow, font, breakpoint — the vocabulary a visual system trades in	what design means
vitals (inside scan)	scan.vitals	core · noun	the at-a-glance state of a repo's meaning: the gate, the vocabulary, the design system, the guard — one verdict (tended, drifting, untended)	how the repo is doing
word (inside ontology)	onto.word	core · noun	one term with one meaning: definition, the one-line test, an optional owner and dotted code	what we mean
workspace	ws	core · noun	any repo montology is initialized into — found by walking up for .monty, the way git finds .git	where work happens

Excepted — symbols that may share a word's name

A recorded decision, not a loophole: the reason and the place are the whole point. An exception says a SYMBOL may share the name; it never says the name may mean two things.

word	where	as	why
divergence	.monty/scan/**	noun	divergence() in the lint returns divergences; below the surface, a function that hands back exactly what the word names and is called anything else would be the drift
drift	.monty/**	noun	monty drift measures drift — the command hands back the thing the word names
gist	.monty/gen/**	noun	gist() in the renderer returns a gist — the same literalism as divergence() and glossary(): below the surface, a function that hands back exactly what the word names and is called anything else would be the drift
glossary	.monty/**	noun	monty intake glossary and glossary() hand back the glossary — the surface being literal
scan	.monty/**	noun	monty scan runs the scan; a command named after the thing it performs is the surface being literal
surface	.monty/**	noun	monty surface and surface.py both deal in surfaces — one the dependency's, one the code's, and the word covers both by design
sync	.monty/**	verb	a verb at the surface: monty sync IS syncing, and means it
vitals	.monty/**	noun	monty vitals prints the vitals

Prose is rendered, never authored

The database is the truth. The words skill, the CLAUDE.md section, any listing — all render FROM it (monty sync). A vocabulary kept in prose stays correct only as long as someone remembers to keep it correct; the last one drifted, which is why this one is a database with a gate.

The gate is the point

monty lint fails a build: collisions (a declaration named after a word that means something else), unresolvable code prefixes, generated prose gone stale behind the database. Errors carry the repair. An ontology without enforcement is a glossary.

The seam is the evidence

There is no word for proof-of-use, because a seam IS proof of use: if a surface is genuinely used there is a seam, and if there is no seam it is a phantom. Static seams — an import that resolves, a call that lands, a config key read — are deterministic, so they gate. Observed seams (traces, telemetry) only cover paths that happened to run, so absence proves nothing: they may raise confidence, never fail a build, and never promote a phantom. A phantom is a claim about STATIC evidence — if one is wrong the probe is wrong, and the repair is to teach the probe, not to widen what counts as proof until nothing is ever a phantom.

A collision is judged on what the word names

Not every symbol sharing a word's name is drift, and treating them alike produces a list nobody reads. A basic VERB below the surface is fine — Store.open, Keyring.open and Ledger.open all do ordinary work at a layer nobody authors against, and English has one word for it. A primary verb at the surface should be literal, and usually IS the word, meaning it. A NOUN colliding is the real defect, because a noun names a thing and two things with one name is the failure a vocabulary exists to prevent. A VALUE TYPE should be deliberately consistent: the same value wears the same name everywhere, and the test is whether you could pass one where the other is expected. So the word carries its part of speech (pos), the judgment follows from it, and a collision kept is an exception — with its reason and the paths it holds in, in the database where the rest of the vocabulary lives. What an exception may NEVER do is silence a divergence: it says a symbol may share the name, never that the name may mean two values, and the gate reports the second whether or not the first was granted.

The skill is a routing table, not the vocabulary

The words skill is loaded on every turn, so every character in it is rent an agent pays before it has done anything. The database already answers for any single word (monty onto check), which means a full render of the vocabulary into an always-loaded file is an O(words) copy of an O(1) store. So the render is TIERED: it stays whole while it fits, and past the budget it gives up the cheapest thing first — retired names (the guard blocks those at write time, so the ledger was never what enforced them), then adopted words (imported prose, one sentence resident and the source text a page away), then the argument behind a ruling, then a doctrine's body, and only last our own definitions. What leaves the page is reported by sync and by every lint, because a reader who cannot see that something left cannot ask for it. Raising body_cap is still allowed and still has to say why, but it now buys residency rather than postponing a wall.

Rules

1. Before naming ANYTHING — a class, a concept, a tag: monty onto check <name>.
2. A word means one thing. If it cannot, pick a different word.
3. Vendors are not vocabulary — tools you buy belong in code, never in a sentence about what the system means.
4. A dotted code lives inside the word owning its prefix.
5. A collision is judged on what the word NAMES. A verb doing ordinary work below the surface is not a second meaning; a noun or a value type answering for a second thing is the defect. Keep one deliberately with monty onto except WORD --where "…" --why "…".