rite
The nine gates, the touch/cool/flinch economy, and the loop that turns a litany into a verdict. RITE is the only writer of `A.state`; everything else reads that table and listens on the bus.
RITE — the rules of The Acceding
The nine gates, the touch/cool/flinch economy, and the loop that turns a
litany into a verdict. RITE is the only writer of A.state; everything else
reads that table and listens on the bus.
The nine gates
| # | Gate | Demand | A refusal costs |
|---|---|---|---|
| 1 | THE PORCH | three different glyphs | 0.07 |
| 2 | THE FONT | all three of WATER | 0.08 |
| 3 | THE HINGE | a glyph and its undoing | 0.09 |
| 4 | THE VOW | three withholding, and not the tenderest word | 0.10 |
| 5 | THE UNBARRED | no IRON, and one word twice with a different third | 0.11 |
| 6 | THE CENSER | all three of ASH | 0.12 |
| 7 | THE AMNESTY | nothing from the last litany, and three suits | 0.13 |
| 8 | THE OPEN HAND | three giving, opening and closing on one word | 0.15 |
| 9 | THE CROWN | one word, three times | 0.17 |
Two glyphs to a suit and three slots to a litany, so gates 2 and 6 cannot be answered without saying a word twice, and gates 5, 8 and 9 ask for the repeat outright. The re-saying is forced by the content.
Gate 9 is the whole plan in one move: three sayings of a word from cold land it exactly on the flinch threshold and never over it, so the crown is free to whoever kept one word rested and costs a flinch to whoever did not.
The numbers, and why
Applied over A.TUNING at load. Every one of them was measured against a
simulated run of five player models, not guessed.
TOUCH_PER_SAY | 0.22 | three sayings from cold = 0.66, the threshold exactly |
FLINCH_AT | 0.66 | at or over, the next saying flinches |
COOL_PER_TIER | 0.18 | what an unspoken glyph sheds when a gate opens |
FLINCH_EXTRA_TOUCH | 0.15 | a flinched word is left tenderer still |
IRRITATION_PER_FLINCH | 0.22 | doubled at full touch, by FLINCH_SCALE |
RELIEF_PER_ACCEDE | 0.10 | an opened gate settles the machine |
REFUSAL_TOUCH_REFUND | 0.50 | see below |
TENDER_AT | 0.45 | LITANY marks a slab tender from here up |
A refused litany is half-remembered. The Engine takes the full touch of
every word as it is uttered and gives half of it back when it does not
accede — it keeps what it granted, not what it heard. This is what makes nine
unfamiliar demand kinds learnable: a wrong guess costs patience and a beat,
not a whole word. The economy of an accepted litany, which the curve is
tuned against, is untouched by it. A refusal emits cool with
cause = "refusal", so the meters visibly drop back.
The utterance is paid for before it is judged. If the flinches in a litany fill the patience, the Engine seals on the spot and the litany never gets a verdict — right words or not.
Measured outcomes, over the real module:
| player | result |
|---|---|
| plans a rotation | wins at gate 9, no flinches |
| wrong once at every gate, then corrects | wins at gate 9, patience 0.75 |
| leans on one word every litany | sealed around gate 4–5 |
| ignores the demand | sealed by gate 5 |
| says one word three times, always | sealed at gate 1 |
What the other slices need from it
LITANY
M.demand() returns { n, title, liturgy, plain, barred, miss } for the gate
the player stands at. barred is the list of glyphs that cannot appear in
any answer to this gate — brute-forced, so it stays true for the composite
gates and for gate 4, which reads the touch table. Dim them.
M.tenderness(glyphId) returns { touch, tender, wouldFlinch, projected, placed, barred } — everything a glyph slab needs to warn before it costs
something. projected accounts for the copies of that glyph already in the
litany, so a slab can show what it will be worth when this litany is
spoken, not what it is worth now.
M.ladder() and M.upcoming(k) are not optional decoration. The Engine
does not hide what it will ask for. A player who cannot see that gate 6 wants
ASH has no way to avoid spending ash at gate 5, and the game becomes a memory
test instead of a plan. Render the gate above at minimum; the whole ladder on
the how-to-play card is better. The difficulty was tuned against a player who
can see one gate ahead.
M.bestLitany({ lookahead = true }) returns a satisfying litany, cheapest
first, if the Verger should ever offer help.
Callback: RITE answers rite:skip. LITANY's own lit:skip already calls
M.skip() directly, which is fine.
CHOIR
RITE speaks these ids, and shows the written form of any line that has no clip rather than dropping it:
verger.open.1, verger.open.2, verger.touch (the brief, in that order),
engine.greet, engine.accede, engine.refuse, engine.flinch,
engine.seal, engine.crown, and glyph.<id> for all eight glyphs — spoken
once as the word is set down, and again as part of the chant when the litany is
committed. That chant is the resaying, heard.
Three demand kinds are new and are registered into A.DEMAND_KINDS at
runtime: twice_said, bookend, not_tenderest. Anything generating a
clip per demand kind needs those three as well as the seeded nine.
Sfx ids RITE fires: place, unplace, accede, refuse, seal.
STAGECRAFT and COLUMN
M.begin() enters brief and RITE holds the timer itself, so the opening
always ends whether or not anything else is listening; M.skip() cuts it
short. Bus events, in the order one gate produces them:
gate → place ×3 → speak → (flinch) → verdict → accede → cool →
gate, or verdict → irritation on a refusal, or phase + lose on a
seal. win fires when the ninth gate accedes.
Known seam
While the chant and the verdict line are playing, LITANY's line card sits over the glyph slabs and pointer input to them is lost. RITE keeps that window as short as it can — the chant is 0.34 s a word — but the card's own dismissal is LITANY's.
Re-running it
M.audit() brute-forces all 512 ordered litanies against every gate and
reports how many answer each. A zero anywhere is an unwinnable game. It is
cheap; run it after any change to the curriculum.
Scoped to this part · feeds back into the world's score.