The specification: three ways in, one probe at the door

Where and how flows form — specifically, how a fragment actually comes to exist, and what stands between "someone wants this" and "the machine will run it."

Source: spec/PROGRAMME_MANUAL.md (chapters 0, 2, 12–13), lib/application/{figure-records,validate-figure,programme-shelf,act-deepen}.ts, lib/side/figures/composer-fixture.ts.

§Chapter 0's rule, stated first because everything else follows from it

"A particular approach is only ever a programme, never code."

A figure — the specification's word for any named arrangement of knots and binds — is one of four declared forms: a records programme (a plain YAML list of registration records, read at the moment it is used, never compiled in); a blueprint set (named seats a person or a deepen request can open as a Cell — this is Part 2's cascade seats and the press-reader seat of Part 4 both); a Cell package (a charter plus a blueprint plus a policy, re-entering admission fresh every time it is reused — never persisted as a running thing); or a Cell's own accepted export, when that export happens to carry a blueprint — which is precisely what the composer, below, produces.

§Way one — hand-written, on the shelf

The most direct route: a person writes a YAML file under programmes/, following the shelf's own declared-record convention (state what it declares, where it lives, who consumes it, what proves it worked). It is read fresh every time it is used — nothing about a programme is cached or compiled ahead of time — and it enters the log either by name at the front door (the world reads the person's opening words and picks the closest match from an enumerated list) or by direct request. This is how every worked example in Part 4 and Part 2 actually got onto the log.

§Way two — built live, by filling slots

The composer is a figure whose whole purpose is to let a person assemble a different figure's blueprint without writing YAML at all. It presents four slots — the bind (the new figure's own identity: an id, a title, what it publishes, its threshold), the perception (which channel it listens to and how it winds), the questions (one control question per commit, accumulating — never overwriting each other), and the harvest (a bare trigger: "I am done filling the slots above"). Only once all four are present does the harvest bind fire, folding everything collected into a genuine blueprint — a local, deterministic action (assemble@1), not a request to the outside world. The composer is, itself, an ordinary Cell, admitted through the same ceremony as anything else — which means its own output is nothing special either: a blueprint, ready to be presented for admission as a fresh figure like any other.

§Way three — a seat, opened for you

deepen — "Open a Cell", the gesture Part 4 and Part 7 both walk in detail — takes a named seat from a blueprint set and builds its inner fragment automatically, without any hand-written YAML at all. Depending on the seat, the act constructs either the simplest possible inner figure (one knot waiting for the person's own words, one bind that releases them — deepenBlueprint) or a slightly richer one for a reader seat (one knot waiting for a question, some material, and the person's word to proceed; one bind that asks the world with the seat's own fixed instruction and result schema — readerBlueprint, the shape behind every Cell in Part 4's worked example). Either way, what gets built is still, underneath, nothing but knot-and-bind pairs — the act is simply doing the authoring a person would otherwise have done by hand.

§The one probe every route passes through, regardless

All three routes converge on the exact same gate: validateFigure. Before any proposed set of records is allowed anywhere near a real session, it is run, whole, through a disposable throwaway session built purely to test it — the very same registration machinery that will judge it for real, run once in private first. An unknown listener strategy, a malformed condition, a duplicated id — all of it fails here, in the machine's own words, and the real session never even sees a record that could have poisoned it. The manual's own name for this discipline is blunt: "the machine judges its own food." And its own honest limit is stated just as plainly: this proves the records are well-shaped, never that the study they describe is a good one — that is what an assessment, a review, and ultimately a person reading the result are for (Part 7).

§The vocabulary of choices, once you are authoring

The construct catalogue (manual chapter 2) is short on purpose: everything composes from sequence and join alone. A deterministic gate, when the only question is whether something is present. A semantic accumulation knot, when a judgement needs to ripen through several rounds before it is ready. A canvas — several lanes feeding on each other under a shared budget. A journal knot, for a side record that is not itself the study's main thread. unfold, for generative fan-out with a closing form declared in advance — deliberately flat only; nested fan-out is refused. And a rising ladder of how heavy an answer's execution is allowed to be: emit: writes (say it plainly) rises to emit: unfold (say several things, of a declared shape) rises to a full Cell (delegate it, under a brief, to be judged before it counts). Building a new fragment is choosing the lightest rung on that ladder that honestly fits the question — never reaching for a Cell where a plain listener-and-doer pair would do.