diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b08f046..c5a2bf73 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -58,6 +58,13 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
+- **STATS & RULES' formulas say what they read, and catch a misspelt name.** A name the system
+  hasn't got (`@strr` for `@str`) used to count as 0 without a word, on STATS & RULES and in the
+  graph view's panel, and PUBLISH let it through. Now each formula has a line under it saying it in
+  words ("worked out from Strength", "2 for each level", "your Strength"), and a misspelt name shows
+  there in red with a USE @str button that fixes it. In a condition, the IF, THEN or ELSE with the
+  mistake gets the line. The page's own INSERT panel and VALUE column stay as they were, and all its
+  formulas are read in one request a moment after typing stops.
 - **The formula box on ROLLS and RESTS.** A roll's ADD and AGAINST, and a rest's refill amounts,
   now get the same box as CHOICES. A line under each says it in words with what it comes to for
   the sample character: "against your rolled stat · sample, rolling Strength, rolled stat 16:
diff --git a/README.md b/README.md
index d558fab0..11837532 100644
--- a/README.md
+++ b/README.md
@@ -449,7 +449,7 @@ CITY_NET/
 │   │   ├── choices.js          # A system's choices (7a1a; approved mockup builder-choices, 2026-10-27): the lists a character picks from (classes, backgrounds, feats), each named one and many, picked once, so many times or any, levelled or not, and MORE THAN ONCE for multiclassing; options with an optional requirement (a formula) and features, each unlocking at a level in a levelled list and doing any of: modifiers on a stat, formula or health field, uses refilled by a rest, rolls it gives, a change it lets a roll take, another list to pick from, or only words. Option and feature ids share one set; an option's level is read as @<option>_level, so that name must be free. A character's picks (7a1b) are kept on their sheet under _choices, which players never write as a field (sheets/templates.js), and read keeping only what holds; their levels (@soldier_level, a levelled list's sum @classes_level, and @level unless the system has its own), the features unlocked by level, and overlayOf: each stat with its modifiers and each formula's modifiers, worked out on every save and never written into a stat, so a pick taken away takes its effects with it. A modifier's amount reads the sheet as typed and levels, never a formula. Rolls (tableRolls.js) and PUBLISH's preview (versionDiff.js) read the same numbers. At the table (7a3a): spent uses kept under _uses; every save writes _worked (workedOf: picks, levels, where each change comes from, uses left, options not met); requirements met or not on the sheet as it reads, and in words (INTELLECT >= 13); choicesShown, the lists as the sheet draws them, never a formula
 │   │   ├── choicesImport.js    # A list's options and features read from a file (choices import 1; approved mockup choices-import, 2026-10-28): `[options]` and `[features]` rows matched by name against the draft, nothing deleted; an empty cell leaves a part, `-` clears it; a feature found by level too only when its name repeats; a line with a mistake skipped and named by its line; only words, levels, requirements and uses read. Returns the list as it would be and what changes; saves nothing
 │   │   ├── tokenMax.js         # A feature's modifier on the token's maximum (7a5a3; decision 10 of the approved mockup nested-choices): Tough's `2 * @level` put on the token's real HP MAX or WOUNDS while the pick counts and taken off when it doesn't, the current moving with it; the sheet keeps what it added and to which token, so a second save adds nothing and a new token starts clean; after any sheet change, and every player's when a new version of the running game is published
-│   │   ├── formulaPreview.js   # The builder's formula box (formula box 1; approved mockup formula-box, 2026-10-29): a modifier's amount, a requirement or a feature's uses read by the game's own parser for the sample character (every level at 3), with each name it reads and its value; or its mistake, stricter than PUBLISH: a name the system hasn't got (with the nearest real one) and an amount reading a formula. POST /api/systems/preview-formulas. Formula box 2 adds a roll's ADD and AGAINST (also reading @this, @this_mod, @tie, @tie_mod for the first stat the roll is ROLLED BY, named as `rolling`) and a rest's refill amounts (the character's own numbers, dice said as the least and most they come to)
+│   │   ├── formulaPreview.js   # The builder's formula box (formula box 1; approved mockup formula-box, 2026-10-29): a modifier's amount, a requirement or a feature's uses read by the game's own parser for the sample character (every level at 3), with each name it reads and its value; or its mistake, stricter than PUBLISH: a name the system hasn't got (with the nearest real one) and an amount reading a formula. POST /api/systems/preview-formulas. Formula box 2 adds a roll's ADD and AGAINST (also reading @this, @this_mod, @tie, @tie_mod for the first stat the roll is ROLLED BY, named as `rolling`) and a rest's refill amounts (the character's own numbers, dice said as the least and most they come to). Formula box 3 adds a STATS & RULES formula (kind formula), read like a requirement: any name, formulas included
 │   │   ├── conditions.js       # A system's conditions: the standard set every system starts with (Blinded, Bleeding, Poisoned... ten in all), each renamed, described, given modifiers and an end (when removed, after rounds, or at the rests it names) or turned off, and the system's own, up to 60 in all. A definition stores only its changes; conditionsOf gives each one whole. Icons are one of 24 drawn for CITY_NET or an uploaded picture; modifiers name a stat, a formula or all rolls, one on all rolls reaching every roll of the system's own (tableRolls.js); any condition may wait on a house rule
 │   │   ├── diceFaces.js        # A system's own dice (6c1a): symbols (a name, a mark of a character or two or one of the condition icons, what each cancels as a pair, what it also counts as, one step) and dice whose faces show a signed number, symbols, both or nothing (2 to 100 faces, a danger color for a bad die); checked as an untrusted file is, read whole for the rolls (symbolsOf, diceOf); a symbol's look (6c2b1): its mark, a drawn or uploaded icon (as a condition's), or a 16 by 16 drawing kept in the system (16 rows of 4 hex digits), one picture at a time
 │   │   ├── rollStyles.js       # A custom system's own rolls (Phase 6): dice of any size, Fate dice and named dice, counts worked out from the character; read as a sum, the highest or lowest kept, or successes counted; formula text added, a target met over or under, bands read like a lookup table; exploding dice and naturals; matched dice (a pair of 10s adding successes, doubles), ones that cancel successes, glitches (and the worse one with nothing succeeding), a named die's own effect (Messy, Bestial), and the zero-dice rule; the changes a player picks before rolling (advantage and disadvantage cancelling, a push, a bonus) with what each costs, taken from a stat or added to one (Blades' push adds 2 Stress); CP:R's exploding-and-imploding first die; and the presets the builder starts from (D&D, PbtA, Blades, Vampire, Fate, CWN, CP:R, SR6); the system's `rolls` section checked (up to 60, different ids, ROLLED BY stats, stats groups and formulas it has, its tables callable). Each roll checked in the builder's words; dice only from the source handed in (the server's secure one at the table). A system's own dice (6c1b): a kind of dice may be one of them, landing on one of its faces, its number (0 for none) what every rule reads; COUNT THE SYMBOLS counts the kept dice's symbols (one that also counts as another counted as both), cancels each pair one for one, and reads what is left of `on` (or the numbers); every check against the system's own dice and symbols
@@ -615,7 +615,7 @@ CITY_NET/
 │       ├── system_builder_choices_numbers.test.js # What picks do to a character's numbers: picks read from the sheet keeping only what holds (a known option, once, within what the list allows, MORE THAN ONCE for multiclassing, levels from 1 to the highest); each option's level, a list's sum and @level, a system's own level left alone; features unlocked by level; on a save, a stat's modifier reaching the formulas reading it while the stat stays as typed, a formula's added before what reads it, amounts from levels, a pick taken away taking its effects; an amount reading a formula refused, a list's sum name kept free; rolls reading the same numbers; PUBLISH's preview showing a feature changed; the picks never a player's to write
 │       ├── system_builder_nested_choices.test.js # Lists inside lists (7a5a1): PICKED and HOW MANY checked, loops through other lists named; a pick under a feature counting while it is unlocked and has room, kept waiting when it locks, deeper lists in any order, a list picked both ways counting its own apart, picks a list's way no longer counts kept; only what counts reaching the numbers; what the sheet is told; picking under a feature and every refusal
 │       ├── system_builder_token_max.test.js # A feature on the token's maximum (7a5a3): its bonus summed and never added to the sheet twice; the token moved by what changed since the sheet last said, a new token clean; at the table a pick, a level and a drop moving the maximum and current (never below 0, never over the maximum), a stat the bonus reads changed by the player, the GM's sheet route or an import; nothing without a token, with token health off or in a game not running; a new version published
-│       ├── system_builder_formula_preview.test.js # Level formulas at the sample level, stats, formulas, tables and functions read, a name the system hasn't got with the nearest (a tie to the first), an amount reading a formula refused but a level with a formula's id allowed, what doesn't read, empty, no levels without a levelled list, at most 20 a request; the route, main admin only; formula box 2: a roll's own names for its first ROLLED BY stat and a skill's tie, known only in a roll, a roll not found reading 0; a rest's amount with dice as least and most, by-name dice counts, sheet fields by label, a misspelt name, a table and a one-sided die refused; the new kinds in a request
+│       ├── system_builder_formula_preview.test.js # Level formulas at the sample level, stats, formulas, tables and functions read, a name the system hasn't got with the nearest (a tie to the first), an amount reading a formula refused but a level with a formula's id allowed, what doesn't read, empty, no levels without a levelled list, at most 20 a request; the route, main admin only; formula box 2: a roll's own names for its first ROLLED BY stat and a skill's tie, known only in a roll, a roll not found reading 0; a rest's amount with dice as least and most, by-name dice counts, sheet fields by label, a misspelt name, a table and a one-sided die refused; the new kinds in a request; a STATS & RULES formula reading stats, formulas and tables, and a misspelt name with the nearest
 │       ├── system_builder_picking.test.js # Picking: a player's pick (room, not twice, a requirement in words), never a drop, their own levels and spent uses within bounds; the GM past a requirement but not past room, and taking a pick away; every save writing the picks, levels, where each change comes from, uses and what isn't met (none for a system without choices); the lists as the sheet draws them, never a formula; a rest refilling the uses it or what it counts as refills; no _ name a player's to write; through the socket as a player (their own only, told why not, nothing written) and as the GM (on the player named)
 │       ├── system_builder_citysys_zip.test.js # Sharing with pictures: the uploads a system names and where a symbol shows, left out cleanly (a mark for a bare symbol), a zip made and read back, a picture missing from disk left out, one shared picture; a zip someone sent refused when broken, empty, too large or holding two systems, nothing unpacked outside its places, past an upload's size or past the count (a broken entry proves it), and only named pictures stored; through the routes: the count listed, ?images=1 a zip, otherwise the .citysys without, a zip installed on a server without its pictures, nothing stored when refused, GM only
 │       ├── system_builder_words.test.js # Every term in every form resolved for the builder; only the terms a system renamed sent with its sheet; the server's own text, the starter sheet and a one-pool HEALTH folder using a system's word only where it chose one
