Freeze Age instability scores and classify authored writing (#64 #65 )

Audit Legacy instability and allow unstable supported writing
Persist repaired Age writing and provisional instability penalties, retain fatal diagnostics for unsupported content, and hide TerraBlender's deferred placeholder biome from creative and JEI.
2026-10-09 00:12:31 -04:00 · 2026-10-08 14:10:42 -04:00 · 2026-10-08 06:01:33 -04:00 · 2026-10-08 05:43:18 -04:00
58 changed files with 1116 additions and 198 deletions
@@ -4,12 +4,13 @@ Rivencraft is a clean, incremental port of the ideas and gameplay of
 [Mystcraft Legacy](https://github.com/Mystcraft/Mystcraft-Legacy) to Minecraft
 1.21.1 on NeoForge.

-The bootstrap, books/linking, Ages, and writing-system milestones are complete.
+The bootstrap, books/linking, Ages, writing-system, and Age-grammar milestones are complete.
 The writing system uses a data-pack symbol catalog and persistent
-ordered-writing model. The project currently provides functional Linking Books
-and randomly seeded, persistent vanilla-like Ages created from page-free
-Descriptive Books. Instability and full symbol-to-world grammar interpretation
-have not been ported yet.
+ordered-writing model. Linking Books and Descriptive Books create persistent
+Ages from either authored supported symbols or seeded random completion.
+Instability and the remaining unsupported Legacy symbol effects have not been
+ported yet. The [Milestone 5 acceptance record](docs/MILESTONE_5_ACCEPTANCE.md)
+lists the supported grammar, optional integrations, and limits.

 Milestone 4 now includes stackable blank Pages plus server-created symbol,
 unresolved-symbol, and baseline link-panel states. Page visuals follow the
@@ -117,14 +118,14 @@ symbol meanings, page order, and runtime profile, so later data-pack changes do
 not reinterpret an existing Age. An authored terrain page selects its runtime
 profile. Built-in pages cover Standard, Amplified, Cave, Island, Flat, and Void;
 authored biome, environment, and supported feature pages also affect new Ages.
-Further symbol effects are scheduled for later Milestone 5 slices. The
+The
 writing is also stored on the book; the Descriptive Book screen's turned pages
 show ordered symbols and unresolved IDs. The Descriptive Book screen follows
 Legacy's book spread: the title and Age details are on the left, the destination
 preview is on the right, and clicks in the bottom corners turn pages. Ordered
-symbol pages appear before the final blank spread; their pictograms await
-Milestone 5. Link-panel-only books show their details in the enchantment-table
-font.
+symbol pages appear before the final blank spread with their runtime-rendered
+pictograms. Link-panel-only books use Rivencraft glyphs for their generated
+Age description.

 ## Linking Book

@@ -17,7 +17,7 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id

-List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'desk', 'binder', 'mixer', 'recipe']
+List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'generation', 'desk', 'binder', 'mixer', 'recipe']
 List<String> selectedArchivedGameTestSuites = providers.gradleProperty('withArchivedGameTests')
        .map { it.toBoolean() }.orElse(false).get() ? archivedGameTestSuites
        : providers.gradleProperty('archivedGameTestSuites').orElse('').get()
@@ -7,9 +7,8 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | Rivencraft asset | Upstream asset | Upstream revision | Changes |
 | --- | --- | --- | --- |
 | `assets/rivencraft/textures/item/page.png` | `assets/mystcraft/textures/items/page_background.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
-| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Notebook draws the native 30×40 page at atlas coordinates `(156, 0)` |
+| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared by the Notebook, Desk, Binder, and turned left book page after removing a byte-identical duplicate |
 | `assets/rivencraft/textures/gui/bookui_cover.png` | `assets/mystcraft/gui/bookui_cover.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared book cover, with gold edges drawn only for Descriptive Books |
-| `assets/rivencraft/textures/gui/bookui_pagel.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; turned left page |
 | `assets/rivencraft/textures/gui/bookui_pager.png` | `assets/mystcraft/gui/bookui_pager.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; link-panel frame on the first right page |
 | `assets/rivencraft/textures/gui/bookui_rpage_full.png` | `assets/mystcraft/gui/bookui_rpage_full.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; full right written page |
 | `assets/rivencraft/textures/item/writing_desk.png` | `assets/mystcraft/textures/items/writingdesk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
@@ -25,7 +24,7 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | `assets/rivencraft/textures/item/page_link_panel.png` | `page_background.png` and `PageBuilder.BasicPageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Reproduces the legacy 160 px scale, black panel at `(25,30)`–`(135,75)`, and 128 px resample |
 | `assets/rivencraft/textures/gui/symbolcomponents.png` | `assets/mystcraft/textures/symbolcomponents.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Byte-identical shared 512×512 component sheet for client-side page composition |
 | Runtime-composed symbol pages (`SymbolPageTextures`) | `page_background.png`, `textures/symbolcomponents.png`, `WordData`, `ModSymbols`, and `PageBuilder.PageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Replaces the six pre-generated symbol PNGs; layers four poem words on the shared page background and caches bounded client textures |
-| `assets/rivencraft/textures/block/crystal_block.png`, `budding_crystal.png` | `assets/mystcraft/textures/blocks/crystal.png` | Legacy 0.13.7.06 local extraction | Exact 16×16 blue tile reused for both solid crystal blocks |
+| `assets/rivencraft/textures/block/crystal_block.png` | `assets/mystcraft/textures/blocks/crystal.png` | Legacy 0.13.7.06 local extraction | Exact 16×16 blue tile shared by Crystal Block and Budding Crystal models after removing a byte-identical duplicate |
 | `assets/rivencraft/textures/block/{small,medium,large}_crystal_bud.png`, `crystal_cluster.png` | Minecraft 1.21.1 `textures/block/{small,medium,large}_amethyst_bud.png`, `amethyst_cluster.png` | Minecraft 1.21.1 | Original 16×16 alpha masks and silhouettes preserved; hue shifted toward Legacy blue, with brighter saturation; exported as 8-bit RGBA (not indexed PNG) |
 | `assets/rivencraft/textures/item/crystal_shard.png` | Original sprite generated with OpenAI ImageGen from the Legacy crystal palette | 2026-10-05 | Cropped and nearest-neighbor scaled to 16×16 |
 | `assets/rivencraft/sounds/linking/link-fissure.ogg` | `assets/mystcraft/sounds/linking/link-fissure.ogg` | Legacy 0.13.7.06 local extraction | Namespace/path rename only; plays when a Star Fissure returns an entity home |
@@ -17,10 +17,15 @@ core tests when investigating an issue:
 ```shell
 ./gradlew runGameTestServer -ParchivedGameTestSuites=desk
 ./gradlew runGameTestServer -ParchivedGameTestSuites=grammar,binder
+./gradlew runGameTestServer -ParchivedGameTestSuites=generation
 ```

-Available suite names are `linking`, `environment`, `writing`, `grammar`, `desk`,
-`binder`, `mixer`, and `recipe`. Run all Rivencraft tests before a
+Available suite names are `linking`, `environment`, `writing`, `grammar`,
+`generation`, `desk`, `binder`, `mixer`, and `recipe`. The `generation` archive
+keeps the detailed feature, structure, ore, crystal, and fissure regressions
+out of the default smoke run. Three checks formerly registered twice in the
+core and their archives now run only through the core wrapper. Run all
+Rivencraft tests before a
 release or after broad cross-system changes:

 ```shell
@@ -47,6 +52,27 @@ automated check, and hand its exact scenario to the player for in-game
 verification. Do not keep retrying a stalled test or leave its process running.
 Keep the narrower non-stalling plan, persistence, and runtime checks automated.

+For issue #41, the combined archive and the focused `linking` archive initially
+stalled during the multi-profile travel acceptance test. That test is no longer
+registered with GameTest; the rerun passed all 116 registered tests before the
+subsequent random-biome-count adjustment. The 51-test core suite passes after
+that adjustment, but the full archive stalled again late in its first batch;
+do not treat that interrupted run as a pass. Verify its
+scenario manually: in a fresh world, bind
+one Descriptive Book for each of Standard, Flat, Amplified, Island, Cave, and
+Void terrain (use the corresponding Terrain Page to select each one). Visit
+each Age, confirm a safe arrival platform and headroom, and
+travel back using a bound Linking Book. The narrower creation, persistence,
+terrain, and travel checks remain automated. See
+[random Age weights](RANDOM_AGE_WEIGHTS.md) for the Legacy rank mapping and
+the opt-in weighting regression.
+
+Also bind several Link-Panel-only Descriptive Books with no authored biome
+pages. Check that each Age retains its biome set after leaving, unloading, and
+reopening it, and that the selected biome count varies between Ages without
+exceeding the eligible pool. This covers the bounded random-biome path touched
+after the last successful full-archive run.
+
 The optional `-PwithSereneSeasons=true` runtime is for a real dev client, not
 the GameTest server: Serene Seasons sends a season payload to GameTest mock
 players, which cannot negotiate its channel. Follow the real-client Serene test in
