Foundations

Two problems, one family.

Every other family teaches a move, and every move presupposes facts it never argues: what a skill minimally is, that the model holds nothing between calls, that a documented contract is persuasion rather than enforcement, that checking a result is cheaper than producing it, that a discarded run must not have changed the world. Left unstated, the presuppositions fail silently — designs inherit the stateful-colleague error, verifiers stack failure instead of compounding reliability, "discard" quietly means "keep the mess."

And a family named foundations attracts everything that feels basic. Without an admission rule it decays into a junk drawer — the residual home for material that merely lacked a better one.

The prerequisite residence test (settled 2026-07-05, foundations grilling)

A node lives in Foundations iff understanding it is required to properly apply the other families. Two corollaries:

• The residual clause is rejected. "Baseline info that doesn't fit elsewhere" is the junk-drawer test, not this one. Load-bearing content that fails the prerequisite test belongs inside the node that owns it, never here. (First eviction: the shared-workspace stub — its channel amendment dissolved into LLM Dispatch, its governing law into The Contract.)
• The curriculum role is a consequence, not the definition. Prerequisites are what you teach first — so Foundations naturally opens the masterclass — but a node earns residence by being presupposed, not by being introductory.

What a skill buys — the floor every family stands on

A skill is a trade. Bought: addressability (a named handle you invoke on purpose), replayability (capture intent once, invoke repeatedly across sessions), discoverability (it shows up in the skill list), a trigger contract (the description says when it fires), and a composable seam (other things can build on the name + contract). Paid: a namespace slot, a line of attention (the description stays resident so the model can route — the cost The Context Economy prices as propagation scope), and a maintenance surface (something now exists to keep correct).

This enumeration is root material because every family presupposes it: each pattern in the tree is a way of making the trade pay better — Baseline Skill is the trade at its smallest, and the the altitude above the single skill (N skills, compounding costs) is the trade at scale, where N slots compound. A skill that doesn't earn its slot is a bad trade however well it is built.

The residents — five pillars, the keystone, the baseline

The family settled at five pillars + the keystone + the baseline (2026-07-05; both then-contested residents passed the test). Each earns residence its own way:

• The baseline artifact — Baseline Skill: the reference shape (name + description + body) every later pattern is a structural diff against. Prerequisite because a diff needs its base.
• Two primitives — motivation-agnostic substrates the strategies wield rather than apply: The Contract (the seam) and LLM Dispatch (the parent-child execution edge). Prerequisite because every family's move creates seams, crosses actor boundaries, or both — and pays off only when they are contracted.
• Three premises — facts to internalize, not moves to make:
  • Statelessness — the window is the entire state, re-shipped every call; the fact the context-engineering arithmetic and the verification family's recovery moves both derive from.
  • Effect Discipline — which recovery moves a dispatch's effects leave legal; presupposed by verification's discard, persistence's artifacts, and control flow's gate.
  • Verification Asymmetry — checking ≪ doing, for the covered portion of intent, on external rungs only; presupposed directly everywhere, because every family checks seams.
• The keystone — The Contract Keystone: the argument assembled from the pillars. The contract is the possibility condition of checking, the asymmetry its affordability condition, effect discipline the legality of the recovery move. Not another pattern — the reason the library exists.

The test's price is strictness. Each admission is a standing claim that every other family depends on the node — so the burden of proof sits with admission, and the family stays small on purpose. What Foundations refuses on principle: prices (taught at The Context Economy), moves (taught in the families that make them), and mechanics (storage, staging layouts — instances, not substrate). The refusals cost cross-references; they buy a root that stays true as the tree grows.

The test read backwards: which family breaks, and how it breaks, when a pillar goes unheld. (The arrow list settled 2026-07-05; the failure readings name each arrow's silent failure — relocated from Relationships and sharpened 2026-08-02.)

• Verification ← the asymmetry + the contract + statelessness's feature face. Unheld: there is nothing declared to check against, and checking isn't known to be affordable — verifiers stack failure instead of compounding reliability.
• Persistence ← effect discipline + the contract + statelessness. Unheld: artifacts outlive the run unowned — "discard" quietly means "keep the mess."
• Context engineering ← statelessness's cost face. Unheld: the stateful-colleague error — budgeting as if the window persisted, so the re-shipping bill is never priced.
• Control flow ← effect discipline. Unheld: gates placed downstream of effects they can no longer revoke.
• Composition, externalization, distillation ← the contract's seam. Unheld: their moves multiply seams, and an uncontracted seam moves work around without making any of it checkable.

An admission rule is evidenced by what it discriminates, and this one has run three times with non-default outcomes (all 2026-07-05, foundations grilling):

• One eviction. The shared-workspace stub failed the test and dissolved — its channel amendment into LLM Dispatch, its governing law into The Contract. This is the externally checkable item: the material demonstrably lives at its two destinations, not here.
• Two contested admissions. Both then-contested residents passed under live challenge, not by default; their residence arguments stand in Model and claims.
• One demotion. The curriculum role was argued as the family's definition and survived only as a consequence — the test cut a plausible framing, not merely weak content.

• Children: Baseline Skill (with the tell-me-a-joke exemplar and its flavor sidecar), The Contract, The Contract Keystone, LLM Dispatch, Statelessness, Effect Discipline, Verification Asymmetry.
• Where the prices are taught — not here. The price arithmetic lives at The Context Economy (Context engineering › statics; moved out of Foundations 2026-07-02). Foundations holds the substrate fact — statelessness — and economy derives the arithmetic from it.

The uses relation (Parnas, "Designing Software for Ease of Extension and Contraction", 1979): A uses B when A's function depends on a correct B, so a useful subset holds B without A and none holds A without B. The residence test is that relation over ideas rather than programs; its rejected residual clause is coincidental cohesion (Stevens, Myers & Constantine, 1974) refused by name. Nothing links against a premise, so an unheld one fails silently.

• Vocabulary boundary: addressability and replayability currently have only two claimants, this node and baseline-skill, so they remain ordinary prose rather than glossary terms. A third independent claimant would change that classification.