@@ -801,7 +801,7 @@ CITY_NET/
 │   │   │   ├── WordsPage.tsx            # WORDS: the app's terms in one table, each one's one, many and short forms with the app's word as placeholder (a blank box stores nothing); a term whose part is off greyed; a "?" on each form's column, the header still named by its word
 │   │   │   ├── FeaturesPage.tsx         # PARTS (FEATURES until 7a2a): the parts of the app as switches (SHEET IMPORT usable since 4h2c), the bank opening out to its currencies and celebrations (BankSettings) and shops to their building types and catalogues; a part that is on can wait on a house rule (ONLY WITH)
 │   │   │   ├── BankSettings.tsx         # The bank's settings on PARTS: each currency counted in whole numbers, decimals or coins, its debt and below-zero switches, icon and READS AS line; MAKE MAIN; the celebrations and whale threshold; a "?" beside each of those settings
-│   │   │   ├── statsRulesFields.tsx     # STATS & RULES' editing controls, one copy for FORMS and the graph view's node panel: a stats group's section (names, ranges, ties, samples, + STAT), a table's section (rows, TRY IT), a formula's name and id with what reads it, its text (a condition's IF, THEN and ELSE) with its mistake and its alternative under a house rule, and INSERT's chips
+│   │   │   ├── statsRulesFields.tsx     # STATS & RULES' editing controls, one copy for FORMS and the graph view's node panel: a stats group's section (names, ranges, ties, samples, + STAT), a table's section (rows, TRY IT), a formula's name and id with what reads it, its text (a condition's IF, THEN and ELSE) with its mistake and its alternative under a house rule, and INSERT's chips. Formula box 3: under each formula the words line, and a misspelt name in red with its fix under the box it is in, the box described by it
 │   │   │   ├── statsRulesStyles.ts      # The look those controls share
 │   │   │   ├── DiceTab.tsx              # STATS & RULES' DICE tab (6c2b2), between TABLES and ROLLS: the system's own dice listed (+ DIE, three presets, COPY FROM THE TABLE'S DICE offering the table's own CUSTOM_DIE.EXE dice), the die picked (name, faces counted, the theme's color or danger), its faces as the dice show them and the face picked (a number, blank for none; symbols added and taken off), the system's symbols (name, mark, cancels, counts as, ×) each with its LOOK (MARK, a drawn ICON, DRAW on the pad, UPLOAD as a condition icon), and TEST thrown on the server; a "?" beside each setting and the symbols' columns
 │   │   │   ├── DrawPad.tsx              # A dice symbol drawn (6c2b2): the 16 by 16 pad (press and drag, lines through its middle to center by, DRAW or ERASE, CLEAR, one edit a stroke, a square a key press at a time), a drawing in the color around it, and a symbol as the dice show it (its drawing, its icon, or its mark); a face as the dice show it, for the DICE tab and TEST ROLL
@@ -818,6 +818,7 @@ CITY_NET/
 │   │   │   ├── ChoicesPage.tsx          # CHOICES (7a2b1; approved mockup builder-choices, 2026-10-27): the lists a character picks from down the left; the open list with ONE / MANY, A CHARACTER PICKS (ONE, SEVERAL with how many, ANY), MORE THAN ONCE and LEVELLED, a line saying what the list now means (with @<list>_level when levelled), and its options; the open option with its name, words and an optional requirement, its level name in a levelled list, and its features (FeaturesEditor.tsx). DELETE asks first, saying what goes; a "?" beside every setting
 │   │   │   ├── ChoicesImport.tsx        # IMPORT on a CHOICES list (choices import 2; approved mockup choices-import, 2026-10-28): over the list and option columns, DOWNLOAD THIS LIST and DOWNLOAD EXAMPLE, a file pasted or uploaded, PREVIEW read by the server, mistakes warned of by line (named at the top as links that select the line, marked in the line numbers beside the text), APPLY into the draft only for the text previewed
 │   │   │   ├── FormulaIcon.tsx          # The formula box's button mark: "math format professional" from Microsoft's Fluent UI System Icons (MIT), picked by the user 2026-10-29, drawn in the text's color so it follows the theme
+│   │   │   ├── FormulaWords.tsx         # The line under a formula: in words with the sample's value, or its mistake in red with USE @name; the formula box's (a live status) and STATS & RULES' and the graph panel's (read with its box, no value, a condition's parts only when wrong)
 │   │   │   ├── FeaturesEditor.tsx       # An option's features on CHOICES (7a2b2): grouped by the level each unlocks at in a levelled list, each row tagged with what it does (MODIFIER, USES, ROLL, CHANGE, CHOICE, TEXT); the open one with its name, AT LEVEL (set when the box is left or on Enter, so typing 12 never moves it to 1 on the way), words, modifiers (what each changes, grouped stats / formulas / health, and by how much), uses and the rest that refills them, rolls it gives, roll changes it lets the character take, and a list it opens; DELETE FEATURE asks first; a "?" beside every setting
 │   │   │   ├── PublishPreviewPage.tsx   # What PUBLISH shows first from v2 on, in place of the open page: what the new version changes BY CHANGE (each line with who it reaches and their own value, or the SAMPLE), BY CHARACTER when someone plays it, KEPT on what stops showing, NOTHING CHANGES FOR ANY CHARACTER when so, the one line for the rest, BACK TO EDITING and PUBLISH vN (not while the draft has problems)
 │   │   │   ├── ConditionIcon.tsx        # A condition's icon: one drawn for CITY_NET, stroked in the theme's color, or an uploaded picture through <img> only; anything unknown draws the target
@@ -1014,7 +1015,8 @@ CITY_NET/
 │   │   │   ├── useEnemyVehicles.ts # The GM's enemy vehicles, and the tokens on the map level that could fill their seats. Asked for rather than pushed, and refused to anyone but the GM — so a player's client never holds enemy pools or armour at all, which is what keeps "what may players see" from being a question the feature has to answer
 │   │   │   ├── useVehicleRoster.ts # Every vehicle in play and who is in which seat. Held outside the window because the buttons that open it need to know whether the table owns a vehicle at all — one subscription, so the two cannot disagree. Takes the socket ref, not its current value: a ref is not reactive, and reading it before the socket exists binds to nothing forever
 │   │   │   ├── useFormulaInsert.ts # INSERT for formulas: where the cursor last was, in which box (a formula's text or a condition's IF, THEN or ELSE), and a name put there; FORMULAS and the node panel share it
-│   │   │   ├── useFormulaBox.tsx  # The formula box (formula box 1; approved mockup formula-box, 2026-10-29): a formula's text with a FORMULA button (FormulaIcon.tsx), given to the page as the box and the help under its row; under it, always, the formula in words with the sample's value, or its mistake in red with USE @name; the button alone opens SHAPE (a common formula written from a number and a name) and INSERT (names put at the cursor). On CHOICES: REQUIRES, each modifier's amount (the × beside it red), USES. Formula box 2: on a roll's ADD and AGAINST (naming its roll to the server) and a rest's amounts (DICE and DICE AND A STAT asking which die and which stat or formula; the box's length limit passed in)
+│   │   │   ├── useFormulaBox.tsx  # The formula box (formula box 1; approved mockup formula-box, 2026-10-29): a formula's text with a FORMULA button (FormulaIcon.tsx), given to the page as the box and the help under its row; under it, always, the formula in words with the sample's value, or its mistake in red with USE @name; the button alone opens SHAPE (a common formula written from a number and a name) and INSERT (names put at the cursor). On CHOICES: REQUIRES, each modifier's amount (the × beside it red), USES. Formula box 2: on a roll's ADD and AGAINST (naming its roll to the server) and a rest's amounts (DICE and DICE AND A STAT asking which die and which stat or formula; the box's length limit passed in). Its words line is components/FormulaWords.tsx
+│   │   │   ├── useFormulaReads.ts # Many formulas read by the server at once (formula box 3): one request a moment after typing stops, twenty to a request, empty ones never asked, an answer kept only for the text it was for, nothing read with an api without the call
 │   │   │   ├── usePreviewValues.ts # A draft's formulas worked out by the server for its sample character a moment after editing stops, and with each house rule an alternative follows on: FORMULAS and the graph view show the same values; the graph view asks with the house rules TRY ON THE MAP has on
 │   │   │   ├── usePlayerSheet.ts   # Shared sheet state, debounced saves, house-rule flags, action emitters (roll/deathSave/stabilize/castSpell); used by CharacterSheetWindow and SheetPage
 │   │   │   └── __tests__/
@@ -1027,6 +1029,7 @@ CITY_NET/
 │   │   │       ├── useRollFlash.test.ts   # Someone else's roll while the tray is shut flashes it, not your own nor with the bell off nor with the tray open; stops as the tray opens, which still opens on the history; forgotten once shut; one stable handler reading the tray and bell as they are now
 │   │   │       ├── useChoicesRefused.test.tsx # The server's refusal of a pick shown, a new one starting the clock again, gone after; the listener taken off on unmount; nothing without a socket (7a3b2)
 │   │   │       ├── useFormulaBox.test.tsx # The words, then the server's sample value; nothing asked of an empty box; a mistake in red, the box marked, USE @name fixing it; an answer for older text never shown; SHAPE and INSERT only by the button; shapes written and rewritten; a requirement on a stat; INSERT at the cursor