@@ -0,0 +1,9 @@
+# Frozen Age instability score (Milestone 6, issue #64)
+
+Every newly created Age now gets a version-1 `Instability` compound inside its server-owned `rivencraft_ages` saved definition. It contains the total `Score` and an ordered `Breakdown` of reason, original page index (zero-based, or -1 for an Age-wide cause), points, and explanation. `AgeRegistrySavedData.instability(UUID)` is the read-only server query. No client tooltip or live data-pack lookup is needed to read a saved score.
+
+The baseline is explicitly zero for page-free and Link-Panel-only random Ages, and for authored Ages. Incomplete writing receives seed-based completion and a zero-point explanatory entry. Supported writing defects use the provisional Milestone 6 grammar costs: duplicate/conflicting single-choice pages +500, out-of-order or misplaced pages +100. Legacy's audited bright-lighting symbol adds +500 whether authored or seed-selected. Other balance costs are not guessed for symbols that Rivencraft has not implemented. The score is not yet an active hazard or effect selection.
+
+The score is calculated after the Age plan and effective traits are chosen, then saved with the Age identity before its dimension is generated. The same UUID returns the existing definition, including the same score, on repeated use. Spawn updates preserve it. Reload only deserializes the frozen breakdown; it never reruns the current grammar or catalog. An older Age definition without `Instability` is migrated to a persisted version-1 neutral score of zero, rather than retroactively scoring its writing. A future scoring-rule change must introduce an explicit new schema/migration policy, not silently reinterpret existing Ages.
+
+Unknown or unsupported pages remain invalid for *new* Ages. Their absence from a later registry does not change an already saved score. Focused GameTests cover stable/defective writing, random baseline and bright lighting, repeated identity, save round-trip, and missing-symbol/old-save behavior.
@@ -0,0 +1,64 @@
+# Mystcraft Legacy instability audit (Milestone 6, issue #63)
+
+This is a behavior contract for Milestone 6, **not a completed runtime instability system**. It compares the user-provided 0.13.7.06 class files at `/home/dnorberg/Documents/mystcraft-src/mystcraft-1.12.2-0.13.7.06/` with [Mystcraft Legacy source at commit `9bc8ddc`](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae). Values below are source defaults, not a claim that every historical config or server used them. Rivencraft 0.5.1.0 saves a provisional writing-instability score and repaired active-page order, but has no hazard loop yet.
+
+## Score, grammar, and selection in Legacy
+
+Legacy's [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java) calculates `debug + symbol + block + book/base + bonus`, then applies difficulty 0/1/2/3 multipliers of 0.25/0.5/1/1.75. Global instability is enabled by default; an Age also has its own enable flag. The unmodified score is not simply “number of bad pages.” Block profiling may delay a usable score: `blockinstability` is null until **more than** 400 Age chunks are profiled, and `getInstabilityScore()` returns zero until then. It is recalculated after additional profiling. [`ChunkProfiler`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/ChunkProfiler.java) compares watched block abundance with a baseline, subtracting only positive excess above each baseline. The baseline is profiled or read from balance config; [`InstabilityDataCalculator`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/InstabilityDataCalculator.java) sets its default tolerance to 1.05, and default `useconfigs=false`. We should not copy its 400-chunk profiling delay or dynamic block scan into 1.21.1 without a separate performance case.
+
+| Input | Verified Legacy behavior | Rivencraft M6 interpretation |
+| --- | --- | --- |
+| Missing required controller | Terrain, biome controller, weather, and lighting are generated when missing. `InstabilityData.missing.controller = 0`; lighting explicitly adds zero. Missing pages themselves are not a penalty. | Keep Age-seeded completion. No penalty solely for an omitted branch. |
+| Repeated same symbol | `addSymbol` increments a per-`IAgeSymbol` count and adds that symbol's `instabilityModifier(count)`. This method is symbol-specific; there is no universal “duplicate = N” rule. | Distinguish legal repeated features/materials from repeated single-choice pages. Do not add a flat duplicate penalty to every occurrence. |
+| Extra/conflicting controller | Registering a second terrain, biome, weather, or lighting controller adds `InstabilityData.extra.controller = 500`; the **last registered** controller replaces the prior one. This is separate from each symbol's own modifier. | Eligible supported conflicts may become unstable rather than fatal in #65, with deterministic winner and a saved penalty. |
+| Dangling modifier | An unconsumed modifier contributes its `dangling` value; a default `Modifier` has `dangling=100`. Replacing a pending modifier charges the old one. `clearModifiers()` charges 20% (`clearPercentage=0.20`) of each pending value, with Java integer compound-assignment truncation. | Record the ordered offending page and a reason; calculate a deterministic penalty from the consumed/leftover modifier semantics, not from GUI position alone. |
+| Unsupported/unmatched page | Legacy logs unmatched symbols during reconstruction and skips their logic; its `AgeData.getBaseInstability()` still has a TODO for calculating instability from pages. This is not a sound compatibility contract. | Remains fatal for *new* books until semantic and runtime support exists; never silently erase the page or pretend its effect applied. Existing saved books retain their IDs. |
+| Other penalties/bonuses | `AgeController.addInstability(int)` is available to symbol logic. The base/book score is persisted as a `short`; Legacy's [`InstabilityBonusManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/bonus/InstabilityBonusManager.java) also has dynamic player death/behavior components. | Persist a versioned score breakdown for Age writing and environmental contributions. Do not infer death/troll mechanics from the mere existence of Legacy classes. |
+
+Source for controller and modifier defaults: [`InstabilityData`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java). The local 0.13.7.06 `Modifier.class` confirms `dangling_default=100`. Legacy grammar **ranks** weight which missing symbols are selected; they are not a direct instability score or deck tier. See [grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) and [random weights](RANDOM_AGE_WEIGHTS.md).
+
+[`InstabilityController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityController.java) rounds its working score toward zero to the current smallest registered positive provider cost (500 by default), then rebuilds active effects when that rounded score changes. Each seeded deck preserves its saved card order; new cards are shuffled with the Age seed. For each deck it subtracts the deck entry cost, then walks cards in order, paying each provider activation cost until the next card cannot be afforded. A provider's occurrences become its level. **Deck costs are gates, not mutually exclusive severity bands**: at high score multiple decks can contribute effects. Provider `.enabled` config can remove cards. The actual effect set cannot be inferred from a score alone without the saved deck orders and enabled providers ([`Deck`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/Deck.java), [`InstabilityManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityManager.java)).
+
+| Legacy deck | Entry cost | Examples of registered cards |
+| --- | ---: | --- |
+| basic | 0 | enemy regeneration/resistance, fatigue, hunger, poison, slowness, weakness |
+| harsh | 2,500 | stronger/global potions, burning, lightning, wither |
+| destructive | 10,000 | crumble, explosions, lightning, meteors, wither |
+| eating | 15,000 | colored decay, blindness, nausea, wither |
+| death | 20,000 | global blindness/nausea/wither, colored decay |
+
+These entry costs are from [`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), not guaranteed first-activation scores: each card also costs 500–5,000 depending on provider. A zero-cost basic deck still needs enough score to buy its first card. `stability.*` numbers in that file are provider activation costs, despite the misleading field name.
+
+## Effect inventory and modern policy
+
+[`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java) is the authoritative list of *registered* providers. Some implemented classes are commented out there; their existence does not mean they occur normally. Each Legacy environmental effect is called for chunks that the Age's runtime processes, often with its own chance. No per-Age global work budget is visible in these effect classes.
+
+| Family | Legacy behavior | M6 disposition |
+| --- | --- | --- |
+| Player and hostile-mob potions | Local/global blindness, fatigue, hunger, nausea, poison, slowness, weakness, wither; hostile regeneration/resistance ([`EffectPotion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectPotion.java)). | Implement in #67 with server-only, Age-scoped entity targeting and rate limits. No effects in preview/snapshot worlds. |
+| Colored decay | Blue, purple, red, white providers place advancing decay and extra-tick it; black provider is commented out. Decay handlers differ in spread/consumption ([providers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/providers), [handlers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/decay)). | Implement bounded, reversible-by-admin world mutation in #68; exact 1.12 spread/update rates require adaptation and tests. Exclude protected spawn/portal areas. Black/green/yellow are **not** proven active Legacy providers. |
+| Lightning and explosions | Random per-chunk strike/explosion attempts ([`EffectLightning`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectLightning.java), [`EffectExplosions`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExplosions.java)). | Implement in #69 with explicit block-damage and fire policy; no effect outside the Age. |
+| Meteor, scorching | Meteor entity spawn and sky-exposed entity ignition ([`EffectMeteor`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectMeteor.java), [`EffectScorched`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectScorched.java)). | #70: modern meteor entity/impact needs an explicit damage budget; scorching can use modern fire/damage checks. Legacy `meteor/roar.ogg` is available. |
+| Crumble and erosion | Crumble maps blocks to weaker states; erosion spreads adjacent fluids and has extra lake-generation methods ([`EffectCrumble`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectCrumble.java), [`EffectErosion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectErosion.java)). | #70: bounded block palette and protected-area checks. Erosion's provider is commented out in Legacy registration: treat it as deliberate opt-in adaptation, not baseline parity. |
+| Extra ticks | Registered alongside blue/purple/red/white decay, targeting decay blocks ([`EffectExtraTicks`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExtraTicks.java)). | Implement only as a bounded decay helper in #68; do not accelerate arbitrary blocks/block entities. |
+| Other dormant code | Black decay, global burning, bedrock crumble, erosion provider are commented out. | Defer unless a later issue explicitly requests them. An authored symbol requiring one must fail clearly until supported. |
+
+Assets in the supplied local tree: `assets/mystcraft/textures/blocks/decay_{black,blue,green,purple,red,white,yellow}.png`, corresponding decay block/item model JSON, and `assets/mystcraft/sounds/entity/meteor/roar.ogg`. Before importing, review attribution/license and fit modern 16×16 assets. Texture availability does not make an effect active. Use current Minecraft effects/sounds where adaptation is cleaner; no new artwork is needed for this audit.
+
+## Rivencraft boundary and proposed safety contract
+
+[`WritingGrammar`](../src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java) classifies `INCOMPLETE` as seeded completion and supported writing defects as accepted instability. `AgeGenerationPlan.compile()` freezes the original writing, repaired active-page indexes, and a provisional writing-instability score before world generation. #64 now persists a versioned score breakdown; saved provider/deck choice remains future work. The plan must not mutate an already-created Age when a data pack changes. Server-side settings may disable execution, but should not rewrite the saved authored score.
+
+For #65, **eligible-to-become-unstable** means a known, supported page whose semantics and resulting world are still deterministic: repeated/conflicting single-choice pages and otherwise valid out-of-order or misplaced pages. The implementation retains every original page, uses the last single-choice page, sorts active categories, and saves 500 per extra/conflicting choice or 100 per misplaced page. These are provisional Rivencraft values, not a full port of every `IAgeSymbol.instabilityModifier`. Missing branches are explicitly classified as zero-cost seeded completion; legal repeated feature/material pages are not automatically errors. **Remain fatal**: missing/duplicate/misordered Link Panel, over-capacity book, unresolved or schema-v1 display-only symbol, unsupported weather/angle/runtime profile/biome/feature, unavailable required optional mod, and any combination the compiler cannot represent safely. Binder and unbound-book previews distinguish blocked writing, seeded completion, and accepted instability before binding; the server revalidates on output. This intentionally differs from Legacy's silent unmatched-symbol skip, universal controller cost assumptions, and modifier-specific dangling costs. A full symbol-specific Legacy penalty port remains a separate balance task, not a claim of parity in this slice.
+
+Automated #65 checks cover classification, preserved input slots on rejection, and an accepted unstable preview. The live output/one-time Age creation check is assigned to in-game testing because the GameTest storage phase stalled when that transaction ran; the test world is not retained.
+
+Proposed server defaults for #66–#72 (to confirm during implementation): instability scoring on for newly created Ages; passive entity effects on; world-mutating hazards **off by default** until an operator opts in; explicit per-Age toggle and separate per-family switches. Enforce a central work budget rather than letting every loaded chunk and provider roll independently: default at most one hazard attempt per Age per 20 ticks, one block mutation per successful attempt, and no forced chunk loads. Budgets should be configurable with hard upper bounds, including active Ages, target radius, tick interval, block changes/explosions/meteor impacts, entity effect attempts, and decay spread. Never target another dimension, unloaded chunk, book preview/snapshot, protected spawn/link platform, or portal. Stop safely when the Age unloads or settings change. These are **Rivencraft proposals**, not Legacy defaults or code that exists today; implementation issues must test/adjust them, especially multiple concurrent Ages. Expose score breakdown, selected effects, enablement, and budget suppression in server diagnostics (#72).
+
+M6 owns scoring, selection, effects, controls, and regression. M7 still owns portal/transport and broader polish; M6 must not depend on new M7 structures. An illegal biome/terrain combination that is presently unrepresentable remains a generation failure until a separate, safe compiler path exists; instability must not be used to disguise absent worldgen support. Existing pre-release saves need explicit migration behavior in #73 rather than a silent rescore.
+
+## Verification and open questions
+
+- Inspected pinned source for `AgeController`, `AgeData`, `GrammarTree`, `InstabilityData`, `InstabilityManager`, `InstabilityController`, `Deck`, all active provider families, effect classes, `ChunkProfiler`, and `InstabilityDataCalculator`; checked matching local 0.13.7.06 class names and `Modifier.dangling_default` with `javap`.
+- The supplied extraction has no generated user balance config; registered defaults can be overridden or providers disabled. There is no single universal instability value for “wrong order” or “duplicate page.” `IAgeSymbol.instabilityModifier(count)` implementations and runtime configs determine the final Legacy value.
+- Exact Legacy visual/decay behavior, dynamic bonus registration, and full 1.12 block-baseline parity need focused checks when their slices are implemented. Do not label proposed modern caps as source facts.
@@ -0,0 +1,39 @@
+# Milestone 5 acceptance: Age grammar
+
+This is the completion record for [Gitea issue #42](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/issues/42) and release 0.5.0.0. Issues #28–#41, #45–#59, #61, and #62 are closed. #39 was closed with an explicit Ecliptic Seasons limitation, not with a working Ecliptic adapter. #42 is the final gate. Issues #43, #44, and #60 are separate open follow-ups, not hidden Milestone 5 completion claims.
+
+## Authoring and generation contract
+
+- Schema-v2 symbol JSON lives at `data/<namespace>/rivencraft/symbols/<path>.json`. Its file path is the stable page ID; `name`, `description`, and `category` are display metadata, while typed `semantics.role` and `semantics.value` control generation on the server. See [schema and role table](SYMBOL_SEMANTICS.md). Schema v1 remains display-only. Registry-derived biome, solid-block, and source-fluid pages are generated from valid registered entries rather than requiring one PNG or JSON definition per material.
+- Ordered writing is parsed as Link Panel, terrain, biomes/controller, weather, season, lighting, sky, celestial modifiers/celestial, then material/feature pairs. Missing branches are seeded completion warnings. Unresolved symbols, unsupported combinations, conflicting single-choice pages, incorrect order, and an invalid Link Panel produce Binder diagnostics before items are consumed. Repeated feature and material pages retain their occurrence order. See [grammar and diagnostics](WRITING_GRAMMAR.md).
+- Legacy's grammar ranks informed the random-choice weights; Rivencraft does not claim to run Legacy's complete 1.12.2 grammar or reproduce its terrain byte-for-byte. The [source audit](LEGACY_AGE_GRAMMAR_AUDIT.md), [weight table](RANDOM_AGE_WEIGHTS.md), and [runtime profiles](AGE_PROFILES.md) record exact mappings and adaptations. Authored supported symbols override seeded choices. A page-free or Link-Panel-only Descriptive Book creates a random Age. The resolved plan, seed, profile, biome IDs, traits, features, and writing order are saved with its Age identity before chunks generate. Reopening a book or restarting must not reroll it.
+- Feature pages cover decorations, terrain additions, dense ores, crystals, fissures, and supported structures including Trial Chambers and newer vanilla structures. Material pages may explicitly choose a compatible block/fluid or receive a seeded compatible feature. Terrain and biome eligibility still restrict combinations; incompatibility is reported rather than silently ignored. [Age documentation](AGES.md) and [feature rules](WRITING_GRAMMAR.md) describe the supported subset.
+
+## Optional integrations and fallback
+
+| Integration | Milestone 5 result |
+| --- | --- |
+| TerraBlender | Optional adapter reads registered Overworld and Nether region biome IDs. Any compatible biome-producing mod using those regions can supply eligible pages; no Biomes O' Plenty ID is hard-coded. Missing TerraBlender leaves vanilla Age generation intact. A removed biome warns and uses an eligible load-time fallback without rewriting the saved plan. See [TerraBlender checks](TERRABLENDER_COMPATIBILITY.md). |
+| Serene Seasons | Optional per-Age seasonal modes: No Seasons, Seasons, Eternal Winter/Summer/Fall/Spring. The adapter enrolls dynamic Age IDs in Serene's whitelist and synchronizes connected clients without a restart. Its internal config/saved-clock hooks are version-sensitive because a public dynamic-dimension registration/fixed-season API is unavailable. Without Serene, only No Seasons is valid for a *new* book; saved Ages retain their data with effects inactive. See [config and real-client checks](SERENE_SEASONS_COMPATIBILITY.md). |
+| Ecliptic Seasons | Deliberately not integrated. Its 1.21.1 `ValidDimensions` setting requires a world restart and caches validity on server/client level load; no supported live registration or per-dimension calendar-control API was found. Issue #39 records the blocker and the upstream API needed to revisit it. Rivencraft does not require Ecliptic and does not support both season mods together. |
+| JEI, Create/Ponder, Immersive Portals | Optional presentation/integration paths; none is required for core dedicated-server loading or Age grammar. Existing preview fallback and manual checks remain in [preview compatibility](PREVIEW_COMPATIBILITY.md). |
+
+## Migration, limits, and milestone boundary
+
+Existing saved writing keeps its stable IDs and order. Unresolved pages remain recoverable in books instead of being silently replaced. Existing bound books without a plan are not reinterpreted as newly authored grammar. A frozen plan can load without the old symbol definition or runtime-profile JSON, but missing referenced registry resources prevent or alter that load as documented in [runtime profiles](AGE_PROFILES.md); restore the data pack/mod and keep a backup. The migration regression suite covers legacy writing components, schema-v1 display pages, missing symbols, and old Binder/Desk data. It is **not** a promise of full compatibility with every pre-release world; that broader requirement is tracked separately by open issue #60.
+
+Milestone 5 owns recognized symbol semantics, ordered grammar, deterministic completion, persistent Age configuration, and supported feature/integration effects. Milestone 6 owns instability from invalid or excessive writing and server-safe instability effects. Milestone 7 owns remaining structures/polish, portals, recipes, models, sounds, advancements, and migration depth. Several Legacy structures and crystals were pulled forward into Milestone 5 as their own closed port issues; that does not imply the rest of Milestone 7 is complete. Custom multi-body skies, gradients, unsupported direct Rain/Snow pages, and exact Legacy terrain/feature parity remain outside the accepted M5 subset. Open issue #44 tracks custom skybox work.
+
+## Test and acceptance matrix
+
+| Check | Result or handoff |
+| --- | --- |
+| Default dedicated-server GameTests, no optional mods | 26/26 passed after moving 25 detailed generation checks to the selectable `generation` archive. Core persistence, grammar, transaction, and migration checks remain. |
+| Focused generation archive | 51/51 passed on the reduced core plus `-ParchivedGameTestSuites=generation`. No generation test was deleted; 25 detailed checks moved out of the default run. |
+| Full archive | Previously passed 116/116 before the final random-biome-count adjustment in #41. Its later rerun stalled in the first batch and was stopped under the project GameTest rule; **not** claimed as a passing current run. Manual random-Age biome and six-terrain travel checks are in [GameTest handoffs](GAMETESTS.md). |
+| Optional TerraBlender | An earlier optional-mod GameTest run passed 51/51; Biomes O' Plenty/Nether-region behavior was checked in-game during #37. The published jar does not bundle TerraBlender. |
+| Optional Serene Seasons | In-game acceptance was recorded on #38 for six pages, saved whitelist, and no-restart sync. The GameTest mock player cannot negotiate Serene's season packet; the real-client path is documented. |
+| Gradle build and JAR | `./gradlew build --offline --no-daemon` passed and produced `build/libs/rivencraft-0.5.0.0.jar`. Its SHA-256 is attached to the Gitea release. |
+| Asset audit | Three byte-identical PNGs were replaced by references to their retained counterparts; no other unreferenced shipped textures or sounds were found. The user-provided `dev images` reference remains untouched. |
+
+Completion checklist: implementation issues reviewed; #39 explicitly scoped as unsupported; schema/Legacy/grammar/generation/integration/migration boundaries documented; core and focused validation recorded; current archive stall disclosed; release JAR and SHA-256 published; issue #42 and Milestone 5 closed **only after** those release artifacts are verified.
@@ -34,14 +34,17 @@ acceptance issue and all required implementation issues are complete.
   renderer compatibility. **Complete.** See
   [Milestone 3](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/8).
 4. **Writing system** — pages, notebooks, desks, book assembly, and the baseline
-   Ink Mixer for Link Panels. Symbol effects are deferred until Milestone 5.
+   Ink Mixer for Link Panels. Symbol effects were deferred to Milestone 5.
   **Complete.** See [Milestone 4](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/9)
   and [writing-system data and migration](WRITING_DATA.md).
-5. **Age grammar** — translate symbol combinations into modern biome, noise,
-   dimension-type, and world-generation configuration. Optional integrations
-   may add composable biome regions and seasonal behavior. See the
+5. **Age grammar** — translate supported symbol combinations into modern biome,
+   noise, dimension-type, and world-generation configuration, with optional
+   TerraBlender and Serene Seasons integration. **Complete for the supported
+   subset.** See the [acceptance record](MILESTONE_5_ACCEPTANCE.md) and
   [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md).
-6. **Instability** — deterministic validation and server-safe effects.
+6. **Instability** — deterministic validation and server-safe effects. Start with the
+   [Legacy instability audit](LEGACY_INSTABILITY_AUDIT.md), which separates
+   source behavior from proposed 1.21.1 safety limits.
 7. **Structures and polish** — libraries, crystals, portals, recipes, models,
   sounds, advancements, compatibility, and migration tests.

@@ -61,17 +64,16 @@ live rendering when their dependencies are installed. The tested selection
 matrix and integration boundaries are documented in
 [PREVIEW_COMPATIBILITY.md](PREVIEW_COMPATIBILITY.md).

-The writing system and Age grammar will build on the existing page-free Age
-path. Page-free books remain a useful deterministic fallback and test fixture
-after written symbol combinations become available.
+The writing system and Age grammar build on the existing page-free Age path.
+Page-free books remain a useful deterministic fallback and test fixture.

 Milestone 4 delivered a versioned, data-pack-defined symbol catalog and an
 immutable ordered-writing model. See [WRITING_DATA.md](WRITING_DATA.md). These
-contracts preserve unknown symbol identifiers and store author intent; they do
-not interpret symbols into Age generation, which remains Milestone 5 work.
+contracts preserve unknown symbol identifiers and store author intent;
+Milestone 5 adds the server-owned interpretation and persistent Age plan.
 The Ink Mixer is included in Milestone 4 after book assembly; it
 uses paper and Ink Vials to make baseline Link Panels. Adding modifier
-ingredients and symbol-driven link properties belongs to Milestone 5.
+ingredients and symbol-driven link properties were delivered in Milestone 5.

 ## Provenance rules

@@ -0,0 +1,18 @@
+# Random Age selection (issue #41)
+
+Page-free and Link-Panel-only books still make one random Age definition from the Age seed. A written page overrides its branch; random completion never rewrites the book. The resulting terrain, traits, season mode, biome pool, and feature choices are saved with the Age identity, so loading an existing Age does not reroll it. This change affects **new** Ages only.
+
+The rank-weight calculation follows Mystcraft Legacy's `GrammarGenerator.buildRankWeights` in the user-provided 0.13.7.06 classes: starting at the highest numbered (rarest) rank, a rank's weight is at least one greater than the preceding rank's total divided by the number of entries at the current rank. A missing intermediate rank still advances the weight. The corresponding `SymbolRules` entries supply the ranks. This is a selection policy, not a port of Legacy's full grammar tree or its Minecraft 1.12 world generator.
+
+| Branch | Relative tickets for supported choices |
+| --- | --- |
+| Terrain | Standard 6, Flat 5, Amplified/Island/Cave/Void 1 each. Cave and Island occupy the rare slots corresponding to Legacy Nether and End terrain. Additional data-pack runtime profiles default to the rare rank and cause the group weights to be recomputed. |
+| Biome controller | Native/Single/Medium 3 each; Tiled/Grid/Tiny/Small/Large/Huge 1 each. The selected controller still applies terrain eligibility and minimum-biome rules. |
+| Additional random biomes | After Rivencraft's existing controller minimum, each extra biome has a 2-in-3 continuation chance and a 1-in-3 stop chance, capped by the eligible biome pool (including optional TerraBlender additions). This mirrors Legacy's ranked biome-list branch without changing the project's authored-page minimums. |
+| Lighting | Normal 3; Dark/Bright 1 each. |
+| Weather | Normal 9; Fast/Slow/Off/Always/Cloudy/Rain/Snow/Storm 1 each. WeatherOn is named Always here. |
+| Season (Serene Seasons only) | Seasons 6, No Seasons 5, each eternal season 1. These are Rivencraft ranks for features absent from Legacy; normal cycling is most common and eternal seasons are rare. No season policy is rolled without Serene Seasons. |
+
+Random-feature selection remains bounded to two material features and two structures. Within those limits, surface/deep lakes have Legacy rank 1; lava lakes rank 2 as a separate new fluid choice; spheres/spikes/obelisks rank 3; and floating islands/tendrils rank 4. Rocks, which are a Rivencraft generalization, use rank 4. For structures, villages/strongholds/mineshafts use rank 1, dungeons/Nether fortresses rank 2, and newer Minecraft structures rank 3. Eligibility filtering still removes features incompatible with the selected terrain/biomes. Separate rare Skylands, Crystals, and Legacy-weighted Star Fissure rolls remain. This preserves Rivencraft's existing count limits rather than claiming exact parity with the full Legacy feature grammar. Existing saved random feature lists are retained. The current celestial stopped-time chance (1 in 7) follows the verified Legacy period ranks; other numeric celestial values still use Rivencraft's documented range.
+
+Regression coverage: `RandomAgeWeightGameTests` (archived grammar suite) checks exact terrain rank tickets and stable selections across many seeds. Core Age persistence tests cover page-free and Link-Panel-only books, plan/trait round-trips, and migrated definitions. Binder and grammar archives cover page order, missing symbols, rejected assembly, and replayed output. The default GameTest runtime has none of TerraBlender, Serene Seasons, Ecliptic Seasons, JEI, Create, Ponder, or Immersive Portals installed. Optional-mod interactions and real unload/restart checks remain manual per `GAMETESTS.md`.
@@ -40,10 +40,12 @@ For an eternal mode, Rivencraft sets Serene's per-Age saved clock to the midpoin

 - The Serene adapter uses Serene's internal saved season state because there is no public per-dimension season-freeze API. The real-client behavior above, including each eternal mode and No Seasons, still needs player verification. Serene's [temperature and precipitation hooks](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHooks.java) only cool eligible biomes.
 - Serene Seasons' [season tick](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHandler.java) advances from a dimension's day-time changes. A Rivencraft Age with a stopped celestial cycle may also have a stopped season; this needs an in-game check.
- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration remains issue #39; simultaneous installation is not a supported target.
+- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration was closed as unsupported for live dynamic Ages in issue #39; simultaneous installation is not a supported target.

 ## Verification so far

 `./gradlew build` passed for candidate 0.4.9.2, and the baseline plus archived environment GameTests passed (35 required tests). The archive now covers seasonal page visibility, exclusivity, and saved-plan persistence without Serene installed. With Serene Seasons 10.1.0.8 and GlitchCore 2.1.0.2 in the optional local runtime, the GameTest server previously crashed when Serene Seasons sent `sereneseasons:sync_season_cycle` to a GameTest mock player that had not negotiated its client payload channel. The stack trace originates in Serene Seasons' `SeasonHandler.sendSeasonUpdate`, through GlitchCore's packet handler and NeoForge's packet check. This is a GameTest mock-network limitation, not a completed absent/present compatibility check. Do not keep rerunning that suite with Serene Seasons; use the real-client test path above instead.

 For candidate 0.4.10.1, `./gradlew build --offline` and the focused environment archive passed (36 required GameTests). The new regression check covers omitted-page selection, explicit-page precedence, no-Serene behavior, and save/reload. Actual Serene weather, whitelisting, and eternal-season visuals still require the real-client steps above.
+
+The user subsequently reported an in-game pass for issue #38, recorded in its Gitea comment and release V0.4.9.2. The earlier candidate notes above describe the historical automated checks; the real-client matrix remains useful when upgrading Serene Seasons or GlitchCore.
@@ -16,7 +16,7 @@ Milestone 5 issue #29 adds typed meaning to the existing data-pack symbol catalo
 }
 ```

-`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that a later compiler must resolve and validate. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
+`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that the compiler resolves and validates. A syntactically valid resource ID alone does not guarantee the profile or feature exists.

 `poem` is optional, client-safe artwork metadata: exactly four alphabetic words, ordered top, right, bottom, left. The client layers their glyphs from the shared Legacy component sheet at runtime. GUI thumbnails use the full transparent artwork over their page backgrounds; item icons use the same artwork reduced from 16 to 13 pixels across, over the page texture. Unregistered words use a stable generated component combination; when a symbol has no poem, the six original built-in IDs retain their Legacy poems and other IDs produce four stable fallback words. This affects appearance only, never Age generation. Generated images are cached up to 256 entries and discarded on resource reload.

@@ -28,17 +28,20 @@ The Writing Desk's 88 collection tabs use Legacy's number components, chiefly th
 | `biome_controller` | `native`, `single`, `tiled`, `grid`, `tiny`, `small`, `medium`, `large`, or `huge`. |
 | `biome` | Canonical namespaced biome ID. |
 | `lighting` | `normal`, `dark`, or `bright`. |
+| `sky` | `overworld`, `nether`, or `end`. |
 | `weather` | `normal`, `fast`, `slow`, `off`, `always`, `cloudy`, `rain`, `snow`, or `storm`. |
+| `season` | `no_seasons`, `seasons`, `eternal_winter`, `eternal_summer`, `eternal_fall`, or `eternal_spring`. Seasonal effects other than No Seasons require optional Serene Seasons. |
 | `celestial` | `normal_time` (the first representable single-cycle behavior). |
 | `period_modifier` | JSON number in `[0, 2]`; zero is stopped time. |
 | `angle_modifier` | JSON number in `[0, 360)` degrees. |
 | `phase_modifier` | JSON number in `[0, 360)` degrees; the compiler will convert to turns. |
-| `feature` | Canonical namespaced feature-effect ID; future generation mapping must recognize it. |
+| `block` | Canonical namespaced material ID for a compatible following feature; registered full-collision blocks and source fluids receive generated Pages. |
+| `feature` | Canonical namespaced feature-effect ID; the compiler must recognize and validate it. This includes supported decorations and structures. |

-These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, special structures, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field.
+These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field. Recognized schema values can still be rejected by the current compiler when their runtime effect is unsupported, such as angle modifiers or direct Rain/Snow weather pages.

 The server rejects a v2 definition with an unknown top-level or semantics field, missing/incorrectly typed field, unknown role or choice, malformed/non-canonical resource ID, or out-of-range/non-finite number. An invalid definition is logged with its file ID and excluded from the active catalog. Saved pages and books still retain that ID, allowing the player to recover them if the data pack is corrected. A reload atomically replaces the catalog rather than mutating saved writing.

-Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, but does **not yet apply** written symbols to Age generation; issue #31 adds compilation.
+Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only display metadata; semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, and the server compiles supported writing into a frozen Age plan before Binder inputs are consumed.

 The six built-in definitions demonstrate terrain, biome-controller, lighting, weather, celestial, and feature roles. A third-party pack may add its own definitions under its namespace. Use an explicit semantic role even when the display category has the same name; the two fields serve different purposes.
@@ -4,22 +4,22 @@

 New Binder writing has at most one Link Panel plus 27 symbol pages. The Link Panel must be first. A Link-Panel-only book, or an older book with no writing component, keeps the existing random Age path. Any authored supported symbol makes the book a partial or complete grammar. From 0.4.3.0, the server compiles it into a persistent Age plan before consuming Binder inputs or generating chunks.

-The supported order follows the representable subset of the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md): terrain; zero or more biome pages; biome controller; weather; lighting; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more distinct features, each optionally preceded by a compatible block-material page. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers are intentional. Biome pages may repeat, preserving author order and any future weighting; feature IDs may not repeat. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.
+The supported order follows the representable subset of the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md): terrain; zero or more biome pages; biome controller; weather; season; lighting; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more features, each optionally preceded by a compatible material page. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, season, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers, biome pages, feature pages, and material pages are intentional and retain their order. An unpaired material page receives a seeded compatible feature during compilation. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.

-Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. The minimum biome count is zero for Native, one for Single, and two for Tiled/Grid and Tiny–Huge. Native cannot consume authored biome pages; Single accepts only one. Unknown IDs, schema-v1 display-only symbols, wrong ordering, misplaced modifiers, duplicates, conflicts, missing/extra Link Panels, and oversized writing are errors. The Binder disables output and exposes the first error on the result-slot tooltip. When that error belongs to a page, its thumbnail is tinted and outlined red, the strip scrolls to it, and hovering it shows the diagnostic. This maps the parser's compact entry position back through any empty page positions. Rejected inputs remain removable. Binding an unwritten Descriptive Book rechecks its server-owned writing and reports the first error without creating an Age. A terrain symbol whose profile is unavailable is also rejected before Binder inputs are consumed.
+Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. Native consumes no authored biome pages; Single consumes one; Tiled/Grid and Tiny–Huge require two, with seeded filler when pages are missing. From 0.5.1.0, known misplaced or repeated pages no longer block creation: the book keeps its original order, while the server repairs category order, uses the last single-choice controller, and stores a writing-instability score in the Age plan. A conflicting/repeated choice adds 500; an out-of-order page or misplaced modifier adds 100. Native ignores surplus authored biome pages and Single uses the first, with the conflict recorded as instability. These are Rivencraft's provisional penalties, not a claim of exact Legacy values for every symbol. Incorrectly placed pages are **not** red-highlighted; their warning remains available as a tooltip. Unknown IDs, schema-v1 display-only symbols, unavailable dependencies/profiles, unsupported semantic effects or feature/material pairs, missing/extra Link Panels, and oversized writing still reject a new Age. The Binder disables output for those fatal errors and shows a red page indication where applicable. Rejected inputs remain removable.

-The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the Age seed, and a copy of the selected runtime profile. An explicit terrain page overrides random terrain selection; an omitted terrain uses a seed-selected compatible profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages affect new Ages, and the supported feature subset below is compiled into the same frozen plan; instability remains Milestone 6 work.
+The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the active repaired-page indexes, the writing-instability score, the Age seed, and a copy of the selected runtime profile. An explicit terrain page overrides random terrain selection; an omitted terrain uses a seed-selected compatible profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages affect new Ages, and the supported feature subset below is compiled into the same frozen plan. Runtime effects for a nonzero writing-instability score are not implemented yet.

 ## Supported feature pages (issue #35)

 Feature pages come after the celestial section. Their order is retained in the plan and in decoration placement. The Caves page adds a second, Age-seeded vanilla cave-carving pass to Noise terrain, including Standard, Amplified, Island, and Cave terrain. It chooses the vanilla Overworld or Nether cave carver from the source biome. This is separate from the Milestone 7 issue about Cave **terrain** generation. Flat and Void terrain have no suitable solid noise body and reject Caves with a binder diagnostic.

-Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Small Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, Rocks select a valid solid block and each lake page selects a valid source-fluid block from the registered pool. The selection is deterministic for an Age seed and feature ID, so all chunks in that Age use the same material across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Small Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.
+Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Lava Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, each material-bearing feature selects a valid solid block or source fluid from the registered pool. The selection is deterministic for the Age seed and feature occurrence, so repeated feature pages can receive different materials while remaining stable across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Lava Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.

-Material pages are generated for registered full-collision, non-fluid blocks and genuine source-fluid blocks, including eligible blocks supplied by other mods. Blocks with block entities are excluded. Waterlogged plants and coral are not fluid blocks and receive no pages. Valid source-fluid blocks appear only in the Fluid Pages creative tab; valid full-collision solids appear only in Block Pages. Both categories use the same saved material-page semantics. Put a Block Page immediately before Rocks to choose a rock material, or a Fluid Page immediately before Surface Lakes, Deep Lakes, or Small Lakes to choose a lake fluid. A material page left alone, placed before a different category, or attached to an incompatible feature is rejected. Both the feature and material ID are frozen in the saved plan, so future chunks retain their choice after restart. Existing chunks are not retroactively decorated. Portals and the Cave-terrain bug remain separate work.
+Material pages are generated for registered full-collision, non-fluid blocks and genuine source-fluid blocks, including eligible blocks supplied by other mods. Blocks with block entities are excluded. Waterlogged plants and coral are not fluid blocks and receive no pages. Valid source-fluid blocks appear only in the Fluid Pages creative tab; valid full-collision solids appear only in Block Pages. Both categories use the same saved material-page semantics. Put a Block Page before a compatible solid feature (Rocks, Floating Islands, Tendrils, Spheres, Spikes, or Obelisks), or a Fluid Page before a lake feature. A material page with no explicit feature receives a seeded compatible one. A material directly attached to an incompatible feature is rejected. The effective feature and material IDs are frozen with the Age, so future chunks retain their choices after restart. Existing chunks are not retroactively decorated.

 Crystal Formations are an authored, material-free feature on exposed solid terrain, including Flat terrain; Cave and Void reject the page. Like Legacy, one in fifteen eligible chunks attempts a formation, with the site fixed by the Age seed and chunk coordinates. The modern formation is a compact mound with budding hearts instead of Legacy's long crystal lines. Budding blocks grow through small, medium, and large buds into clusters using vanilla amethyst timing and sounds. Non-silk cluster harvest yields Crystal Shards; four shards craft one Crystal Block. These blocks and shards use 16×16 textures: Legacy's crystal tile for solids and hue-shifted vanilla amethyst sprites for buds and clusters. A page-free Age can also randomly select Crystal Formations; an authored page always retains its exact choice in the saved plan.

 Star Fissures are a material-free feature on every terrain profile, including Cave and Void. The fissure is generated once beside the first resolved spawn, using Legacy's spawn-chunk offset and 10–17 paired, irregular X-span rows running along +Z. Legacy's y=0 portal floor maps to the modern dimension's minimum build height, replacing lower bedrock if present. The rift opens to the sky on ordinary terrain; in Cave terrain it opens into the cavern but stops below the upper bedrock roof. Water in the carved columns is cleared before the portal is placed. Its non-solid portal links to the Overworld spawn with the Legacy fissure sound; the animated starfield is drawn with Minecraft's current End Portal renderer, which uses the same end-sky/end-portal art as Legacy's custom renderer. Random Ages sample Legacy's default small-feature grammar for fissure selection: the stop/one/repeat branches have rank-derived weights 1:1:3, and the fissure has weight 1 of 9 among its small-feature rules. The remainder of random feature selection still follows Rivencraft's current pipeline, rather than running Legacy's entire Age grammar.

-The Rivencraft symbol-page creative tabs read a generated index of bundled symbol definitions and group Pages by each definition's category, except biome-controller roles, which appear in a separate Biome Generation tab rather than the Biome tab. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page in the matching category tab on the next build; a new bundled category receives its own tab. Registry-derived Block and Fluid Pages have separate tabs and both appear in optional JEI. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.
+The Rivencraft symbol-page creative tabs read a generated index of bundled symbol definitions and group Pages by each definition's category, except biome-controller roles, which appear in a separate Biome Generation tab rather than the Biome tab. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page in the matching category tab on the next build; a new bundled category receives its own tab. Registry-derived Block and Fluid Pages have separate tabs and both appear in optional JEI. Registry-derived biome pages share a creative/JEI feed; `terrablender:deferred_placeholder` is excluded because it is TerraBlender's internal staging biome, not a player-facing biome choice. Other modded biomes remain listed. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.
@@ -36,7 +36,7 @@ mod_name=Rivencraft
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=LGPL-3.0-or-later
 # The mod version. Rivencraft uses the x.y.z.b policy documented in README.md.
-mod_version=0.4.20.0
+mod_version=0.5.3.0
 immersive_portals_version=6.0.7
 terrablender_version=4.1.0.8
 serene_seasons_version_id=B6nTjh4b
@@ -5,7 +5,6 @@ import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
-import net.dnorberg.rivencraft.book.AgeGenerationPlan;
 import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.item.PageItem;
@@ -117,19 +116,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
            if (!page.isEmpty() && (!validPage(page) || !PageItem.isUsableWriting(page) || page.getCount() != 1
                    || PageItem.content(page).kind() == PageContent.Kind.BLANK)) return false;
        }
-        OrderedWriting writing = currentWriting();
-        if (!writingGrammar().canCreate()) return false;
-        try {
-            if (level instanceof ServerLevel serverLevel) {
-                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
-            } else {
-                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
-                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
-            }
-            return true;
-        } catch (IllegalArgumentException exception) {
-            return false;
-        }
+        return writingGrammar().canCreate();
    }

    public WritingGrammar.Result writingGrammar() {
@@ -138,7 +125,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
        List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(parsed.diagnostics());
        var terrain = parsed.symbols().stream()
                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
-                .findFirst();
+                .reduce((first, last) -> last);
        if (terrain.isPresent()) {
            var profileId = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
            if (!AgeRuntimeProfiles.profiles().containsKey(profileId)) {
@@ -181,18 +168,21 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
            // check. This also pinpoints biome-pool conflicts that cannot be inferred from
            // an individual feature page alone (for example Trees with only Nether biomes).
            if (level instanceof ServerLevel serverLevel && diagnostics.stream().noneMatch(
-                    diagnostic -> diagnostic.code() == WritingGrammar.Code.UNSUPPORTED_FEATURE)) {
+                    WritingGrammar.Diagnostic::error)) {
                try {
                    AgeRegistrySavedData.validateNewWriting(serverLevel, title, currentWriting());
                } catch (IllegalArgumentException exception) {
-                    if (exception.getMessage() != null && (exception.getMessage().startsWith("Feature ")
-                            || exception.getMessage().startsWith("Caves "))) {
-                        parsed.symbols().stream().filter(symbol -> symbol.semantics().role()
-                                        == SymbolSemantics.Role.FEATURE).findFirst().ifPresent(symbol ->
-                                diagnostics.add(new WritingGrammar.Diagnostic(
-                                        WritingGrammar.Code.UNSUPPORTED_FEATURE, symbol.index(),
-                                        exception.getMessage())));
-                    }
+                    boolean feature = exception.getMessage() != null
+                            && (exception.getMessage().startsWith("Feature ")
+                            || exception.getMessage().startsWith("Caves "));
+                    int index = feature ? parsed.symbols().stream()
+                            .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                            .mapToInt(WritingGrammar.ParsedSymbol::index).findFirst().orElse(-1) : -1;
+                    diagnostics.add(new WritingGrammar.Diagnostic(
+                            feature ? WritingGrammar.Code.UNSUPPORTED_FEATURE
+                                    : WritingGrammar.Code.UNSUPPORTED_COMBINATION,
+                            index, exception.getMessage() == null ? "The Age compiler rejected this writing"
+                                    : exception.getMessage()));
                }
            }
        }
@@ -80,13 +80,13 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
        int minimum = minimum(distribution);
        int target = minimum;
        if (authored.isEmpty()) {
-            // The terrain's available pool is the upper bound, including any
-            // compatible TerraBlender region biomes present at creation time.
+            // Legacy's BiomesAdv continuation/stop ranks are 2:3, which yield
+            // two continuation tickets for every one stop ticket. Keep our
+            // existing minimum and cap the list at the available biome pool.
            int availableBiomeCount = new LinkedHashSet<>(availableBiomes).size();
            int maximum = distribution == AgeTraits.BiomeDistribution.SINGLE ? 1 : availableBiomeCount;
-            if (maximum >= minimum) {
-                target += new Random(seed ^ 0x42494F4D45434F55L).nextInt(maximum - minimum + 1);
-            }
+            Random countRandom = new Random(seed ^ 0x42494F4D45434F55L);
+            while (target < maximum && countRandom.nextInt(3) != 0) target++;
        }
        // An authored Void Age must not acquire The Void as an unrequested second biome.
        List<ResourceLocation> filler = profile.terrain() == AgeRuntimeProfile.Terrain.VOID && !authored.isEmpty()
@@ -21,7 +21,8 @@ public record AgeDefinition(
        AgeTraits traits,
        AgeGenerationPlan plan,
        @Nullable AgeSeasonMode seasonMode,
-        List<AgeFeatureSelection.Choice> randomFeatures
+        List<AgeFeatureSelection.Choice> randomFeatures,
+        AgeInstability instability
 ) {
    public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
            Rivencraft.MOD_ID, "random_vanilla"
@@ -34,6 +35,7 @@ public record AgeDefinition(
        Objects.requireNonNull(generationProfile, "generationProfile");
        Objects.requireNonNull(dimensionId, "dimensionId");
        Objects.requireNonNull(traits, "traits");
+        Objects.requireNonNull(instability, "instability");
        randomFeatures = List.copyOf(randomFeatures);
        if (plan != null && !randomFeatures.isEmpty()) {
            throw new IllegalArgumentException("Authored Ages cannot also have random features");
@@ -47,14 +49,14 @@ public record AgeDefinition(
                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                         BlockPos spawn, AgeTraits traits) {
        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, null, null, List.of());
+                dimensionId, spawn, traits, null, null, List.of(), AgeInstability.legacyNeutral());
    }

    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan) {
        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, plan, null, List.of());
+                dimensionId, spawn, traits, plan, null, List.of(), AgeInstability.legacyNeutral());
    }

    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
@@ -62,7 +64,15 @@ public record AgeDefinition(
                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
                         @Nullable AgeSeasonMode seasonMode) {
        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, plan, seasonMode, List.of());
+                dimensionId, spawn, traits, plan, seasonMode, List.of(), AgeInstability.legacyNeutral());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
+                         @Nullable AgeSeasonMode seasonMode, List<AgeFeatureSelection.Choice> randomFeatures) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, randomFeatures, AgeInstability.legacyNeutral());
    }

    public static ResourceLocation dimensionId(UUID ageId) {
@@ -93,6 +103,6 @@ public record AgeDefinition(

    public AgeDefinition withSpawn(BlockPos spawn) {
        return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode, randomFeatures);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode, randomFeatures, instability);
    }
 }
@@ -15,14 +15,14 @@ public final class AgeEnvironmentCompiler {
        AgeTraits.Weather weather = seeded.weather();
        double period = seeded.celestialPeriod();
        float phase = seeded.celestialPhase();
-        boolean normalTime = plan.symbols().stream()
+        boolean normalTime = plan.activeSymbols().stream()
                .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.CELESTIAL);
        if (normalTime) period = 1.0D;
        boolean writtenPeriod = false;
        boolean writtenPhase = false;
        float phaseDegrees = 0.0F;

-        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.symbols()) {
+        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.activeSymbols()) {
            SymbolSemantics semantics = symbol.semantics();
            switch (semantics.role()) {
                case LIGHTING -> lighting = AgeTraits.Lighting.valueOf(
@@ -61,7 +61,7 @@ public final class AgeEnvironmentCompiler {
    /** Vanilla effects are the sky styles the current renderer can honor exactly. */
    public static ResourceLocation skyEffects(AgeGenerationPlan plan, ResourceLocation fallback) {
        if (plan == null) return fallback;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SKY)
                .map(symbol -> ((SymbolSemantics.ChoiceValue) symbol.semantics().value()).id())
                .map(choice -> switch (choice) {
@@ -73,7 +73,7 @@ public final class AgeEnvironmentCompiler {
    }

    public static boolean hasWrittenPhase(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.PHASE_MODIFIER);
    }

@@ -137,7 +137,7 @@ public final class AgeFeatureSelection {
        Map<ResourceLocation, List<ResourceLocation>> materialOrders = new HashMap<>();
        Map<ResourceLocation, Integer> occurrences = new HashMap<>();
        List<Choice> resolved = new ArrayList<>();
-        for (Choice choice : choices(plan.symbols().stream().map(symbol -> symbol.semantics()).toList(),
+        for (Choice choice : choices(plan.activeSymbols().stream().map(symbol -> symbol.semantics()).toList(),
                plan.runtimeProfile(), plan.ageSeed())) {
            if (choice.material().isPresent()
                    || !isRock(choice.id()) && !isLake(choice.id())
@@ -159,13 +159,15 @@ public final class AgeFeatureSelection {
    public static List<Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile, RegistryAccess registries) {
        Random random = new Random(ageSeed ^ 0x4D4154455249414CL);
        int count = random.nextInt(3);
-        List<ResourceLocation> features = new ArrayList<>();
-        for (ResourceLocation id : BLOCK_FEATURES) if (error(id, profile, registries) == null) features.add(id);
-        for (ResourceLocation id : FLUID_FEATURES) if (error(id, profile, registries) == null) features.add(id);
-        Collections.shuffle(features, random);
+        List<LegacyRankChoice.Option<ResourceLocation>> features = new ArrayList<>();
+        for (ResourceLocation id : BLOCK_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
+        for (ResourceLocation id : FLUID_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
        List<Choice> choices = new ArrayList<>();
-        for (ResourceLocation feature : features) {
-            if (choices.size() >= count) break;
+        while (choices.size() < count && !features.isEmpty()) {
+            ResourceLocation feature = LegacyRankChoice.choose(random, features);
+            features.removeIf(option -> option.value().equals(feature));
            var category = solidFeature(feature)
                    ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
            List<ResourceLocation> materials = BlockSymbolPages.availableBlocks(category).stream()
@@ -186,6 +188,13 @@ public final class AgeFeatureSelection {
        return List.copyOf(choices);
    }

+    static int randomMaterialRank(ResourceLocation feature) {
+        if (feature.equals(id("surface_lakes")) || feature.equals(id("deep_lakes"))) return 1;
+        if (feature.equals(id("lava_lakes"))) return 2; // New separate fluid choice.
+        if (spheres(feature) || spikes(feature) || obelisks(feature)) return 3;
+        return 4; // Legacy Floating Islands/Tendrils and the new Rocks choice.
+    }
+
    /**
     * Legacy's default FeatureSmalls0 grammar: stop without a feature (rank 4),
     * emit one (rank 4), or emit one and repeat (rank 2). Its rank-derived
@@ -302,45 +311,51 @@ public final class AgeFeatureSelection {
    }

    public static boolean isRock(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "rocks"));
+        return is(choice, "rocks");
    }

    public static boolean isLake(ResourceLocation choice) {
-        return choice.getNamespace().equals("rivencraft") && List.of(
-                "surface_lakes", "deep_lakes", "lava_lakes").contains(choice.getPath());
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "surface_lakes", "deep_lakes", "lava_lakes" -> true;
+            default -> false;
+        };
    }

    public static boolean surfaceVegetation(ResourceLocation choice) {
-        return choice.getNamespace().equals("rivencraft")
-                && List.of("flowers", "trees", "huge_trees").contains(choice.getPath());
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "flowers", "trees", "huge_trees" -> true;
+            default -> false;
+        };
    }

    public static boolean caves(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "caves"));
+        return is(choice, "caves");
    }

    public static boolean ravines(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "ravines"));
+        return is(choice, "ravines");
    }

    public static boolean floatingIslands(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "floating_islands"));
+        return is(choice, "floating_islands");
    }

    public static boolean tendrils(ResourceLocation choice) {
-        return choice.equals(id("tendrils"));
+        return is(choice, "tendrils");
    }

    public static boolean spheres(ResourceLocation choice) {
-        return choice.equals(id("spheres"));
+        return is(choice, "spheres");
    }

    public static boolean spikes(ResourceLocation choice) {
-        return choice.equals(id("spikes"));
+        return is(choice, "spikes");
    }

    public static boolean obelisks(ResourceLocation choice) {
-        return choice.equals(id("obelisks"));
+        return is(choice, "obelisks");
    }

    private static boolean solidFeature(ResourceLocation choice) {
@@ -349,7 +364,11 @@ public final class AgeFeatureSelection {
    }

    public static boolean skylands(ResourceLocation choice) {
-        return choice.equals(id("skylands"));
+        return is(choice, "skylands");
+    }
+
+    private static boolean is(ResourceLocation choice, String path) {
+        return choice.getNamespace().equals("rivencraft") && choice.getPath().equals(path);
    }

    public static boolean supportsSurfaceVegetation(ResourceLocation id, RegistryAccess registries) {
@@ -16,8 +16,9 @@ import net.minecraft.resources.ResourceLocation;

 /** A frozen interpretation of authored pages. Later slices consume its resolved branches. */
 public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
-                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
-    public static final int CURRENT_VERSION = 2;
+                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection,
+                                List<Integer> activeSymbolIndices, int writingInstability) {
+    public static final int CURRENT_VERSION = 3;

    public AgeGenerationPlan {
        if (version < 1 || version > CURRENT_VERSION) {
@@ -25,12 +26,14 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
        }
        Objects.requireNonNull(writing, "writing");
        symbols = List.copyOf(symbols);
+        activeSymbolIndices = List.copyOf(activeSymbolIndices);
+        if (writingInstability < 0) throw new IllegalArgumentException("Negative writing instability");
        Objects.requireNonNull(runtimeProfile, "runtimeProfile");
        if (runtimeProfile.schemaVersion() != AgeRuntimeProfile.CURRENT_SCHEMA_VERSION) {
            throw new IllegalArgumentException("Unsupported runtime profile snapshot version");
        }
-        if (version == CURRENT_VERSION && biomeSelection == null) {
-            throw new IllegalArgumentException("Version 2 Age plan requires a biome selection snapshot");
+        if (version >= 2 && biomeSelection == null) {
+            throw new IllegalArgumentException("Version 2+ Age plan requires a biome selection snapshot");
        }
        for (ResolvedSymbol symbol : symbols) {
            if (symbol.index() < 0 || symbol.index() >= writing.entries().size()
@@ -38,12 +41,31 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
                throw new IllegalArgumentException("Resolved symbol does not match original page order");
            }
        }
+        if (version >= 3 && !symbols.isEmpty() && activeSymbolIndices.isEmpty()) {
+            throw new IllegalArgumentException("Version 3 Age plan has no active symbols");
+        }
+        if (activeSymbolIndices.stream().distinct().count() != activeSymbolIndices.size()) {
+            throw new IllegalArgumentException("Age plan repeats an active symbol index");
+        }
+        for (int index : activeSymbolIndices) {
+            if (symbols.stream().noneMatch(symbol -> symbol.index() == index)) {
+                throw new IllegalArgumentException("Active symbol is not in the saved writing: " + index);
+            }
+        }
    }

    /** Existing version 1 plans retain their original biome behavior on reload. */
    public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
                             AgeRuntimeProfile runtimeProfile) {
-        this(version, ageSeed, writing, symbols, runtimeProfile, null);
+        this(version, ageSeed, writing, symbols, runtimeProfile, null,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
+    }
+
+    /** Existing call sites and version-2 plans retain every resolved symbol. */
+    public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
+                             AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
+        this(version, ageSeed, writing, symbols, runtimeProfile, biomeSelection,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
    }

    /** No plan is made for old page-free books or Link-Panel-only random Ages. */
@@ -52,7 +74,9 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
        WritingGrammar.Result parsed = WritingGrammar.parse(writing);
        if (!parsed.canCreate()) throw new IllegalArgumentException(parsed.firstError().orElseThrow().message());
        if (parsed.randomFallback()) return null;
-        ResourceLocation terrain = parsed.symbols().stream()
+        List<WritingGrammar.ParsedSymbol> active = parsed.activeSymbols();
+        WritingGrammar.Result effective = new WritingGrammar.Result(active, parsed.diagnostics());
+        ResourceLocation terrain = active.stream()
                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                .findFirst().orElse(null);
@@ -64,23 +88,29 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
        ResourceLocation selected = terrain == null ? seedProfile : terrain;
        AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
        if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
-        AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
-        AgeFeatureSelection.compile(parsed, profile, biomes, registries, ageSeed);
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(effective, traits, profile, ageSeed, registries);
+        AgeFeatureSelection.compile(effective, profile, biomes, registries, ageSeed);
        AgeGenerationPlan plan = new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
                parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
                        symbol.index(), symbol.reference(), symbol.semantics())).toList(),
-                profile, biomes);
+                profile, biomes, active.stream().map(WritingGrammar.ParsedSymbol::index).toList(),
+                parsed.writingInstability());
        AgeEnvironmentCompiler.apply(plan, traits);
        AgeSeasonMode.validate(plan);
        return plan;
    }

    public ResourceLocation authoredTerrain() {
-        return symbols.stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
+        return activeSymbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                .findFirst().orElse(null);
    }

+    public List<ResolvedSymbol> activeSymbols() {
+        return activeSymbolIndices.stream().map(index -> symbols.stream()
+                .filter(symbol -> symbol.index() == index).findFirst().orElseThrow()).toList();
+    }
+
    public CompoundTag save() {
        CompoundTag tag = new CompoundTag();
        tag.putInt("Version", version);
@@ -106,6 +136,10 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
            resolved.add(item);
        }
        tag.put("Resolved", resolved);
+        if (version >= 3) {
+            tag.putIntArray("ActiveSymbolIndices", activeSymbolIndices);
+            tag.putInt("WritingInstability", writingInstability);
+        }
        CompoundTag profile = new CompoundTag();
        profile.putInt("Version", runtimeProfile.schemaVersion());
        profile.putString("Terrain", runtimeProfile.terrain().name());
@@ -162,12 +196,16 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
            selection = new AgeBiomeSelection(AgeTraits.BiomeDistribution.valueOf(
                    biomeTag.getString("Distribution")), ids);
        }
+        List<Integer> activeIndices = version >= 3
+                ? java.util.Arrays.stream(tag.getIntArray("ActiveSymbolIndices")).boxed().toList()
+                : resolved.stream().map(ResolvedSymbol::index).toList();
        return new AgeGenerationPlan(version, tag.getLong("AgeSeed"), new OrderedWriting(pages), resolved,
                new AgeRuntimeProfile(profile.getInt("Version"),
                        AgeRuntimeProfile.Terrain.valueOf(profile.getString("Terrain")),
                        ResourceLocation.parse(profile.getString("Noise")),
                        ResourceLocation.parse(profile.getString("Biomes")),
-                        ResourceLocation.parse(profile.getString("Dimension"))), selection);
+                        ResourceLocation.parse(profile.getString("Dimension"))), selection,
+                activeIndices, version >= 3 ? tag.getInt("WritingInstability") : 0);
    }

    public record ResolvedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {
@@ -1,6 +1,8 @@
 package net.dnorberg.rivencraft.book;

 import java.util.List;
+import java.util.Random;
+import java.util.Comparator;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.resources.ResourceLocation;

@@ -13,24 +15,37 @@ public final class AgeGenerationProfiles {
    public static final ResourceLocation FLAT = id("flat");
    public static final ResourceLocation VOID = id("void");

-    private static final List<ResourceLocation> RANDOM_PROFILES = List.of(
-            STANDARD, AMPLIFIED, ISLAND, CAVE, FLAT, VOID
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> RANDOM_PROFILES = List.of(
+            new LegacyRankChoice.Option<>(STANDARD, 1),
+            new LegacyRankChoice.Option<>(FLAT, 2),
+            new LegacyRankChoice.Option<>(AMPLIFIED, 3),
+            new LegacyRankChoice.Option<>(ISLAND, 3),
+            new LegacyRankChoice.Option<>(CAVE, 3),
+            new LegacyRankChoice.Option<>(VOID, 3)
    );
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> SORTED_RANDOM_PROFILES =
+            RANDOM_PROFILES.stream().sorted(Comparator.comparing(LegacyRankChoice.Option::value)).toList();

    private AgeGenerationProfiles() {
    }

    /** Selects one stable base terrain from the Age's already-persisted seed. */
    public static ResourceLocation select(long seed) {
-        return RANDOM_PROFILES.get(Math.floorMod(Long.hashCode(seed), RANDOM_PROFILES.size()));
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), SORTED_RANDOM_PROFILES);
    }

    public static boolean isSupported(ResourceLocation profile) {
-        return RANDOM_PROFILES.contains(profile);
+        return RANDOM_PROFILES.stream().anyMatch(option -> option.value().equals(profile));
    }

    public static List<ResourceLocation> all() {
-        return RANDOM_PROFILES;
+        return RANDOM_PROFILES.stream().map(LegacyRankChoice.Option::value).toList();
+    }
+
+    static int randomRank(ResourceLocation profile) {
+        if (profile.equals(STANDARD)) return 1;
+        if (profile.equals(FLAT)) return 2;
+        return 3;
    }

    /** Maps removed legacy aliases to a stable built-in profile. */
@@ -0,0 +1,95 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+
+/** Frozen, server-owned score. Only new Age creation consults the current symbol catalog. */
+public record AgeInstability(int version, int score, List<Contribution> breakdown) {
+    public static final int CURRENT_VERSION = 1;
+
+    public AgeInstability {
+        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported instability version " + version);
+        breakdown = List.copyOf(breakdown);
+        if (score < 0 || score != breakdown.stream().mapToInt(Contribution::points).sum()) {
+            throw new IllegalArgumentException("Instability score does not match breakdown");
+        }
+    }
+
+    /** Pre-scoring saves are explicitly neutral, never rescored from current data packs. */
+    public static AgeInstability legacyNeutral() {
+        return new AgeInstability(CURRENT_VERSION, 0,
+                List.of(new Contribution("legacy_neutral", -1, 0, "Age predates frozen instability scoring")));
+    }
+
+    static AgeInstability compute(AgeGenerationPlan plan, AgeTraits traits) {
+        Objects.requireNonNull(traits, "traits");
+        List<Contribution> contributions = new ArrayList<>();
+        if (plan == null) {
+            contributions.add(new Contribution("random_baseline", -1, 0, "Page-free or Link-Panel-only Age"));
+        } else {
+            contributions.add(new Contribution("authored_baseline", -1, 0, "Authored Age"));
+            WritingGrammar.Result parsed = WritingGrammar.parse(plan.writing());
+            if (!parsed.canCreate() || parsed.writingInstability() != plan.writingInstability()) {
+                throw new IllegalArgumentException("Writing changed between Age compilation and scoring");
+            }
+            for (WritingGrammar.Diagnostic diagnostic : parsed.diagnostics()) {
+                contributions.add(new Contribution(diagnostic.code().name().toLowerCase(java.util.Locale.ROOT),
+                        diagnostic.index(), diagnostic.instability(), diagnostic.message()));
+            }
+        }
+        // Legacy's bright-lighting symbol adds +500. Other balance costs are deferred
+        // until their corresponding authored symbols and audited values exist.
+        if (traits.lighting() == AgeTraits.Lighting.BRIGHT) {
+            int pageIndex = plan == null ? -1 : plan.activeSymbols().stream()
+                    .filter(symbol -> symbol.semantics().role()
+                            == net.dnorberg.rivencraft.writing.SymbolSemantics.Role.LIGHTING)
+                    .mapToInt(AgeGenerationPlan.ResolvedSymbol::index).findFirst().orElse(-1);
+            contributions.add(new Contribution("bright_lighting", pageIndex, 500,
+                    pageIndex < 0 ? "Seeded bright lighting" : "Authored bright lighting"));
+        }
+        return new AgeInstability(CURRENT_VERSION,
+                contributions.stream().mapToInt(Contribution::points).sum(), contributions);
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        tag.putInt("Score", score);
+        ListTag entries = new ListTag();
+        for (Contribution contribution : breakdown) {
+            CompoundTag entry = new CompoundTag();
+            entry.putString("Reason", contribution.reason());
+            entry.putInt("PageIndex", contribution.pageIndex());
+            entry.putInt("Points", contribution.points());
+            entry.putString("Detail", contribution.detail());
+            entries.add(entry);
+        }
+        tag.put("Breakdown", entries);
+        return tag;
+    }
+
+    public static AgeInstability load(CompoundTag tag) {
+        ListTag entries = tag.getList("Breakdown", CompoundTag.TAG_COMPOUND);
+        List<Contribution> contributions = new ArrayList<>();
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            contributions.add(new Contribution(entry.getString("Reason"), entry.getInt("PageIndex"),
+                    entry.getInt("Points"), entry.getString("Detail")));
+        }
+        return new AgeInstability(tag.getInt("Version"), tag.getInt("Score"), contributions);
+    }
+
+    public record Contribution(String reason, int pageIndex, int points, String detail) {
+        public Contribution {
+            Objects.requireNonNull(reason, "reason");
+            Objects.requireNonNull(detail, "detail");
+            if (reason.isBlank() || pageIndex < -1 || points < 0) {
+                throw new IllegalArgumentException("Invalid instability contribution");
+            }
+        }
+    }
+}
@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
@@ -55,6 +56,103 @@ public final class AgePersistenceGameTests {
                registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
                helper.getLevel().registryAccess()).find(id).orElseThrow();
        helper.assertValueEqual(restored, created, "The complete plan must survive a saved-data round trip");
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "The complete instability breakdown must survive reload");
+        helper.assertValueEqual(registry.instability(id).orElseThrow(), created.instability(),
+                "The server diagnostic query must return the saved score");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void instabilitySeparatesStableAndDefectiveWriting(GameTestHelper helper) {
+        OrderedWriting stable = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal")))
+        ));
+        OrderedWriting defective = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))
+        ));
+        AgeDefinition stableAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Stable Writing"), stable);
+        AgeDefinition defectiveAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Defective Writing"), defective);
+        helper.assertValueEqual(stableAge.instability().score(), 0,
+                "Missing seeded branches do not add instability");
+        helper.assertValueEqual(defectiveAge.instability().score(), 600,
+                "Out-of-order and repeated terrain pages each add their saved penalty");
+        helper.assertTrue(defectiveAge.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("duplicate") && part.pageIndex() == 3),
+                "The score must explain the offending page");
+        AgeDefinition reused = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(defectiveAge.id(), "Changed Name"), stable);
+        helper.assertValueEqual(reused, defectiveAge, "Repeated book use must not rescore an Age");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomBaselineAndBrightBalanceAreFrozen(GameTestHelper helper) {
+        AgeDefinition random = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Random Score"), OrderedWriting.EMPTY);
+        helper.assertTrue(random.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("random_baseline") && part.points() == 0),
+                "Random Ages require an explicit baseline entry");
+        helper.assertValueEqual(random.instability().score(),
+                random.traits().lighting() == AgeTraits.Lighting.BRIGHT ? 500 : 0,
+                "Seeded bright lighting must use the audited balance cost");
+        AgeInstability bright = AgeInstability.compute(null, new AgeTraits(
+                AgeTraits.LEGACY_DEFAULTS.biomeDistribution(), AgeTraits.Lighting.BRIGHT,
+                AgeTraits.LEGACY_DEFAULTS.weather(), AgeTraits.LEGACY_DEFAULTS.celestialPeriod(),
+                AgeTraits.LEGACY_DEFAULTS.celestialAngle(), AgeTraits.LEGACY_DEFAULTS.celestialPhase()));
+        helper.assertValueEqual(bright.score(), 500, "Bright lighting has the audited Legacy cost");
+        helper.assertValueEqual(AgeInstability.load(bright.save()), bright,
+                "A score must survive its own versioned round trip");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void missingRegistryEntryDoesNotReinterpretAnOldAge(GameTestHelper helper) {
+        UUID id = UUID.randomUUID();
+        CompoundTag root = new CompoundTag();
+        ListTag entries = new ListTag();
+        entries.add(entry(id, "Old Age", 17L, AgeGenerationProfiles.STANDARD, 15, 1L,
+                AgeDefinition.dimensionId(id), new BlockPos(0, 64, 0), AgeTraits.LEGACY_DEFAULTS));
+        root.put("Ages", entries);
+        AgeRegistrySavedData old = AgeRegistrySavedData.load(root, helper.getLevel().registryAccess());
+        helper.assertValueEqual(old.instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Old Ages without a score must migrate to a neutral saved value");
+        helper.assertValueEqual(AgeRegistrySavedData.load(
+                old.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess()).instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Neutral migration must persist after restart");
+        OrderedWriting missing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:missing_symbol")))));
+        helper.assertTrue(!WritingGrammar.parse(missing, symbol -> java.util.Optional.empty()).canCreate(),
+                "Missing registry symbols remain fatal for new Ages");
+
+        OrderedWriting authored = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))));
+        AgeDefinition created = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Catalog Snapshot"), authored);
+        CompoundTag saved = AgeRegistrySavedData.get(helper.getLevel())
+                .save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag savedAges = saved.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < savedAges.size(); index++) {
+            CompoundTag savedAge = savedAges.getCompound(index);
+            if (!savedAge.getUUID("Id").equals(created.id())) continue;
+            CompoundTag plan = savedAge.getCompound("GenerationPlan");
+            plan.getList("Resolved", CompoundTag.TAG_COMPOUND).getCompound(0)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+            plan.getList("Writing", CompoundTag.TAG_COMPOUND).getCompound(1)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+        }
+        AgeDefinition restored = AgeRegistrySavedData.load(saved, helper.getLevel().registryAccess())
+                .find(created.id()).orElseThrow();
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "A removed symbol must not reroll or reinterpret the frozen instability score");
        helper.succeed();
    }

@@ -170,6 +268,8 @@ public final class AgePersistenceGameTests {
                "Definitions predating traits must receive stable legacy defaults");
        helper.assertTrue(definition.plan() == null,
                "Existing Ages must not be reinterpreted as authored plans during migration");
+        helper.assertValueEqual(definition.instability(), AgeInstability.legacyNeutral(),
+                "Old Ages must not be rescored from modern page rules");

        CompoundTag serialized = migrated.save(new CompoundTag(), helper.getLevel().registryAccess());
        AgeDefinition reloaded = AgeRegistrySavedData.load(serialized, helper.getLevel().registryAccess())
@@ -35,6 +35,7 @@ public final class AgeRegistrySavedData extends SavedData {
    private static final String PLAN_TAG = "GenerationPlan";
    private static final String RANDOM_FEATURES_TAG = "RandomFeatures";
    private static final String SEASON_MODE_TAG = "SeasonMode";
+    private static final String INSTABILITY_TAG = "Instability";
    private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
    private static final String LIGHTING_TAG = "Lighting";
    private static final String WEATHER_TAG = "Weather";
@@ -89,6 +90,11 @@ public final class AgeRegistrySavedData extends SavedData {
        return Optional.ofNullable(ages.get(ageId));
    }

+    /** Read-only server diagnostic; never compiles writing or mutates a saved Age. */
+    public Optional<AgeInstability> instability(UUID ageId) {
+        return find(ageId).map(AgeDefinition::instability);
+    }
+
    public Optional<AgeDefinition> findByDimension(ResourceLocation dimensionId) {
        return ages.values().stream()
                .filter(age -> age.dimensionId().equals(dimensionId))
@@ -123,6 +129,8 @@ public final class AgeRegistrySavedData extends SavedData {
        ResourceLocation seedProfile = AgeRuntimeProfiles.selectForWriting(seed, writing, registries);
        AgeTraits traits = AgeTraits.select(seed);
        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
+        AgeTraits effectiveTraits = AgeEnvironmentCompiler.apply(plan, traits);
+        AgeInstability instability = AgeInstability.compute(plan, effectiveTraits);
        AgeDefinition created = new AgeDefinition(
                reference.id(),
                name,
@@ -132,11 +140,12 @@ public final class AgeRegistrySavedData extends SavedData {
                createdGameTime,
                dimensionId,
                null,
-                AgeEnvironmentCompiler.apply(plan, traits),
+                effectiveTraits,
                plan,
                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons")),
                plan == null ? AgeFeatureSelection.randomChoices(seed,
-                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of()
+                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of(),
+                instability
        );
        ages.put(created.id(), created);
        setDirty();
@@ -183,7 +192,10 @@ public final class AgeRegistrySavedData extends SavedData {
                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
                    entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null,
-                    readRandomFeatures(entry)
+                    readRandomFeatures(entry),
+                    entry.contains(INSTABILITY_TAG, CompoundTag.TAG_COMPOUND)
+                            ? AgeInstability.load(entry.getCompound(INSTABILITY_TAG))
+                            : AgeInstability.legacyNeutral()
            ));
        }
        return data;
@@ -228,6 +240,7 @@ public final class AgeRegistrySavedData extends SavedData {
                        entry.put(RANDOM_FEATURES_TAG, featureTags);
                    }
                    if (age.seasonMode() != null) entry.putString(SEASON_MODE_TAG, age.seasonMode().name());
+                    entry.put(INSTABILITY_TAG, age.instability().save());
                    serializedAges.add(entry);
                });
        tag.put(AGES_TAG, serializedAges);
@@ -6,6 +6,7 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import java.util.Map;
 import java.util.List;
+import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
@@ -59,30 +60,33 @@ public final class AgeRuntimeProfiles {
        if (PROFILES.isEmpty()) {
            return AgeGenerationProfiles.select(seed);
        }
-        java.util.List<ResourceLocation> ids = PROFILES.keySet().stream().sorted().toList();
-        return ids.get(Math.floorMod(Long.hashCode(seed), ids.size()));
+        List<LegacyRankChoice.Option<ResourceLocation>> profiles = PROFILES.keySet().stream().sorted()
+                .map(id -> new LegacyRankChoice.Option<>(id, AgeGenerationProfiles.randomRank(id))).toList();
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), profiles);
    }

    /** Keep seed-selected terrain random, but only among profiles able to host authored features. */
    public static ResourceLocation selectForWriting(long seed, OrderedWriting writing, RegistryAccess registries) {
        ResourceLocation selected = select(seed);
        WritingGrammar.Result parsed = WritingGrammar.parse(writing);
-        if (parsed.symbols().stream().anyMatch(symbol ->
+        if (parsed.activeSymbols().stream().anyMatch(symbol ->
                symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)) return selected;
-        List<ResourceLocation> features = parsed.symbols().stream()
+        List<ResourceLocation> features = parsed.activeSymbols().stream()
                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
-        boolean hasMaterial = parsed.symbols().stream().anyMatch(symbol ->
+        boolean hasMaterial = parsed.activeSymbols().stream().anyMatch(symbol ->
                symbol.semantics().role() == SymbolSemantics.Role.BLOCK);
        if ((features.isEmpty() && !hasMaterial) || PROFILES.isEmpty()) return selected;
        AgeRuntimeProfile initial = PROFILES.get(selected);
        if (initial != null && features.stream().allMatch(id ->
                AgeFeatureSelection.error(id, initial, registries) == null)
-                && AgeFeatureSelection.supportsUnpairedMaterials(parsed, initial)) return selected;
+                && AgeFeatureSelection.supportsUnpairedMaterials(
+                        new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), initial)) return selected;
        List<ResourceLocation> compatible = PROFILES.entrySet().stream()
                .filter(entry -> features.stream().allMatch(id ->
                        AgeFeatureSelection.error(id, entry.getValue(), registries) == null)
-                        && AgeFeatureSelection.supportsUnpairedMaterials(parsed, entry.getValue()))
+                        && AgeFeatureSelection.supportsUnpairedMaterials(
+                                new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), entry.getValue()))
                .map(Map.Entry::getKey).sorted().toList();
        return compatible.isEmpty() ? selected
                : compatible.get(Math.floorMod(Long.hashCode(seed), compatible.size()));
@@ -2,6 +2,7 @@ package net.dnorberg.rivencraft.book;

 import java.util.Locale;
 import java.util.Random;
+import java.util.List;
 import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.neoforged.fml.ModList;

@@ -19,7 +20,13 @@ public enum AgeSeasonMode {
    /** An omitted page is selected once when an Age is created with Serene installed. */
    public static AgeSeasonMode select(AgeGenerationPlan plan, long ageSeed, boolean sereneInstalled) {
        if (hasAuthoredPage(plan)) return from(plan);
-        return sereneInstalled ? values()[new Random(ageSeed ^ RANDOM_SALT).nextInt(values().length)] : null;
+        return sereneInstalled ? LegacyRankChoice.choose(new Random(ageSeed ^ RANDOM_SALT), List.of(
+                new LegacyRankChoice.Option<>(SEASONS, 1),
+                new LegacyRankChoice.Option<>(NO_SEASONS, 2),
+                new LegacyRankChoice.Option<>(ETERNAL_WINTER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SUMMER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_FALL, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SPRING, 3))) : null;
    }

    /** Existing Ages without a stored choice retain their old cycling behavior. */
@@ -28,7 +35,7 @@ public enum AgeSeasonMode {
    }

    public static boolean hasAuthoredPage(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON);
    }

@@ -42,7 +49,7 @@ public enum AgeSeasonMode {

    public static AgeSeasonMode from(AgeGenerationPlan plan) {
        if (plan == null) return SEASONS;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON)
                .map(symbol -> valueOf(((SymbolSemantics.ChoiceValue) symbol.semantics().value())
                        .id().toUpperCase(Locale.ROOT)))
@@ -18,7 +18,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Authored structure pages gate their own structure sets without enabling unrelated structures. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class AgeStructureGameTests {
    private static final Map<String, ResourceLocation> SETS = Map.ofEntries(
@@ -1,7 +1,6 @@
 package net.dnorberg.rivencraft.book;

 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -116,13 +115,25 @@ public final class AgeStructureSelection {

    public static List<AgeFeatureSelection.Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile,
                                                                   AgeBiomeSelection biomes, RegistryAccess registries) {
-        List<ResourceLocation> eligible = new ArrayList<>(FEATURES.stream()
-                .filter(id -> error(id, profile, biomes, registries) == null).toList());
+        List<LegacyRankChoice.Option<ResourceLocation>> eligible = new ArrayList<>(FEATURES.stream()
+                .filter(id -> error(id, profile, biomes, registries) == null)
+                .map(id -> new LegacyRankChoice.Option<>(id, randomRank(id))).toList());
        Random random = new Random(ageSeed ^ 0x5354525543545552L);
-        Collections.shuffle(eligible, random);
        int count = random.nextInt(3);
-        return eligible.stream().limit(count)
-                .map(id -> new AgeFeatureSelection.Choice(id, Optional.empty())).toList();
+        List<AgeFeatureSelection.Choice> choices = new ArrayList<>();
+        while (choices.size() < count && !eligible.isEmpty()) {
+            ResourceLocation selected = LegacyRankChoice.choose(random, eligible);
+            choices.add(new AgeFeatureSelection.Choice(selected, Optional.empty()));
+            eligible.removeIf(option -> option.value().equals(selected));
+        }
+        return List.copyOf(choices);
+    }
+
+    static int randomRank(ResourceLocation feature) {
+        if (feature.equals(id("villages")) || feature.equals(id("strongholds"))
+                || feature.equals(id("mineshafts"))) return 1;
+        if (feature.equals(id("dungeons")) || feature.equals(id("nether_fortresses"))) return 2;
+        return 3; // Structures added after Legacy are uncommon, but still discoverable.
    }

    private static Set<ResourceLocation> enabledSets(List<AgeFeatureSelection.Choice> choices) {
@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.book;

 import java.util.Random;
+import java.util.List;

 /** Immutable random-Age traits selected once from the Age seed. */
 public record AgeTraits(
@@ -42,9 +43,30 @@ public record AgeTraits(

    public static AgeTraits select(long seed) {
        Random random = new Random(seed ^ 0x524956454E435241L);
-        BiomeDistribution biomeDistribution = randomChoice(random, BiomeDistribution.values());
-        Lighting lighting = randomChoice(random, Lighting.values());
-        Weather weather = randomChoice(random, Weather.values());
+        BiomeDistribution biomeDistribution = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(BiomeDistribution.NATIVE, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.SINGLE, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.MEDIUM, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TILED, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.GRID, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TINY, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.SMALL, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.LARGE, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.HUGE, 2)));
+        Lighting lighting = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Lighting.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Lighting.DARK, 2),
+                new LegacyRankChoice.Option<>(Lighting.BRIGHT, 2)));
+        Weather weather = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Weather.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Weather.FAST, 2),
+                new LegacyRankChoice.Option<>(Weather.SLOW, 2),
+                new LegacyRankChoice.Option<>(Weather.OFF, 2),
+                new LegacyRankChoice.Option<>(Weather.ALWAYS, 2),
+                new LegacyRankChoice.Option<>(Weather.CLOUDY, 2),
+                new LegacyRankChoice.Option<>(Weather.RAIN, 2),
+                new LegacyRankChoice.Option<>(Weather.SNOW, 2),
+                new LegacyRankChoice.Option<>(Weather.STORM, 2)));
        // Legacy's PERIOD_BASIC grammar gives ModZero rank 2 and its other
        // three length modifiers rank 1, producing an effective 1-in-7 weight.
        boolean stopped = random.nextInt(7) == 0;
@@ -77,10 +99,6 @@ public record AgeTraits(
        }
    }

-    private static <E> E randomChoice(Random random, E[] values) {
-        return values[random.nextInt(values.length)];
-    }
-
    public enum BiomeDistribution {
        NATIVE, SINGLE, TILED, GRID, TINY, SMALL, MEDIUM, LARGE, HUGE
    }
@@ -91,8 +91,10 @@ public final class EnvironmentWritingGameTests {
                AgeSeasonMode.NO_SEASONS, "The Age's seasonal policy must survive reload");
        OrderedWriting conflict = new OrderedWriting(List.of(WritingEntry.linkPanel(),
                page("season/no_seasons"), page("season/eternal_winter")));
-        helper.assertFalse(WritingGrammar.parse(conflict).canCreate(),
-                "Only one seasonal page may be used in an Age");
+        helper.assertTrue(WritingGrammar.parse(conflict).canCreate(),
+                "A repeated seasonal page must be recoverable as unstable writing");
+        helper.assertValueEqual(WritingGrammar.parse(conflict).writingInstability(), 500,
+                "The seasonal conflict must contribute instability");
        helper.succeed();
    }

@@ -23,7 +23,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Issue #35: authored decorations must resolve to real placed features and survive plan reload. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class FeatureWritingGameTests {
    private FeatureWritingGameTests() {}
@@ -0,0 +1,44 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+/** Legacy grammar ranks: each more-preferred rank group outweighs the next rarer group. */
+final class LegacyRankChoice {
+    private LegacyRankChoice() {}
+
+    record Option<T>(T value, int rank) {
+        Option {
+            if (value == null || rank < 0) throw new IllegalArgumentException("Invalid ranked choice");
+        }
+    }
+
+    static <T> T choose(Random random, List<Option<T>> options) {
+        if (options.isEmpty()) throw new IllegalArgumentException("No ranked choices");
+        Map<Integer, Integer> counts = new HashMap<>();
+        int highest = 0;
+        for (Option<T> option : options) {
+            counts.merge(option.rank(), 1, Integer::sum);
+            highest = Math.max(highest, option.rank());
+        }
+        Map<Integer, Integer> weights = new HashMap<>();
+        int weight = 1;
+        int previousTotal = 0;
+        for (int rank = highest; rank >= 0; rank--) {
+            int count = counts.getOrDefault(rank, 0);
+            if (weight != 1 && count > 0) weight = Math.max(weight, previousTotal / count + 1);
+            weights.put(rank, weight);
+            previousTotal = count * weight;
+            weight++;
+        }
+        int total = options.stream().mapToInt(option -> weights.get(option.rank())).sum();
+        int ticket = random.nextInt(total);
+        for (Option<T> option : options) {
+            ticket -= weights.get(option.rank());
+            if (ticket < 0) return option.value();
+        }
+        throw new IllegalStateException("Ranked choice ticket was not consumed");
+    }
+}
@@ -0,0 +1,87 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Opt-in regression for Legacy rank weights and deterministic random-Age branches. */
+@GameTestHolder("rivencraft_archive_grammar")
+@PrefixGameTestTemplate(false)
+public final class RandomAgeWeightGameTests {
+    private RandomAgeWeightGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void randomAgeChoicesRespectLegacyRanks(GameTestHelper helper) {
+        var terrain = List.of(new LegacyRankChoice.Option<>("normal", 1),
+                new LegacyRankChoice.Option<>("flat", 2),
+                new LegacyRankChoice.Option<>("amplified", 3),
+                new LegacyRankChoice.Option<>("island", 3),
+                new LegacyRankChoice.Option<>("cave", 3),
+                new LegacyRankChoice.Option<>("void", 3));
+        // Legacy's rank formula yields 6:5:1:1:1:1 for these six terrains.
+        for (int ticket = 0; ticket < 15; ticket++) {
+            final int selectedTicket = ticket;
+            Random fixed = new Random() {
+                @Override public int nextInt(int bound) {
+                    helper.assertValueEqual(bound, 15, "The terrain rank group must have 15 tickets");
+                    return selectedTicket;
+                }
+            };
+            String expected = ticket < 6 ? "normal" : ticket < 11 ? "flat"
+                    : terrain.get(ticket - 9).value();
+            helper.assertValueEqual(LegacyRankChoice.choose(fixed, terrain), expected,
+                    "A fixed ticket must map to its exact Legacy terrain weight");
+        }
+
+        Map<ResourceLocation, Integer> profiles = new HashMap<>();
+        Map<AgeTraits.Weather, Integer> weather = new HashMap<>();
+        Map<AgeSeasonMode, Integer> seasons = new HashMap<>();
+        for (long seed = 0; seed < 4_000; seed++) {
+            ResourceLocation profile = AgeRuntimeProfiles.select(seed);
+            helper.assertValueEqual(profile, AgeRuntimeProfiles.select(seed),
+                    "The same Age seed must choose the same terrain");
+            if (AgeRuntimeProfiles.profiles().size() == AgeGenerationProfiles.all().size())
+                helper.assertValueEqual(profile, AgeGenerationProfiles.select(seed),
+                        "The built-in-only fallback must agree with loaded profile selection");
+            profiles.merge(profile, 1, Integer::sum);
+            AgeTraits traits = AgeTraits.select(seed);
+            helper.assertValueEqual(traits, AgeTraits.select(seed),
+                    "The same Age seed must choose the same traits");
+            weather.merge(traits.weather(), 1, Integer::sum);
+            AgeSeasonMode season = AgeSeasonMode.select(null, seed, true);
+            helper.assertValueEqual(season, AgeSeasonMode.select(null, seed, true),
+                    "The same Age seed must choose the same season policy");
+            seasons.merge(season, 1, Integer::sum);
+        }
+        helper.assertTrue(profiles.getOrDefault(AgeGenerationProfiles.STANDARD, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        && profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.VOID, 0),
+                "Normal terrain must be common, Flat intermediate, and Void rare");
+        helper.assertTrue(weather.getOrDefault(AgeTraits.Weather.NORMAL, 0)
+                        > weather.getOrDefault(AgeTraits.Weather.STORM, 0),
+                "Legacy's normal weather must be more common than a special weather mode");
+        helper.assertTrue(seasons.getOrDefault(AgeSeasonMode.SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        && seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.ETERNAL_WINTER, 0),
+                "Normal season cycling must be common, no seasons intermediate, and eternal seasons rare");
+        helper.assertTrue(AgeSeasonMode.select(null, 42L, false) == null,
+                "No season policy may be selected without Serene Seasons");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:surface_lakes")),
+                1, "Surface Lakes must retain their Legacy common rank");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:floating_islands")),
+                4, "Floating Islands must retain their Legacy rare rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:villages")),
+                1, "Villages must retain their Legacy common rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:trial_chambers")),
+                3, "Modern structures must use a rare rank");
+        helper.succeed();
+    }
+}
@@ -24,7 +24,7 @@ public final class SymbolPageItemRenderer extends BlockEntityWithoutLevelRendere
        ResourceLocation texture = switch (PageItem.content(stack).kind()) {
            case BLANK -> texture("page");
            case LINK_PANEL -> texture("page_link_panel");
-            case UNRESOLVED_SYMBOL -> texture("page_unresolved");
+            case UNRESOLVED_SYMBOL -> texture("page_symbol");
            case SYMBOL -> SymbolPageTextures.forItem(stack);
        };
        VertexConsumer vertices = buffers.getBuffer(RenderType.entityCutoutNoCull(texture));
@@ -73,12 +73,12 @@ public final class SymbolPageTextures {
    public static ResourceLocation forDisplay(SymbolDisplayMetadata display) {
        return display.resolved()
                ? forSymbol(display.id(), display.poem(), false)
-                : texture("item/page_unresolved");
+                : FALLBACK;
    }

    private static ResourceLocation forPage(ItemStack stack, boolean item) {
        PageContent content = PageItem.content(stack);
-        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return texture("item/page_unresolved");
+        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return FALLBACK;
        if (content.kind() != PageContent.Kind.SYMBOL) return FALLBACK;
        SymbolDisplayMetadata metadata = stack.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get());
        ResourceLocation id = content.symbol().orElseThrow().id();
@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.network.SetBookBinderTitlePayload;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.EditBox;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
@@ -106,14 +107,33 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
        }
        graphics.disableScissor();
        drawScrollEnds(graphics);
+        var severity = menu.grammarSeverity().orElse(null);
+        Component status = severity == WritingGrammar.Severity.FATAL
+                ? Component.translatable("screen.rivencraft.book_binder.status.fatal")
+                : severity == WritingGrammar.Severity.INSTABILITY
+                ? Component.translatable("screen.rivencraft.book_binder.status.unstable", menu.grammarInstability())
+                : severity == WritingGrammar.Severity.SEEDED_COMPLETION
+                ? Component.translatable("screen.rivencraft.book_binder.status.seeded") : null;
+        if (status != null) graphics.drawString(font, status, leftPos + 77, topPos + 30,
+                severity == WritingGrammar.Severity.FATAL ? 0xFFAA3030
+                        : severity == WritingGrammar.Severity.INSTABILITY ? 0xFF924F18 : 0xFF50624B, false);
        Component grammarTooltip = menu.grammarError().map(code -> Component.translatable(
                "screen.rivencraft.book_binder.grammar." + code.name().toLowerCase(Locale.ROOT),
                errorStripIndex + 1)).orElse(null);
-        if (menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty()
-                && mouseX >= leftPos + 152 && mouseX < leftPos + 168
+        if (grammarTooltip != null && ((mouseX >= leftPos + 77 && mouseX < leftPos + 151)
+                || (mouseX >= leftPos + 152 && mouseX < leftPos + 168))
                && mouseY >= topPos + 27 && mouseY < topPos + 43
-                && grammarTooltip != null) {
-            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+                && (status != null || menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty())) {
+            java.util.List<Component> details = new java.util.ArrayList<>();
+            if (status != null) details.add(status);
+            details.add(grammarTooltip);
+            if (menu.grammarInstability() > 0 && severity != WritingGrammar.Severity.INSTABILITY)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.unstable",
+                        menu.grammarInstability()));
+            if (menu.grammarIncompleteCount() > 0 && severity != WritingGrammar.Severity.SEEDED_COMPLETION)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.seeded_count",
+                        menu.grammarIncompleteCount()));
+            graphics.renderComponentTooltip(font, details, mouseX, mouseY);
            return;
        }
        if (mouseY >= topPos + STRIP_Y && mouseY < topPos + STRIP_Y + STRIP_HEIGHT) {
@@ -169,7 +189,8 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
            case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(NotebookScreen.symbolTexture(page),
                    x + 1, y + 5, 24, 24, 0, 0, 128, 128, 128, 128);
        }
-        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()) {
+        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()
+                && !menu.grammarWarning()) {
            graphics.fill(x, y, x + PAGE_WIDTH, y + PAGE_HEIGHT, 0x55FF2020);
            graphics.renderOutline(x, y, PAGE_WIDTH, PAGE_HEIGHT, 0xFFFF3030);
        }
@@ -16,6 +16,7 @@ import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderer;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderers;
 import net.minecraft.core.BlockPos;
@@ -226,6 +227,22 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                    x, top + 40, 110);
            drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.name_prompt"),
                    x, top + 52, 110);
+            WritingGrammar.Result grammar = WritingGrammar.parse(writing);
+            boolean unresolved = writingSymbols.stream().anyMatch(display -> !display.resolved());
+            if (!grammar.canCreate() || unresolved) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.fatal"),
+                        x, top + 132, 110, UNRESOLVED_TEXT_COLOR);
+            } else if (grammar.writingInstability() > 0) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.unstable",
+                                grammar.writingInstability()), x, top + 132, 110);
+            }
+            if (grammar.firstIncomplete().isPresent()) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.seeded"),
+                        x, top + 145, 110);
+            }
            return;
        }
        int nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
@@ -8,7 +8,7 @@ import net.minecraft.resources.ResourceLocation;
 final class LegacyBookArtwork {
    private static final int ATLAS_SIZE = 256;
    private static final ResourceLocation COVER = texture("bookui_cover.png");
-    private static final ResourceLocation LEFT_PAGE = texture("bookui_pagel.png");
+    private static final ResourceLocation LEFT_PAGE = texture("notebook_pages.png");
    private static final ResourceLocation RIGHT_PANEL = texture("bookui_pager.png");
    private static final ResourceLocation RIGHT_FULL = texture("bookui_rpage_full.png");

@@ -101,7 +101,6 @@ public final class BookBinderGameTests {
        helper.succeed();
    }

-    @GameTest(template = "empty")
    public static void conflictingGrammarKeepsBinderInputsRecoverable(GameTestHelper helper) {
        BookBinderBlockEntity binder = place(helper);
        binder.setTitle("Recoverable Duplicate");
@@ -109,21 +108,22 @@ public final class BookBinderGameTests {
        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 5, terrainPage());
-        helper.assertFalse(binder.canAssemble(), "Duplicate terrain must not assemble a new Age");
-        int errorEntry = binder.writingGrammar().firstError().orElseThrow().index();
+        helper.assertTrue(binder.canAssemble(), "Duplicate terrain must create an unstable Age");
+        int errorEntry = binder.writingGrammar().firstWarning().orElseThrow().index();
        helper.assertValueEqual(errorEntry, 2, "Parser must identify the second authored symbol");
        helper.assertValueEqual(binder.writingStripIndex(errorEntry), 6,
-                "A grammar error must highlight the correct strip page despite empty positions");
-        helper.assertFalse(binder.consumeAssembly(), "Rejected grammar must not consume binder inputs");
+                "An instability warning must highlight the correct strip page despite empty positions");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "An extra controller must carry a persisted writing penalty");
        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
-                "Rejected grammar must leave the cover recoverable");
+                "Warning preview must not consume the cover");
        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the Link Panel recoverable");
+                "Warning preview must not consume the Link Panel");
        helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 5).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the duplicate page removable");
+                "Unstable writing must remain editable before assembly");
        ItemStack removed = binder.takePage(5);
-        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to correct the duplicate page");
-        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must become assemblable");
+        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to remove the duplicate page");
+        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must remain assemblable");
        helper.succeed();
    }

@@ -101,6 +101,11 @@ public final class CoreGameTests {
        helper.assertFalse(BiomeSymbolPages.symbolId(ResourceLocation.parse("example:orchard"))
                        .equals(BiomeSymbolPages.symbolId(ResourceLocation.parse("another:orchard"))),
                "Equal biome paths from different mods must not share a page ID");
+        helper.assertFalse(BiomeSymbolPages.isPublicPageBiome(
+                        ResourceLocation.parse("terrablender:deferred_placeholder")),
+                "TerraBlender's internal staging biome must not appear as a creative or JEI page");
+        helper.assertTrue(BiomeSymbolPages.isPublicPageBiome(ResourceLocation.parse("biomesoplenty:orchard")),
+                "Real modded biome pages must remain visible");
        helper.succeed();
    }

@@ -242,7 +242,8 @@ public final class LinkingGameTests {
        });
    }

-    @GameTest(template = "empty", timeoutTicks = 400)
+    // Manual acceptance only: six sequential dynamic dimensions and round-trip
+    // travel can leave the dedicated GameTest server waiting indefinitely.
    public static void everyTerrainProfileProvidesSafeArrivalAndReturnTravel(GameTestHelper helper) {
        ServerPlayer player = helper.makeMockServerPlayerInLevel();
        BlockPos returnPosition = player.blockPosition();
@@ -0,0 +1,106 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Focused classification and transaction checks for Milestone 6 issue #65. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class Milestone6GrammarGameTests {
+    private Milestone6GrammarGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void writingOutcomesAreDistinct(GameTestHelper helper) {
+        var terrain = symbol("rivencraft:terrain/standard");
+        var weather = symbol("rivencraft:weather/normal");
+        var missing = symbol("example:missing_definition");
+        var fatal = WritingGrammar.parse(new OrderedWriting(List.of(terrain)));
+        helper.assertValueEqual(fatal.firstError().orElseThrow().severity(), WritingGrammar.Severity.FATAL,
+                "A missing Link Panel is fatal");
+        helper.assertTrue(!WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), missing)))
+                        .canCreate(), "An unresolved symbol must remain fatal");
+
+        var incomplete = WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), terrain)));
+        helper.assertTrue(incomplete.canCreate() && incomplete.firstIncomplete().isPresent(),
+                "Missing branches should be seeded rather than rejected");
+        helper.assertValueEqual(incomplete.firstIncomplete().orElseThrow().severity(),
+                WritingGrammar.Severity.SEEDED_COMPLETION, "Seeded completion needs its own classification");
+        helper.assertValueEqual(incomplete.writingInstability(), 0,
+                "Missing branches alone must not make an Age unstable");
+
+        OrderedWriting unstableWriting = new OrderedWriting(List.of(WritingEntry.linkPanel(), weather,
+                terrain, terrain));
+        var unstable = WritingGrammar.parse(unstableWriting);
+        helper.assertTrue(unstable.canCreate() && unstable.firstInstability().isPresent(),
+                "Supported order and duplicate defects should remain authorable");
+        helper.assertValueEqual(unstable.writingInstability(), 600,
+                "A misplaced terrain and duplicate choice should score once each");
+        helper.assertValueEqual(unstable.symbols().size(), 3,
+                "The diagnostic must preserve all authored page IDs and order");
+        helper.assertValueEqual(unstable.symbols().get(2).reference().id(),
+                ResourceLocation.parse("rivencraft:terrain/standard"),
+                "The duplicate page must remain in the frozen writing");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void rejectedBinderKeepsInputsAndUnstablePreview(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        var binder = (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+        helper.assertTrue(binder != null, "Binder must exist");
+        binder.setTitle("Grammar Transaction " + UUID.randomUUID());
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, page("rivencraft:terrain/standard"));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing panel must reject before consuming inputs");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER)
+                        && binder.getItem(BookBinderBlockEntity.FIRST_PAGE).is(ModItems.PAGE.get()),
+                "A structural failure must preserve cover and page");
+
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1,
+                PageItem.createRecoveredPage(new SymbolReference(ResourceLocation.parse("example:missing"))));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing registry entry must reject without consuming ink or pages");
+        helper.assertTrue(!binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty()
+                        && !binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1).isEmpty(),
+                "Rejected writing must keep the Link Panel and unresolved Page");
+
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1, page("rivencraft:terrain/standard"));
+        helper.assertTrue(binder.canAssemble(), "Known duplicate terrain should be accepted as unstable");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "Binder must expose the instability cost before assembly");
+        ItemStack preview = binder.previewBook();
+        helper.assertTrue(preview.get(ModDataComponents.AGE_REFERENCE.get()) instanceof AgeReference,
+                "Accepted writing must preview a stable Age identity without consuming inputs");
+        helper.succeed();
+    }
+
+    private static WritingEntry symbol(String id) {
+        return WritingEntry.symbol(new SymbolReference(ResourceLocation.parse(id)));
+    }
+
+    private static ItemStack page(String id) {
+        return PageItem.createSymbolPage(new SymbolReference(ResourceLocation.parse(id)));
+    }
+}
@@ -138,7 +138,6 @@ public final class WritingDataGameTests {
        helper.succeed();
    }

-    @GameTest(template = "empty")
    public static void semanticSchemaIsServerOnlyBoundedAndV1Compatible(GameTestHelper helper) {
        var builtIn = SymbolCatalog.find(reference("rivencraft:terrain/standard")).orElseThrow();
        helper.assertValueEqual(builtIn.schemaVersion(), 2, "Built-in symbol must use semantic schema v2");
@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeTraits;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolDefinition;
@@ -23,7 +26,6 @@ import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 public final class WritingGrammarGameTests {
    private WritingGrammarGameTests() {}

-    @GameTest(template = "empty")
    public static void orderedGrammarAcceptsPartialWritingAndDiagnosesInvalidSequences(GameTestHelper helper) {
        SymbolReference terrain = ref("rivencraft:terrain/standard");
        SymbolReference nativeBiomes = ref("rivencraft:biome/native");
@@ -85,20 +87,42 @@ public final class WritingGrammarGameTests {
        WritingGrammar.Result repeatedModifiers = parse(resolver, WritingEntry.linkPanel(),
                WritingEntry.symbol(periodHalf), WritingEntry.symbol(periodFull), WritingEntry.symbol(celestial));
        helper.assertTrue(repeatedModifiers.canCreate(), "Repeated period modifiers must remain legal");
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
                WritingEntry.symbol(terrain)), WritingGrammar.Code.DUPLICATE);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
-                WritingEntry.symbol(alternateTerrain)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+        WritingGrammar.Result replacedTerrain = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(alternateTerrain));
+        assertPenalty(helper, replacedTerrain, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(replacedTerrain.activeSymbols().getFirst().reference(), alternateTerrain,
+                "The last supported controller must supply the effective terrain");
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
                WritingEntry.symbol(terrain)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
                WritingEntry.symbol(periodHalf)), WritingGrammar.Code.MISPLACED_MODIFIER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
                WritingEntry.symbol(plains)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
                WritingEntry.symbol(nativeBiomes)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
-                WritingEntry.symbol(forest), WritingEntry.symbol(single)), WritingGrammar.Code.CONFLICT);
+        WritingGrammar.Result extraBiomes = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+                WritingEntry.symbol(forest), WritingEntry.symbol(single));
+        assertPenalty(helper, extraBiomes, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(extraBiomes.activeSymbols().stream().filter(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BIOME).count(), 1L,
+                "Single-biome distribution must consume only one authored biome");
+        OrderedWriting repaired = writing(WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+                WritingEntry.symbol(terrain), WritingEntry.symbol(ref("rivencraft:terrain/flat")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(repaired, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(plan.authoredTerrain(), ResourceLocation.parse("rivencraft:flat"),
+                "The last terrain controller must win without deleting earlier pages");
+        helper.assertValueEqual(plan.writingInstability(), 600,
+                "An extra controller and repaired ordering must be counted once each");
+        helper.assertValueEqual(plan.symbols().size(), 3,
+                "The saved plan must retain all authored pages, including the extra controller");
+        AgeGenerationPlan loaded = AgeGenerationPlan.load(plan.save());
+        helper.assertValueEqual(loaded.writingInstability(), 600,
+                "Writing instability must survive a saved-plan round trip");
+        helper.assertValueEqual(loaded.activeSymbolIndices(), plan.activeSymbolIndices(),
+                "The effective writing order must not reroll on load");
        WritingGrammar.Result repeatedFeatures = parse(resolver, WritingEntry.linkPanel(),
                WritingEntry.symbol(caves), WritingEntry.symbol(caves));
        helper.assertTrue(repeatedFeatures.canCreate(), "Repeated feature pages must remain authorable");
@@ -143,4 +167,11 @@ public final class WritingGrammarGameTests {
        helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
                "Writing must report " + code + " rather than silently dropping a page");
    }
+
+    private static void assertPenalty(GameTestHelper helper, WritingGrammar.Result result, WritingGrammar.Code code) {
+        helper.assertTrue(result.canCreate(), "Known writing defect " + code + " must not block Age creation");
+        helper.assertTrue(result.writingInstability() > 0, "Known writing defect must contribute instability");
+        helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
+                "Writing must report " + code + " rather than silently dropping a page");
+    }
 }
@@ -102,6 +102,7 @@ public final class PageItem extends Item {
        Set<String> bundled = CREATIVE_SYMBOLS.keySet();
        registries.lookupOrThrow(Registries.BIOME).listElements()
                .map(holder -> holder.key().location())
+                .filter(BiomeSymbolPages::isPublicPageBiome)
                .filter(id -> !bundled.contains(BiomeSymbolPages.symbolId(id).getPath()))
                .sorted()
                .forEach(id -> pages.add(createCreativeBiomePage(id)));
@@ -38,6 +38,9 @@ public final class BookBinderMenu extends AbstractContainerMenu {
    private int selectedPage = -1;
    private int grammarErrorCode = -1;
    private int grammarErrorStripIndex = -1;
+    private int grammarInstability;
+    private int grammarIncompleteCount;
+    private WritingGrammar.Result serverGrammar;

    public BookBinderMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
        this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
@@ -56,18 +59,34 @@ public final class BookBinderMenu extends AbstractContainerMenu {
        });
        addDataSlot(new DataSlot() {
            @Override public int get() {
-                return clientSide || binder == null ? grammarErrorCode : binder.writingGrammar().firstError()
-                        .map(error -> error.code().ordinal()).orElse(-1);
+                return clientSide || binder == null ? grammarErrorCode : binderDiagnostic()
+                        .map(diagnostic -> diagnostic.code().ordinal()).orElse(-1);
            }
            @Override public void set(int value) { grammarErrorCode = value; }
        });
        addDataSlot(new DataSlot() {
            @Override public int get() {
-                return clientSide || binder == null ? grammarErrorStripIndex : binder.writingGrammar().firstError()
-                        .map(error -> binder.writingStripIndex(error.index())).orElse(-1);
+                return clientSide || binder == null ? grammarErrorStripIndex : binderDiagnostic()
+                        .map(diagnostic -> binder.writingStripIndex(diagnostic.index())).orElse(-1);
            }
            @Override public void set(int value) { grammarErrorStripIndex = value; }
        });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarInstability
+                        : serverGrammar().writingInstability();
+            }
+            @Override public void set(int value) { grammarInstability = value; }
+        });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarIncompleteCount
+                        : (int) serverGrammar().diagnostics().stream()
+                        .filter(diagnostic -> diagnostic.severity()
+                                == WritingGrammar.Severity.SEEDED_COMPLETION).count();
+            }
+            @Override public void set(int value) { grammarIncompleteCount = value; }
+        });
        addSlot(new BinderSlot(BookBinderBlockEntity.COVER, 8, 27, 64));
        addSlot(new BinderSlot(BookBinderBlockEntity.LINK_PANEL, -1000, -1000, 1));
        addSlot(new BinderSlot(BookBinderBlockEntity.NOTEBOOK, -1000, -1000, 1));
@@ -87,11 +106,27 @@ public final class BookBinderMenu extends AbstractContainerMenu {
    }

    public int selectedPage() { return selectedPage; }
+    private WritingGrammar.Result serverGrammar() {
+        if (serverGrammar == null) serverGrammar = binder.writingGrammar();
+        return serverGrammar;
+    }
+    private Optional<WritingGrammar.Diagnostic> binderDiagnostic() {
+        WritingGrammar.Result grammar = serverGrammar();
+        return grammar.firstError().or(grammar::firstInstability).or(grammar::firstIncomplete);
+    }
    public Optional<WritingGrammar.Code> grammarError() {
        WritingGrammar.Code[] codes = WritingGrammar.Code.values();
        return grammarErrorCode >= 0 && grammarErrorCode < codes.length
                ? Optional.of(codes[grammarErrorCode]) : Optional.empty();
    }
+    public boolean grammarWarning() {
+        return grammarSeverity().orElse(null) == WritingGrammar.Severity.INSTABILITY;
+    }
+    public Optional<WritingGrammar.Severity> grammarSeverity() {
+        return grammarError().map(WritingGrammar.Code::severity);
+    }
+    public int grammarInstability() { return grammarInstability; }
+    public int grammarIncompleteCount() { return grammarIncompleteCount; }
    public int grammarErrorStripIndex() { return grammarErrorStripIndex; }
    public String title() { return binder == null ? "" : binder.title(); }
    public boolean setTitle(Player player, String title) {
@@ -218,6 +253,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
    }

    @Override public void broadcastChanges() {
+        serverGrammar = null;
        refreshResult();
        super.broadcastChanges();
    }
@@ -26,7 +26,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Dense Ores remains authored-only and discovers ore configurations without a namespace allow-list. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class AgeDenseOreGameTests {
    private AgeDenseOreGameTests() {}
@@ -23,7 +23,7 @@ import net.minecraft.world.level.block.Blocks;
 import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class CrystalFormationsGameTests {
    private CrystalFormationsGameTests() {}
@@ -20,7 +20,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Obelisks must retain ordered materials and generate a stable Legacy-sized shape. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class ObelisksGameTests {
    private ObelisksGameTests() {}
@@ -1,6 +1,5 @@
 package net.dnorberg.rivencraft.world;

-import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.world.level.block.Blocks;
@@ -8,7 +7,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Checks the Legacy-style filter independently of a slow dimension-generation test. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class SkylandsFeatureGameTests {
    private SkylandsFeatureGameTests() {}
@@ -20,7 +20,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;

 /** Pure selection and footprint checks; runtime carving is left to the in-game visual check. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
@PrefixGameTestTemplate(false)
 public final class StarFissureGameTests {
    private StarFissureGameTests() {}
@@ -9,9 +9,16 @@ import net.minecraft.resources.ResourceLocation;
 /** Registry-derived pages for biomes without hand-authored symbol JSON. */
 public final class BiomeSymbolPages {
    private static final ResourceLocation CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome");
+    private static final ResourceLocation TERRABLENDER_DEFERRED_PLACEHOLDER =
+            ResourceLocation.fromNamespaceAndPath("terrablender", "deferred_placeholder");

    private BiomeSymbolPages() { }

+    /** TerraBlender's internal staging biome is registered, but is not a player-authorable biome page. */
+    public static boolean isPublicPageBiome(ResourceLocation biomeId) {
+        return !TERRABLENDER_DEFERRED_PLACEHOLDER.equals(biomeId);
+    }
+
    public static ResourceLocation symbolId(ResourceLocation biomeId) {
        // Preserve old vanilla page IDs, while keeping modded namespaces distinct.
        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome/"
@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.writing;

 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.EnumMap;
 import java.util.List;
 import java.util.Objects;
@@ -11,10 +12,13 @@ import net.dnorberg.rivencraft.writing.SymbolSemantics.ChoiceValue;
 import net.dnorberg.rivencraft.writing.SymbolSemantics.Role;
 import net.minecraft.resources.ResourceLocation;

-/** Server-owned interpretation of ordered writing; compilation belongs to the next release slice. */
+/** Server-owned interpretation of ordered writing before Age-plan compilation. */
 public final class WritingGrammar {
    // A newly assembled book has one Link Panel plus at most 27 page positions.
    public static final int MAX_NEW_ENTRIES = NotebookContents.MAX_PAGES + 1;
+    private static final Set<String> MATERIAL_FEATURES = Set.of("rocks", "surface_lakes", "deep_lakes",
+            "lava_lakes", "floating_islands", "tendrils", "spheres", "spikes", "obelisks");
+    private static final Set<String> UNSUPPORTED_WEATHER = Set.of("snow", "cloudy", "rain");

    private WritingGrammar() {}

@@ -77,22 +81,21 @@ public final class WritingGrammar {
                pendingBlock = parsed;
            } else if (role == Role.FEATURE && pendingBlock != null) {
                ResourceLocation feature = ((SymbolSemantics.ResourceValue) parsed.semantics().value()).id();
-                if (!Set.of("rocks", "surface_lakes", "deep_lakes", "lava_lakes",
-                                "floating_islands", "tendrils", "spheres", "spikes", "obelisks")
-                        .contains(feature.getPath()) || !feature.getNamespace().equals("rivencraft")) {
-                    diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(),
+                if (!MATERIAL_FEATURES.contains(feature.getPath())
+                        || !feature.getNamespace().equals("rivencraft")) {
+                    diagnostics.add(new Diagnostic(Code.UNSUPPORTED_FEATURE, pendingBlock.index(),
                            "This feature cannot consume a material page"));
                }
                pendingBlock = null;
            }
            if (role == Role.ANGLE_MODIFIER || role == Role.WEATHER
                    && parsed.semantics().value() instanceof ChoiceValue choice
-                    && Set.of("snow", "cloudy", "rain").contains(choice.id())) {
+                    && UNSUPPORTED_WEATHER.contains(choice.id())) {
                diagnostics.add(new Diagnostic(Code.UNSUPPORTED_ENVIRONMENT, index,
                        "This environment effect needs renderer or precipitation support"));
            }
            if (singular(role)) {
-                ParsedSymbol previous = singular.putIfAbsent(role, parsed);
+                ParsedSymbol previous = singular.put(role, parsed);
                if (previous != null) {
                    Code code = previous.semantics().value().equals(parsed.semantics().value())
                            ? Code.DUPLICATE : Code.CONFLICT;
@@ -172,16 +175,40 @@ public final class WritingGrammar {
    public enum Code {
        TOO_MANY, MISSING_PANEL, PANEL_ORDER, DUPLICATE_PANEL, UNRESOLVED, UNSUPPORTED,
        DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER, INCOMPLETE, UNSUPPORTED_PROFILE,
-        UNKNOWN_BIOME, UNSUPPORTED_BIOME, UNSUPPORTED_ENVIRONMENT, UNSUPPORTED_FEATURE
+        UNKNOWN_BIOME, UNSUPPORTED_BIOME, UNSUPPORTED_ENVIRONMENT, UNSUPPORTED_FEATURE,
+        UNSUPPORTED_COMBINATION;
+
+        public Severity severity() {
+            return switch (this) {
+                case INCOMPLETE -> Severity.SEEDED_COMPLETION;
+                case DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER -> Severity.INSTABILITY;
+                default -> Severity.FATAL;
+            };
+        }
    }

+    public enum Severity { FATAL, SEEDED_COMPLETION, INSTABILITY }
+
    public record Diagnostic(Code code, int index, String message) {
        public Diagnostic {
            Objects.requireNonNull(code, "code");
            Objects.requireNonNull(message, "message");
        }

-        public boolean error() { return code != Code.INCOMPLETE; }
+        public Severity severity() {
+            return code.severity();
+        }
+
+        public boolean error() { return severity() == Severity.FATAL; }
+
+        /** The known writing defects have an explicit, provisional M6 score. */
+        public int instability() {
+            return switch (code) {
+                case DUPLICATE, CONFLICT -> 500;
+                case OUT_OF_ORDER, MISPLACED_MODIFIER -> 100;
+                default -> 0;
+            };
+        }
    }

    public record ParsedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {
@@ -200,5 +227,45 @@ public final class WritingGrammar {
        public boolean randomFallback() { return symbols.isEmpty() && diagnostics.isEmpty(); }
        public boolean canCreate() { return diagnostics.stream().noneMatch(Diagnostic::error); }
        public Optional<Diagnostic> firstError() { return diagnostics.stream().filter(Diagnostic::error).findFirst(); }
+        public Optional<Diagnostic> firstWarning() {
+            return firstInstability();
+        }
+        public Optional<Diagnostic> firstInstability() {
+            return diagnostics.stream().filter(diagnostic -> diagnostic.severity() == Severity.INSTABILITY).findFirst();
+        }
+        public Optional<Diagnostic> firstIncomplete() {
+            return diagnostics.stream().filter(diagnostic -> diagnostic.severity() == Severity.SEEDED_COMPLETION).findFirst();
+        }
+        public int writingInstability() {
+            return diagnostics.stream().mapToInt(Diagnostic::instability).sum();
+        }
+
+        /** Preserve the book's original entries, but compile a repaired Legacy-style order. */
+        public List<ParsedSymbol> activeSymbols() {
+            EnumMap<Role, ParsedSymbol> lastChoice = new EnumMap<>(Role.class);
+            for (ParsedSymbol symbol : symbols) {
+                if (singular(symbol.semantics().role())) lastChoice.put(symbol.semantics().role(), symbol);
+            }
+            List<ParsedSymbol> active = new ArrayList<>();
+            for (ParsedSymbol symbol : symbols) {
+                if (!singular(symbol.semantics().role())
+                        || lastChoice.get(symbol.semantics().role()) == symbol) active.add(symbol);
+            }
+            active.sort(Comparator.comparingInt(symbol -> stage(symbol.semantics().role())));
+            ParsedSymbol controller = lastChoice.get(Role.BIOME_CONTROLLER);
+            if (controller != null && controller.semantics().value() instanceof ChoiceValue choice) {
+                if (choice.id().equals("native")) {
+                    active.removeIf(symbol -> symbol.semantics().role() == Role.BIOME);
+                } else if (choice.id().equals("single")) {
+                    boolean retained = false;
+                    for (int index = 0; index < active.size(); index++) {
+                        if (active.get(index).semantics().role() != Role.BIOME) continue;
+                        if (!retained) retained = true;
+                        else active.remove(index--);
+                    }
+                }
+            }
+            return List.copyOf(active);
+        }
    }
 }
@@ -47,10 +47,22 @@
  "screen.rivencraft.book_binder.grammar.unsupported": "Page %s: this symbol needs semantic schema v2; update its data pack or remove it",
  "screen.rivencraft.book_binder.grammar.unsupported_profile": "Page %s: its Age profile is unavailable; restore the data pack or remove this page",
  "screen.rivencraft.book_binder.grammar.unsupported_environment": "Page %s: this weather or sky effect is not supported yet",
-  "screen.rivencraft.book_binder.grammar.duplicate": "Page %s: remove the duplicate symbol",
-  "screen.rivencraft.book_binder.grammar.conflict": "Page %s: replace the conflicting symbol",
-  "screen.rivencraft.book_binder.grammar.out_of_order": "Page %s: move this symbol before later categories",
-  "screen.rivencraft.book_binder.grammar.misplaced_modifier": "Page %s: move this modifier before its celestial page",
+  "screen.rivencraft.book_binder.grammar.duplicate": "Page %s: duplicate page adds instability; the last choice is used",
+  "screen.rivencraft.book_binder.grammar.conflict": "Page %s: conflicting page adds instability; the supported choice is used",
+  "screen.rivencraft.book_binder.grammar.out_of_order": "Page %s: incorrect order adds instability; the Age repairs the order",
+  "screen.rivencraft.book_binder.grammar.misplaced_modifier": "Page %s: misplaced modifier adds instability; the Age repairs its order",
+  "screen.rivencraft.book_binder.grammar.incomplete": "Missing branches will be completed from the Age seed",
+  "screen.rivencraft.book_binder.grammar.unknown_biome": "Page %s: biome is unavailable; restore its data pack",
+  "screen.rivencraft.book_binder.grammar.unsupported_biome": "Page %s: biome is incompatible with this terrain",
+  "screen.rivencraft.book_binder.grammar.unsupported_feature": "Page %s: feature is incompatible with this Age",
+  "screen.rivencraft.book_binder.grammar.unsupported_combination": "These pages cannot generate together; no inputs will be consumed",
+  "screen.rivencraft.book_binder.status.fatal": "Blocked",
+  "screen.rivencraft.book_binder.status.unstable": "Unstable +%s",
+  "screen.rivencraft.book_binder.status.seeded": "Seeded",
+  "screen.rivencraft.book_binder.status.seeded_count": "%s missing branches will be seeded",
+  "screen.rivencraft.age.writing.fatal": "Writing blocked",
+  "screen.rivencraft.age.writing.unstable": "Unstable +%s",
+  "screen.rivencraft.age.writing.seeded": "Missing parts seeded",
  "screen.rivencraft.writing_desk.ink": "Ink: %s/%s",
  "screen.rivencraft.writing_desk.search": "Search",
  "screen.rivencraft.writing_desk.sort": "Sort pages by name (A–Z)",
@@ -1 +1 @@
-{"parent":"minecraft:block/cube_all","textures":{"all":"rivencraft:block/budding_crystal"}}
+{"parent":"minecraft:block/cube_all","textures":{"all":"rivencraft:block/crystal_block"}}
@@ -1,6 +1,6 @@
 {
  "parent": "minecraft:item/generated",
  "textures": {
-    "layer0": "rivencraft:item/page_unresolved"
+    "layer0": "rivencraft:item/page_symbol"
  }
 }
Author	SHA1	Message	Date
dnorberg	7a47e40e2d	Freeze Age instability scores and classify authored writing (#64 #65 ) Build / build (push) Canceled after 0s Details	2026-10-09 00:12:31 -04:00
dnorberg	86cda69d11	Audit Legacy instability and allow unstable supported writing Build / build (push) Canceled after 0s Details Persist repaired Age writing and provisional instability penalties, retain fatal diagnostics for unsupported content, and hide TerraBlender's deferred placeholder biome from creative and JEI.	2026-10-08 14:10:42 -04:00
dnorberg	a03e005a03	Complete Milestone 5 acceptance and streamline tests and assets (#42 ) Build / build (push) Canceled after 0s Details	2026-10-08 06:01:33 -04:00
dnorberg	32b676db30	Weight random Age choices like Legacy and expand regression coverage (#41 ) Build / build (push) Canceled after 0s Details	2026-10-08 05:43:18 -04:00