+│   │   │       ├── useFormulaReads.test.tsx # Twenty to a request and the rest in another, empty ones never asked; an answer only for its own text; nothing read without the call
 │   │   │       ├── useVehicleRoster.test.tsx             # Binds when the socket turns up, empties on a system switch, re-asks on a sheet save
 │   │   │       ├── useVideoMapTexture.test.ts            # Every assertion is a silent failure: an unmuted video never starts, a hidden tab keeps decoding, a released map keeps its buffers, and a browser that refuses autoplay leaves a still frame with no explanation
 │   │   │       ├── usePlayerSheet.save.test.tsx          # Edits held 400ms so typing is one save, and anything still waiting sent rather than dropped when the sheet goes away
@@ -1106,7 +1109,7 @@ CITY_NET/
 │   │   │   ├── houseRules.ts       # HOUSE RULES as logic: a system's own house rules (up to 20, a new one starting off), changed keeping their ids, deleted leaving what waited on them always there (no part, section or condition waits on it, a formula loses its alternative), and what waits on a rule with the page GO TO opens; the draft as it would be worked out with one rule on, or as the game would run it with a set of rules on (the server's withHouseRules mirrored, held to it); the rules a running game has on (useHouseRules) and the boxes changed from them; held to the server's checks
 │   │   │   ├── choices.ts         # CHOICES as logic (7a2b1): a system's lists and their options read, made (named to rename, ids free of every option's, feature's and level name's), changed (one pick, not levelled and not again store nothing; several capped) and removed (a list taking with it any feature opening it; an option from its own list only), and the level names formulas read; an option's features (7a2b2) made at a level, changed (blank words, level 1 or any level outside a levelled list, empty lists, no uses and no list store nothing; a level past the highest is the highest) and removed, what each does as tags, and what a feature can name: the stats, formulas and health fields, every rest (the off ones said so), the rolls and their changes. Mirrors backend choices.js, every edit held to its checks
 │   │   │   ├── choicesImport.ts   # IMPORT as logic (choices import 2): DOWNLOAD EXAMPLE made from the system (its @names, its rests by name, a level column only for a levelled list, made-up rows) and DOWNLOAD THIS LIST (cells quoted as a spreadsheet would, rests by name where the reader finds them so, a # note for what a feature does beyond words and uses), a previewed list put into the draft, a line to select, and changes in the page's words
-│   │   │   ├── formulaBox.ts      # The formula box as logic (formula box 1): a formula in words (+2 for each level, needs Strength 13 or more), its sample line, INSERT's groups (no formulas for an amount), and the SHAPES with why one can't be used yet and what each writes (a name at the cursor is statsRules.ts' insertToken). Formula box 2: ADD (+ your rolled stat's modifier), AGAINST (against 13, against your rolled stat) and a rest's amount (1d8 + CON modifier, sample 3 to 10); THIS ROLL in INSERT, no levels or tables for a rest; the shapes THE STAT ROLLED, ITS MODIFIER, DICE, DICE AND A STAT
+│   │   │   ├── formulaBox.ts      # The formula box as logic (formula box 1): a formula in words (+2 for each level, needs Strength 13 or more), its sample line, INSERT's groups (no formulas for an amount), and the SHAPES with why one can't be used yet and what each writes (a name at the cursor is statsRules.ts' insertToken). Formula box 2: ADD (+ your rolled stat's modifier), AGAINST (against 13, against your rolled stat) and a rest's amount (1d8 + CON modifier, sample 3 to 10); THIS ROLL in INSERT, no levels or tables for a rest; the shapes THE STAT ROLLED, ITS MODIFIER, DICE, DICE AND A STAT. Formula box 3: a STATS & RULES formula said as a value with no sign (2 for each level, your Strength), formulaTexts (each formula, or a condition's three parts, keyed id:box) and isMistake
 │   │   │   ├── choicesShown.ts    # The CHOICES block as logic (7a3b1): the lists in words from the render copy, the character's picks, levels, uses and what isn't met from the sheet's worked-out view (_worked) read safely; each list as drawn (picks with levels, unlocked features by level, the next to come, room, what's left to pick and what it needs, the total and its breakdown), a use pip's click, and what a feature does in a few words. Works no number out: the server does. choiceEffects (7a3b2): what the picks do to each field, for the sheet's badge (a stat as typed and with its bonuses, a formula as saved and without them, each bonus named), from what the server says each modifier came from
 │   │   │   ├── builderHelp.ts      # Every word of the builder's help in one place: the first-time tour (welcome, then the rail SETUP to PUBLISH), the HELP page's topics (getting started, every page with GO TO, formulas, THE MAP (GRAPH: nodes and wires, + ADD, CUT, diamonds, notes, groups, UNDO, PROBLEMS, TRY ON THE MAP), dice, health models, sharing and versions, who sees the target, the examples to open) and the formula reference, held to the engine's own functions by a test; and the words of the "?" beside each setting, by page. The tour's STATS & RULES step points to HOUSE RULES and the map, and CHOICES has a step of its own (nine since 2026-10-28)
 │   │   │   ├── versionPreview.ts   # What PUBLISH would change, as the builder says it: each change the server names in words (KEPT where something stops showing), grouped BY CHANGE with who it reaches and their own value (or the SAMPLE when nobody plays it; a number moving because a formula it reads changed gets its own line), BY CHARACTER, the one line for what touches no character, the heading and the line under it; HOUSE RULES as a group, and a formula's alternative apart from its own change
@@ -1289,7 +1292,7 @@ CITY_NET/
 │       ├── sheet-subclass-levels.spec.ts # A list a feature opens follows its opener's level (7a5d): in the builder ARCHETYPES set THROUGH FEATURES, told it follows the FIGHTER, Remarkable Athlete put at 7; at the table CHAMPION picked under Martial Archetype at Fighter 3 with Improved Critical only, Remarkable Athlete at Fighter 7, the character level 7
 │       ├── sheet-rest-levels.spec.ts # A rest's amount reading levels: FIGHTER raised to 3 with Tough's +2 Grit at 2, the GM's long rest sets Resolve to @fighter_level + @grit = 8, on the server and the player's open sheet; the long rest rolling no dice leaves the player's tray shut, and a short rest rolling 1d4 opens it
 │       ├── sheet-token-max.spec.ts # A feature on the token's maximum (7a5a3): a FIGHTER at level 3 picks TOUGH and the token goes from 20 to 26 of 26, the sheet naming the bonus and MAX HEALTH following; a level down, 24; the GM drops TOUGH from the player's sheet and it is back at 20
-│       ├── builder-formula-box.spec.ts # The formula box (formula box 1): a misspelt name in red and USE @level, the words with the sample's value, PER CLASS LEVEL and an INSERT name, AT LEAST on REQUIRES, saved as written with no problems; formula box 2: on ROLLS, @thsi in AGAINST fixed with USE @this and read rolling Strength, ADD from ITS MODIFIER; on RESTS, 1d8 + @con_mod from DICE AND A STAT, 3 to 10 for the sample; saved with no problems
+│       ├── builder-formula-box.spec.ts # The formula box (formula box 1): a misspelt name in red and USE @level, the words with the sample's value, PER CLASS LEVEL and an INSERT name, AT LEAST on REQUIRES, saved as written with no problems; formula box 2: on ROLLS, @thsi in AGAINST fixed with USE @this and read rolling Strength, ADD from ITS MODIFIER; on RESTS, 1d8 + @con_mod from DICE AND A STAT, 3 to 10 for the sample; saved with no problems; formula box 3: on STATS & RULES, @strr in red under Grip with USE @str, fixed, said as worked out from Strength, the VALUE 1 then 17, saved
 │       ├── sheet-visibility.spec.ts # Who sees what on a customized sheet: the owner (the GM's field read-only), another player looking them up from GLOBAL_CHAT (public lines only, nothing else sent), the GM opening the whole sheet the same way and setting the GM's field (coverage family 1)
 │       └── builder-smoke.spec.ts   # The GM signs in, opens the System Builder, meets and skips the first-time tour (reset first), finds MY SYSTEMS, and goes back to the map
 ├── Dockerfile.backend
diff --git a/backend/__tests__/system_builder_formula_preview.test.js b/backend/__tests__/system_builder_formula_preview.test.js
index 652ca58d..37787dee 100644
--- a/backend/__tests__/system_builder_formula_preview.test.js
+++ b/backend/__tests__/system_builder_formula_preview.test.js
@@ -170,3 +170,13 @@ describe('the route', () => {
     expect((await request(app).post('/api/systems/preview-formulas').send({ definition: DEF })).status).toBe(401);
   });
 });
+
+describe('a formula of STATS & RULES (formula box 3)', () => {
+  it('reads stats, other formulas and tables, and says a name the system hasn\'t got with the nearest', () => {
+    expect(previewFormula(DEF, '@con_mod + @str', 'formula')).toEqual({ ok: true, value: 18, reads: [
+      { id: 'con_mod', label: 'CON modifier', value: 2 }, { id: 'str', label: 'Strength', value: 16 },
+    ] });
+    expect(previewFormula(DEF, '@strr + 1', 'formula')).toEqual({ ok: false, problem: '@strr isn\'t one of this system\'s names', name: 'strr', suggest: 'str' });
+    expect(previewFormulas(DEF, [{ text: '@con_mod', kind: 'formula' }])[0].ok).toBe(true);
+  });
+});
diff --git a/backend/systemBuilder/formulaPreview.js b/backend/systemBuilder/formulaPreview.js
index 5febbcbc..ebcc79bf 100644
--- a/backend/systemBuilder/formulaPreview.js
+++ b/backend/systemBuilder/formulaPreview.js
@@ -29,9 +29,9 @@ const { effectiveSheet, fieldsOf } = require('./sheet');
 const SAMPLE_LEVEL = 3;
 /**
  * What a formula box holds: a modifier's amount, an option's requirement, a feature's uses; a roll's
- * ADD and AGAINST; a rest's refill amount.
+ * ADD and AGAINST; a rest's refill amount; a formula of STATS & RULES (formula box 3).
  */
-const KINDS = new Set(['amount', 'requires', 'uses', 'add', 'against', 'refill']);
+const KINDS = new Set(['amount', 'requires', 'uses', 'add', 'against', 'refill', 'formula']);
 /** What a roll's own names are called in words. */
 const ROLL_OWN = new Map([['this', 'rolled stat'], ['this_mod', 'rolled stat\'s modifier'], ['tie', 'tied stat'], ['tie_mod', 'tied stat\'s modifier']]);
 /** The most formulas one request reads. */
diff --git a/e2e/COVERAGE.md b/e2e/COVERAGE.md
index f9b95b5f..5940d5a5 100644
--- a/e2e/COVERAGE.md
+++ b/e2e/COVERAGE.md
@@ -88,7 +88,7 @@ panel), so a control that looks fine but does nothing is caught for all of them.
 | A bonus named on the field it changes | a stat as typed and with it; a formula with it | `choices_numbers` | `sheet-choices` (10 → 11, Guard Stance +1) | **AT THE TABLE** |
 | A rest refilling a feature's uses | the rest itself; one it counts as | `picking` | `sheet-choices` (a short rest) | **AT THE TABLE** (the rest itself) |
 | A list filled from a file | IMPORT: new and changed options and features, empty cells and `-`, skipped lines, same-named features | `choices_import` | `builder-choices-import` (this list downloaded, changed with one wrong line, uploaded, warned of, applied; played on a sheet) | **AT THE TABLE** |
-| Writing a formula | the formula box on REQUIRES, modifier amounts and USES, a roll's ADD and AGAINST, and a rest's amounts: words and the sample's value, a mistake with its fix, SHAPE, INSERT | `formula_preview` | `builder-formula-box` | **BUILDER ONLY** (a builder aid: what it writes is played at the table by `sheet-choices`, `sheet-token-max`, `sheet-rolls` and the rests' own journeys) |
+| Writing a formula | the formula box on REQUIRES, modifier amounts and USES, a roll's ADD and AGAINST, a rest's amounts, and STATS & RULES' formulas (words and fixes beside their own INSERT and VALUE): words and the sample's value, a mistake with its fix, SHAPE, INSERT | `formula_preview` | `builder-formula-box` | **BUILDER ONLY** (a builder aid: what it writes is played at the table by `sheet-choices`, `sheet-token-max`, `sheet-rolls` and the rests' own journeys) |
 
 ## Sheets and NPCs
 
diff --git a/e2e/README.md b/e2e/README.md
index 4eafe049..9af5b19a 100644
--- a/e2e/README.md
+++ b/e2e/README.md
@@ -160,7 +160,7 @@ one machine, files in order.
 | `tests/sheet-subclass-levels.spec.ts` | A list a feature opens takes the level of what opened it (7a5d): in the builder ARCHETYPES is set THROUGH FEATURES and says each one's features unlock by the level of the pick that opened it: FIGHTER; Champion's Remarkable Athlete is put at LEVEL 7, saved with no problems; published, a player raises FIGHTER to 3, picks CHAMPION under Martial Archetype (Pick an Archetype) and has Improved Critical with NEXT · LV 7: Remarkable Athlete; at Fighter 7 it unlocks, the archetype's worked level is 7 and the character's levels stay 7 |
 | `tests/sheet-rest-levels.spec.ts` | A rest's amount reads the character's levels (rest levels): a published system whose long rest sets Resolve to `@fighter_level + @grit`; a player sets Grit 3 and raises FIGHTER to 3 (Tough, at 2, adds 2 Grit); the GM calls LONG REST from the GAME tab's rests; Resolve becomes 8 on the server and on the player's open sheet; with no dice rolled, the player's DICE_TRAY.EXE stays shut (quiet rests), and a SHORT REST rolling 1d4 then opens it |
 | `tests/sheet-token-max.spec.ts` | A feature on the token's maximum (7a5a3): a player with a 20 HP token, a FIGHTER at level 3, picks TOUGH (+2 HP per level) and sees 26 / 26 on HIT_POINTS, the bonus named on the sheet's HP and MAX HEALTH at 26; a level down, 24; the GM opens their sheet from VIEW_PLAYER_INFO and drops TOUGH, and the token is back at 20 |
-| `tests/builder-formula-box.spec.ts` | The formula box (formula box 1): on Tough, `2 * @lvl` in red with USE @level, then +2 for each level · sample Level 3: +6 from the real server; PER CLASS LEVEL for FIGHTER at 3 and @con from INSERT at the cursor; AT LEAST on Fighter's REQUIRES (the sample meets it); the draft saved as written with no problems; and formula box 2: on ROLLS, `@thsi` in AGAINST shown in red and fixed with USE @this, then against your rolled stat · sample, rolling Strength, rolled stat 16: target 16; ADD written by ITS MODIFIER; on RESTS, a short rest's amount written by DICE AND A STAT with CON MODIFIER as 1d8 + @con_mod, said 1d8 + CON modifier · sample CON modifier 2: 3 to 10; the draft saved as written with no problems |
+| `tests/builder-formula-box.spec.ts` | The formula box (formula box 1): on Tough, `2 * @lvl` in red with USE @level, then +2 for each level · sample Level 3: +6 from the real server; PER CLASS LEVEL for FIGHTER at 3 and @con from INSERT at the cursor; AT LEAST on Fighter's REQUIRES (the sample meets it); the draft saved as written with no problems; and formula box 2: on ROLLS, `@thsi` in AGAINST shown in red and fixed with USE @this, then against your rolled stat · sample, rolling Strength, rolled stat 16: target 16; ADD written by ITS MODIFIER; on RESTS, a short rest's amount written by DICE AND A STAT with CON MODIFIER as 1d8 + @con_mod, said 1d8 + CON modifier · sample CON modifier 2: 3 to 10; the draft saved as written with no problems; and formula box 3: on STATS & RULES' FORMULAS, Grip's `@strr + 1` in red under its box with USE @str, the VALUE 1; fixed, it reads `@str + 1`, says worked out from Strength, the VALUE 17, and the draft is saved so |
 | `tests/sheet-visibility.spec.ts` | Who sees what on a customized sheet (coverage family 1): its owner fills in a public field, a private one and a combat value and can't change the GM's field; another player, looking them up from GLOBAL_CHAT's user list (VIEW_PLAYER_INFO), sees only the public lines, and the server sends nothing else; the GM opens the whole sheet the same way (OPEN_SHEET) and sets the GM's field, which the owner then sees |
 | `tests/player-journey.spec.ts` | A custom system running (set up through the API), played in two browsers at once: a player makes a character and sees the system's words and its formula worked out; the GM types in a catalogue, gives the player something from it with a note, and calls a rest from the GAME tab; the player sees the gift arrive and the rest change their sheet |
 | `tests/builder-smoke.spec.ts` | The GM signs in, opens the System Builder, meets and skips the first-time tour (reset first, so it always shows), and goes back to the map |
diff --git a/e2e/tests/builder-formula-box.spec.ts b/e2e/tests/builder-formula-box.spec.ts
index f958b4ac..3dc0cd2c 100644
--- a/e2e/tests/builder-formula-box.spec.ts
+++ b/e2e/tests/builder-formula-box.spec.ts
@@ -125,3 +125,35 @@ test('the formula box on a roll\'s ADD and AGAINST and a rest\'s amount', async
   expect([draft.rolls[0].add, draft.rolls[0].against, draft.rests.short_rest.refills[0].amount]).toEqual(['@this_mod', '@this', '1d8 + @con_mod']);
   expect(problems).toEqual([]);
 });
+
+// Formula box 3: on STATS & RULES, a formula with a misspelt name, which used to read 0 without a
+// word, in red under its box with the fix; fixed, it says what it reads, and the VALUE follows.
+test('the words and fixes under STATS & RULES formulas', async ({ page, request }, info) => {
+  const name = `Formula Rules ${info.retry + 1}`;
+  const token = await gmToken(request);
+  const { id } = await asGm(request, token, 'post', '/api/systems', { definition: {
+    format: 1, name,
+    stats: [{ id: 'abilities', label: 'ABILITIES', stats: [{ id: 'str', label: 'Strength' }] }],
+    samples: { str: 16 },
+    derived: [{ id: 'grip', label: 'Grip', formula: '@strr + 1' }],
+  } });
+  await asGm(request, token, 'put', '/api/systems/view', { page: 'rules', view: 'forms' });
+  await signInAsGm(page);
+  await openBuilder(page);
+  const card = page.getByTestId(/^system-/).filter({ hasText: name.toUpperCase() });
+  if (!(await card.getByRole('button', { name: 'OPEN', exact: true }).isVisible())) await card.getByRole('button').first().click();
+  await card.getByRole('button', { name: 'OPEN', exact: true }).click();
+  await builderPage(page, 'STATS & RULES');
+  await page.getByRole('tab', { name: 'FORMULAS' }).click();
+  const grip = page.getByTestId('formula-grip');
+  await expect(grip.getByTestId('formula-words')).toContainText("@strr isn't one of this system's names");
+  await expect(page.getByTestId('value-grip')).toHaveText('1');
+  await grip.getByRole('button', { name: 'USE @str' }).click();
+  await expect(grip.getByLabel('Grip formula')).toHaveValue('@str + 1');
+  await expect(grip.getByTestId('formula-words')).toHaveText('worked out from Strength');
+  await expect(page.getByTestId('value-grip')).toHaveText('17');
+
+  await expect(page.getByTestId('save-status')).toHaveText(/· SAVED /, { timeout: 15_000 });
+  const { draft } = await asGm(request, token, 'get', `/api/systems/${id}`);
+  expect(draft.derived[0].formula).toBe('@str + 1');
+});
diff --git a/frontend/src/components/FormulaWords.tsx b/frontend/src/components/FormulaWords.tsx
new file mode 100644
index 00000000..bc084fed
--- /dev/null
+++ b/frontend/src/components/FormulaWords.tsx
@@ -0,0 +1,47 @@
+import React from 'react';
+import { wordsOf, sampleLine, isMistake, type FormulaKind, type FormulaRead } from '../sheets/formulaBox';
+
+// The line under a formula (formula box 1; approved mockup docs/mockups/formula-box.html,
+// 2026-10-29): the formula in words with what it comes to for the sample character, or its mistake
+// in red with a fix for a name nearly right. The formula box (hooks/useFormulaBox.tsx) draws it under
+// its box; STATS & RULES and the graph view's panel draw it under each formula (formula box 3), where
+// the VALUE column already says the sample's value.
+
+const fix: React.CSSProperties = {
+  border: '1px dashed var(--green)', background: 'none', color: 'var(--green)', fontFamily: 'monospace', fontSize: 10, letterSpacing: 1, padding: '3px 7px', cursor: 'pointer',
+};
+
+interface Props {
+  kind: FormulaKind;
+  text: string;
+  /** What the server made of this very text, or null while it hasn't answered. */
+  read: FormulaRead | null | undefined;
+  /** The text with a name put right, for USE @name. */
+  onFix: (next: string) => void;
+  /** The sample's value after the words: off where a VALUE column shows it. */
+  sample?: boolean;
+  /** A live status read out as it changes (one box); off where many sit on a page, read with their box instead. */
+  live?: boolean;
+  /** For the box's aria-describedby. */
+  id?: string;
+}
+
+export function FormulaWords({ kind, text, read, onFix, sample = true, live = true, id }: Props) {
+  if (!text.trim()) return null;
+  const bad = isMistake(read);
+  const said = wordsOf(kind, text, read && read.ok ? read.reads : []);
+  return (
+    <div id={id} role={live ? 'status' : undefined} data-testid="formula-words"
+      style={{ textAlign: 'left', fontSize: 11, lineHeight: 1.5, color: bad ? 'var(--danger)' : 'var(--cyan)', display: 'flex', gap: 6, flexWrap: 'wrap', alignItems: 'center' }}>
+      {bad
+        ? <>
+            <span>{read.problem}</span>
+            {read.name && read.suggest && (
+              <button type="button" style={fix}
+                onClick={() => onFix(text.replace(new RegExp(`@${read.name}(?![a-z0-9_])`), `@${read.suggest}`))}>USE @{read.suggest}</button>
+            )}
+          </>
+        : <span>{said}{sample && read && read.ok && <span style={{ color: 'var(--green)', opacity: 0.75 }}> · {sampleLine(kind, read)}</span>}</span>}
+    </div>
+  );
+}
diff --git a/frontend/src/components/GraphPanel.tsx b/frontend/src/components/GraphPanel.tsx
index ab83f4fc..2e0cca68 100644
--- a/frontend/src/components/GraphPanel.tsx
+++ b/frontend/src/components/GraphPanel.tsx
@@ -9,6 +9,8 @@ import { mapGroupsOf, groupOf, withFormulaInGroup, withMapGroupLabel, withoutMap
 import { notesOf, pinChoices, withNoteText, withNotePinned, withoutNote, NOTE_MAX } from '../sheets/graphNotes';
 import type { Tried } from '../hooks/usePreviewValues';
 import { useFormulaInsert } from '../hooks/useFormulaInsert';
+import { useFormulaReads } from '../hooks/useFormulaReads';
+import { formulaTexts } from '../sheets/formulaBox';
 import { GroupSection, TableSection, FormulaName, FormulaBody, InsertChips } from './statsRulesFields';
 import { small, why, btn, field } from './statsRulesStyles';
 import { RollEditor, TestRoll } from './RollsTab';
@@ -184,15 +186,18 @@ export function GroupPanel({ definition, edit, group, onClose, graph, positions
 }
 
 /** A formula as FORMULAS shows it, laid out down the panel: name, text, = value, alternative. */
-function FormulaForm({ definition, edit, id, preview, tried, insert, trying }: Omit<Props, 'node' | 'onClose' | 'onGoTo'> & { id: string; insert: ReturnType<typeof useFormulaInsert> }) {
+function FormulaForm({ definition, edit, id, preview, tried, insert, trying, api }: Omit<Props, 'node' | 'onClose' | 'onGoTo'> & { id: string; insert: ReturnType<typeof useFormulaInsert> }) {
   const f = formulaList(definition).find((x) => x.id === id);
+  // Formula box 3: this formula read by the server, for its words and a name the system hasn't got.
+  const reads = useFormulaReads(definition, api, f ? formulaTexts([f]) : []);
   if (!f) return null;
   const value = preview?.values[f.id];
   const rule = f.alternative && trying?.has(f.alternative.rule) ? houseRuleList(definition).find((r) => r.id === f.alternative!.rule) : undefined;
   return (
     <div data-testid={`panel-formula-${f.id}`} style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
       <FormulaName definition={definition} edit={edit} f={f} />
-      <FormulaBody definition={definition} edit={edit} f={f} problem={preview?.problems[f.id]} tried={tried} bind={(box) => insert.bind(f.id, box)} />
+      <FormulaBody definition={definition} edit={edit} f={f} problem={preview?.problems[f.id]} tried={tried} bind={(box) => insert.bind(f.id, box)}
+        reads={(box) => reads[`${f.id}:${box}`] ?? null} />
       <OnTheWayIn definition={definition} edit={edit} id={f.id} />
       <div style={{ display: 'flex', alignItems: 'baseline', justifyContent: 'flex-end', gap: 8 }}>
         <span style={small}>ON THE SAMPLE{rule ? `, WITH ${(rule.name || rule.id).toUpperCase()} (TRYING)` : ''}</span>
@@ -218,7 +223,7 @@ export function GraphPanel({ definition, edit, node, preview, tried, onClose, on
         {formulaIds.length > 0 && (
           <>
             <span style={small}>MODIFIERS · FROM {node.via?.label}</span>
-            {formulaIds.map((id) => <FormulaForm key={id} definition={definition} edit={edit} id={id} preview={preview} tried={tried} insert={insert} trying={trying} />)}
+            {formulaIds.map((id) => <FormulaForm key={id} definition={definition} edit={edit} id={id} preview={preview} tried={tried} insert={insert} trying={trying} api={api} />)}
           </>
         )}
       </>
@@ -226,7 +231,7 @@ export function GraphPanel({ definition, edit, node, preview, tried, onClose, on
   } else if (node.kind === 'formula' || node.kind === 'condition') {
     body = (
       <>
-        <FormulaForm definition={definition} edit={edit} id={node.id} preview={preview} tried={tried} insert={insert} trying={trying} />
+        <FormulaForm definition={definition} edit={edit} id={node.id} preview={preview} tried={tried} insert={insert} trying={trying} api={api} />
         <MapGroupField definition={definition} edit={edit} id={node.id} />
         <div><button type="button" className="utility-btn" style={btn} onClick={() => edit(withoutFormula(definition, node.id))}>REMOVE {node.kind === 'condition' ? 'CONDITION' : 'FORMULA'}</button></div>
       </>
diff --git a/frontend/src/components/StatsRulesPage.tsx b/frontend/src/components/StatsRulesPage.tsx
index a432f2a4..4cac393b 100644
--- a/frontend/src/components/StatsRulesPage.tsx
+++ b/frontend/src/components/StatsRulesPage.tsx
@@ -8,6 +8,8 @@ import { RollsTab } from './RollsTab';
 import { DiceTab } from './DiceTab';
 import { groupOf } from '../sheets/graphGroups';
 import { useFormulaInsert } from '../hooks/useFormulaInsert';
+import { useFormulaReads } from '../hooks/useFormulaReads';
+import { formulaTexts } from '../sheets/formulaBox';
 import { usePreviewValues } from '../hooks/usePreviewValues';
 import { HINTS } from '../sheets/builderHelp';
 import { ColumnHead } from './HelpHint';
@@ -104,6 +106,8 @@ function FormulasTab({ definition, edit, api, onEditInGraph }: Props) {
   const formulas = formulaList(definition);
   const { preview, tried } = usePreviewValues(definition, api);
   const insert = useFormulaInsert(definition, edit);
+  // Formula box 3: every formula read at once, for its words and a name the system hasn't got.
+  const reads = useFormulaReads(definition, api, formulaTexts(formulas));
 
   return (
     <div style={{ display: 'grid', gridTemplateColumns: 'minmax(0, 1fr) 230px', gap: 16, alignItems: 'start' }}>
@@ -127,7 +131,8 @@ function FormulasTab({ definition, edit, api, onEditInGraph }: Props) {
                     <tr data-testid={`formula-${f.id}`}>
                       <td style={td}><FormulaName definition={definition} edit={edit} f={f} /></td>
                       <td style={td}>
-                        <FormulaBody definition={definition} edit={edit} f={f} problem={preview?.problems[f.id]} tried={tried} bind={(box) => insert.bind(f.id, box)} />
+                        <FormulaBody definition={definition} edit={edit} f={f} problem={preview?.problems[f.id]} tried={tried} bind={(box) => insert.bind(f.id, box)}
+                          reads={(box) => reads[`${f.id}:${box}`] ?? null} />
                       </td>
                       <td data-testid={`value-${f.id}`} style={{ ...td, textAlign: 'right', color: 'var(--cyan)', fontSize: 13 }}>
                         {value !== undefined ? value : '·'}
diff --git a/frontend/src/components/__tests__/StatsRulesPage.test.tsx b/frontend/src/components/__tests__/StatsRulesPage.test.tsx
index 7429ae7a..1ccc01dd 100644
--- a/frontend/src/components/__tests__/StatsRulesPage.test.tsx
+++ b/frontend/src/components/__tests__/StatsRulesPage.test.tsx
@@ -87,12 +87,16 @@ describe('STATS', () => {
 describe('FORMULAS', () => {
   const req = createRequire(import.meta.url);
   const { previewDerived } = req('../../../../backend/systemBuilder/derived.js');
-  /** The route's own work, done here with the server's engine. */
-  const server = vi.fn(async (_url: RequestInfo | URL, init?: RequestInit) => {
-    const { definition } = JSON.parse(String(init!.body));
-    const body = previewDerived({ lookups: definition.lookups, derived: definition.derived }, definition.samples || {});
+  const { previewFormulas } = req('../../../../backend/systemBuilder/formulaPreview.js');
+  /** The routes' own work, done here with the server's engine: the values, and each formula read for the box (formula box 3). */
+  const server = vi.fn(async (url: RequestInfo | URL, init?: RequestInit) => {
+    const { definition, formulas } = JSON.parse(String(init!.body));
+    const body = String(url).includes('preview-formulas')
+      ? { results: previewFormulas(definition, formulas), sampleLevel: 3 }
+      : previewDerived({ lookups: definition.lookups, derived: definition.derived }, definition.samples || {});
     return { ok: true, status: 200, json: async () => body } as unknown as Response;
   });
+  const valueCalls = () => server.mock.calls.filter((c) => String(c[0]).includes('preview-values')).length;
   const SYSTEM: Definition = { ...HEARTH, samples: { str: 16, dex: 14 },
     lookups: { mod: { bands: [{ upTo: 7, value: -1 }, { upTo: 13, value: 0 }, { value: 1 }] } },
     derived: [{ id: 'str_mod', label: 'Strength mod', formula: 'mod(@str)' }, { id: 'save', label: 'Save', formula: '16 - @str_mod' }] };
@@ -118,20 +122,51 @@ describe('FORMULAS', () => {
   it('works the values out again a moment after typing stops', async () => {
     await openFormulas();
     await waitFor(() => expect(value('save')).toBe('15'));
-    const calls = server.mock.calls.length;
+    const calls = valueCalls();
     const formula = screen.getByLabelText('Save formula');
     await userEvent.clear(formula);
     await userEvent.type(formula, '20 - @str_mod');
     await waitFor(() => expect(value('save')).toBe('19'));
     // Asked once for the whole burst of typing, not once a key.
-    expect(server.mock.calls.length - calls).toBeLessThanOrEqual(2);
+    expect(valueCalls() - calls).toBeLessThanOrEqual(2);
+  });
+
+  it('says each formula in words under it, and a name the system hasn\'t got in red with its fix (formula box 3)', async () => {
+    const { last } = await openFormulas({ ...SYSTEM, derived: [...(SYSTEM.derived as object[]), { id: 'grip', label: 'Grip', formula: '@strr' }] });
+    const row = within(screen.getByTestId('formula-grip'));
+    await waitFor(() => expect(row.getByTestId('formula-words').textContent).toBe("@strr isn't one of this system's names" + 'USE @str'));
+    const box = screen.getByLabelText('Grip formula');
+    expect(box.getAttribute('aria-invalid')).toBe('true');
+    expect(box.getAttribute('aria-describedby')).toBe(row.getByTestId('formula-words').id);
+    // Read with its box, not called out as it changes: twenty of them sit on this page.
+    expect(row.getByTestId('formula-words').getAttribute('role')).toBeNull();
+    await userEvent.click(row.getByRole('button', { name: 'USE @str' }));
+    expect((last().derived as { id: string; formula: string }[]).find((f) => f.id === 'grip')!.formula).toBe('@str');
+    await waitFor(() => expect(row.getByTestId('formula-words').textContent).toBe('your Strength'));
+    expect(box.hasAttribute('aria-invalid')).toBe(false);
+    expect(within(screen.getByTestId('formula-save')).getByTestId('formula-words').textContent).toBe('worked out from Strength mod');
+  });
+
+  it('marks only the part of a condition with a misspelt name, its fix under that part', async () => {
+    const { last } = await openFormulas({ ...SYSTEM, derived: [...(SYSTEM.derived as object[]), { id: 'hurt', label: 'Hurt', kind: 'condition', when: '@str < 5', then: '1', else: '@str_md' }] });
+    const row = within(screen.getByTestId('formula-hurt'));
+    await waitFor(() => expect(row.getByRole('button', { name: 'USE @str_mod' })).toBeInTheDocument());
+    expect(row.getAllByTestId('formula-words')).toHaveLength(1);
+    expect(screen.getByLabelText('Hurt else').getAttribute('aria-invalid')).toBe('true');
+    expect(screen.getByLabelText('Hurt if').hasAttribute('aria-invalid')).toBe(false);
+    await userEvent.click(row.getByRole('button', { name: 'USE @str_mod' }));
+    expect((last().derived as { id: string; else: string }[]).find((f) => f.id === 'hurt')!.else).toBe('@str_mod');
+    await waitFor(() => expect(row.queryByTestId('formula-words')).toBeNull());
   });
 
   it('never lets a late answer for an older formula overwrite a newer one', async () => {
     const answers: ((body: object) => void)[] = [];
-    const slow = vi.fn(() => new Promise<Response>((resolve) => {
-      answers.push((body) => resolve({ ok: true, status: 200, json: async () => body } as unknown as Response));
-    }));
+    // Only the values are held back; the words (formula box 3) come at once, and say nothing here.
+    const slow = vi.fn((url: RequestInfo | URL) => (String(url).includes('preview-values')
+      ? new Promise<Response>((resolve) => {
+        answers.push((body) => resolve({ ok: true, status: 200, json: async () => body } as unknown as Response));
+      })
+      : Promise.resolve({ ok: true, status: 200, json: async () => ({ results: [], sampleLevel: 3 }) } as unknown as Response)));
     const Harness = () => {
       const [def, setDef] = useState<Definition>(SYSTEM);
       return <StatsRulesPage definition={def} api={systemsApi('gm', slow as unknown as typeof fetch)} edit={setDef} />;
diff --git a/frontend/src/components/statsRulesFields.tsx b/frontend/src/components/statsRulesFields.tsx
index a8dda2cb..42990bff 100644
--- a/frontend/src/components/statsRulesFields.tsx
+++ b/frontend/src/components/statsRulesFields.tsx
@@ -10,6 +10,8 @@ import { houseRuleList } from '../sheets/houseRules';
 import type { Tried } from '../hooks/usePreviewValues';
 import type { FormulaBox } from '../hooks/useFormulaInsert';
 import { OnlyWith } from './OnlyWith';
+import { FormulaWords } from './FormulaWords';
+import { isMistake, type FormulaRead } from '../sheets/formulaBox';
 import { HINTS } from '../sheets/builderHelp';
 import { ColumnHead, FieldName } from './HelpHint';
 import { small, why, btn, field, th, td, box, head } from './statsRulesStyles';
@@ -182,11 +184,11 @@ export function FormulaName({ definition, edit, f }: Edits & { f: Formula }) {
 /** Where INSERT puts a name in one box: the box's input, and where its cursor is. */
 export type InsertBinding = { inputRef?: (el: HTMLInputElement | null) => void; onCursor?: (at: number) => void };
 
-/** One box of formula text, its cursor told to INSERT. */
-function TextBox({ label, value, bad, onText, inputRef, onCursor }: InsertBinding & { label: string; value: string; bad: boolean; onText: (text: string) => void }) {
+/** One box of formula text, its cursor told to INSERT, described by its words line. */
+function TextBox({ label, value, bad, onText, inputRef, onCursor, describedBy }: InsertBinding & { label: string; value: string; bad: boolean; onText: (text: string) => void; describedBy?: string }) {
   return (
     <input ref={inputRef} type="text" aria-label={label} maxLength={1000} value={value}
-      aria-invalid={bad ? true : undefined}
+      aria-invalid={bad ? true : undefined} aria-describedby={describedBy}
       style={{ ...field, width: '100%', borderColor: bad ? 'var(--danger)' : 'var(--green)' }}
       onChange={(e) => { onText(e.target.value); onCursor?.(e.target.selectionStart ?? e.target.value.length); }}
       onSelect={(e) => onCursor?.((e.target as HTMLInputElement).selectionStart ?? 0)}
@@ -199,12 +201,16 @@ const PART_WORD: Record<ConditionPart, string> = { when: 'IF', then: 'THEN', els
 /**
  * A formula's text, or a condition's IF, THEN and ELSE (5b6a: IF something isn't 0, THEN one
  * number, ELSE another); its mistake under it, and a formula's alternative under a house rule.
- * `bind` lets INSERT put a name where the cursor is, in whichever box.
+ * `bind` lets INSERT put a name where the cursor is, in whichever box. `reads` (formula box 3)
+ * is what the server made of each box: a formula said in words under it, and a name the system
+ * hasn't got in red with its fix, under each box it is in. The VALUE beside it says the sample's.
  */
-export function FormulaBody({ definition, edit, f, problem, tried, bind }: Edits & {
+export function FormulaBody({ definition, edit, f, problem, tried, bind, reads }: Edits & {
   f: Formula; problem?: string; tried: Record<string, Tried>; bind?: (box: FormulaBox) => InsertBinding;
+  reads?: (box: FormulaBox) => FormulaRead | null;
 }) {
   const name = f.label || f.id;
+  const wordsId = (box: FormulaBox) => `formula-words-${f.id}-${box}`;
   return (
     <>
       {isCondition(f)
@@ -213,14 +219,26 @@ export function FormulaBody({ definition, edit, f, problem, tried, bind }: Edits
             {CONDITION_PARTS.map((part) => (
               <React.Fragment key={part}>
                 <span style={{ ...small, color: 'var(--cyan)', opacity: 1 }}>{PART_WORD[part]}</span>
-                <TextBox label={`${name} ${PART_WORD[part].toLowerCase()}`} value={partOf(f, part)} bad={!!problem}
+                <TextBox label={`${name} ${PART_WORD[part].toLowerCase()}`} value={partOf(f, part)} bad={!!problem || isMistake(reads?.(part))}
+                  describedBy={isMistake(reads?.(part)) ? wordsId(part) : undefined}
                   onText={(text) => edit(withCondition(definition, f.id, { [part]: text }))} {...bind?.(part)} />
+                {/* A condition's parts get a line only for a mistake: their words would say little. */}
+                {isMistake(reads?.(part)) && <>
+                  <span />
+                  <FormulaWords id={wordsId(part)} kind="formula" text={partOf(f, part)} read={reads?.(part)} live={false}
+                    onFix={(text) => edit(withCondition(definition, f.id, { [part]: text }))} />
+                </>}
               </React.Fragment>
             ))}
           </div>
         )
-        : <TextBox label={`${name} formula`} value={f.formula ?? ''} bad={!!problem}
-            onText={(text) => edit(withFormula(definition, f.id, { formula: text }))} {...bind?.('formula')} />}
+        : <>
+            <TextBox label={`${name} formula`} value={f.formula ?? ''} bad={!!problem || isMistake(reads?.('formula'))}
+              describedBy={reads ? wordsId('formula') : undefined}
+              onText={(text) => edit(withFormula(definition, f.id, { formula: text }))} {...bind?.('formula')} />
+            {reads && <FormulaWords id={wordsId('formula')} kind="formula" text={f.formula ?? ''} read={reads('formula')} sample={false} live={false}
+              onFix={(text) => edit(withFormula(definition, f.id, { formula: text }))} />}
+          </>}
       {problem && <div role="alert" style={{ ...why, color: 'var(--danger)', opacity: 1, fontSize: 11 }}>{problem}</div>}
       {!isCondition(f) && <Alternative f={f} definition={definition} edit={edit} tried={tried} />}
     </>
diff --git a/frontend/src/hooks/__tests__/useFormulaReads.test.tsx b/frontend/src/hooks/__tests__/useFormulaReads.test.tsx
new file mode 100644
index 00000000..6c74c223
--- /dev/null
+++ b/frontend/src/hooks/__tests__/useFormulaReads.test.tsx
@@ -0,0 +1,47 @@
+import React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { useFormulaReads, type FormulaToRead } from '../useFormulaReads';
+import type { Definition, systemsApi } from '../../sheets/systemsApi';
+import type { FormulaRead } from '../../sheets/formulaBox';
+
+/**
+ * Many formulas read at once (formula box 3): one request a moment after typing stops, twenty
+ * formulas to a request, empty ones never asked about, and an answer kept only for the text it was
+ * for.
+ */
+const DEF = { format: 1, name: 'Hearth' } as Definition;
+const answering = (answer: (text: string) => FormulaRead) => ({
+  previewFormulas: vi.fn(async (_d: Definition, formulas: { text: string }[]) => ({ ok: true, value: { results: formulas.map((f) => answer(f.text)), sampleLevel: 3 } })),
+}) as unknown as ReturnType<typeof systemsApi> & { previewFormulas: ReturnType<typeof vi.fn> };
+
+function Probe({ api, items }: { api?: Pick<ReturnType<typeof systemsApi>, 'previewFormulas'>; items: FormulaToRead[] }) {
+  return <pre data-testid="reads">{JSON.stringify(useFormulaReads(DEF, api, items))}</pre>;
+}
+const reads = (): Record<string, FormulaRead | null> => JSON.parse(screen.getByTestId('reads').textContent!);
+const item = (key: string, text: string): FormulaToRead => ({ key, text, kind: 'formula' });
+
+describe('reading many formulas', () => {
+  it('asks once for up to twenty, more in another request, never an empty one', async () => {
+    const api = answering((text) => ({ ok: true, value: Number(text), reads: [] }));
+    const items = [...Array.from({ length: 23 }, (_, i) => item(`f${i}`, String(i))), item('blank', '  ')];
+    render(<Probe api={api} items={items} />);
+    await waitFor(() => expect(reads().f22).toEqual({ ok: true, value: 22, reads: [] }));
+    expect(api.previewFormulas.mock.calls.map((c) => (c[1] as unknown[]).length)).toEqual([20, 3]);
+    expect(reads().blank).toBeNull();
+  });
+
+  it('gives an answer back only while its text is still the text', async () => {
+    const api = answering(() => ({ ok: true, value: 1, reads: [] }));
+    const { rerender } = render(<Probe api={api} items={[item('a', '1')]} />);
+    await waitFor(() => expect(reads().a).not.toBeNull());
+    rerender(<Probe api={api} items={[item('a', '2')]} />);
+    expect(reads().a).toBeNull();
+  });
+
+  it('reads nothing with no api, or one without the call', async () => {
+    render(<Probe api={{} as never} items={[item('a', '1')]} />);
+    await new Promise((r) => setTimeout(r, 450));
+    expect(reads()).toEqual({ a: null });
+  });
+});
diff --git a/frontend/src/hooks/useFormulaBox.tsx b/frontend/src/hooks/useFormulaBox.tsx
index e82d1aa3..c622abc7 100644
--- a/frontend/src/hooks/useFormulaBox.tsx
+++ b/frontend/src/hooks/useFormulaBox.tsx
@@ -1,9 +1,10 @@
 import React, { useEffect, useRef, useState } from 'react';
 import type { Definition, systemsApi } from '../sheets/systemsApi';
 import {
-  wordsOf, sampleLine, insertGroups, shapesOf, writeShape, levelTokens, DIE_SIDES,
+  insertGroups, shapesOf, writeShape, levelTokens, DIE_SIDES, isMistake,
   type FormulaKind, type FormulaRead, type Shape,
 } from '../sheets/formulaBox';
+import { FormulaWords } from '../components/FormulaWords';
 import { allStats, formulaList, insertToken } from '../sheets/statsRules';
 import { FormulaIcon } from '../components/FormulaIcon';
 import { PREVIEW_DELAY_MS } from './usePreviewValues';
@@ -93,7 +94,7 @@ export function useFormulaBox({ definition, api, kind, roll, value, onChange, la
   };
   const current = shapes.find((s) => s.id === shape?.id);
   const shown = value.trim() && read?.text === value ? read.result : null;
-  const bad = !!shown && !shown.ok;
+  const bad = isMistake(shown);
 
   const field = (
     <span style={{ display: 'flex', gap: 6, minWidth: 0 }}>
@@ -113,22 +114,9 @@ export function useFormulaBox({ definition, api, kind, roll, value, onChange, la
     </span>
   );
 
-  const words = wordsOf(kind, value, shown && shown.ok ? shown.reads : []);
   const help = (
     <>
-      {value.trim() && (
-        <div role="status" data-testid="formula-words" style={{ textAlign: 'left', fontSize: 11, lineHeight: 1.5, color: bad ? 'var(--danger)' : 'var(--cyan)', display: 'flex', gap: 6, flexWrap: 'wrap', alignItems: 'center' }}>
-          {bad && shown && !shown.ok
-            ? <>
-                <span>{shown.problem}</span>
-                {shown.name && shown.suggest && (
-                  <button type="button" style={chip(false)}
-                    onClick={() => onChange(value.replace(new RegExp(`@${shown.name}(?![a-z0-9_])`), `@${shown.suggest}`))}>USE @{shown.suggest}</button>
-                )}
-              </>
-            : <span>{words}{shown && shown.ok && <span style={{ color: 'var(--green)', opacity: 0.75 }}> · {sampleLine(kind, shown)}</span>}</span>}
-        </div>
-      )}
+      <FormulaWords kind={kind} text={value} read={shown || null} onFix={onChange} />
       {open && (
         <div role="group" aria-label={`Help writing ${label}`} style={{ textAlign: 'left', border: '1px solid var(--cyan)', padding: '8px 10px', display: 'flex', flexDirection: 'column', gap: 6, fontSize: 11 }}>
           <div style={{ display: 'flex', gap: 5, flexWrap: 'wrap', alignItems: 'center' }}>
diff --git a/frontend/src/hooks/useFormulaReads.ts b/frontend/src/hooks/useFormulaReads.ts
new file mode 100644
index 00000000..c1c5e74b
--- /dev/null
+++ b/frontend/src/hooks/useFormulaReads.ts
@@ -0,0 +1,47 @@
+import { useEffect, useState } from 'react';
+import type { Definition, systemsApi } from '../sheets/systemsApi';
+import type { FormulaKind, FormulaRead } from '../sheets/formulaBox';
+import { PREVIEW_DELAY_MS } from './usePreviewValues';
+
+/** The most formulas one request reads (backend systemBuilder/formulaPreview.js MOST). */
+const PER_REQUEST = 20;
+
+/** One formula to read: a key of the caller's own, its text, and what it is. */
+export interface FormulaToRead { key: string; text: string; kind: FormulaKind }
+
+/**
+ * Many formulas read by the server at once (formula box 3): STATS & RULES lists every formula, so it
+ * asks once a moment after typing stops, twenty to a request, not once per box. Each answer is kept
+ * with the text it was for, and given back only while that is still the text: an answer for older
+ * text is never shown. Empty texts are never asked about.
+ */
+export function useFormulaReads(definition: Definition, api: Pick<ReturnType<typeof systemsApi>, 'previewFormulas'> | undefined, items: FormulaToRead[]): Record<string, FormulaRead | null> {
+  const [answers, setAnswers] = useState<Record<string, { text: string; read: FormulaRead }>>({});
+  const asked = items.filter((i) => i.text.trim());
+  const signature = JSON.stringify(asked);
+
+  useEffect(() => {
+    // An api without the call (a page given only what it draws with) reads nothing.
+    if (typeof api?.previewFormulas !== 'function' || !asked.length) return undefined;
+    let live = true;
+    const timer = setTimeout(() => {
+      for (let at = 0; at < asked.length; at += PER_REQUEST) {
+        const part = asked.slice(at, at + PER_REQUEST);
+        api!.previewFormulas(definition, part.map(({ text, kind }) => ({ text, kind }))).then((r) => {
+          const results = r.ok ? r.value?.results : undefined;
+          if (!live || !Array.isArray(results)) return;
+          setAnswers((prev) => {
+            const next = { ...prev };
+            part.forEach((item, i) => { const read = results[i]; if (read) next[item.key] = { text: item.text, read }; });
+            return next;
+          });
+        });
+      }
+    }, PREVIEW_DELAY_MS);
+    return () => { live = false; clearTimeout(timer); };
+    // The texts asked are in the signature; the definition decides what each name means.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [api, definition, signature]);
+
+  return Object.fromEntries(items.map((i) => [i.key, answers[i.key]?.text === i.text ? answers[i.key].read : null]));
+}
diff --git a/frontend/src/sheets/__tests__/formulaBox.test.ts b/frontend/src/sheets/__tests__/formulaBox.test.ts
index 66234ea1..3cce6670 100644
--- a/frontend/src/sheets/__tests__/formulaBox.test.ts
+++ b/frontend/src/sheets/__tests__/formulaBox.test.ts
@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { wordsOf, sampleLine, insertGroups, levelTokens, shapesOf, writeShape } from '../formulaBox';
+import { wordsOf, sampleLine, insertGroups, levelTokens, shapesOf, writeShape, formulaTexts, isMistake } from '../formulaBox';
 import type { Definition } from '../systemsApi';
 
 /**
@@ -156,3 +156,29 @@ describe('a roll\'s ADD and AGAINST, and a rest\'s amount (formula box 2)', () =
     expect([writeShape('dice', 2, '@level', 6), writeShape('dice', 0), writeShape('dice_and_stat', 1, '@con_mod', 10)]).toEqual(['2d6', '1d8', '1d10 + @con_mod']);
   });
 });
+
+describe('a formula of STATS & RULES (formula box 3)', () => {
+  it('says it as a value, with no sign', () => {
+    expect(wordsOf('formula', '10')).toBe('10, always');
+    expect(wordsOf('formula', '2 * @level', LEVEL)).toBe('2 for each level');
+    expect(wordsOf('formula', '@str', [{ id: 'str', label: 'Strength', value: 16 }])).toBe('your Strength');
+    expect(wordsOf('formula', 'floor(@level / 2)', LEVEL)).toBe('half your level, rounded down');
+    expect(wordsOf('formula', '10 + @dex + @armor')).toBe('worked out from dex, armor');
+  });
+
+  it('asks for a formula\'s text, or a condition\'s three parts, keyed as the page binds them', () => {
+    expect(formulaTexts([
+      { id: 'save', label: 'Save', formula: '16 - @str_mod' },
+      { id: 'hurt', label: 'Hurt', kind: 'condition', when: '@str < 5', then: '1', else: '@str_mod' },
+      { id: 'blank', label: 'Blank' },
+    ] as never)).toEqual([
+      { key: 'save:formula', text: '16 - @str_mod', kind: 'formula' },
+      { key: 'hurt:when', text: '@str < 5', kind: 'formula' }, { key: 'hurt:then', text: '1', kind: 'formula' }, { key: 'hurt:else', text: '@str_mod', kind: 'formula' },
+      { key: 'blank:formula', text: '', kind: 'formula' },
+    ]);
+  });
+
+  it('tells a mistake from an answer, and from no answer yet', () => {
+    expect([isMistake({ ok: false, problem: 'x' }), isMistake({ ok: true, value: 1, reads: [] }), isMistake(null)]).toEqual([true, false, false]);
+  });
+});
diff --git a/frontend/src/sheets/builderHelp.ts b/frontend/src/sheets/builderHelp.ts
index 8e98b83b..06462bbf 100644
--- a/frontend/src/sheets/builderHelp.ts
+++ b/frontend/src/sheets/builderHelp.ts
@@ -184,7 +184,7 @@ export const HINTS = {
   'rules.highest': 'The highest it should be, shown with the lowest under the box on the sheet. Empty: no highest.',
   'rules.tiedTo': 'The stat this one goes with, like a skill with its ability (Shoot with Dexterity). A formula still names every stat it reads.',
   'rules.sample': 'A made-up character\'s value, for checking formulas: FORMULAS works every value out from these. Saved with the draft; players never see it.',
-  'rules.formula': 'Written the way the rulebook says it: @ and an id for a stat or another formula, a table by its id like mod(@str), and the functions under INSERT.',
+  'rules.formula': 'Written the way the rulebook says it: @ and an id for a stat or another formula, a table by its id like mod(@str), and the functions under INSERT. The line under it says it in words; a name the system hasn\'t got shows there in red with the nearest one to use, since it would count as 0.',
   'rules.value': 'What the formula comes to for the sample character, worked out by the game\'s own engine a moment after you stop typing.',
   'rules.upTo': 'The highest number this row covers. Rows are read top to bottom, and the last one catches anything higher.',
   'rules.gives': 'What a number in this row turns into: the table\'s answer.',
diff --git a/frontend/src/sheets/formulaBox.ts b/frontend/src/sheets/formulaBox.ts
index 47fa0c6d..29f0986a 100644
--- a/frontend/src/sheets/formulaBox.ts
+++ b/frontend/src/sheets/formulaBox.ts
@@ -9,11 +9,14 @@
 // what dice decide as a range, the least to the most.
 
 import type { Definition } from './systemsApi';
-import { allStats, formulaList, tableList, FUNCTIONS } from './statsRules';
+import { allStats, formulaList, tableList, isCondition, partOf, CONDITION_PARTS, FUNCTIONS, type Formula } from './statsRules';
 import { choiceLists } from './choices';
 
-/** What a box holds: a modifier's amount, an option's requirement, a feature's uses; a roll's ADD and AGAINST; a rest's amount. */
-export type FormulaKind = 'amount' | 'requires' | 'uses' | 'add' | 'against' | 'refill';
+/**
+ * What a box holds: a modifier's amount, an option's requirement, a feature's uses; a roll's ADD and
+ * AGAINST; a rest's amount; a formula of STATS & RULES (formula box 3).
+ */
+export type FormulaKind = 'amount' | 'requires' | 'uses' | 'add' | 'against' | 'refill' | 'formula';
 
 /** One name a formula reads, as the server worked it out for the sample. */
 export interface FormulaReads { id: string; label: string; value: number }
@@ -28,6 +31,9 @@ export type FormulaRead =
   }
   | { ok: false; problem: string; name?: string; suggest?: string };
 
+/** Whether the server's answer says the formula has a mistake. */
+export const isMistake = (read: FormulaRead | null | undefined): read is FormulaRead & { ok: false } => !!read && !read.ok;
+
 const signed = (n: number) => (n < 0 ? `−${-n}` : `+${n}`);
 const word = (id: string, reads: FormulaReads[]) => reads.find((r) => r.id === id)?.label ?? id;
 
@@ -56,16 +62,18 @@ export const wordsOf = (kind: FormulaKind, text: string, reads: FormulaReads[] =
     if ((m = t.match(/^@([a-z][a-z0-9_]*)\s*>\s*(-?\d+)$/))) return `needs ${word(m[1], reads)} over ${m[2]}`;
     return `needs ${t.replace(/@([a-z][a-z0-9_]*)/g, (_, id: string) => word(id, reads))}`;
   }
-  const unit = kind === 'uses' ? (n: string) => `${n} use${n === '1' ? '' : 's'}` : (n: string) => signed(Number(n));
+  // A formula of STATS & RULES is a value, not something added: no sign.
+  const plain = kind === 'uses' || kind === 'formula';
+  const unit = kind === 'uses' ? (n: string) => `${n} use${n === '1' ? '' : 's'}` : kind === 'formula' ? (n: string) => n : (n: string) => signed(Number(n));
   if ((m = t.match(/^(-?\d+)$/))) return `${unit(m[1])}, always`;
   // N * @name, or @name * N.
   const per = t.match(/^(\d+)\s*\*\s*@([a-z][a-z0-9_]*)$/) ?? t.match(/^@([a-z][a-z0-9_]*)\s*\*\s*(\d+)$/);
   if (per) {
     const [n, id] = /^\d+$/.test(per[1]) ? [per[1], per[2]] : [per[2], per[1]];
-    return `${kind === 'uses' ? n : signed(Number(n))} for each ${word(id, reads).toLowerCase()}`;
+    return `${plain ? n : signed(Number(n))} for each ${word(id, reads).toLowerCase()}`;
   }
-  if ((m = t.match(/^@([a-z][a-z0-9_]*)$/))) return `${kind === 'uses' ? 'as many as' : '+'} your ${word(m[1], reads)}`;
-  if ((m = t.match(/^floor\(\s*@([a-z][a-z0-9_]*)\s*\/\s*2\s*\)$/))) return `${kind === 'uses' ? 'half' : '+ half'} your ${word(m[1], reads).toLowerCase()}, rounded down`;
+  if ((m = t.match(/^@([a-z][a-z0-9_]*)$/))) return `${kind === 'uses' ? 'as many as your' : kind === 'formula' ? 'your' : '+ your'} ${word(m[1], reads)}`;
+  if ((m = t.match(/^floor\(\s*@([a-z][a-z0-9_]*)\s*\/\s*2\s*\)$/))) return `${plain ? 'half' : '+ half'} your ${word(m[1], reads).toLowerCase()}, rounded down`;
   return named();
 };
 
@@ -86,6 +94,14 @@ export const sampleLine = (kind: FormulaKind, read: FormulaRead & { ok: true }):
   return names || read.rolling ? `${sample}${names ? ` ${names}` : ''}: ${said}` : said;
 };
 
+/**
+ * What STATS & RULES asks the server to read (formula box 3): each formula's text, or a condition's
+ * IF, THEN and ELSE, keyed `id:box` as the page binds its boxes.
+ */
+export const formulaTexts = (formulas: Formula[]): { key: string; text: string; kind: FormulaKind }[] => formulas.flatMap((f) => (isCondition(f)
+  ? CONDITION_PARTS.map((part) => ({ key: `${f.id}:${part}`, text: partOf(f, part), kind: 'formula' as const }))
+  : [{ key: `${f.id}:formula`, text: f.formula ?? '', kind: 'formula' as const }]));
+
 /** One list of names INSERT offers, under a title. */
 export interface InsertGroup { title: string; items: { token: string; label: string }[] }