diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 7f5f658..0e31e2b 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -22,6 +22,14 @@ version numbers (`powderline.support_matrix()` lists the declarations).
 Defined in `src/powderline/schema_core.py`. Not used by any gateway yet: the
 engine schemas adopt it in re/04–06.
 
+> **Pre-release revision (re/03b, not a new version).** Before its first
+> release, core 1.0.0 replaced its structure-only phase model (`PhaseStructure`
+> with plain values, plus `null`-valued "structure" parameters) with the
+> **phase block** described below: one block per phase, every structural
+> quantity a refinable parameter, flags and bounds checked against the symmetry,
+> and `space_group` in gemmi's canonical spelling. No recipe was ever written
+> against the earlier draft.
+
 - **Recipe frame** (`CoreRecipe`): `schema_name` (`"<engine>.<workflow>"`),
   `core_schema_version`, `engine_schema_version`, `metadata`, `payload` (typed
   by the engine schema). Unknown keys are errors at every level.
@@ -29,10 +37,10 @@ engine schemas adopt it in re/04–06.
   at most **1 MiB** as UTF-8 JSON. The cap is the constant
   `schema_core.METADATA_MAX_BYTES`; change it there and record the change here.
 - **Parameters**: `[value, refine_flag]` (no bounds) or
-  `[value, refine_flag, min, max]` (bounds the engine honors). A bounded list
-  where bounds aren't supported is an error. `refine_flag` is a JSON boolean.
-  `value` may be `null` (= start from the phase structure's value) only for
-  quantities that mirror a structure value.
+  `[value, refine_flag, min, max]` (bounds the engine honors; `min`/`max` may
+  be `null` = open). A bounded list where bounds aren't supported is an error.
+  `value` is always a number and `refine_flag` a JSON boolean; neither is ever
+  `null`.
 - **Data and ranges**: `xrd_data` (2θ in degrees, weights 1/σ², validated as in
   0.26.0); `fit_range` `[min, max]`, with `max > min`, inside the data's 2θ range.
 - **Background**: Chebyshev (`num_coefficients`, `coefficients`, `refine_flag`).
@@ -43,40 +51,144 @@ engine schemas adopt it in re/04–06.
   take a whole number (`4` or `4.0`), not `4.5`.
 - **Accepted core versions** (this release): `==1.0.0`.
 
-- **Phase structure** (`PhaseStructure`): `phase_name`, `space_group`,
-  `unit_cell`, `atoms` (keyed by label). Structural interpretation is checked
-  once, in core, so every engine gets the same structure. All structural
-  problems are reported together, each at its own field (`unit_cell`,
-  `atoms.<label>`, `atoms.<label>.Multiplicity`, `atoms.<label>.Uaniso`); they
-  are checked once the individual fields are valid:
-  - **Space group**: a Hermann–Mauguin symbol. Two-origin groups need an explicit
-    `:1`/`:2` and rhombohedral groups `:H`/`:R` (e.g. `"F d -3 m:2"`,
-    `"R -3 m:H"`). Individual engines may accept fewer settings.
+- **Phase block** (`Phase`): one block per phase, keyed by the phase name in
+  the engine payload's `phases` (no `phase_name` field). Core owns
+  `space_group`, `unit_cell` and `atoms`; each engine schema adds its own phase
+  fields next to them (e.g. gsasii `scale`, `peak_broadening`) and may add
+  its own checks, but never redefine, skip or rewrite core's fields and
+  validation (checked when the engine schema is defined, and by a test). Every structural quantity is a parameter (`[value, flag]`,
+  or `[value, flag, min, max]` in engines with bounds): cell `a`–`gamma`; atom
+  `x`, `y`, `z`, `occupancy`, `Uiso` or `U11`…`U23`. `element`, `ADP`,
+  `Multiplicity` and `space_group` are plain values. Nothing is `null` and
+  nothing has a default: `occupancy` must be stated; `Multiplicity` (derived,
+  so optional) is left out when not stated, never `null`.
+  **Names:** atom labels (the `atoms` keys) and phase names (the engine
+  payload's `phases` keys) start with a letter and contain only ASCII letters,
+  digits and `_` (`O1`, `LaB6_a`); phase names, and the atom labels of a
+  phase, must also differ by more than case. This is the form every engine can use as-is: GSAS-II renames a phase
+  with surrounding spaces or non-ASCII characters (and its settings were then
+  skipped), easydiffraction accepts no other atom label, TOPAS writes the names
+  into its input file, phase names become report file names (which ignore case
+  on Windows and macOS), and problems are reported at `.`-joined paths
+  (`atoms.O1.Uiso`). So `"2H-MoS2"` is written e.g. `MoS2_2H`.
+  Structural interpretation is checked once, in core, so every engine gets the
+  same structure. **The recipe is the record of the refinement intent**, and
+  validation never changes what it means. Values fixed or tied by symmetry
+  follow one rule (see *Symmetry-determined values* below): the first member
+  of each tie group is stated freely and kept as written; every other value is
+  derived from the symmetry and must be stated, either exactly (a constant
+  with a decimal form, such as `0.5` or `0`) or to the precision that states it
+  beyond doubt (a third, `0.333333`; a value derived from another stated
+  value). The validated model, which every engine receives, holds the derived
+  values. PowderLine never rewrites a recipe file; only a Python dump of a
+  validated model shows a derived value's full spelling
+  (`0.3333333333333333`), which means the same and validates the same. All problems
+  are reported together, each at its own field
+  (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
+  `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
+  `unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`); they are checked
+  once the individual fields are valid:
+  - **Space group**: gemmi's canonical extended Hermann–Mauguin name, exactly:
+    `"P m -3 m"`, `"C 1 2/m 1"`, `"P 1 21/c 1"`, `"R -3 m:H"`, `"F d -3 m:2"`.
+    Every setting has exactly one such name, and it states the setting
+    (two-origin groups `:1`/`:2`, rhombohedral groups `:H`/`:R`, the monoclinic
+    unique axis). Any other spelling (`"Pm-3m"`, `"C2/m"`, `"p m -3 m"`) is an
+    error whose message gives the canonical name; a symbol without a setting
+    (`"R -3 m"`, `"F d -3 m"`) lists both choices, and a short monoclinic
+    symbol (`"P21/c"`, `"C2/m"`) lists every setting of that space group by
+    unique axis, because it states neither the unique axis nor the cell choice.
+    Each engine translates the name to its own convention, and may accept fewer
+    settings. The accepted names are those of gemmi 0.7.5, which PowderLine pins
+    exactly; the list is `tests/data/canonical_space_groups.txt`, and any change
+    to it is recorded here.
   - **Unit cell**: `a`, `b`, `c` (Å, > 0), `alpha`, `beta`, `gamma` (degrees,
-    0–180). No `volume` (every engine derives it). The cell must fit the
-    space group **exactly** (to floating-point precision): e.g. cubic
-    `a = b = c` and all angles 90°. A mismatch is an error naming each
-    parameter and its symmetric value. (GSAS-II alone would silently apply the
-    symmetry only when the cell is refined.)
+    0–180). In engines with bounds, a stated bound must lie in the same range
+    (a length's `min` > 0; an angle's `min`/`max` strictly between 0 and 180);
+    `null` means no bound. No `volume` (every engine derives it). The cell must fit the
+    space group: tied lengths and angles equal the first one (cubic
+    `b = a`, `c = a`), and fixed angles are exactly 90° (or 120° for `gamma`
+    on hexagonal axes), to within 1e-9 (relative on lengths, degrees on
+    angles), the floating-point noise of a cell computed by a program. The
+    validated model holds the first member's value and the exact angles. A
+    mismatch is an error stating each value and the value to write
+    (`stated b = 4.2, but by symmetry b = a; write b = 4.15692`). (GSAS-II
+    alone would silently apply the symmetry only when the cell is refined.)
   - **Elements**: a bare element symbol spelled exactly (`"Fe"`, not `"FE"`).
     Charged scattering types (`"Fe3+"`) are not supported yet and are rejected,
     never reduced to the neutral atom.
   - **Occupancy**: 0 to 1 inclusive, even where an engine would accept more.
-  - **Special positions**: an atom whose symmetry images lie within 5e-6
-    (fractional) of itself is on a special position, so write special
-    coordinates with **at least 6 decimals** (e.g. `0.333333`). An atom 5e-6 to
-    2e-3 from a special position is an **error** (`0.33`, `0.3333`, `0.33333`):
-    state it to ≥ 6 decimals or move it off. Accepted special positions are
-    replaced by their **exact** coordinates (fixed coordinates become the exact
-    fraction; coupled ones satisfy their relation, by the smallest change). Each
-    adjustment is reported as a structured warning, and these exact values are
-    what every engine receives.
+  - **Symmetry-determined values** (special positions, anisotropic ADPs,
+    tied bounds). Within 5e-6 of a special position an atom is on it; from
+    5e-6 to 2e-3 off is an error (state the position, or move the atom at least
+    2e-3 off it: `0.33` and `0.3333` are neither). On a special position:
+    - the **first member of each tie group** (x before y before z; U11 before
+      U22 …) is the free parameter: it is kept exactly as written, whatever its
+      value;
+    - a **constant** of the site, i.e. a coordinate fixed by symmetry or a
+      Uij that must be 0, is written **exactly** when it has a decimal form
+      (`0.5`, `0.25`, `0.125`, `0`), and to **at least 6 decimals** when it has
+      none, i.e. when it is a third (`0.333333` for 1/3, `0.166667` for 1/6);
+    - a value **derived from another stated value**, i.e. a coupled
+      coordinate (`(x, 2x, 1/4)`, `(x, x + 1/2, z)`, `(x, x + 1/3, 1/6)`), a
+      coupled Uij (`U22 = U11`, `U12 = U22/2`) or a tied member's bounds, is
+      stated to the precision of its kind (coordinates within 5e-6, i.e. 6
+      decimals; Uij within 1e-6 Ų) and read as the value derived from the
+      first member;
+    - anything else is an **error** whose message gives the values to write.
+
+    The validated model holds the derived values, so every tie holds exactly
+    and every engine starts from the same structure. How PowderLine reads
+    some typical statements:
+
+    | Stated | Symmetry | Validated model | Why |
+    |---|---|---|---|
+    | `x = 0.4999999` at (1/2, 0, 0) | x fixed = 1/2 | **error**: write `x = 0.5` | 1/2 has a decimal form: write it exactly |
+    | `x, y = 0.333333, 0.666667` at (1/3, 2/3, 1/4) | fixed thirds | 1/3, 2/3 | a third has no decimal form; 6 decimals state it |
+    | `x, y = 0.3333333333333, 0.6666666666667` | fixed thirds | 1/3, 2/3 | any precision beyond 6 decimals reads the same |
+    | `x, y = 0.833333, 0.666667` at 6h (x, 2x, 1/4) | y = 2x − 1 | x = 0.833333, y = 0.666666 | x is free and kept; y follows it |
+    | `x, y = 0.1, 0.2000001` at (x, 2x, 0) | y = 2x | x = 0.1, y = 0.2 | y follows x |
+    | `x, y = 0.066667, 0.4` at (x, x + 1/3, 1/6) | y = x + 1/3 | x = 0.066667, y = 0.40000033… | y follows x, even where the stated y is a short decimal |
+    | `U13 = 1e-9` at 6h | U13 fixed = 0 | **error**: write `U13 = 0.0` | 0 has a decimal form: write it exactly |
+    | `U12 = 0.006174` with `U22 = 0.012347` at 6h | U12 = U22/2 | U12 = 0.0061735 | U12 follows U22 |
+    | y bounds `[0.300004, 0.5]`, x bounds `[0, 0.2]` at (x, −x + 1/2, z) | y = −x + 1/2 | `[0.3, 0.5]` | bounds follow the first member's |
+
+    Most crystallographic programs instead move any atom within a distance
+    tolerance onto the special position (SHELXL 0.2 Å, cctbx 0.5 Å), and
+    pymatgen reads `0.3333` as 1/3. PowderLine does not: a constant that can
+    be written exactly must be, and `0.3333` is ambiguous.
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
-  - **ADPs**: `ADP` is `"Uiso"` (with `Uiso`, Ų) or `"Uaniso"` (with all of
-    `U11 U22 U33 U12 U13 U23`, Ų). Anisotropic ADPs must respect the site
-    symmetry: within 1e-6 Ų they are set to the symmetric values and reported;
-    beyond that it is an error.
+  - **ADPs**: `ADP` selects the thermal parameter that is **required**:
+    `"Uiso"` requires `Uiso` (Ų); `"Uaniso"` requires `Uaniso` with all six of
+    `U11 U22 U33 U12 U13 U23` (Ų). The other one must be left out. A missing
+    or extra one is an error at that field (`atoms.<label>.Uiso`,
+    `atoms.<label>.Uaniso.U23`), and the JSON Schema states the same rule.
+    Anisotropic ADPs follow the site symmetry as described under
+    *Symmetry-determined values*. A `Uaniso` that is not positive definite (a
+    principal mean-square displacement ≤ 0, so no thermal ellipsoid exists) is
+    **accepted with a structured warning** (`uaniso_not_positive_definite`,
+    giving the principal values in Ų along Cartesian axes), like a negative
+    `Uiso`: it can show that the parameter compensates for something the model
+    lacks (e.g. absorption). Engines carry it as given.
+  - **Refinement intent follows the symmetry.** Parameters tied by symmetry
+    are **one** parameter, and every member is stated: cubic `a, b, c`;
+    tetragonal/hexagonal `a, b`; rhombohedral axes (`:R`) `a, b, c` and
+    `alpha, beta, gamma`; coordinates such as `(x, 2x, 1/4)` or
+    `(x, x + 1/2, z)`; Uij such as `U11 = U22`, `U12 = U22/2`, `U13 = -U23`.
+    - Tied members carry the **same refine flag**; the error is reported at
+      every member whose flag differs from the first member's.
+    - A parameter **fixed** by symmetry (a cubic angle, `x` of an atom at the
+      origin, `U12` on a mirror site) has refine flag `false` and, where the
+      engine has bounds, no bounds (`null`, `null`).
+    - Different groups are independent (orthorhombic `a` refined, `b` fixed).
+    - **Bounds** (engines with bounds) follow the tie like the values:
+      `y = k·x + c` maps x's `[min, max]` to `[k·min + c, k·max + c]`
+      (swapped for negative k; an open side stays open), e.g. `(x, x + 1/2, z)`
+      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. They are derived values
+      (see *Symmetry-determined values*): stated within 5e-6 for coordinates,
+      1e-6 Ų for Uij and 1e-9 (relative) for the cell, and read as the mapped
+      values; otherwise the error gives them.
+    - Atoms at the same position are independent: their flags are never tied.
 
 ## gsasii engine schema
 
diff --git a/pixi.lock b/pixi.lock
index b51a946..0dd2960 100644
--- a/pixi.lock
+++ b/pixi.lock
@@ -17362,7 +17362,7 @@ packages:
   name: powderline
   requires_dist:
   - fastapi>=0.115
-  - gemmi>=0.7,<0.8
+  - gemmi==0.7.5
   - h5py>=3.12
   - httpx>=0.28
   - numpy>=2.0
diff --git a/pixi.toml b/pixi.toml
index 834faf8..b1839b2 100644
--- a/pixi.toml
+++ b/pixi.toml
@@ -58,7 +58,11 @@ emmet-core = ">=0.87.1,<0.88"
 fastapi = ">=0.115.0,<1"
 uvicorn = ">=0.34.0,<1"
 httpx = ">=0.28.0,<1"
-gemmi = ">=0.7.5,<0.8"
+# gemmi is pinned exactly: core's space-group contract is its canonical names
+# (A105, tests/data/canonical_space_groups.txt) and the symmetry rules are
+# characterized against this version. Widen only after re-running the symmetry
+# tests and updating that file (re/03b review B4).
+gemmi = "==0.7.5"
 packaging = ">=22"
 # GSAS-II is built as a conda package via pixi-build (see `preview` above) from
 # the tacaswell fork, which adds the conda recipe. This installs GSAS-II on ALL
diff --git a/pyproject.toml b/pyproject.toml
index b0fc914..fbfc1ae 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -51,7 +51,7 @@ dependencies = [
     "fastapi>=0.115",
     "uvicorn>=0.34",
     "httpx>=0.28",
-    "gemmi>=0.7,<0.8",
+    "gemmi==0.7.5",  # exact: the space-group names and symmetry rules depend on it (pixi.toml)
     "packaging>=22",
 ]
 
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 89997f2..25a3331 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -21,15 +21,21 @@
 
 from __future__ import annotations
 
+import inspect
 import json
+import keyword
 import math
-from typing import Annotated, Any, Literal, Optional
+import re
+from fractions import Fraction
+from dataclasses import dataclass
+from typing import Annotated, Any, Callable, Generic, Literal, Optional, TypeVar
 
 import gemmi
 import numpy as np
 from packaging.specifiers import SpecifierSet
 from packaging.version import InvalidVersion, Version
 from pydantic import (
+    AfterValidator,
     BaseModel,
     BeforeValidator,
     ConfigDict,
@@ -38,14 +44,27 @@
     Strict,
     StrictBool,
     ValidationError,
+    WithJsonSchema,
     field_validator,
     model_serializer,
     model_validator,
 )
+from pydantic.json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
 from powderline.exceptions import StructuredWarning, SymmetryError
-from powderline.symmetry import analyze_site, check_cell, check_uij, resolve_space_group
+from powderline.symmetry import (
+    ADJUSTMENT_REPORT_TOL,
+    CELL_TOL,
+    SPECIAL_POSITION_TOL,
+    UIJ_TOL,
+    Ties,
+    analyze_site,
+    canonical_space_group,
+    cell_tie_groups,
+    check_cell,
+    coupling_groups,
+)
 
 # --- versions (A40, A65) ---------------------------------------------------
 
@@ -112,6 +131,40 @@ def _array_schema(title: str, items: list[dict], description: str, **extra) -> d
 _STRICT = ConfigDict(extra="forbid")
 
 
+class CoreJsonSchema(GenerateJsonSchema):
+    """JSON Schema generator that names a parametrized core model after its origin.
+
+    pydantic names ``Atom[RefinableParameter]`` ``Atom_RefinableParameter_`` in
+    ``$defs``; a recipe document holds one engine's schema (one parameter type),
+    so plain ``Atom`` is unambiguous and readable. Only the short candidate names
+    (no module path, no id) are shortened: pydantic's content-based dedup then
+    falls back to its qualified names if two parametrizations ever share one
+    document, and the id-bearing name it needs unique is left intact (devkit
+    ``tasks/re03b-spike-generics.md``).
+    """
+
+    def normalize_name(self, name: str) -> str:
+        if "." not in name and ":" not in name:
+            name = re.sub(r"\[[^\]]*\]", "", name)
+        return super().normalize_name(name)
+
+
+class CoreModel(BaseModel):
+    """Base of the core models: ``extra='forbid'`` and :class:`CoreJsonSchema` by default.
+
+    Engine schemas build on it (directly, or through :class:`CoreRecipe` and
+    :class:`Phase`), so their generated JSON Schema is readable too.
+    """
+
+    model_config = _STRICT
+
+    @classmethod
+    def model_json_schema(cls, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE,
+                          schema_generator: type[GenerateJsonSchema] = CoreJsonSchema,
+                          mode: JsonSchemaMode = "validation", **kwargs) -> dict[str, Any]:
+        return super().model_json_schema(by_alias, ref_template, schema_generator, mode, **kwargs)
+
+
 # --- numbers -----------------------------------------------------------------
 
 
@@ -131,7 +184,79 @@ def _integer_not_text_or_bool(v: Any) -> Any:
 CoreInt = Annotated[int, BeforeValidator(_integer_not_text_or_bool)]
 
 
-# --- parameter models (A20, A32, A71) ---------------------------------------
+# --- names ------------------------------------------------------------------
+
+#: A phase name or atom label: an ASCII letter, then ASCII letters, digits or ``_``.
+NAME_PATTERN = r"^[A-Za-z][A-Za-z0-9_]*$"
+#: Longest phase name or atom label. Phase names become file names with a suffix of
+#: up to 21 characters (``_unit_cell_report.csv``); file systems allow 255 per name
+#: and Windows 260 per path by default, so a name stays well inside both.
+NAME_MAX_LENGTH = 64
+#: Python's (hard) keywords: valid by the pattern but not identifiers (``None``, ``class``).
+NAME_KEYWORDS = tuple(keyword.kwlist)
+#: JSON Schema of a name (also the ``propertyNames`` of a name-keyed object).
+NAME_JSON_SCHEMA = {"type": "string", "pattern": NAME_PATTERN, "maxLength": NAME_MAX_LENGTH,
+                    "not": {"enum": list(NAME_KEYWORDS)}}
+
+
+def _check_name(name: str) -> str:
+    """The name rule every engine can honor, which is also a Python identifier (re/03b review C6).
+
+    - GSAS-II renames a phase whose name has surrounding spaces or non-ASCII
+      characters, and the parameterization then skips that phase silently.
+    - easydiffraction accepts atom labels only of the form ``[A-Za-z_][A-Za-z0-9_]*``.
+    - TOPAS emits phase names inside quotes and builds parameter names from them.
+    - Phase names become report file names (``<phase>_unit_cell_report.csv``), so
+      no character a file system rejects (``/``, ``:``, ...) and a bounded length.
+    - Field paths are joined with ``.`` (``atoms.O1.Uiso``).
+    """
+    if not name.strip():
+        raise ValueError("a name must not be empty or blank")
+    if re.fullmatch(NAME_PATTERN, name) is None:
+        raise ValueError(f"name {name!r} must start with a letter and contain only ASCII letters, digits "
+                         "and '_' (e.g. 'O1', 'LaB6_a')")
+    if len(name) > NAME_MAX_LENGTH:
+        raise ValueError(f"name {name[:20]!r}... has {len(name)} characters; the limit is {NAME_MAX_LENGTH}")
+    if keyword.iskeyword(name):
+        raise ValueError(f"name {name!r} is a Python keyword; choose another name")
+    return name
+
+
+#: A phase name or an atom label (a dict key), see :func:`_check_name`. Core uses
+#: it for the atom labels; engine schemas use it for their ``phases`` keys (with
+#: :func:`name_keyed`, and :func:`check_names_unique_ignoring_case` for phases).
+CoreName = Annotated[str, AfterValidator(_check_name), WithJsonSchema(NAME_JSON_SCHEMA)]
+
+
+def check_names_unique_ignoring_case(names, what: str) -> None:
+    """Raise ``ValueError`` if two of ``names`` differ only in case.
+
+    Phase names become file names, and Windows and macOS file systems ignore
+    case, so ``LaB6`` and ``lab6`` would overwrite each other's reports (and
+    easydiffraction lowercases them). Engine payloads call it on their phases.
+    """
+    seen: dict[str, str] = {}
+    for name in names:
+        other = seen.setdefault(name.lower(), name)
+        if other != name:
+            raise ValueError(f"{what} {other!r} and {name!r} differ only in case; rename one")
+
+
+def name_keyed(schema: dict) -> None:
+    """``json_schema_extra`` for a ``dict[CoreName, ...]`` field: state the key rule as ``propertyNames``.
+
+    pydantic writes a key rule as ``patternProperties`` (pattern only), which
+    leaves other keys unchecked in JSON Schema; this checks every key against
+    :data:`NAME_JSON_SCHEMA`.
+    """
+    pattern_properties = schema.pop("patternProperties", None)
+    if pattern_properties:
+        ((_pattern, value),) = pattern_properties.items()
+        schema["propertyNames"] = {k: v for k, v in NAME_JSON_SCHEMA.items() if k != "type"}
+        schema["additionalProperties"] = value
+
+
+# --- parameter models (A20, A32, A93) ---------------------------------------
 
 
 def _finite(name: str, v: Optional[float]) -> Optional[float]:
@@ -145,8 +270,7 @@ class RefinableParameter(BaseModel):
 
     Used where the engine has no native bounds for the quantity. A 4-element
     list here is an error, never silently truncated (A20). ``value`` is
-    required; see :class:`StructureRefinableParameter` for the quantities whose
-    starting value may come from the phase structure.
+    required (never ``null``, A93/A96).
     """
 
     model_config = _STRICT
@@ -184,9 +308,7 @@ def _to_list(self) -> list:
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler) -> dict:
-        nullable = cls.model_fields["value"].annotation is not float
-        return _array_schema(cls.__name__, [_NUMBER_OR_NULL if nullable else _NUMBER, _BOOLEAN],
-                             "[value, refine_flag]" + (_NULL_VALUE_NOTE if nullable else ""))
+        return _array_schema(cls.__name__, [_NUMBER, _BOOLEAN], "[value, refine_flag]")
 
 
 class BoundedRefinableParameter(BaseModel):
@@ -194,8 +316,8 @@ class BoundedRefinableParameter(BaseModel):
 
     ``min``/``max`` may each be ``null`` (unbounded on that side). When given,
     ``min <= max`` and ``min <= value <= max``. Used only where the engine
-    honors the bounds natively (A20, A33). ``value`` is required; see
-    :class:`StructureBoundedRefinableParameter`.
+    honors the bounds natively (A20, A33). ``value`` is required (never
+    ``null``, A93/A96).
     """
 
     model_config = _STRICT
@@ -229,8 +351,7 @@ def _bounds(self) -> "BoundedRefinableParameter":
         lo, hi = self.min, self.max
         if lo is not None and hi is not None and lo > hi:
             raise ValueError(f"min ({lo}) must be <= max ({hi})")
-        if self.value is not None:
-            check_within_bounds(self.value, self, "value")
+        check_within_bounds(self.value, self, "value")
         return self
 
     @model_serializer
@@ -239,45 +360,12 @@ def _to_list(self) -> list:
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler) -> dict:
-        nullable = cls.model_fields["value"].annotation is not float
-        return _array_schema(cls.__name__,
-                             [_NUMBER_OR_NULL if nullable else _NUMBER, _BOOLEAN,
-                              _NUMBER_OR_NULL, _NUMBER_OR_NULL],
-                             "[value, refine_flag, min, max]; min/max may be null"
-                             + (_NULL_VALUE_NOTE if nullable else ""))
-
-
-_NULL_VALUE_NOTE = "; value null = start from the phase structure's value"
-
-
-class StructureRefinableParameter(RefinableParameter):
-    """:class:`RefinableParameter` for a quantity that mirrors a phase-structure value.
-
-    For cell lengths/angles and atom x/y/z, occupancy, Uiso/Uaniso only (A71):
-    ``value`` may be ``null``, meaning "start from the structure's value"
-    (today's behavior: the GSAS-II setters skip a null value).
-    """
-
-    value: Optional[CoreFloat]
-
-
-class StructureBoundedRefinableParameter(BoundedRefinableParameter):
-    """:class:`BoundedRefinableParameter` for a quantity that mirrors a phase-structure value.
-
-    ``value`` may be ``null`` (start from the structure's value, A71); the
-    bounds are then checked against that value by the phase-level validator
-    (:func:`check_within_bounds`).
-    """
-
-    value: Optional[CoreFloat]
+        return _array_schema(cls.__name__, [_NUMBER, _BOOLEAN, _NUMBER_OR_NULL, _NUMBER_OR_NULL],
+                             "[value, refine_flag, min, max]; min/max may be null")
 
 
 def check_within_bounds(value: float, param: BoundedRefinableParameter, field: str) -> None:
-    """Raise ``ValueError`` unless ``param.min <= value <= param.max`` (open ends pass).
-
-    Also used at the phase level for a null-valued
-    :class:`StructureBoundedRefinableParameter`, with the structure's value.
-    """
+    """Raise ``ValueError`` unless ``param.min <= value <= param.max`` (open ends pass)."""
     if param.min is not None and value < param.min:
         raise ValueError(f"{field} ({value}) is below min ({param.min})")
     if param.max is not None and value > param.max:
@@ -497,201 +585,732 @@ def _coefficients_finite(cls, v):
         return v
 
 
-# --- phase structure (A32, A35, A62, A63, A69, A73) -------------------------
+# --- phase block (A93-A96, A100, A105; values: A63, A69, A73, A76-A78) -------
 
+#: The parameter type of a phase block: :class:`RefinableParameter`, or
+#: :class:`BoundedRefinableParameter` for an engine that honors bounds (A20).
+#: One type for every structural field, cell and atoms (review N6).
+P = TypeVar("P", RefinableParameter, BoundedRefinableParameter)
 
-class UnitCell(BaseModel):
-    """Cell constants (values, not refinables). No ``volume``: every engine
-    derives it from a..gamma (A75)."""
 
-    model_config = _STRICT
+def _absent_not_null(v: Any, info) -> Any:
+    """A field that may be left out is never ``null`` (A96): reject an explicit null."""
+    if v is None:
+        raise ValueError(f"{info.field_name} must not be null; leave it out instead")
+    return v
+
 
-    a: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    b: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    c: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    alpha: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
-    beta: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
-    gamma: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
+def _absent_not_null_schema(unit: Optional[str] = None):
+    """JSON Schema of a field that may be left out but is never null (A96).
+
+    The field is ``Optional`` only so that "left out" can be held as ``None``;
+    the schema shows the non-null type, no ``"default": null``, and the unit.
+    """
+    def extra(schema: dict) -> None:
+        schema.pop("default", None)
+        any_of = schema.pop("anyOf", None)
+        if any_of:
+            schema.update(next(s for s in any_of if s.get("type") != "null"))
+        if unit:
+            schema.update(_unit(unit))
+    return extra
+
+
+class UnitCell(CoreModel, Generic[P]):
+    """Cell constants, each a refinable parameter. No ``volume``: every engine
+    derives it from a..gamma (A75). The values must fit the space group (A77,
+    checked by :class:`Phase`)."""
+
+    a: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    b: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    c: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    alpha: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
+    beta: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
+    gamma: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
 
     @field_validator("a", "b", "c")
     @classmethod
     def _length(cls, v, info):
-        if not (math.isfinite(v) and v > 0):
-            raise ValueError(f"cell length {info.field_name} must be positive, got {v}")
+        if not v.value > 0:
+            raise ValueError(f"cell length {info.field_name} must be positive, got {v.value}")
+        if isinstance(v, BoundedRefinableParameter) and v.min is not None and not v.min > 0:
+            raise ValueError(f"cell length {info.field_name}: min must be positive (a cell length is), "
+                             f"got {v.min}; use null for no lower bound")
         return v
 
     @field_validator("alpha", "beta", "gamma")
     @classmethod
     def _angle(cls, v, info):
-        if not (math.isfinite(v) and 0 < v < 180):
-            raise ValueError(f"cell angle {info.field_name} must be between 0 and 180 degrees, got {v}")
+        if not 0 < v.value < 180:
+            raise ValueError(f"cell angle {info.field_name} must be between 0 and 180 degrees, got {v.value}")
+        if isinstance(v, BoundedRefinableParameter):
+            for side, bound in (("min", v.min), ("max", v.max)):
+                if bound is not None and not 0 < bound < 180:
+                    raise ValueError(f"cell angle {info.field_name}: {side} must be between 0 and 180 degrees "
+                                     f"(a cell angle is), got {bound}; use null for no {side} bound")
         return v
 
 
 _UANISO_KEYS = ("U11", "U22", "U33", "U12", "U13", "U23")
 
 
-class Atom(BaseModel):
-    """One atom of a phase structure (values, not refinables).
-
-    Coordinates are fractional JSON numbers. A special position is declared by
-    stating it to at least 6 decimals. The validated phase holds canonical
-    (exact) coordinates and reports every adjustment (A73). ``Multiplicity`` is
-    optional and, when stated, must match the derived value (A69 T3).
-    ``occupancy`` is 0 to 1 inclusive, even where an engine would accept more
-    (A76). ``Uaniso`` must respect the site symmetry: within 1e-6 A^2 it is set
-    to the symmetric values and reported, beyond that it is an error (A78).
+class UanisoTensor(CoreModel, Generic[P]):
+    """Anisotropic ADPs: all six of U11, U22, U33, U12, U13, U23, each a parameter (A^2)."""
+
+    U11: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U22: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U33: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U12: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U13: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U23: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+
+
+#: JSON Schema of the ADP pairing (A96): ``ADP`` selects which one of ``Uiso`` /
+#: ``Uaniso`` is required; the other must be left out.
+_ADP_PAIRING_SCHEMA = {"allOf": [
+    {"if": {"properties": {"ADP": {"const": adp}}},
+     "then": {"required": [adp], "not": {"required": [other]}}}
+    for adp, other in (("Uiso", "Uaniso"), ("Uaniso", "Uiso"))
+]}
+
+
+class Atom(CoreModel, Generic[P]):
+    """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
+
+    Coordinates are fractional JSON numbers. On a special position, the values
+    fixed or tied by symmetry follow :class:`Phase`'s rule (A73, A120, A121): a
+    fixed value with a decimal form exactly (``0.5``), a third to at least 6
+    decimals (``0.333333``), a coupled one within 6 decimals of the value
+    derived from its group's first member. ``occupancy`` is required
+    and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
+    stated, must match the derived value (A69 T3). ``ADP`` selects which
+    thermal parameter is **required**: ``Uiso``, or ``Uaniso`` with all six of
+    U11..U23; the other must be left out (an error at that field otherwise, and
+    the JSON Schema states the rule). ``Uaniso`` follows the site symmetry by
+    the same rule: a fixed component exactly 0, a coupled one within 1e-6 A^2
+    (A78, A121). Nothing is ``null`` (A96).
     """
 
-    model_config = _STRICT
+    model_config = ConfigDict(extra="forbid", json_schema_extra=_ADP_PAIRING_SCHEMA)
 
     element: str = Field(description="Bare element symbol, exactly as in the periodic table (e.g. 'Fe')")
-    x: CoreFloat = Field(description="Fractional x coordinate")
-    y: CoreFloat = Field(description="Fractional y coordinate")
-    z: CoreFloat = Field(description="Fractional z coordinate")
-    occupancy: CoreFloat = Field(default=1.0, ge=0.0, le=1.0, description="Site occupancy, 0 to 1 inclusive (A76)")
-    Multiplicity: Optional[CoreInt] = Field(default=None, description="Site multiplicity; cross-checked when stated")
+    x: P = Field(description="Fractional x coordinate")
+    y: P = Field(description="Fractional y coordinate")
+    z: P = Field(description="Fractional z coordinate")
+    occupancy: P = Field(description="Site occupancy, 0 to 1 inclusive (A76)")
+    Multiplicity: Optional[CoreInt] = Field(default=None, json_schema_extra=_absent_not_null_schema(),
+                                            description="Site multiplicity; optional, cross-checked when stated")
     ADP: Literal["Uiso", "Uaniso"] = Field(description="Displacement-parameter type")
-    Uiso: Optional[CoreFloat] = Field(default=None, json_schema_extra=_unit(UNIT_ANGSTROM2))
-    Uaniso: Optional[dict[Literal["U11", "U22", "U33", "U12", "U13", "U23"], CoreFloat]] = Field(
-        default=None, json_schema_extra=_unit(UNIT_ANGSTROM2),
-        description="All six of U11, U22, U33, U12, U13, U23")
+    Uiso: Optional[P] = Field(default=None, json_schema_extra=_absent_not_null_schema(UNIT_ANGSTROM2),
+                              description="Isotropic ADP; required when ADP is 'Uiso', else left out")
+    Uaniso: Optional[UanisoTensor[P]] = Field(
+        default=None, json_schema_extra=_absent_not_null_schema(),
+        description="All six of U11, U22, U33, U12, U13, U23; required when ADP is 'Uaniso', else left out")
+
+    _not_null = field_validator("Multiplicity", "Uiso", "Uaniso", mode="before")(_absent_not_null)
 
     @field_validator("element")
     @classmethod
     def _element(cls, v: str) -> str:
         return check_element_symbol(v)
 
-    @field_validator("x", "y", "z", "occupancy", "Uiso")
-    @classmethod
-    def _finite(cls, v, info):
-        return _finite(info.field_name, v)
-
-    @field_validator("Uaniso")
+    @field_validator("occupancy")
     @classmethod
-    def _uaniso_finite(cls, v):
-        if v is not None:
-            for k, u in v.items():
-                _finite(k, u)
+    def _occupancy(cls, v):
+        if not 0.0 <= v.value <= 1.0:
+            raise ValueError(f"occupancy must be between 0 and 1 inclusive, got {v.value}")
         return v
 
+    @model_serializer(mode="wrap")
+    def _omit_absent(self, handler):
+        """Leave out absent optional fields, so a dump validates again (no ``null``, A96)."""
+        data = handler(self)
+        for name in ("Multiplicity", "Uiso", "Uaniso"):
+            if getattr(self, name) is None:
+                data.pop(name, None)
+        return data
+
     @model_validator(mode="after")
     def _adp_block(self) -> "Atom":
-        if self.ADP == "Uiso":
-            if self.Uiso is None:
-                raise ValueError("ADP 'Uiso' requires a Uiso value")
-            if self.Uaniso is not None:
-                raise ValueError("ADP 'Uiso' must not also give Uaniso")
-        else:
-            if self.Uaniso is None or set(self.Uaniso) != set(_UANISO_KEYS):
-                raise ValueError(f"ADP 'Uaniso' requires all of {', '.join(_UANISO_KEYS)}")
-            if self.Uiso is not None:
-                raise ValueError("ADP 'Uaniso' must not also give Uiso")
+        """``ADP`` selects the required thermal parameter; errors at the field concerned."""
+        required, other = ("Uiso", "Uaniso") if self.ADP == "Uiso" else ("Uaniso", "Uiso")
+        problems = []
+        if getattr(self, required) is None:
+            problems.append(InitErrorDetails(
+                type=PydanticCustomError("missing", "{field} is required when ADP is '{adp}'",
+                                         {"field": required, "adp": self.ADP}),
+                loc=(required,), input=None))
+        if getattr(self, other) is not None:
+            problems.append(InitErrorDetails(
+                type=PydanticCustomError("extra_forbidden", "{field} must be left out when ADP is '{adp}'",
+                                         {"field": other, "adp": self.ADP}),
+                loc=(other,), input=getattr(self, other).model_dump()))
+        if problems:
+            raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
 
 
-class PhaseStructure(BaseModel):
-    """A phase's crystal structure: space group, cell, atoms (core-owned, A35).
-
-    Validation derives each atom's site (multiplicity, DOF) from the space group
-    (:func:`powderline.symmetry.analyze_site`). It rejects ambiguous positions
-    and stated multiplicities that don't match. It replaces stated coordinates
-    with the canonical ones, so every engine receives the same exact structure.
-    Each adjustment is reported by :meth:`warnings` (A73). The unit cell must
-    fit the space group exactly (A77), and anisotropic ADPs the site symmetry
-    (A78).
+_OPEN_PARAMETER_TYPE = (
+    "{name} has no parameter type: subclass Phase[RefinableParameter] (no bounds) or "
+    "Phase[BoundedRefinableParameter] (bounds); a deliberately generic subclass declares "
+    "Generic[P] and is parametrized before use"
+)
 
-    Every structural problem is reported at its own location (A70):
-    ``unit_cell``, ``atoms.<label>`` (the position), ``atoms.<label>.Multiplicity``,
-    ``atoms.<label>.Uaniso``; all of them together, in one ``ValidationError``.
+#: Phase fields owned by core; an engine subclass may not redeclare them (A93).
+RESERVED_PHASE_FIELDS = ("space_group", "unit_cell", "atoms")
+
+
+class Phase(CoreModel, Generic[P]):
+    """A phase block's core part: space group, cell and atoms (A93).
+
+    Engine schemas subclass ``Phase[TheirParameterType]`` and add their own
+    phase fields flat (gsasii: ``scale``, ``peak_broadening``); the phase name
+    is the key of the payload's ``phases`` dict (A100). Core's field names are
+    reserved (:data:`RESERVED_PHASE_FIELDS`): redeclaring one raises
+    ``TypeError`` when the subclass is defined.
+
+    ``space_group`` is gemmi's canonical name (A105). Validation derives each
+    atom's site (multiplicity, DOF) from it (:func:`powderline.symmetry.analyze_site`)
+    and rejects ambiguous positions and stated multiplicities that don't match.
+
+    **One rule for symmetry-determined values** (A115, A120, A121, A123): the
+    first member of each tie group is an independent parameter, kept exactly as
+    stated. Every other value is *derived* from the space group and those
+    parameters in exact rational arithmetic, and the validated model holds the
+    derived value (the float nearest it), so every tie holds exactly and every
+    engine receives one structure. The recipe states every derived value; how
+    closely is checked per kind:
+
+    - a **constant** of the space group (a fixed coordinate, a fixed Uij = 0)
+      with an exact decimal form must be written exactly (to floating-point
+      precision, :data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`): ``0.5``,
+      not ``0.4999999``; ``0``, not ``1e-9``. One with none (a third) is
+      written to at least 6 decimals (within 5e-6, A73) and read;
+    - a value **derived from another stated value** (a coupled coordinate
+      ``y = 2x``, ``y = x + 1/3``; a coupled Uij ``U12 = U22/2``; a tied
+      member's bounds) is read within the stated precision of its family:
+      coordinates 5e-6 (A73), Uij 1e-6 A^2 (A78);
+    - the **cell** (A77, A123): tied lengths and angles equal the first
+      member's, and fixed angles are 90 or 120, within ``CELL_TOL``
+      (1e-9, relative on lengths).
+
+    Anything else is an error that gives the values to write. Reading carries
+    no warning: within these tolerances the recipe has only that meaning (A73's
+    band rule excludes "just off" positions), and a dump of the model validates
+    as itself.
+
+    Refine flags and bounds must agree with the symmetry ties
+    (:func:`~powderline.symmetry.cell_tie_groups`,
+    :func:`~powderline.symmetry.coupling_groups`; A94, A95, A98, A106):
+    the members of one tie group carry the same flag (F1); a symmetry-fixed
+    parameter has flag false (F2) and no bounds (A106); different groups are
+    independent (F3); with bounds, each member's bounds follow the tie's
+    relation from the first member's (F4: ``member = k*rep + c`` maps
+    ``[min, max]`` to ``[k*min + c, k*max + c]``, swapped for k < 0). Atoms on
+    the same site are independent (A104).
+
+    Every problem is reported at its own location (A70): ``unit_cell``,
+    ``atoms.<label>`` (the position), ``atoms.<label>.Multiplicity``,
+    ``atoms.<label>.Uaniso``; a flag or bound rule at the parameter
+    (``unit_cell.b``, ``atoms.<label>.y``, ``atoms.<label>.Uaniso.U12``), for F1
+    at every member whose flag differs from the group's first member (review
+    N1); all of them together, in one ``ValidationError``.
     These checks run only once every field is valid: pydantic does not run
     model-level validators after a field error, so e.g. an unknown element is
     reported first, and the symmetry checks follow once it is fixed.
-    Validation never modifies the caller's :class:`Atom` objects; adjusted atoms
-    are copies.
-    """
 
-    model_config = _STRICT
+    :meth:`warnings` holds informative findings that change nothing: a
+    ``Uaniso`` that is not positive definite (A118).
+    """
 
-    phase_name: str = Field(min_length=1)
-    space_group: str = Field(description="Hermann-Mauguin symbol with an explicit setting "
-                                         "for two-origin (':1'/':2') and rhombohedral (':H'/':R') groups")
-    unit_cell: UnitCell
-    atoms: dict[str, Atom] = Field(min_length=1, description="Atoms keyed by unique label")
+    space_group: str = Field(description="gemmi's canonical extended Hermann-Mauguin name, e.g. "
+                                         "'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2' (A105)")
+    unit_cell: UnitCell[P]
+    atoms: dict[CoreName, Atom[P]] = Field(
+        min_length=1, json_schema_extra=name_keyed,
+        description="Atoms keyed by unique label: a letter, then ASCII letters, digits or '_'")
 
     _sites: dict = PrivateAttr(default_factory=dict)
     _warnings: list = PrivateAttr(default_factory=list)
 
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        """Guard core's contract in every engine subclass (A93, A109, A114, A122).
+
+        A subclass may add fields and validators that *check*, but nothing that
+        replaces, skips or rewrites core's validation:
+
+        1. no class in its MRO besides core's own (a subclass or a mixin) may
+           redeclare core's fields, reuse the name of a core validator, private
+           attribute or method, or define a pydantic entry point
+           (:data:`_RESERVED_ENTRY_POINTS`); pydantic collects validators by
+           name, so a same-named validator would silently replace core's;
+        2. every core validator must still be core's own function (catches any
+           route the names miss);
+        3. its own validators run in ``'after'`` mode only (a model validator,
+           or a field validator on a core field): a ``'before'``, ``'wrap'`` or
+           ``'plain'`` one could rewrite the recipe before core reads it, or
+           skip core entirely;
+        4. ``extra`` stays ``'forbid'`` (A19), and the parameter type is
+           :class:`RefinableParameter` or :class:`BoundedRefinableParameter`.
+
+        A canary test runs core's must-fail recipes through every engine phase
+        model (``tests/test_phase_canary.py``).
+        """
+        super().__pydantic_init_subclass__(**kwargs)
+        generic = cls.__pydantic_generic_metadata__
+        if generic["origin"] is not None:
+            wrong = [a for a in generic["args"] if not isinstance(a, TypeVar)
+                     and not (isinstance(a, type) and issubclass(a, (RefinableParameter, BoundedRefinableParameter)))]
+            if wrong:
+                raise TypeError(f"{cls.__name__}: the parameter type must be RefinableParameter or "
+                                f"BoundedRefinableParameter, not {', '.join(map(repr, wrong))}")
+        core_ancestry = set(Phase.__mro__)
+        for klass in cls.__mro__:
+            if klass in core_ancestry:
+                continue
+            if issubclass(klass, Phase) and klass.__pydantic_generic_metadata__["origin"] is not None:
+                continue  # a parametrization (e.g. Phase[RefinableParameter]); its origin is checked itself
+            annotations = inspect.get_annotations(klass)
+            redeclared = [n for n in RESERVED_PHASE_FIELDS if n in annotations]
+            if redeclared:
+                raise TypeError(
+                    f"{klass.__name__} redeclares the core phase field(s) {', '.join(redeclared)}; "
+                    "core owns space_group, unit_cell and atoms (A93)"
+                )
+            reused = sorted(n for n in _reserved_phase_members() if n in klass.__dict__ or n in annotations)
+            if reused:
+                raise TypeError(
+                    f"{klass.__name__} reuses the core phase name(s) {', '.join(reused)}; a same-named "
+                    "validator, method or private attribute would replace core's silently; rename it"
+                )
+            entry = sorted(n for n in _RESERVED_ENTRY_POINTS
+                           if n in klass.__dict__ and _defined_outside_pydantic(klass.__dict__[n]))
+            if entry:
+                raise TypeError(
+                    f"{klass.__name__} defines {', '.join(entry)}; a phase model may not override pydantic's "
+                    "entry points, which could skip or replace core's validation (A122)"
+                )
+        decorators = cls.__pydantic_decorators__
+        replaced = sorted(name for kind, name, func in _core_decorators()
+                          if _underlying(getattr(decorators, kind).get(name)) is not func)
+        if replaced:
+            raise TypeError(f"{cls.__name__} replaces the core validator(s) {', '.join(replaced)} (A109, A122)")
+        core_names = {name for _kind, name, _func in _core_decorators()}
+        rewriting = sorted(
+            [n for n, d in decorators.model_validators.items() if n not in core_names and d.info.mode != "after"]
+            + [n for n, d in decorators.field_validators.items()
+               if n not in core_names and d.info.mode != "after"
+               and ({"*", *RESERVED_PHASE_FIELDS} & set(d.info.fields))]
+            + list(decorators.validators) + list(decorators.root_validators))
+        if rewriting:
+            raise TypeError(
+                f"{cls.__name__}: validator(s) {', '.join(rewriting)} must be 'after' validators (pydantic v2 "
+                "@model_validator / @field_validator): a 'before', 'wrap' or 'plain' validator could rewrite "
+                "the recipe before core reads it, or skip core's validation (A115, A122)"
+            )
+        if cls.model_config.get("extra") != "forbid":
+            raise TypeError(f"{cls.__name__} must keep extra='forbid' (A19)")
+        if cls.__pydantic_generic_metadata__["parameters"] and "__orig_bases__" not in cls.__dict__:
+            # ``class EnginePhase(Phase)`` forgot the parameter type. A deliberately generic
+            # subclass declares ``Generic[P]`` and is checked again when it is validated.
+            raise TypeError(_OPEN_PARAMETER_TYPE.format(name=cls.__name__))
+
+    @model_validator(mode="before")
+    @classmethod
+    def _parameter_type_chosen(cls, data: Any) -> Any:
+        """Refuse to validate without a parameter type (re/03b review A2).
+
+        Unparametrized, ``P`` would accept both parameter shapes, so one phase could
+        mix ``[value, flag]`` and ``[value, flag, min, max]``. An engine schema fixes
+        one type; this is a programming error, so it is a ``TypeError``, not a
+        validation error.
+        """
+        if cls.__pydantic_generic_metadata__["parameters"]:
+            raise TypeError(_OPEN_PARAMETER_TYPE.format(name=cls.__name__))
+        return data
+
     @field_validator("space_group")
     @classmethod
     def _space_group(cls, v: str) -> str:
-        resolve_space_group(v, explicit_setting=True)  # SymmetryError is a ValueError
+        canonical_space_group(v)  # SymmetryError is a ValueError
         return v
 
     @model_validator(mode="after")
-    def _sites_check(self) -> "PhaseStructure":
+    def _sites_check(self) -> "Phase":
         problems: list[InitErrorDetails] = []
 
         def problem(loc: tuple, message: str, value: Any) -> None:
             problems.append(InitErrorDetails(type="value_error", loc=loc, input=value,
                                              ctx={"error": ValueError(message)}))
 
+        def tie_rules(loc: tuple, params: dict, ties: Ties, family: "_Family", context: str,
+                      fixed_text) -> dict:
+            errors, bounds = _tie_rules(params, ties, family, context, fixed_text)
+            for name, message in errors:
+                problem((*loc, name), message, params[name].model_dump())
+            return bounds
+
+        sg = self.space_group
+        seen: dict[str, str] = {}
+        for label in self.atoms:  # A112 (amended): an atom label is unique ignoring case
+            other = seen.setdefault(label.lower(), label)
+            if other != label:
+                problem(("atoms", label), f"atom labels {other!r} and {label!r} differ only in case; rename one",
+                        label)
+
         cell = self.unit_cell
-        try:
-            check_cell(self.space_group, (cell.a, cell.b, cell.c, cell.alpha, cell.beta, cell.gamma))
-        except SymmetryError as exc:
-            problem(("unit_cell",), str(exc), cell.model_dump())
-        for label, atom in list(self.atoms.items()):
+        cell_params = {k: getattr(cell, k) for k in _CELL_FIELDS}
+        cell_ties = cell_tie_groups(sg)
+        fixed_angle = lambda name: _fixed_cell_angle(cell_ties, name)  # noqa: E731
+        derived_cell, write = _derive(cell_ties, {k: p.value for k, p in cell_params.items()}, fixed_angle, _CELL)
+        cell_ok = not write
+        if write:  # A77, A123
+            problem(("unit_cell",),
+                    f"unit cell is inconsistent with {sg!r} ({cell_ties.crystal_system}): stated "
+                    f"{', '.join(f'{k} = {cell_params[k].value!r}' for k in write)}, but by symmetry "
+                    f"{_ties_text(cell_ties, fixed_angle, only=write)}; write {_write_text(write)}",
+                    cell.model_dump())
+        else:
+            try:  # the metric must then be invariant (A77); the tie groups are checked against it exhaustively
+                check_cell(sg, tuple(derived_cell[k] for k in _CELL_FIELDS))
+            except SymmetryError as exc:  # pragma: no cover - cell_tie_groups agrees with the metric
+                problem(("unit_cell",), str(exc), cell.model_dump())
+                cell_ok = False
+        if cell_ok:  # flag and bound rules need a valid cell (A95, A98)
+            bounds = tie_rules(("unit_cell",), cell_params, cell_ties, _CELL,
+                               f"{cell_ties.crystal_system} cell ({sg!r})", lambda name: f"{fixed_angle(name)}")
+            updates = _updated(cell_params, derived_cell, bounds)
+            if updates:
+                self.unit_cell = cell.model_copy(update=updates)  # the caller's cell stays as given
+        model_cell = tuple(getattr(self.unit_cell, k).value for k in _CELL_FIELDS)
+
+        for label, atom in self.atoms.items():
             try:
-                site = analyze_site(self.space_group, (atom.x, atom.y, atom.z))
+                site = analyze_site(sg, (atom.x.value, atom.y.value, atom.z.value))
             except SymmetryError as exc:
                 problem(("atoms", label), str(exc), atom.model_dump())
                 continue  # the checks below need the site
-            update: dict[str, Any] = {}
+            self._sites[label] = site
+            context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
+            ties = coupling_groups(sg, site.canonical)
+            exact_xyz = lambda name: site.exact["xyz".index(name)]  # noqa: E731
+            xyz = {k: getattr(atom, k) for k in "xyz"}
+            stated = dict(zip("xyz", site.stated))
+            derived_xyz, write = _derive(ties.xyz, stated, exact_xyz, _COORDINATES)
+            if write:  # A73, A120, A121: within 5e-6 of a special position, but not stated as it
+                off = max(abs(stated[name] - value) for name, (value, _tol) in write.items())
+                problem(("atoms", label),
+                        f"{context}: {site.stated} is {off:.2g} from a special position, not on it "
+                        f"({_ties_text(ties.xyz, exact_xyz)}); write {_write_text(write)}", atom.model_dump())
             if atom.Multiplicity is not None and atom.Multiplicity != site.multiplicity:
                 problem(("atoms", label, "Multiplicity"),
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
-                        f"({self.space_group!r}, site {site.stated})", atom.Multiplicity)
+                        f"({sg!r}, site {site.stated})", atom.Multiplicity)
+            updates = _updated(xyz, derived_xyz, tie_rules(("atoms", label), xyz, ties.xyz, _COORDINATES, context,
+                                                            lambda name: str(exact_xyz(name))))
             if atom.Uaniso is not None:
-                stated_u = tuple(atom.Uaniso[k] for k in _UANISO_KEYS)
-                try:
-                    symmetric_u, u_adjusted = check_uij(self.space_group, site.canonical, stated_u)
-                except SymmetryError as exc:
-                    problem(("atoms", label, "Uaniso"), str(exc), atom.Uaniso)
-                else:
-                    if u_adjusted:
-                        update["Uaniso"] = dict(zip(_UANISO_KEYS, symmetric_u))
+                uij = {k: getattr(atom.Uaniso, k) for k in _UANISO_KEYS}
+                derived_u, write_u = _derive(ties.uij, {k: p.value for k, p in uij.items()},
+                                             lambda _name: Fraction(0), _UIJ)
+                if write_u:  # A78, A115, A121
+                    problem(("atoms", label, "Uaniso"),
+                            f"{context}: Uaniso is not site-symmetric ({_ties_text(ties.uij, lambda _n: 0)}); "
+                            f"write {_write_text(write_u)}", atom.model_dump()["Uaniso"])
+                elif cell_ok:
+                    principal = _principal_msd(model_cell, tuple(derived_u[k] for k in _UANISO_KEYS))
+                    scale = float(np.max(np.abs(principal)))
+                    if principal[0] <= 1e-12 * scale:  # informative, not an error (A118): changes nothing
+                        shown = ", ".join("0" if abs(v) <= 1e-12 * scale else f"{v:.3g}" for v in principal)
                         self._warnings.append(StructuredWarning(
-                            code="adp_symmetry_adjusted",
-                            message=(f"atom {label!r}: Uaniso {dict(zip(_UANISO_KEYS, stated_u))} "
-                                     f"adjusted to the site-symmetric values {update['Uaniso']}"),
+                            code="uaniso_not_positive_definite",
+                            message=(f"{context}: Uaniso is not positive definite (principal mean-square "
+                                     f"displacements {shown} A^2), so it describes no thermal ellipsoid; "
+                                     "it is used as stated"),
                             field_path=f"atoms.{label}.Uaniso",
                         ))
-            self._sites[label] = site
-            if site.adjusted:
-                update.update(zip(("x", "y", "z"), site.canonical))
-                self._warnings.append(StructuredWarning(
-                    code="special_position_adjusted",
-                    message=(f"atom {label!r}: coordinates {site.stated} are on a special position "
-                             f"(multiplicity {site.multiplicity}); using the exact values "
-                             f"{site.canonical}"),
-                    field_path=f"atoms.{label}",
-                ))
-            if update:
-                self.atoms[label] = atom.model_copy(update=update)
+                u_updates = _updated(uij, derived_u, tie_rules(("atoms", label, "Uaniso"), uij, ties.uij, _UIJ,
+                                                                context, lambda _name: "0"))
+                if u_updates:
+                    updates["Uaniso"] = atom.Uaniso.model_copy(update=u_updates)
+            if updates:
+                self.atoms[label] = atom.model_copy(update=updates)  # the caller's atom stays as given
         if problems:
             raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
 
     def site(self, label: str):
-        """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label``."""
+        """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label`` (its symmetry, not its values:
+        the model's atom holds the coordinates the engines receive)."""
         return self._sites[label]
 
     def warnings(self) -> list:
-        """Structured warnings raised while validating this structure (paths relative to it)."""
+        """Structured warnings from validating this phase (paths relative to it).
+
+        Informative only: a warning never comes with a changed value (A115), so
+        validating the same recipe again gives the same warnings.
+        """
         return list(self._warnings)
 
 
+def _reserved_phase_members() -> frozenset[str]:
+    """Names core's :class:`Phase` defines besides its fields: validators, private attributes, methods."""
+    decorators = Phase.__pydantic_decorators__
+    validators = {n for kind in ("validators", "field_validators", "root_validators", "field_serializers",
+                                 "model_serializers", "model_validators", "computed_fields")
+                  for n in getattr(decorators, kind)}
+    # Methods written in Phase itself (not the ones pydantic or abc generate, e.g. model_post_init).
+    methods = {n for n, v in Phase.__dict__.items()
+               if inspect.isfunction(v) and not n.startswith("__") and v.__qualname__.startswith("Phase.")}
+    return frozenset(validators | methods | set(Phase.__private_attributes__))
+
+
+#: pydantic entry points a phase model (or a mixin in its MRO) may not define: each could
+#: skip or replace core's validation without reusing a core name (A122).
+_RESERVED_ENTRY_POINTS = ("__init__", "model_post_init", "model_validate", "model_validate_json",
+                          "model_validate_strings", "model_construct", "__get_pydantic_core_schema__",
+                          "__pydantic_init_subclass__", "__class_getitem__")
+
+
+def _underlying(obj: Any) -> Any:
+    """The plain function behind a pydantic decorator, classmethod or bound method."""
+    func = getattr(obj, "func", obj)
+    return getattr(func, "__func__", func)
+
+
+def _defined_outside_pydantic(obj: Any) -> bool:
+    """False for the members pydantic generates in every model (e.g. ``model_post_init``)."""
+    func = _underlying(obj)
+    func = getattr(func, "__wrapped__", func)
+    return not (getattr(func, "__module__", None) or "").startswith("pydantic")
+
+
+def _core_decorators() -> list[tuple[str, str, Any]]:
+    """``(kind, name, function)`` of every validator and serializer core's :class:`Phase` defines."""
+    decorators = Phase.__pydantic_decorators__
+    return [(kind, name, _underlying(info))
+            for kind in ("validators", "field_validators", "root_validators", "field_serializers",
+                         "model_serializers", "model_validators")
+            for name, info in getattr(decorators, kind).items()]
+
+
+_CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
+
+
+def _uij_matrix(u) -> np.ndarray:
+    """The symmetric 3x3 matrix of (U11, U22, U33, U12, U13, U23)."""
+    u11, u22, u33, u12, u13, u23 = u
+    return np.array([[u11, u12, u13], [u12, u22, u23], [u13, u23, u33]], dtype=float)
+
+
+def _principal_msd(cell: tuple, u) -> np.ndarray:
+    """The principal mean-square displacements (A^2, ascending) of ``u`` in ``cell`` (A118).
+
+    The Cartesian tensor is ``A N U N A^T`` (``A`` the orthogonalization matrix,
+    ``N = diag(a*, b*, c*)``). It is a congruence transform of the Uij matrix, so
+    the signs are the Uij matrix's (Sylvester's law of inertia), but the values
+    are only right in Cartesian axes (an isotropic hexagonal U has U12 = U11/2).
+    """
+    unit_cell = gemmi.UnitCell(*cell)
+    orth = np.array(unit_cell.orth.mat.tolist())
+    reciprocal = unit_cell.reciprocal()
+    n = np.diag([reciprocal.a, reciprocal.b, reciprocal.c])
+    return np.linalg.eigvalsh(orth @ n @ _uij_matrix(u) @ n @ orth.T)
+
+
+def _same(got: float, want: float) -> bool:
+    """Equal to floating-point precision (``ADJUSTMENT_REPORT_TOL``, relative above 1)."""
+    return abs(got - want) <= ADJUSTMENT_REPORT_TOL * max(1.0, abs(want))
+
+
+def _within(got: float, want: float, tol: float) -> bool:
+    """``got`` states ``want`` within ``tol`` (never tighter than floating-point precision)."""
+    return _same(got, want) or abs(got - want) <= tol
+
+
+def _has_decimal_form(value: Fraction) -> bool:
+    """True when ``value`` has a finite decimal form (1/2, 1/4, 3/8), False for 1/3, 1/6, 1/12.
+
+    Symmetry only produces denominators 1, 2, 3, 4, 6, 8, 12 for fixed
+    coordinates (all settings, every distinct special site), so "no decimal
+    form" means "a third".
+    """
+    d = value.denominator
+    for p in (2, 5):
+        while d % p == 0:
+            d //= p
+    return d == 1
+
+
+@dataclass(frozen=True)
+class _Family:
+    """How closely a recipe must state the derived values of one kind of parameter (A121, A123).
+
+    ``fixed(name, exact)`` and ``member(name, derived)`` give the tolerance for a
+    symmetry-fixed parameter and for a tied member (0 = floating-point precision).
+    """
+
+    fixed: Callable[[str, Fraction], float]
+    member: Callable[[str, float], float]
+
+
+#: Coordinates: a fixed one with a decimal form exactly, a third to 6 decimals (A73, A120);
+#: a coupled one within 6 decimals of the value derived from its group's first member (A121).
+_COORDINATES = _Family(fixed=lambda _n, exact: 0.0 if _has_decimal_form(exact) else SPECIAL_POSITION_TOL,
+                       member=lambda _n, _v: SPECIAL_POSITION_TOL)
+#: Uij: a fixed one is exactly 0; a coupled one within 1e-6 A^2 (A78, A121).
+_UIJ = _Family(fixed=lambda _n, _exact: 0.0, member=lambda _n, _v: UIJ_TOL)
+
+
+def _cell_tol(name: str, value) -> float:
+    return CELL_TOL * abs(float(value)) if name in ("a", "b", "c") else CELL_TOL
+
+
+#: Cell: within CELL_TOL, relative on lengths, degrees on angles (A77, A123).
+_CELL = _Family(fixed=_cell_tol, member=_cell_tol)
+
+
+def _fixed_cell_angle(ties, name: str) -> Fraction:
+    """The exact value of a symmetry-fixed cell angle: 120 for gamma on hexagonal axes, else 90."""
+    return Fraction(120) if name == "gamma" and ties.crystal_system in ("hexagonal", "trigonal") else Fraction(90)
+
+
+def _derive(ties: Ties, stated: dict, exact, family: _Family) -> tuple[dict, dict]:
+    """``(derived, write)`` for one parameter set (a cell, a site's x/y/z, or its Uij; A121).
+
+    Each tie group's first member is the independent parameter and keeps its
+    stated value. Every other value is derived in exact rational arithmetic:
+    a fixed one is its exact value ``exact(name)``, a member ``k * rep + c``.
+    ``derived`` maps every name to the float nearest its derived value (what
+    the model holds); ``write`` maps the names stated beyond ``family``'s
+    tolerance to ``(derived, tolerance)``.
+    """
+    targets: dict[str, tuple[Fraction, float]] = {}
+    for name in ties.fixed:
+        value = Fraction(exact(name))
+        targets[name] = (value, family.fixed(name, value))
+    for group in ties.groups:
+        rep = Fraction(stated[group.members[0]])
+        targets[group.members[0]] = (rep, 0.0)
+        for name, k, c in zip(group.members[1:], group.coefficients[1:], group.offsets[1:]):
+            value = k * rep + c
+            targets[name] = (value, family.member(name, float(value)))
+    derived, write = {}, {}
+    for name, value in stated.items():
+        target, tol = targets[name]
+        derived[name] = float(target)
+        if not _within(value, derived[name], tol):
+            write[name] = (derived[name], tol)
+    return derived, write
+
+
+def _updated(params: dict, derived: dict, bounds: dict) -> dict:
+    """``model_copy`` updates for the parameters whose value or bounds the model holds derived."""
+    updates = {}
+    for name, param in params.items():
+        update = {} if derived[name] == param.value else {"value": derived[name]}
+        if name in bounds and bounds[name] != (param.min, param.max):
+            update["min"], update["max"] = bounds[name]
+        if update:
+            updates[name] = param.model_copy(update=update)
+    return updates
+
+
+def _ties_text(ties: Ties, exact, only=None) -> str:
+    """The symmetry relations of a parameter set, e.g. ``"x = 1/3, y = 2/3"``, ``"y = 2x"``, ``"b = a"``."""
+    parts = [f"{name} = {exact(name)}" for name in ties.fixed]
+    parts += [g.relation_text(m) for g in ties.groups for m in g.members[1:]]
+    if only is not None:
+        parts = [p for p in parts if p.split(" = ")[0] in only]
+    return ", ".join(parts)
+
+
+def _fmt_value(value: float, tol: float) -> str:
+    """A value to write: exactly when its decimal form is short (``0.5``, ``0.0061735``), else the
+    fewest decimals (at least 6) that state it within ``tol`` (``0.333333 (to at least 6 decimals)``)."""
+    text = repr(value)
+    if "e" not in text and len(text.partition(".")[2]) <= 8:
+        return text
+    for n in range(6, 17):
+        rounded = f"{value:.{n}f}"
+        if abs(float(rounded) - value) <= tol / 10:
+            return f"{rounded} (to at least {n} decimals)"
+    return text
+
+
+def _write_text(write: dict) -> str:
+    return ", ".join(f"{name} = {_fmt_value(value, tol)}" for name, (value, tol) in write.items())
+
+
+def _fmt_bounds(lo: Optional[float], hi: Optional[float], tol: Optional[float] = None) -> str:
+    """``[min, max]`` as stated (``repr``), or, with ``tol``, as values to write (:func:`_fmt_value`)."""
+    texts = ["null" if v is None else repr(v) if tol is None else _fmt_value(v, tol) for v in (lo, hi)]
+    values, notes = zip(*(t.partition(" (")[::2] for t in texts))
+    note = max(notes)
+    return f"[{', '.join(values)}]" + (f" ({note}" if note else "")
+
+
+_HOW_MANY = {2: "both", 3: "all three"}
+
+
+def _tie_rules(params: dict, ties: Ties, family: _Family, context: str,
+               fixed_value) -> tuple[list[tuple[str, str]], dict]:
+    """The flag and bound rules of one parameter set (cell, a site's x/y/z, or its Uij).
+
+    - **F2** (A95): a symmetry-fixed parameter has refine flag false.
+    - **A106**: a symmetry-fixed parameter has no bounds (min and max null).
+    - **F1** (A95): the members of a tie group carry the same flag. The error is
+      reported at every member whose flag differs from the group's first
+      member, naming the whole group (review N1).
+    - **F4** (A98, A121): with bounds, each member's bounds are derived from the
+      first member's like its value: ``member = k*rep + c`` maps ``[min, max]``
+      to ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
+      the matching side. Stated within ``family``'s member tolerance, they are
+      read as the derived bounds; otherwise an error gives them.
+    - **F3**: different groups are independent (nothing to check).
+
+    Returns ``([(name, message)], {name: (min, max) derived})``.
+    """
+    errors: list[tuple[str, str]] = []
+    bounds: dict[str, tuple] = {}
+    for name in ties.fixed:
+        param = params[name]
+        if param.refine_flag:
+            errors.append((name, f"{context}: {name} is fixed by symmetry (= {fixed_value(name)}); "
+                                 "set its refine flag to false"))
+        if isinstance(param, BoundedRefinableParameter) and (param.min is not None or param.max is not None):
+            errors.append((name, f"{context}: {name} is fixed by symmetry (= {fixed_value(name)}); "
+                                 "give it no bounds (min and max null)"))
+    for group in ties.groups:
+        if len(group.members) < 2:
+            continue
+        rep = params[group.members[0]]
+        flag_words = _HOW_MANY.get(len(group.members), f"all {len(group.members)}")
+        relations = group.relations_text()
+        for name in group.members[1:]:
+            if params[name].refine_flag != rep.refine_flag:
+                errors.append((name, f"{context}: {', '.join(group.members)} are one parameter"
+                                     f"{f' ({relations})' if relations else ''}; "
+                                     f"set the same refine flag on {flag_words}"))
+        if not isinstance(rep, BoundedRefinableParameter):
+            continue
+        for name in group.members[1:]:
+            param = params[name]
+            k, c = group.relation(name)
+            lo, hi = (None if v is None else float(k * Fraction(v) + c) for v in (rep.min, rep.max))
+            if k < 0:
+                lo, hi = hi, lo
+            tol = family.member(name, max(abs(v) for v in (lo, hi, 0.0) if v is not None))
+            if all((got is None) == (want is None) and (got is None or _within(got, want, tol))
+                   for got, want in ((param.min, lo), (param.max, hi))):
+                bounds[name] = (lo, hi)
+                continue
+            errors.append((name, f"{context}: the bounds of {name} must follow "
+                                 f"{group.relation_text(name)} from the bounds of {group.members[0]} "
+                                 f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi, tol)}, "
+                                 f"not {_fmt_bounds(param.min, param.max)}"))
+    return errors, bounds
+
 
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
 
@@ -712,7 +1331,7 @@ def _check_metadata(v: Optional[dict]) -> Optional[dict]:
     return v
 
 
-class CoreRecipe(BaseModel):
+class CoreRecipe(CoreModel):
     """The core-owned top level of every recipe; engine schemas subclass it.
 
     An engine schema narrows ``schema_name`` to its own names, types ``payload``,
@@ -721,8 +1340,6 @@ class CoreRecipe(BaseModel):
     for JSON-serializability and size, and echoed into results (A21, A64).
     """
 
-    model_config = _STRICT
-
     schema_name: str = Field(pattern=SCHEMA_NAME_PATTERN,
                              description='Engine and workflow, e.g. "gsasii.rietveld"')
     core_schema_version: str = Field(description="Core schema version the recipe is written against")
diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index 90d5387..3a9bb77 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -13,6 +13,12 @@
   A73): multiplicity + DOF from the space group, the ambiguous-band error, and
   the canonical (exact) special-position coordinates every gateway sends to its
   engine. Policy and evidence: devkit ``tasks/re03-symmetry-tolerance.md``.
+* :func:`canonical_space_group` -- the core schema's space-group rule: gemmi's
+  canonical name only (A105).
+* :func:`cell_tie_groups` / :func:`coupling_groups` -- which cell, coordinate
+  and Uij parameters are one parameter by symmetry, with their exact relation
+  (affine for coordinates), and which are fixed: the basis of the phase
+  block's flag and bound rules (A94, A95, A98).
 
 Space-group operations come from gemmi; the stabiliser / projector math is our
 own (~small, spec in plan §5). ``gemmi`` is an approved runtime dependency (D3).
@@ -143,6 +149,58 @@ def resolve_space_group(space_group: str, *, explicit_setting: bool = False) ->
     return sg
 
 
+def canonical_space_group(space_group: str) -> gemmi.SpaceGroup:
+    """Return the gemmi group whose canonical name is exactly ``space_group`` (core rule, A105).
+
+    The canonical name is gemmi's extended Hermann-Mauguin symbol ``xhm()``
+    (``"P m -3 m"``, ``"C 1 2/m 1"``, ``"R -3 m:H"``, ``"F d -3 m:2"``); it is
+    unique over gemmi's table and names the setting. Any other spelling raises
+    :class:`SymmetryError` whose message names the canonical form. gemmi's
+    lenient lookup is used only to build that suggestion, never to accept: it
+    would silently pick a default (``"Fd-3m"`` -> origin 1, ``"R-3m"`` -> ``:H``,
+    ``"C2/m"`` -> b-unique). A symbol without a setting lists the choices:
+    ``:H``/``:R``, ``:1``/``:2``, or every monoclinic setting of the group, by
+    unique axis.
+    The legacy 0.26.0 paths keep the lenient :func:`resolve_space_group`.
+    """
+    raw = str(space_group)
+    sg = gemmi.find_spacegroup_by_name(raw)
+    if sg is not None and sg.xhm() == raw:
+        return sg
+    if sg is None:
+        sg = gemmi.find_spacegroup_by_name(raw.replace(" ", ""))
+    if sg is None:
+        raise SymmetryError(
+            f"unrecognized space-group symbol {raw!r}; write gemmi's canonical name "
+            "(e.g. 'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2')"
+        )
+    if ":" not in raw and sg.ext in ("H", "R"):
+        hexagonal, rhombohedral = (gemmi.find_spacegroup_by_name(f"{sg.hm}:{s}").xhm() for s in "HR")
+        raise SymmetryError(
+            f"space group {raw!r} does not name its setting; write {hexagonal!r} (hexagonal axes) "
+            f"or {rhombohedral!r} (rhombohedral axes)"
+        )
+    if ":" not in raw and sg.ext in ("1", "2"):
+        origin1, origin2 = (gemmi.find_spacegroup_by_name(f"{sg.hm}:{s}").xhm() for s in "12")
+        raise SymmetryError(
+            f"space group {raw!r} has two origin choices; write {origin1!r} or {origin2!r}"
+        )
+    if sg.crystal_system_str() == "monoclinic" and raw.replace(" ", "") != sg.hm.replace(" ", ""):
+        # A short monoclinic symbol ("P21/c", "C2/m") leaves the unique axis and the cell
+        # choice unstated; gemmi silently picks one, so list them all (review B3).
+        by_axis: dict[str, list[str]] = {}
+        for s in gemmi.spacegroup_table():
+            if s.number == sg.number:
+                by_axis.setdefault(_monoclinic_unique_axis(_expanded_ops(s)), []).append(repr(s.xhm()))
+        choices = "; ".join(f"unique axis {axis}: {', '.join(names)}" for axis, names in sorted(
+            by_axis.items(), key=lambda item: "bca".index(item[0])))
+        raise SymmetryError(
+            f"space group {raw!r} does not state its unique axis or cell choice (gemmi would read it "
+            f"as {sg.xhm()!r}); write the setting you mean: {choices}"
+        )
+    raise SymmetryError(f"space group {raw!r} is not in the canonical form; write {sg.xhm()!r}")
+
+
 def _expanded_ops(sg: gemmi.SpaceGroup) -> list[tuple[np.ndarray, np.ndarray]]:
     """All symmetry operations (centering expanded) as (R float 3x3, t float 3)."""
     den = float(gemmi.Op.DEN)
@@ -158,20 +216,23 @@ def _expanded_ops(sg: gemmi.SpaceGroup) -> list[tuple[np.ndarray, np.ndarray]]:
 
 
 def _monoclinic_unique_axis(ops: list[tuple[np.ndarray, np.ndarray]]) -> str:
-    """Unique axis of a monoclinic group from its proper 2-fold direction.
+    """Unique axis of a monoclinic group: its 2-fold axis or its mirror/glide normal.
 
-    The single proper 2-fold (det +1, trace -1) fixes the unique axis; its
-    invariant direction maps to the dominant cell axis a/b/c.
+    Every operation of a monoclinic point group other than 1 and -1 is a proper
+    2-fold (trace -1) or a mirror (trace +1). For either, ``det(R) R`` is a proper
+    2-fold about the unique axis, whose invariant direction maps to the dominant
+    cell axis a/b/c. Mirror-only groups (Pm, Pc, Cm, Cc) have no proper 2-fold,
+    so the mirror normal is needed (A102).
     """
     for R, _t in ops:
-        if abs(np.linalg.det(R) - 1.0) < _MAT_TOL and abs(np.trace(R) + 1.0) < _MAT_TOL:
-            evals, evecs = np.linalg.eig(R)
+        if abs(abs(np.trace(R)) - 1.0) < _MAT_TOL:
+            evals, evecs = np.linalg.eig(np.sign(np.linalg.det(R)) * R)
             for i in range(3):
                 if abs(evals[i].real - 1.0) < _MAT_TOL and abs(evals[i].imag) < _MAT_TOL:
                     direction = np.abs(evecs[:, i].real)
                     return _LENGTHS[int(np.argmax(direction))]
     raise SymmetryError(
-        "could not determine the monoclinic unique axis (no proper 2-fold found)"
+        "could not determine the monoclinic unique axis (no 2-fold axis or mirror found)"
     )
 
 
@@ -362,10 +423,15 @@ class SiteAnalysis:
 
     Attributes:
         stated: the coordinates as given.
-        canonical: the coordinates every gateway uses -- equal to ``stated`` for
-            a general position; on a special position, symmetry-fixed axes are
-            exact (see ``exact``) and coupled axes satisfy their relation (to
-            floating-point precision), by the least change from ``stated``.
+        canonical: ``stated`` moved onto the special position by the least
+            (orthogonal) change: equal to ``stated`` for a general position;
+            on a special position, symmetry-fixed axes are exact (see
+            ``exact``) and coupled axes satisfy their relation (to
+            floating-point precision). Used here to find the stabilizer and
+            the tie offsets. It is **not** what the engines receive: the
+            validated core ``Phase`` holds those coordinates (A120), and keeps
+            a tie group's first member as stated where ``canonical`` may move
+            it (e.g. by ~1e-7 at a ``y = x + 1/3`` tie).
         exact: per axis, the exact rational value of a symmetry-fixed
             coordinate (``None`` for a free or coupled axis).
         axes: ``"FREE"`` / ``"FIXED"`` / ``"COUPLED"`` per axis.
@@ -393,7 +459,7 @@ def _fmt_xyz(xyz) -> str:
 
 
 def _fmt_exact(values, exact) -> str:
-    return "(" + ", ".join(str(e) if e is not None else f"{v:.6g}" for v, e in zip(values, exact)) + ")"
+    return "(" + ", ".join(str(e) if e is not None else f"{v:.6f}" for v, e in zip(values, exact)) + ")"
 
 
 def _barycenter(x: np.ndarray, ops) -> np.ndarray:
@@ -600,3 +666,194 @@ def check_uij(space_group: str, xyz, uij) -> tuple[tuple[float, ...], bool]:
     if not np.any(np.abs(symmetric - stated) > ADJUSTMENT_REPORT_TOL):
         return tuple(float(v) for v in stated), False
     return tuple(float(v) for v in symmetric), True
+
+
+# --- (f) tie groups: cell (A95) and site coupling groups (A94, A98, A102) ---
+
+
+@dataclass(frozen=True)
+class TieGroup:
+    """Parameters that are one parameter by symmetry: ``member = k * rep + c``.
+
+    The first member is the representative (``k = 1``, ``c = 0``). ``k`` and
+    ``c`` are exact. Offsets are nonzero only for coordinates (affine ties such
+    as ``(x, x+1/2, z)``); they come from the canonical position, so they
+    reflect the lattice translate that was stated (A98). Cell ties are equalities.
+
+    Attributes:
+        members: parameter names, in canonical order (a..gamma, x/y/z, U11..U23).
+        coefficients: ``k`` per member.
+        offsets: ``c`` per member.
+    """
+
+    members: tuple[str, ...]
+    coefficients: tuple[Fraction, ...]
+    offsets: tuple[Fraction, ...]
+
+    def relation(self, member: str) -> tuple[Fraction, Fraction]:
+        """``(k, c)`` of ``member = k * rep + c``."""
+        i = self.members.index(member)
+        return self.coefficients[i], self.offsets[i]
+
+    def relation_text(self, member: str) -> str:
+        """``member``'s relation to the representative, e.g. ``"y = x + 1/2"`` or ``"b = a"``."""
+        k, c = self.relation(member)
+        return f"{member} = {_affine_text(k, self.members[0], c)}"
+
+    def relations_text(self) -> str:
+        """The non-trivial relations, e.g. ``"y = x + 1/2"`` or ``"U12 = U22/2"``; ``""`` for equal ties."""
+        rep = self.members[0]
+        parts = [f"{m} = {_affine_text(k, rep, c)}" for m, k, c in
+                 zip(self.members[1:], self.coefficients[1:], self.offsets[1:]) if (k, c) != (1, 0)]
+        return ", ".join(parts)
+
+
+@dataclass(frozen=True)
+class Ties:
+    """Symmetry ties of one parameter set: tie groups of the free parameters, and the fixed ones.
+
+    Every parameter is in exactly one group or in ``fixed``. A singleton group is
+    an independent parameter.
+    """
+
+    groups: tuple[TieGroup, ...]
+    fixed: tuple[str, ...]
+
+    def group_of(self, name: str) -> TieGroup | None:
+        return next((g for g in self.groups if name in g.members), None)
+
+
+@dataclass(frozen=True)
+class CellTies(Ties):
+    """:class:`Ties` of the unit cell, with the crystal system and monoclinic unique axis."""
+
+    crystal_system: str = ""
+    unique_axis: str | None = None
+
+
+@dataclass(frozen=True)
+class SiteTies:
+    """Coordinate and Uij :class:`Ties` of one atomic site (U11, U22, U33, U12, U13, U23)."""
+
+    xyz: Ties
+    uij: Ties
+
+
+def _affine_text(k: Fraction, rep: str, c: Fraction) -> str:
+    sign = "-" if k < 0 else ""
+    k = abs(k)
+    term = f"{sign}{k.numerator if k.numerator != 1 else ''}{rep}" + (f"/{k.denominator}" if k.denominator != 1 else "")
+    if c == 0:
+        return term
+    return f"{term} {'+' if c > 0 else '-'} {abs(c)}"
+
+
+def _equal_group(names) -> TieGroup:
+    n = len(names)
+    return TieGroup(tuple(names), (Fraction(1),) * n, (Fraction(0),) * n)
+
+
+def cell_tie_groups(space_group: str) -> CellTies:
+    """Cell tie groups for ``space_group``: equal lengths, tied free angles, fixed angles.
+
+    Every free group is one parameter (A94): cubic ``{a, b, c}``; tetragonal and
+    hexagonal axes ``{a, b}``, ``{c}``; rhombohedral axes (``:R``) ``{a, b, c}`` and
+    ``{alpha, beta, gamma}``; monoclinic: each length plus the unique-axis angle
+    (A102); triclinic: all six independent. Unlike :func:`cell_constraints`
+    (kept for the legacy callers, which rely on its ``:R`` refusal), this covers
+    ``:R``. The setting must be explicit (A62).
+    """
+    sg = resolve_space_group(space_group, explicit_setting=True)
+    system = sg.crystal_system_str()
+    lengths = [_equal_group((n,)) for n in _LENGTHS]
+    if system == "cubic":
+        return CellTies((_equal_group(_LENGTHS),), _ANGLES, system)
+    if system in ("tetragonal", "hexagonal", "trigonal"):
+        if sg.ext == "R":
+            return CellTies((_equal_group(_LENGTHS), _equal_group(_ANGLES)), (), system)
+        return CellTies((_equal_group(("a", "b")), _equal_group(("c",))), _ANGLES, system)
+    if system == "orthorhombic":
+        return CellTies(tuple(lengths), _ANGLES, system)
+    if system == "monoclinic":
+        unique = _monoclinic_unique_axis(_expanded_ops(sg))
+        free = {"a": "alpha", "b": "beta", "c": "gamma"}[unique]
+        return CellTies((*lengths, _equal_group((free,))), tuple(a for a in _ANGLES if a != free),
+                        system, unique)
+    if system == "triclinic":
+        return CellTies((*lengths, *(_equal_group((a,)) for a in _ANGLES)), (), system)
+    raise SymmetryError(  # pragma: no cover - gemmi has no other crystal system
+        f"unsupported crystal system {system!r} for space group {space_group!r}"
+    )
+
+
+def _snap(value: float, max_denominator: int, what: str) -> Fraction:
+    frac = Fraction(value).limit_denominator(max_denominator)
+    if abs(float(frac) - value) > 1e-9:  # pragma: no cover - internal invariant
+        raise SymmetryError(f"{what} {value!r} is not a simple fraction (internal error)")
+    return frac
+
+
+def _tie_groups(projector: np.ndarray, names, values=None) -> Ties:
+    """Tie groups = connected components of the orthogonal projector's nonzero entries.
+
+    Each component must have one degree of freedom (rank 1). Its relation comes
+    from the component's basis vector; with ``values`` (the canonical
+    coordinates) the affine offsets ``c = member - k * rep`` are added.
+    """
+    n = len(names)
+    fixed = [np.linalg.norm(projector[j, :]) < _MAT_TOL for j in range(n)]
+    parent = list(range(n))
+
+    def find(i):
+        while parent[i] != i:
+            i = parent[i]
+        return i
+
+    for j in range(n):
+        for k in range(j + 1, n):
+            if not fixed[j] and not fixed[k] and abs(projector[j, k]) > _MAT_TOL:
+                parent[find(k)] = find(j)
+    components: dict[int, list[int]] = {}
+    for j in range(n):
+        if not fixed[j]:
+            components.setdefault(find(j), []).append(j)
+    groups = []
+    for members in sorted(components.values()):
+        block = projector[np.ix_(members, members)]
+        if abs(np.trace(block) - 1.0) > 1e-6:  # pragma: no cover - checked exhaustively in the tests
+            raise SymmetryError(f"tie group {[names[j] for j in members]} has "
+                                f"{np.trace(block):.3g} degrees of freedom (internal error)")
+        basis = block[:, int(np.argmax(np.diag(block)))]
+        ks = tuple(_snap(float(b / basis[0]), 12, "tie coefficient") for b in basis)
+        if values is None:
+            cs = (Fraction(0),) * len(members)
+        else:
+            rep = values[members[0]]
+            cs = tuple(_snap(float(values[j] - float(k) * rep), _MAX_DENOMINATOR, "tie offset")
+                       for j, k in zip(members, ks))
+        groups.append(TieGroup(tuple(names[j] for j in members), ks, cs))
+    return Ties(tuple(groups), tuple(names[j] for j in range(n) if fixed[j]))
+
+
+def coupling_groups(space_group: str, xyz) -> SiteTies:
+    """Coordinate and Uij tie groups of the site at ``xyz`` (A94, A95, A98).
+
+    The site is analyzed first (:func:`analyze_site`; ambiguous positions raise),
+    and the groups are taken at its canonical position. Non-fixed components are
+    grouped by connectivity of the **orthogonal** projector onto the allowed
+    subspace (the oblique Reynolds average gives wrong Uij groups on hexagonal
+    axes). Every group has one degree of freedom: one engine parameter.
+    Coordinate relations are affine (``y = x + 1/2`` at P-42_1m 4e), with the
+    offset taken from the canonical values; Uij relations are linear
+    (``U12 = U22/2``, ``U13 = -U23``). Checked against GSAS-II's
+    ``GetCSxinel``/``GetCSuinel`` over every distinct special site on the 1/24
+    grid of every setting GSAS-II reads (``tests/test_symmetry_characterization.py``).
+    """
+    site = analyze_site(space_group, xyz)
+    x = np.asarray(site.canonical)
+    ops = _expanded_ops(resolve_space_group(space_group, explicit_setting=True))
+    stab = [R for R, t in ops if np.max(np.abs(_wrap_symmetric(R @ x + t - x))) < SPECIAL_POSITION_TOL]
+    return SiteTies(
+        xyz=_tie_groups(_orthogonal_projector(sum(stab) / len(stab)), _AXIS_LETTERS, x),
+        uij=_tie_groups(_orthogonal_projector(_adp_projector(stab)), _UIJ_NAMES),
+    )
diff --git a/tests/data/canonical_space_groups.txt b/tests/data/canonical_space_groups.txt
new file mode 100644
index 0000000..e7baee8
--- /dev/null
+++ b/tests/data/canonical_space_groups.txt
@@ -0,0 +1,564 @@
+P 1
+P -1
+P 1 2 1
+P 1 1 2
+P 2 1 1
+P 1 21 1
+P 1 1 21
+P 21 1 1
+C 1 2 1
+A 1 2 1
+I 1 2 1
+A 1 1 2
+B 1 1 2
+I 1 1 2
+B 2 1 1
+C 2 1 1
+I 2 1 1
+P 1 m 1
+P 1 1 m
+P m 1 1
+P 1 c 1
+P 1 n 1
+P 1 a 1
+P 1 1 a
+P 1 1 n
+P 1 1 b
+P b 1 1
+P n 1 1
+P c 1 1
+C 1 m 1
+A 1 m 1
+I 1 m 1
+A 1 1 m
+B 1 1 m
+I 1 1 m
+B m 1 1
+C m 1 1
+I m 1 1
+C 1 c 1
+A 1 n 1
+I 1 a 1
+A 1 a 1
+C 1 n 1
+I 1 c 1
+A 1 1 a
+B 1 1 n
+I 1 1 b
+B 1 1 b
+A 1 1 n
+I 1 1 a
+B b 1 1
+C n 1 1
+I c 1 1
+C c 1 1
+B n 1 1
+I b 1 1
+P 1 2/m 1
+P 1 1 2/m
+P 2/m 1 1
+P 1 21/m 1
+P 1 1 21/m
+P 21/m 1 1
+C 1 2/m 1
+A 1 2/m 1
+I 1 2/m 1
+A 1 1 2/m
+B 1 1 2/m
+I 1 1 2/m
+B 2/m 1 1
+C 2/m 1 1
+I 2/m 1 1
+P 1 2/c 1
+P 1 2/n 1
+P 1 2/a 1
+P 1 1 2/a
+P 1 1 2/n
+P 1 1 2/b
+P 2/b 1 1
+P 2/n 1 1
+P 2/c 1 1
+P 1 21/c 1
+P 1 21/n 1
+P 1 21/a 1
+P 1 1 21/a
+P 1 1 21/n
+P 1 1 21/b
+P 21/b 1 1
+P 21/n 1 1
+P 21/c 1 1
+C 1 2/c 1
+A 1 2/n 1
+I 1 2/a 1
+A 1 2/a 1
+C 1 2/n 1
+I 1 2/c 1
+A 1 1 2/a
+B 1 1 2/n
+I 1 1 2/b
+B 1 1 2/b
+A 1 1 2/n
+I 1 1 2/a
+B 2/b 1 1
+C 2/n 1 1
+I 2/c 1 1
+C 2/c 1 1
+B 2/n 1 1
+I 2/b 1 1
+P 2 2 2
+P 2 2 21
+P 21 2 2
+P 2 21 2
+P 21 21 2
+P 2 21 21
+P 21 2 21
+P 21 21 21
+C 2 2 21
+A 21 2 2
+B 2 21 2
+C 2 2 2
+A 2 2 2
+B 2 2 2
+F 2 2 2
+I 2 2 2
+I 21 21 21
+P m m 2
+P 2 m m
+P m 2 m
+P m c 21
+P c m 21
+P 21 m a
+P 21 a m
+P b 21 m
+P m 21 b
+P c c 2
+P 2 a a
+P b 2 b
+P m a 2
+P b m 2
+P 2 m b
+P 2 c m
+P c 2 m
+P m 2 a
+P c a 21
+P b c 21
+P 21 a b
+P 21 c a
+P c 21 b
+P b 21 a
+P n c 2
+P c n 2
+P 2 n a
+P 2 a n
+P b 2 n
+P n 2 b
+P m n 21
+P n m 21
+P 21 m n
+P 21 n m
+P n 21 m
+P m 21 n
+P b a 2
+P 2 c b
+P c 2 a
+P n a 21
+P b n 21
+P 21 n b
+P 21 c n
+P c 21 n
+P n 21 a
+P n n 2
+P 2 n n
+P n 2 n
+C m m 2
+A 2 m m
+B m 2 m
+C m c 21
+C c m 21
+A 21 m a
+A 21 a m
+B b 21 m
+B m 21 b
+C c c 2
+A 2 a a
+B b 2 b
+A m m 2
+B m m 2
+B 2 m m
+C 2 m m
+C m 2 m
+A m 2 m
+A b m 2
+B m a 2
+B 2 c m
+C 2 m b
+C m 2 a
+A c 2 m
+A m a 2
+B b m 2
+B 2 m b
+C 2 c m
+C c 2 m
+A m 2 a
+A b a 2
+B b a 2
+B 2 c b
+C 2 c b
+C c 2 a
+A c 2 a
+F m m 2
+F 2 m m
+F m 2 m
+F d d 2
+F 2 d d
+F d 2 d
+I m m 2
+I 2 m m
+I m 2 m
+I b a 2
+I 2 c b
+I c 2 a
+I m a 2
+I b m 2
+I 2 m b
+I 2 c m
+I c 2 m
+I m 2 a
+P m m m
+P n n n:1
+P n n n:2
+P c c m
+P m a a
+P b m b
+P b a n:1
+P b a n:2
+P n c b:1
+P n c b:2
+P c n a:1
+P c n a:2
+P m m a
+P m m b
+P b m m
+P c m m
+P m c m
+P m a m
+P n n a
+P n n b
+P b n n
+P c n n
+P n c n
+P n a n
+P m n a
+P n m b
+P b m n
+P c n m
+P n c m
+P m a n
+P c c a
+P c c b
+P b a a
+P c a a
+P b c b
+P b a b
+P b a m
+P m c b
+P c m a
+P c c n
+P n a a
+P b n b
+P b c m
+P c a m
+P m c a
+P m a b
+P b m a
+P c m b
+P n n m
+P m n n
+P n m n
+P m m n:1
+P m m n:2
+P n m m:1
+P n m m:2
+P m n m:1
+P m n m:2
+P b c n
+P c a n
+P n c a
+P n a b
+P b n a
+P c n b
+P b c a
+P c a b
+P n m a
+P m n b
+P b n m
+P c m n
+P m c n
+P n a m
+C m c m
+C c m m
+A m m a
+A m a m
+B b m m
+B m m b
+C m c a
+C c m b
+A b m a
+A c a m
+B b c m
+B m a b
+C m m m
+A m m m
+B m m m
+C c c m
+A m a a
+B b m b
+C m m a
+C m m b
+A b m m
+A c m m
+B m c m
+B m a m
+C c c a:1
+C c c a:2
+C c c b:1
+C c c b:2
+A b a a:1
+A b a a:2
+A c a a:1
+A c a a:2
+B b c b:1
+B b c b:2
+B b a b:1
+B b a b:2
+F m m m
+F d d d:1
+F d d d:2
+I m m m
+I b a m
+I m c b
+I c m a
+I b c a
+I c a b
+I m m a
+I m m b
+I b m m
+I c m m
+I m c m
+I m a m
+P 4
+P 41
+P 42
+P 43
+I 4
+I 41
+P -4
+I -4
+P 4/m
+P 42/m
+P 4/n:1
+P 4/n:2
+P 42/n:1
+P 42/n:2
+I 4/m
+I 41/a:1
+I 41/a:2
+P 4 2 2
+P 4 21 2
+P 41 2 2
+P 41 21 2
+P 42 2 2
+P 42 21 2
+P 43 2 2
+P 43 21 2
+I 4 2 2
+I 41 2 2
+P 4 m m
+P 4 b m
+P 42 c m
+P 42 n m
+P 4 c c
+P 4 n c
+P 42 m c
+P 42 b c
+I 4 m m
+I 4 c m
+I 41 m d
+I 41 c d
+P -4 2 m
+P -4 2 c
+P -4 21 m
+P -4 21 c
+P -4 m 2
+P -4 c 2
+P -4 b 2
+P -4 n 2
+I -4 m 2
+I -4 c 2
+I -4 2 m
+I -4 2 d
+P 4/m m m
+P 4/m c c
+P 4/n b m:1
+P 4/n b m:2
+P 4/n n c:1
+P 4/n n c:2
+P 4/m b m
+P 4/m n c
+P 4/n m m:1
+P 4/n m m:2
+P 4/n c c:1
+P 4/n c c:2
+P 42/m m c
+P 42/m c m
+P 42/n b c:1
+P 42/n b c:2
+P 42/n n m:1
+P 42/n n m:2
+P 42/m b c
+P 42/m n m
+P 42/n m c:1
+P 42/n m c:2
+P 42/n c m:1
+P 42/n c m:2
+I 4/m m m
+I 4/m c m
+I 41/a m d:1
+I 41/a m d:2
+I 41/a c d:1
+I 41/a c d:2
+P 3
+P 31
+P 32
+R 3:H
+R 3:R
+P -3
+R -3:H
+R -3:R
+P 3 1 2
+P 3 2 1
+P 31 1 2
+P 31 2 1
+P 32 1 2
+P 32 2 1
+R 3 2:H
+R 3 2:R
+P 3 m 1
+P 3 1 m
+P 3 c 1
+P 3 1 c
+R 3 m:H
+R 3 m:R
+R 3 c:H
+R 3 c:R
+P -3 1 m
+P -3 1 c
+P -3 m 1
+P -3 c 1
+R -3 m:H
+R -3 m:R
+R -3 c:H
+R -3 c:R
+P 6
+P 61
+P 65
+P 62
+P 64
+P 63
+P -6
+P 6/m
+P 63/m
+P 6 2 2
+P 61 2 2
+P 65 2 2
+P 62 2 2
+P 64 2 2
+P 63 2 2
+P 6 m m
+P 6 c c
+P 63 c m
+P 63 m c
+P -6 m 2
+P -6 c 2
+P -6 2 m
+P -6 2 c
+P 6/m m m
+P 6/m c c
+P 63/m c m
+P 63/m m c
+P 2 3
+F 2 3
+I 2 3
+P 21 3
+I 21 3
+P m -3
+P n -3:1
+P n -3:2
+F m -3
+F d -3:1
+F d -3:2
+I m -3
+P a -3
+I a -3
+P 4 3 2
+P 42 3 2
+F 4 3 2
+F 41 3 2
+I 4 3 2
+P 43 3 2
+P 41 3 2
+I 41 3 2
+P -4 3 m
+F -4 3 m
+I -4 3 m
+P -4 3 n
+F -4 3 c
+I -4 3 d
+P m -3 m
+P n -3 n:1
+P n -3 n:2
+P m -3 n
+P n -3 m:1
+P n -3 m:2
+F m -3 m
+F m -3 c
+F d -3 m:1
+F d -3 m:2
+F d -3 c:1
+F d -3 c:2
+I m -3 m
+I a -3 d
+I 1 21 1
+C 1 21 1
+P 21212(a)
+C 2 2 21a)
+C 2 2 2a
+F 2 2 2a
+I 2 2 2a
+P 42 21 2a
+I 2 3a
+A 1
+B 1
+C 1
+F 1
+I 1
+A -1
+B -1
+C -1
+F -1
+I -1
+B 1 2 1
+C 1 1 2
+B 1 21 1
+C 1 1 21
+F 1 2 1
+F 1 m 1
+F 1 d 1
+F 1 2/m 1
+A b a m
+C 4 2 2
+C 4 2 21
+F 4 2 2
+C -4 2 m
+C -4 2 b
+F 4/m m m
diff --git a/tests/symmetry_sites.py b/tests/symmetry_sites.py
new file mode 100644
index 0000000..0156a93
--- /dev/null
+++ b/tests/symmetry_sites.py
@@ -0,0 +1,25 @@
+"""Test helper: enumerate every distinct special site of a space group on the 1/24 grid."""
+
+from __future__ import annotations
+
+import itertools
+
+import gemmi
+import numpy as np
+
+
+def distinct_special_sites(sg: gemmi.SpaceGroup) -> list[tuple[int, int, int]]:
+    """One grid point (in 1/24 units) per distinct site stabilizer met on the 1/24 grid.
+
+    Exact: integer arithmetic mod 24 (gemmi's ``Op.DEN`` is 24). Every fixed
+    special-position coordinate is a multiple of 1/24, so each stabilizer
+    (each orientation of each Wyckoff site) is met.
+    """
+    grid = np.array(list(itertools.product(range(24), repeat=3)), dtype=np.int64)
+    ops = list(sg.operations())
+    rots = np.array([op.rot for op in ops], dtype=np.int64) // gemmi.Op.DEN
+    trans = np.array([op.tran for op in ops], dtype=np.int64) * 24 // gemmi.Op.DEN
+    fixed = np.all((np.einsum("nij,pj->pni", rots, grid) + trans[None]) % 24 == grid[:, None, :], axis=2)
+    special = np.nonzero(fixed.sum(axis=1) > 1)[0]
+    _, first = np.unique(fixed[special], axis=0, return_index=True)
+    return [tuple(int(v) for v in grid[p]) for p in special[np.sort(first)]]
diff --git a/tests/test_gateways.py b/tests/test_gateways.py
index 1156041..9b2faff 100644
--- a/tests/test_gateways.py
+++ b/tests/test_gateways.py
@@ -474,6 +474,22 @@ def find_spec(self, name, path, target=None):
 import powderline.easydiff.gateway
 from powderline import registry
 
+# The core phase block and its symmetry rules run engine-free (re/03b)
+from powderline.schema_core import Phase, RefinableParameter
+from powderline.symmetry import canonical_space_group, cell_tie_groups, coupling_groups
+canonical_space_group("F d -3 m:2")
+assert [g.members for g in cell_tie_groups("R -3 m:R").groups] == [("a", "b", "c"), ("alpha", "beta", "gamma")]
+assert coupling_groups("P -4 21 m", (0.1, 0.6, 0.3)).xyz.groups[0].relations_text() == "y = x + 1/2"
+p = lambda v, f=False: [v, f]
+phase = Phase[RefinableParameter].model_validate({{
+    "space_group": "P 63/m m c",
+    "unit_cell": {{"a": p(3.0, True), "b": p(3.0, True), "c": p(5.0), "alpha": p(90.0), "beta": p(90.0),
+                  "gamma": p(120.0)}},
+    "atoms": {{"C": {{"element": "C", "x": p(1 / 6, True), "y": p(1 / 3, True), "z": p(0.25),
+                     "occupancy": p(1.0), "ADP": "Uiso", "Uiso": p(0.01)}}}},
+}})
+assert phase.site("C").multiplicity == 6 and phase.atoms["C"].x.value == 1 / 6
+
 recipes = {{
     "gsasii": json.loads(Path(r'{recipe_path}').read_text(encoding="utf-8")),
     "topas": json.loads(Path(r'{recipe_path}').read_text(encoding="utf-8")),
diff --git a/tests/test_phase_canary.py b/tests/test_phase_canary.py
new file mode 100644
index 0000000..1f5d62f
--- /dev/null
+++ b/tests/test_phase_canary.py
@@ -0,0 +1,130 @@
+"""Canary: core's must-fail recipes fail through every engine phase model (A122; re/03b PR review S2).
+
+``Phase.__pydantic_init_subclass__`` rejects, when a class is defined, an engine subclass that could
+replace, skip or rewrite core's validation. This is the behavioural check behind that structural guard:
+each engine phase model must reject every core violation at the same location as core does, and must
+hold the same values as core for a valid recipe (so no engine validator rewrites it, A115).
+
+re/04-06 add each engine phase model to ``ENGINE_PHASES``, with the engine fields a valid phase needs;
+``test_every_engine_phase_model_is_covered`` fails until they do.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+import pytest
+from pydantic import ValidationError
+
+from powderline.schema_core import BoundedRefinableParameter, Phase, RefinableParameter
+
+#: ``(module, class name, parameter type, engine fields of a valid phase)`` of every engine phase model.
+ENGINE_PHASES: list[tuple[str, str, type, dict]] = []
+
+
+def _models():
+    models = [(f"Phase[{p.__name__}]", Phase[p], p, {}) for p in (RefinableParameter, BoundedRefinableParameter)]
+    for module, name, param, fields in ENGINE_PHASES:
+        models.append((f"{module}.{name}", getattr(importlib.import_module(module), name), param, fields))
+    return models
+
+
+_MODELS = _models()
+
+
+def _p(value, flag=False, bounded=False, lo=None, hi=None):
+    return [value, flag, lo, hi] if bounded else [value, flag]
+
+
+def _phase(bounded: bool, sg="P m -3 m", cell=(4.0, 4.0, 4.0, 90.0, 90.0, 90.0), atoms=None) -> dict:
+    def atom(xyz, element="O"):
+        return {"element": element, **{k: _p(v, bounded=bounded) for k, v in zip("xyz", xyz)},
+                "occupancy": _p(1.0, bounded=bounded), "ADP": "Uiso", "Uiso": _p(0.01, bounded=bounded)}
+
+    atoms = atoms or {"A": (0.0, 0.0, 0.0), "B": (0.5, 0.2, 0.2)}
+    return {"space_group": sg,
+            "unit_cell": {k: _p(v, bounded=bounded) for k, v in zip(("a", "b", "c", "alpha", "beta", "gamma"), cell)},
+            "atoms": {label: atom(xyz) for label, xyz in atoms.items()}}
+
+
+def _break(case: str, d: dict, bounded: bool) -> tuple:
+    """Make ``d`` violate one core rule; return the location core reports it at."""
+    if case == "space group not canonical (A105)":
+        d["space_group"] = "Pm-3m"
+        return ("space_group",)
+    if case == "fixed parameter refined (F2)":
+        d["unit_cell"]["alpha"][1] = True
+        return ("unit_cell", "alpha")
+    if case == "tied flags differ (F1)":
+        d["unit_cell"]["a"][1] = True
+        return ("unit_cell", "b")
+    if case == "decimal special position not exact (A120)":
+        d["atoms"]["B"]["x"][0] = 0.4999999
+        return ("atoms", "B")
+    if case == "ambiguous position (A73)":
+        d["atoms"]["B"]["z"][0] = 0.2003
+        return ("atoms", "B")
+    if case == "Multiplicity wrong":
+        d["atoms"]["A"]["Multiplicity"] = 2
+        return ("atoms", "A", "Multiplicity")
+    if case == "fixed Uij not exactly 0 (A121)":
+        del d["atoms"]["A"]["Uiso"]
+        d["atoms"]["A"]["ADP"] = "Uaniso"
+        d["atoms"]["A"]["Uaniso"] = {k: _p(v, bounded=bounded) for k, v in
+                                     zip(("U11", "U22", "U33", "U12", "U13", "U23"), (0.01, 0.01, 0.01, 1e-9, 0, 0))}
+        return ("atoms", "A", "Uaniso")
+    if case == "atom labels differ only in case (A112)":
+        d["atoms"]["a"] = d["atoms"].pop("B")
+        return ("atoms", "a")
+    if case == "fixed parameter has bounds (A106)":
+        d["unit_cell"]["alpha"][2:] = [89.0, 91.0]
+        return ("unit_cell", "alpha")
+    if case == "tied bounds differ (F4)":
+        d["unit_cell"]["a"][2:] = [3.9, 4.1]
+        return ("unit_cell", "b")
+    raise AssertionError(case)  # pragma: no cover
+
+
+_CASES = ["space group not canonical (A105)", "fixed parameter refined (F2)", "tied flags differ (F1)",
+          "decimal special position not exact (A120)", "ambiguous position (A73)", "Multiplicity wrong",
+          "fixed Uij not exactly 0 (A121)", "atom labels differ only in case (A112)"]
+_BOUNDED_CASES = ["fixed parameter has bounds (A106)", "tied bounds differ (F4)"]
+
+
+@pytest.mark.parametrize("label, model, param, fields", _MODELS, ids=[m[0] for m in _MODELS])
+def test_core_rules_hold_in_every_phase_model(label, model, param, fields):
+    bounded = param is BoundedRefinableParameter
+    Phase.__dict__["__pydantic_init_subclass__"].__func__(model)  # the structural guard, whatever overrides it
+    for case in _CASES + (_BOUNDED_CASES if bounded else []):
+        d = {**_phase(bounded), **fields}
+        loc = _break(case, d, bounded)
+        with pytest.raises(ValidationError) as exc_info:
+            model.model_validate(d)
+        assert loc in [e["loc"] for e in exc_info.value.errors()], f"{label}: {case}"
+
+
+@pytest.mark.parametrize("label, model, param, fields", _MODELS, ids=[m[0] for m in _MODELS])
+def test_every_phase_model_holds_cores_values(label, model, param, fields):
+    """Thirds and derived members read the same in every model (A120, A121): no engine rewrites them."""
+    bounded = param is BoundedRefinableParameter
+    d = _phase(bounded, "P 63/m m c", (3.2, 3.2, 5.2, 90.0, 90.0, 120.0),
+               {"A": (0.333333, 0.666667, 0.25), "B": (0.833333, 0.666667, 0.25)})
+    core = Phase[param].model_validate(d).model_dump()
+    engine = model.model_validate({**d, **fields}).model_dump()
+    assert {k: engine[k] for k in core} == core
+
+
+def _subclasses(cls):
+    for sub in cls.__subclasses__():
+        yield sub
+        yield from _subclasses(sub)
+
+
+def test_every_engine_phase_model_is_covered():
+    """Every concrete phase model in PowderLine's own modules is in ENGINE_PHASES."""
+    covered = {model for _label, model, _param, _fields in _MODELS}
+    found = {cls for cls in _subclasses(Phase)
+             if cls.__module__.startswith("powderline.")
+             and not cls.__pydantic_generic_metadata__["parameters"]
+             and cls.__pydantic_generic_metadata__["origin"] is not Phase}
+    assert found <= covered, sorted(f"{c.__module__}.{c.__qualname__}" for c in found - covered)
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 775f5ea..b1a83a6 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -4,9 +4,10 @@
 engine schema shares (re/03).
 """
 import json
+from pathlib import Path
 
 import pytest
-from pydantic import ValidationError
+from pydantic import ConfigDict, PrivateAttr, ValidationError, field_validator, model_validator
 
 from powderline.schema_core import (
     CORE_SCHEMA_VERSION,
@@ -502,8 +503,6 @@ def test_check_core_schema_version_rejects_unsupported():
 from powderline.schema_core import (
     BoundedRefinableParameter,
     RefinableParameter,
-    StructureBoundedRefinableParameter,
-    StructureRefinableParameter,
     check_within_bounds,
 )
 from pydantic import BaseModel
@@ -520,16 +519,6 @@ class _WrapperBRP(BaseModel):
     a: BoundedRefinableParameter
 
 
-class _WrapperSRP(BaseModel):
-    """Wrapper for StructureRefinableParameter testing."""
-    a: StructureRefinableParameter
-
-
-class _WrapperSBRP(BaseModel):
-    """Wrapper for StructureBoundedRefinableParameter testing."""
-    a: StructureBoundedRefinableParameter
-
-
 # --- 1. JSON shape round-trip -----------------------------------------------
 
 
@@ -553,26 +542,6 @@ def test_bounded_refinable_parameter_model_dump_json():
     assert json.loads(brp.model_dump_json()) == [1.5, True, 0.0, 2.0]
 
 
-def test_structure_refinable_parameter_model_dump():
-    srp = StructureRefinableParameter.model_validate([None, True])
-    assert srp.model_dump() == [None, True]
-
-
-def test_structure_refinable_parameter_model_dump_with_value():
-    srp = StructureRefinableParameter.model_validate([1.5, False])
-    assert srp.model_dump() == [1.5, False]
-
-
-def test_structure_bounded_refinable_parameter_model_dump():
-    sbrp = StructureBoundedRefinableParameter.model_validate([None, True, 0.0, 2.0])
-    assert sbrp.model_dump() == [None, True, 0.0, 2.0]
-
-
-def test_structure_bounded_refinable_parameter_model_dump_with_value():
-    sbrp = StructureBoundedRefinableParameter.model_validate([1.5, True, 0.0, 2.0])
-    assert sbrp.model_dump() == [1.5, True, 0.0, 2.0]
-
-
 # --- 2. RefinableParameter validation ---------------------------------------
 
 
@@ -716,62 +685,7 @@ def test_bounded_refinable_parameter_null_value_rejected():
     assert _errors(exc_info) == [(('a', 'value'), 'float_type')]
 
 
-# --- 4. StructureRefinableParameter / StructureBoundedRefinableParameter ----
-
-
-def test_structure_refinable_parameter_null_value_accepted_refine_true():
-    srp = StructureRefinableParameter.model_validate([None, True])
-    assert srp.value is None
-    assert srp.refine_flag is True
-
-
-def test_structure_refinable_parameter_null_value_accepted_refine_false():
-    srp = StructureRefinableParameter.model_validate([None, False])
-    assert srp.value is None
-    assert srp.refine_flag is False
-
-
-def test_structure_refinable_parameter_4_element_list_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSRP(a=[1.5, True, 0.0, 2.0])
-    err = exc_info.value
-    assert any("bounds are not supported" in e["msg"] for e in err.errors())
-
-
-def test_structure_refinable_parameter_refine_flag_null_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSRP(a=[None, None])
-    assert _errors(exc_info) == [(('a', 'refine_flag'), 'bool_type')]
-
-
-def test_structure_bounded_refinable_parameter_null_value_accepted():
-    sbrp = StructureBoundedRefinableParameter.model_validate([None, True, 0.0, 2.0])
-    assert sbrp.value is None
-    assert sbrp.refine_flag is True
-
-
-def test_structure_bounded_refinable_parameter_null_value_min_max_order_enforced():
-    with pytest.raises(ValidationError, match="min .* must be <= max"):
-        _WrapperSBRP(a=[None, True, 2.0, 1.0])
-
-
-def test_structure_bounded_refinable_parameter_non_null_value_enforces_bounds_below():
-    with pytest.raises(ValidationError, match="below min"):
-        _WrapperSBRP(a=[0.5, True, 1.0, 2.0])
-
-
-def test_structure_bounded_refinable_parameter_non_null_value_enforces_bounds_above():
-    with pytest.raises(ValidationError, match="above max"):
-        _WrapperSBRP(a=[2.5, True, 1.0, 2.0])
-
-
-def test_structure_bounded_refinable_parameter_refine_flag_null_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSBRP(a=[None, None, 0.0, 2.0])
-    assert _errors(exc_info) == [(('a', 'refine_flag'), 'bool_type')]
-
-
-# --- 5. check_within_bounds -------------------------------------------------
+# --- 4. check_within_bounds -------------------------------------------------
 
 
 def test_check_within_bounds_inside_passes():
@@ -816,7 +730,7 @@ def test_check_within_bounds_above_max_raises():
         check_within_bounds(2.5, param, "test_field")
 
 
-# --- 6. JSON schema ---------------------------------------------------------
+# --- 5. JSON schema ---------------------------------------------------------
 
 
 def test_refinable_parameter_json_schema():
@@ -843,33 +757,7 @@ def test_bounded_refinable_parameter_json_schema():
     assert param_schema["prefixItems"][3] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
 
 
-def test_structure_refinable_parameter_json_schema():
-    schema = _WrapperSRP.model_json_schema()
-    param_schema = schema["$defs"]["StructureRefinableParameter"]
-    assert param_schema["type"] == "array"
-    assert len(param_schema["prefixItems"]) == 2
-    assert param_schema["minItems"] == 2
-    assert param_schema["maxItems"] == 2
-    assert param_schema["prefixItems"][0] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][1] == {"type": "boolean"}
-    assert "structure" in param_schema["description"].lower()
-
-
-def test_structure_bounded_refinable_parameter_json_schema():
-    schema = _WrapperSBRP.model_json_schema()
-    param_schema = schema["$defs"]["StructureBoundedRefinableParameter"]
-    assert param_schema["type"] == "array"
-    assert len(param_schema["prefixItems"]) == 4
-    assert param_schema["minItems"] == 4
-    assert param_schema["maxItems"] == 4
-    assert param_schema["prefixItems"][0] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][1] == {"type": "boolean"}
-    assert param_schema["prefixItems"][2] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][3] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert "structure" in param_schema["description"].lower()
-
-
-# --- 7. Identity preservation -----------------------------------------------
+# --- 6. Identity preservation -----------------------------------------------
 
 
 def test_refinable_parameter_instance_identity_preserved():
@@ -884,18 +772,6 @@ def test_bounded_refinable_parameter_instance_identity_preserved():
     assert w.a is p
 
 
-def test_structure_refinable_parameter_instance_identity_preserved():
-    p = StructureRefinableParameter.model_validate([1.5, True])
-    w = _WrapperSRP(a=p)
-    assert w.a is p
-
-
-def test_structure_bounded_refinable_parameter_instance_identity_preserved():
-    p = StructureBoundedRefinableParameter.model_validate([1.5, True, 0.0, 2.0])
-    w = _WrapperSBRP(a=p)
-    assert w.a is p
-
-
 # --- check_element_symbol (A32, A63) ----------------------------------------
 
 from powderline.schema_core import check_element_symbol  # noqa: E402
@@ -934,55 +810,55 @@ def test_unknown_element_rejected(symbol):
 from fractions import Fraction  # noqa: E402
 from pydantic import ValidationError  # noqa: E402
 
-from powderline.schema_core import UnitCell, Atom, PhaseStructure  # noqa: E402
+from powderline.schema_core import UnitCell, Atom, Phase, RefinableParameter  # noqa: E402
 from powderline.exceptions import SymmetryError  # noqa: E402
 
 
 def _valid_pmm_lab6_phase_dict():
     """Helper: valid P m -3 m LaB6-like phase (cubic a=4.15692, La at origin, B at 0.5,0.5,0.2021)."""
     return {
-        "phase_name": "LaB6",
         "space_group": "P m -3 m",
         "unit_cell": {
-            "a": 4.15692,
-            "b": 4.15692,
-            "c": 4.15692,
-            "alpha": 90.0,
-            "beta": 90.0,
-            "gamma": 90.0,
+            "a": [4.15692, False],
+            "b": [4.15692, False],
+            "c": [4.15692, False],
+            "alpha": [90.0, False],
+            "beta": [90.0, False],
+            "gamma": [90.0, False],
         },
         "atoms": {
             "La1": {
                 "element": "La",
-                "x": 0.0,
-                "y": 0.0,
-                "z": 0.0,
-                "occupancy": 1.0,
+                "x": [0.0, False],
+                "y": [0.0, False],
+                "z": [0.0, False],
+                "occupancy": [1.0, False],
                 "ADP": "Uiso",
-                "Uiso": 0.005,
+                "Uiso": [0.005, False],
             },
             "B1": {
                 "element": "B",
-                "x": 0.5,
-                "y": 0.5,
-                "z": 0.2021,
-                "occupancy": 1.0,
+                "x": [0.5, False],
+                "y": [0.5, False],
+                "z": [0.2021, False],
+                "occupancy": [1.0, False],
                 "ADP": "Uiso",
-                "Uiso": 0.006,
+                "Uiso": [0.006, False],
             },
         },
     }
 
 
-def test_phase_structure_valid_validates():
-    """Valid phase validates with no warnings."""
-    phase = PhaseStructure.model_validate(_valid_pmm_lab6_phase_dict())
-    assert phase.warnings() == []
+def test_phase_valid_validates():
+    """A valid phase validates and holds exactly the stated values (validation never changes them)."""
+    d = _valid_pmm_lab6_phase_dict()
+    phase = Phase[RefinableParameter].model_validate(d)
+    assert phase.model_dump() == d
 
 
-def test_phase_structure_site_multiplicity():
+def test_phase_site_multiplicity():
     """Site multiplicity: La (origin) -> 1, B (0.5,0.5,0.2021) -> 6 in P m -3 m."""
-    phase = PhaseStructure.model_validate(_valid_pmm_lab6_phase_dict())
+    phase = Phase[RefinableParameter].model_validate(_valid_pmm_lab6_phase_dict())
     assert phase.site("La1").multiplicity == 1
     assert phase.site("B1").multiplicity == 6
 
@@ -990,360 +866,473 @@ def test_phase_structure_site_multiplicity():
 def test_unit_cell_length_zero_rejected():
     """UnitCell: a=0 rejected."""
     with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=0.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[0.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_length_negative_rejected():
     """UnitCell: b=-1 rejected."""
     with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=4.0, b=-1.0, c=4.0, alpha=90, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[-1.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_length_non_finite_rejected():
     """UnitCell: c=nan rejected."""
-    with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=4.0, b=4.0, c=float("nan"), alpha=90, beta=90, gamma=90)
+    with pytest.raises(ValidationError, match="must be finite"):
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[float("nan"), False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_zero_rejected():
     """UnitCell: alpha=0 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=0.0, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[0.0, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_180_rejected():
     """UnitCell: beta=180 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=180.0, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[180.0, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_above_180_rejected():
     """UnitCell: gamma=181 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=181.0)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[181.0, False])
 
 
 def test_unit_cell_angle_non_finite_rejected():
     """UnitCell: alpha=inf rejected."""
-    with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=float("inf"), beta=90, gamma=90)
+    with pytest.raises(ValidationError, match="must be finite"):
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[float("inf"), False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_extra_key_rejected():
     """UnitCell: 'volume' key rejected (extra='forbid')."""
     with pytest.raises(ValidationError, match="Extra inputs are not permitted"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=90, volume=64.0)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False], volume=64.0)
 
 
 def test_atom_element_uppercase_rejected_with_suggestion():
     """Atom: 'FE' -> message suggests 'Fe'."""
     with pytest.raises(ValidationError, match="write the element symbol as 'Fe'"):
-        Atom(element="FE", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="FE", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_element_charged_rejected():
     """Atom: 'Fe3+' rejected as charged."""
     with pytest.raises(ValidationError, match="charged scattering types are not supported"):
-        Atom(element="Fe3+", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="Fe3+", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_occupancy_zero_accepted():
     """Atom: occupancy=0 accepted."""
-    atom = Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=0.0, ADP="Uiso", Uiso=0.01)
-    assert atom.occupancy == 0.0
+    atom = Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[0.0, False], ADP="Uiso", Uiso=[0.01, False])
+    assert atom.occupancy.value == 0.0
 
 
 def test_atom_occupancy_one_accepted():
     """Atom: occupancy=1 accepted."""
-    atom = Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=1.0, ADP="Uiso", Uiso=0.01)
-    assert atom.occupancy == 1.0
+    atom = Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
+    assert atom.occupancy.value == 1.0
 
 
 def test_atom_occupancy_negative_rejected():
     """Atom: occupancy=-0.01 rejected."""
-    with pytest.raises(ValidationError, match="greater than or equal to 0"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=-0.01, ADP="Uiso", Uiso=0.01)
+    with pytest.raises(ValidationError, match="occupancy must be between 0 and 1"):
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[-0.01, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_occupancy_above_one_rejected():
     """Atom: occupancy=1.01 rejected."""
-    with pytest.raises(ValidationError, match="less than or equal to 1"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=1.01, ADP="Uiso", Uiso=0.01)
+    with pytest.raises(ValidationError, match="occupancy must be between 0 and 1"):
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.01, False], ADP="Uiso", Uiso=[0.01, False])
+
+
+_U6 = {"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False],
+       "U12": [0.0, False], "U13": [0.0, False], "U23": [0.0, False]}
+
+
+def _adp_atom(**adp):
+    return {"element": "Fe", "x": [0.0, False], "y": [0.0, False], "z": [0.0, False],
+            "occupancy": [1.0, False], **adp}
+
+
+def _adp_errors(exc_info) -> list:
+    return [(e["loc"], e["type"], e["msg"]) for e in exc_info.value.errors()]
 
 
 def test_atom_adp_uiso_without_value_rejected():
-    """Atom: ADP='Uiso' without Uiso rejected."""
-    with pytest.raises(ValidationError, match="requires a Uiso value"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uiso")
+    """ADP selects the required thermal parameter: 'Uiso' without Uiso is missing at Uiso."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uiso"))
+    assert _adp_errors(exc_info) == [(("Uiso",), "missing", "Uiso is required when ADP is 'Uiso'")]
 
 
 def test_atom_adp_uiso_with_uaniso_rejected():
-    """Atom: ADP='Uiso' with Uaniso also given rejected."""
-    with pytest.raises(ValidationError, match="must not also give Uaniso"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01,
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0})
+    """ADP 'Uiso': Uaniso must be left out (error at Uaniso)."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uiso", Uiso=[0.01, False], Uaniso=_U6))
+    assert _adp_errors(exc_info) == [
+        (("Uaniso",), "extra_forbidden", "Uaniso must be left out when ADP is 'Uiso'")]
 
 
 def test_atom_adp_uaniso_missing_component_rejected():
-    """Atom: ADP='Uaniso' missing U23 rejected."""
-    with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso",
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0})
+    """ADP 'Uaniso' needs all six components; a missing one is reported at that component."""
+    u = {k: v for k, v in _U6.items() if k != "U23"}
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uaniso=u))
+    assert _adp_errors(exc_info) == [(("Uaniso", "U23"), "missing", "Field required")]
 
 
 def test_atom_adp_uaniso_unknown_key_rejected():
-    """Atom: ADP='Uaniso' with U14 rejected."""
-    with pytest.raises(ValidationError, match="Input should be"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso",
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0, "U14": 0})
+    """ADP 'Uaniso' with U14: an unknown component, reported at it."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uaniso={**_U6, "U14": [0.0, False]}))
+    assert _adp_errors(exc_info) == [(("Uaniso", "U14"), "extra_forbidden", "Extra inputs are not permitted")]
 
 
 def test_atom_adp_uaniso_with_uiso_rejected():
-    """Atom: ADP='Uaniso' with Uiso also given rejected."""
-    with pytest.raises(ValidationError, match="must not also give Uiso"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso", Uiso=0.01,
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0})
+    """ADP 'Uaniso': Uiso must be left out (error at Uiso)."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uiso=[0.01, False], Uaniso=_U6))
+    assert _adp_errors(exc_info) == [
+        (("Uiso",), "extra_forbidden", "Uiso must be left out when ADP is 'Uaniso'")]
 
 
 def test_atom_adp_wrong_value_rejected():
-    """Atom: ADP='Uaniso' but only Uiso given rejected."""
-    with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso", Uiso=0.01)
+    """ADP 'Uaniso' but only Uiso given: Uaniso missing and Uiso not allowed, both reported."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uiso=[0.01, False]))
+    assert _adp_errors(exc_info) == [
+        (("Uaniso",), "missing", "Uaniso is required when ADP is 'Uaniso'"),
+        (("Uiso",), "extra_forbidden", "Uiso must be left out when ADP is 'Uaniso'"),
+    ]
+
+
+def test_atom_adp_errors_located_inside_the_phase():
+    """Nested in a phase, the ADP pairing error is at atoms.<label>.<field> (A70)."""
+    d = _valid_pmm_lab6_phase_dict()
+    del d["atoms"]["La1"]["Uiso"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _adp_errors(exc_info) == [(("atoms", "La1", "Uiso"), "missing", "Uiso is required when ADP is 'Uiso'")]
+
+
+def test_atom_json_schema_states_the_adp_pairing():
+    """The JSON Schema says ADP selects the required one of Uiso / Uaniso and forbids the other;
+    UanisoTensor requires all six components."""
+    schema = Phase[RefinableParameter].model_json_schema()["$defs"]
+    assert schema["Atom"]["allOf"] == [
+        {"if": {"properties": {"ADP": {"const": "Uiso"}}},
+         "then": {"required": ["Uiso"], "not": {"required": ["Uaniso"]}}},
+        {"if": {"properties": {"ADP": {"const": "Uaniso"}}},
+         "then": {"required": ["Uaniso"], "not": {"required": ["Uiso"]}}},
+    ]
+    assert schema["Atom"]["properties"]["Uaniso"]["$ref"] == "#/$defs/UanisoTensor"
+    assert schema["UanisoTensor"]["required"] == ["U11", "U22", "U33", "U12", "U13", "U23"]
+    assert schema["UanisoTensor"]["additionalProperties"] is False
 
 
 def test_atom_xyz_non_finite_rejected():
     """Atom: x=nan rejected."""
     with pytest.raises(ValidationError, match="must be finite"):
-        Atom(element="Fe", x=float("nan"), y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="Fe", x=[float("nan"), False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
-def test_phase_structure_space_group_no_origin_rejected():
-    """PhaseStructure: 'F d -3 m' (no :1/:2) rejected."""
+def test_phase_space_group_no_origin_rejected():
+    """Phase: 'F d -3 m' (no :1/:2) rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "F d -3 m"
-    with pytest.raises(ValidationError, match="two origin choices"):
-        PhaseStructure.model_validate(d)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    errors = exc_info.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["loc"] == ("space_group",)
+    assert "space group 'F d -3 m' has two origin choices" in errors[0]["msg"]
+    assert "write 'F d -3 m:1' or 'F d -3 m:2'" in errors[0]["msg"]
 
 
-def test_phase_structure_space_group_no_rhombohedral_setting_rejected():
-    """PhaseStructure: 'R -3 m' (no :H/:R) rejected."""
+def test_phase_space_group_no_rhombohedral_setting_rejected():
+    """Phase: 'R -3 m' (no :H/:R) rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "R -3 m"
-    with pytest.raises(ValidationError, match="rhombohedral"):
-        PhaseStructure.model_validate(d)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    errors = exc_info.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["loc"] == ("space_group",)
+    assert "space group 'R -3 m' does not name its setting" in errors[0]["msg"]
+    assert "write 'R -3 m:H'" in errors[0]["msg"]
+    assert "or 'R -3 m:R'" in errors[0]["msg"]
 
 
-def test_phase_structure_space_group_fd3m_origin2_accepted():
-    """PhaseStructure: 'F d -3 m:2' (cubic) accepted."""
+def test_phase_space_group_fd3m_origin2_accepted():
+    """Phase: 'F d -3 m:2' (cubic) accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "F d -3 m:2"
     # Adjust cell to cubic (already is in the helper, but be explicit)
-    d["unit_cell"] = {"a": 8.0, "b": 8.0, "c": 8.0, "alpha": 90, "beta": 90, "gamma": 90}
+    d["unit_cell"] = {"a": [8.0, False], "b": [8.0, False], "c": [8.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]}
     # Put an atom at a general position to avoid special-position complications
     d["atoms"] = {
-        "A1": {"element": "O", "x": 0.125, "y": 0.125, "z": 0.125, "ADP": "Uiso", "Uiso": 0.01}
+        "A1": {"element": "O", "x": [0.125, False], "y": [0.125, False], "z": [0.125, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "F d -3 m:2"
 
 
-def test_phase_structure_space_group_r3m_hexagonal_accepted():
-    """PhaseStructure: 'R -3 m:H' (hexagonal a=b, gamma=120) accepted."""
+def test_phase_space_group_r3m_hexagonal_accepted():
+    """Phase: 'R -3 m:H' (hexagonal a=b, gamma=120) accepted."""
     d = {
-        "phase_name": "test",
         "space_group": "R -3 m:H",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.0, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.4, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "R -3 m:H"
 
 
-def test_phase_structure_special_position_adjusted():
-    """PhaseStructure: P 63/m m c atom at (0.333333,0.666667,0.25) adjusted to 1/3,2/3,1/4."""
+def test_phase_special_position_thirds_read_from_6_decimals():
+    """A120: 1/3 and 2/3 have no exact decimal form, so 6 decimals state them: (0.333333,
+    0.666667, 0.25) on 2c is read as (1/3, 2/3, 1/4), with no warning; the caller's dict is
+    untouched, and a dump writes the exact floats, which validate as themselves."""
+    d = {
+        "space_group": "P 63/m m c",
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
+        "atoms": {
+            "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+        },
+    }
+    phase = Phase[RefinableParameter].model_validate(d)
+    assert (phase.atoms["A1"].x.value, phase.atoms["A1"].y.value, phase.atoms["A1"].z.value) == (1 / 3, 2 / 3, 0.25)
+    assert phase.warnings() == []
+    assert d["atoms"]["A1"]["x"] == [0.333333, False]
+    assert Phase[RefinableParameter].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_phase_special_position_with_a_decimal_form_must_be_exact():
+    """A120: 1/2 and 1/4 have an exact decimal form, so 0.4999999 and 0.2499999 are errors; in one
+    atom the thirds are still read and only the decimal ones are asked for."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.333333, "y": 0.666667, "z": 0.25, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.2499999, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
-    # Check coordinates are exact fractions
-    assert phase.atoms["A1"].x == 1/3
-    assert phase.atoms["A1"].y == 2/3
-    # Check warning
-    warnings = phase.warnings()
-    assert len(warnings) == 1
-    assert warnings[0]["code"] == "special_position_adjusted"
-    assert "A1" in warnings[0]["message"]
-    assert warnings[0]["field_path"] == "atoms.A1"
-
-
-def test_phase_structure_special_position_ambiguous_rejected():
-    """PhaseStructure: atom at (0.3333,0.6667,0.25) in P 63/m m c rejected (ambiguous)."""
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1"),
+                                "atom 'A1' (multiplicity 2 in 'P 63/m m c'): (0.333333, 0.666667, 0.2499999) is "
+                                "1e-07 from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); write z = 0.25")]
+
+
+_R3M_CELL = {"a": [4.0, False], "b": [4.0, False], "c": [20.0, False],
+             "alpha": [90, False], "beta": [90, False], "gamma": [120, False]}
+
+
+def test_coupled_coordinate_with_a_third_offset_read_from_6_decimals():
+    """A120: R-3m:H at (x, x + 1/3, 1/6): y has no exact decimal form, so 6 decimals state it."""
+    atom = {"element": "O", "x": [0.1, True], "y": [0.433333, True], "z": [0.166667, False],
+            "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+    phase = Phase[RP].model_validate({"space_group": "R -3 m:H", "unit_cell": _R3M_CELL, "atoms": {"O1": atom}})
+    assert (phase.atoms["O1"].x.value, phase.atoms["O1"].y.value, phase.atoms["O1"].z.value) == (0.1, 0.1 + 1 / 3, 1 / 6)
+    assert phase.atoms["O1"].y.refine_flag is True
+
+
+def test_tied_bounds_with_a_third_offset_read_from_6_decimals():
+    """A120 for F4: y = x + 1/3 maps x in [0.05, 0.15] to [0.383333.., 0.483333..]; 6 decimals are
+    read as those, 4 decimals are an error giving them to 6 decimals."""
+    cell = {k: [*v, None, None] for k, v in _R3M_CELL.items()}
+
+    def phase(y_bounds):
+        atom = {"element": "O", "x": [0.1, True, 0.05, 0.15], "y": [0.433333, True, *y_bounds],
+                "z": [0.166667, False, None, None], "occupancy": [1.0, False, None, None],
+                "ADP": "Uiso", "Uiso": [0.01, False, None, None]}
+        return {"space_group": "R -3 m:H", "unit_cell": cell, "atoms": {"O1": atom}}
+
+    y = Phase[BRP].model_validate(phase((0.383333, 0.483333))).atoms["O1"].y
+    third = Fraction(1, 3)  # the model holds the float nearest each exact value (A120, A121)
+    assert y.model_dump() == [float(Fraction(0.1) + third), True, float(Fraction(0.05) + third),
+                              float(Fraction(0.15) + third)]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase((0.3833, 0.4833)))
+    assert _errs(exc_info) == [(("atoms", "O1", "y"),
+                                "atom 'O1' (multiplicity 18 in 'R -3 m:H'): the bounds of y must follow y = x + 1/3 "
+                                "from the bounds of x [0.05, 0.15]: write [0.383333, 0.483333] (to at least 6 "
+                                "decimals), not [0.3833, 0.4833]")]
+
+
+def test_phase_special_position_ambiguous_rejected():
+    """Phase: atom at (0.3333,0.6667,0.25) in P 63/m m c rejected (ambiguous)."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.3333, "y": 0.6667, "z": 0.25, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.3333, False], "y": [0.6667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
     with pytest.raises(ValidationError, match="without being on it") as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     # Check that the atom label appears in the error
     assert "A1" in str(exc_info.value)
 
 
-def test_phase_structure_multiplicity_match_accepted():
-    """PhaseStructure: stated Multiplicity equal to derived accepted."""
+def test_phase_multiplicity_match_accepted():
+    """Phase: stated Multiplicity equal to derived accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["Multiplicity"] = 1
     d["atoms"]["B1"]["Multiplicity"] = 6
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.site("La1").multiplicity == 1
     assert phase.site("B1").multiplicity == 6
 
 
-def test_phase_structure_multiplicity_mismatch_rejected():
-    """PhaseStructure: stated Multiplicity != derived rejected."""
+def test_phase_multiplicity_mismatch_rejected():
+    """Phase: stated Multiplicity != derived rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["B1"]["Multiplicity"] = 12  # should be 6
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     msg = str(exc_info.value)
     assert "stated Multiplicity" in msg
     assert "derived" in msg
 
 
-def test_phase_structure_cell_cubic_b_neq_a_rejected():
-    """PhaseStructure: cubic with b != a rejected."""
+def test_phase_cell_cubic_b_neq_a_rejected():
+    """Phase: cubic with b != a rejected."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["b"] = 4.2
+    d["unit_cell"]["b"] = [4.2, False]
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
-    msg = str(exc_info.value)
-    assert "b = 4.2 (symmetric value" in msg
-    assert "inconsistent" in msg
-    assert _errors(exc_info) == [(("unit_cell",), "value_error")]
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("unit_cell",), "unit cell is inconsistent with 'P m -3 m' (cubic): stated b = 4.2, "
+                                                 "but by symmetry b = a; write b = 4.15692")]
 
 
-def test_phase_structure_cell_cubic_gamma_91_rejected():
-    """PhaseStructure: cubic with gamma=91 rejected."""
+def test_phase_cell_cubic_gamma_91_rejected():
+    """Phase: cubic with gamma=91 rejected."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["gamma"] = 91.0
+    d["unit_cell"]["gamma"] = [91.0, False]
     with pytest.raises(ValidationError, match="inconsistent"):
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_structure_cell_hexagonal_gamma_90_rejected():
-    """PhaseStructure: hexagonal with gamma=90 rejected."""
+def test_phase_cell_hexagonal_gamma_90_rejected():
+    """Phase: hexagonal with gamma=90 rejected."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 90},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.4, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
     with pytest.raises(ValidationError, match="inconsistent"):
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_structure_cell_monoclinic_accepted():
-    """PhaseStructure: valid monoclinic C 1 2/m 1 with beta=104.3 accepted."""
+def test_phase_cell_monoclinic_accepted():
+    """Phase: valid monoclinic C 1 2/m 1 with beta=104.3 accepted."""
     d = {
-        "phase_name": "test",
         "space_group": "C 1 2/m 1",
-        "unit_cell": {"a": 5.0, "b": 6.0, "c": 7.0, "alpha": 90, "beta": 104.3, "gamma": 90},
+        "unit_cell": {"a": [5.0, False], "b": [6.0, False], "c": [7.0, False], "alpha": [90, False], "beta": [104.3, False], "gamma": [90, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.0, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.0, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "C 1 2/m 1"
 
 
-def test_phase_structure_uaniso_cubic_m3m_isotropic_accepted():
-    """PhaseStructure: La at (0,0,0) in P m -3 m with isotropic Uaniso (U11=U22=U33, off-diag 0) accepted."""
+def test_phase_uaniso_cubic_m3m_isotropic_accepted():
+    """Phase: La at (0,0,0) in P m -3 m with isotropic Uaniso (U11=U22=U33, off-diag 0) accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["ADP"] = "Uaniso"
-    d["atoms"]["La1"]["Uaniso"] = {"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0}
+    d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
-    phase = PhaseStructure.model_validate(d)
-    assert phase.warnings() == []
+    phase = Phase[RefinableParameter].model_validate(d)
+    assert phase.atoms["La1"].Uaniso.model_dump() == d["atoms"]["La1"]["Uaniso"]
 
 
-def test_phase_structure_uaniso_cubic_m3m_anisotropic_rejected():
-    """PhaseStructure: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry)."""
+def test_phase_uaniso_cubic_m3m_anisotropic_rejected():
+    """Phase: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry); the values to write
+    are derived from the first member (A121)."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["ADP"] = "Uaniso"
-    d["atoms"]["La1"]["Uaniso"] = {"U11": 0.01, "U22": 0.02, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0}
+    d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.02, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
-    with pytest.raises(ValidationError, match="break the site symmetry"):
-        PhaseStructure.model_validate(d)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "La1", "Uaniso"),
+                                "atom 'La1' (multiplicity 1 in 'P m -3 m'): Uaniso is not site-symmetric "
+                                "(U12 = 0, U13 = 0, U23 = 0, U22 = U11, U33 = U11); write U22 = 0.01")]
+
+
+def test_phase_uaniso_hexagonal_6h_coupled_member_read_within_1e_6():
+    """A121: at 6h U12 = U22/2 is derived from the stated U22. A U12 stated within 1e-6 A^2 (A78) is
+    read as the derived value (0.006174 -> 0.0061735); further off is an error giving it."""
+    d = {
+        "space_group": "P 63/m m c",
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
+        "atoms": {
+            "A1": {
+                "element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.25, False],
+                "occupancy": [1.0, False], "ADP": "Uaniso",
+                "Uaniso": {"U11": [0.012, False], "U22": [0.012347, False], "U33": [0.02, False],
+                           "U12": [0.006174, False], "U13": [0.0, False], "U23": [0.0, False]},
+            }
+        },
+    }
+    assert Phase[RefinableParameter].model_validate(d).atoms["A1"].Uaniso.U12.value == 0.0061735
+    d["atoms"]["A1"]["Uaniso"]["U12"][0] = 0.006176
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1", "Uaniso"),
+                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not site-symmetric "
+                                "(U13 = 0, U23 = 0, U12 = U22/2); write U12 = 0.0061735")]
 
 
-def test_phase_structure_uaniso_hexagonal_6h_adjusted():
-    """PhaseStructure: P 63/m m c, site 6h, Uaniso with U11=U22/2 adjusted and reported."""
+def test_phase_uaniso_fixed_component_must_be_exactly_zero():
+    """A121: a symmetry-fixed Uij is a constant of the site, 0, which has a decimal form: 1e-9 is an
+    error ("write U13 = 0.0"), never read as 0."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
             "A1": {
-                "element": "O",
-                "x": 0.2,
-                "y": 0.4,
-                "z": 0.25,
-                "ADP": "Uaniso",
-                "Uaniso": {
-                    "U11": 0.012,
-                    "U22": 0.012347,
-                    "U33": 0.02,
-                    "U12": 0.006174,
-                    "U13": 0.0,
-                    "U23": 0.0,
-                },
+                "element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.25, False],
+                "occupancy": [1.0, False], "ADP": "Uaniso",
+                "Uaniso": {"U11": [0.012, False], "U22": [0.012, False], "U33": [0.02, False],
+                           "U12": [0.006, False], "U13": [1e-9, False], "U23": [0.0, False]},
             }
         },
     }
-    phase = PhaseStructure.model_validate(d)
-    # Check U11 stayed
-    assert phase.atoms["A1"].Uaniso["U11"] == 0.012  # free: returned exactly as stated
-    # Check U12 became U22/2
-    u22 = phase.atoms["A1"].Uaniso["U22"]
-    u12 = phase.atoms["A1"].Uaniso["U12"]
-    assert abs(u12 - u22 / 2) < 1e-15
-    # Check warning
-    warnings = phase.warnings()
-    assert any(w["code"] == "adp_symmetry_adjusted" for w in warnings)
-
-
-def test_phase_structure_multiple_atom_problems_all_reported():
-    """PhaseStructure: two atoms with wrong Multiplicity -> both labels appear in one error."""
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1", "Uaniso"),
+                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not site-symmetric "
+                                "(U13 = 0, U23 = 0, U12 = U22/2); write U13 = 0.0")]
+
+
+def test_phase_multiple_atom_problems_all_reported():
+    """Phase: two atoms with wrong Multiplicity -> both labels appear in one error."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["Multiplicity"] = 2
     d["atoms"]["B1"]["Multiplicity"] = 12
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     msg = str(exc_info.value)
     assert "La1" in msg
     assert "B1" in msg
 
 
-# --- PhaseStructure: error locations, reporting, no side effects (A70) -------
+# --- Phase: error locations, reporting, no side effects (A70) -------
 
 
 def _uaniso(u11, u22, u33, u12=0.0, u13=0.0, u23=0.0):
-    return {"U11": u11, "U22": u22, "U33": u33, "U12": u12, "U13": u13, "U23": u23}
+    return {"U11": [u11, False], "U22": [u22, False], "U33": [u33, False], "U12": [u12, False], "U13": [u13, False], "U23": [u23, False]}
 
 
-def test_phase_structure_all_problems_of_one_atom_reported():
+def test_phase_all_problems_of_one_atom_reported():
     """A wrong Multiplicity does not hide the same atom's Uaniso error."""
     d = _valid_pmm_lab6_phase_dict()
     la = d["atoms"]["La1"]
@@ -1352,21 +1341,21 @@ def test_phase_structure_all_problems_of_one_atom_reported():
     del la["Uiso"]
     la["Uaniso"] = _uaniso(0.01, 0.02, 0.01)
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     assert _errors(exc_info) == [
         (("atoms", "La1", "Multiplicity"), "value_error"),
         (("atoms", "La1", "Uaniso"), "value_error"),
     ]
 
 
-def test_phase_structure_problems_reported_at_their_locations():
+def test_phase_problems_reported_at_their_locations():
     """Cell, position and multiplicity problems: one error each, at its own field."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["b"] = 4.2
-    d["atoms"]["La1"]["x"] = 0.001  # ambiguous band
+    d["unit_cell"]["b"] = [4.2, False]
+    d["atoms"]["La1"]["x"] = [0.001, False]  # ambiguous band
     d["atoms"]["B1"]["Multiplicity"] = 12
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     assert _errors(exc_info) == [
         (("unit_cell",), "value_error"),
         (("atoms", "La1"), "value_error"),
@@ -1378,12 +1367,12 @@ def test_phase_structure_problems_reported_at_their_locations():
     assert "stated Multiplicity 12, derived 6" in msgs[2]
 
 
-def test_phase_structure_locations_nest_in_enclosing_models():
-    """Engine schemas embed PhaseStructure: the locations get the enclosing path, also from JSON."""
+def test_phase_locations_nest_in_enclosing_models():
+    """Engine schemas embed Phase: the locations get the enclosing path, also from JSON."""
     from pydantic import BaseModel
 
     class Payload(BaseModel):
-        structure: PhaseStructure
+        structure: Phase[RefinableParameter]
 
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["B1"]["Multiplicity"] = 12
@@ -1392,19 +1381,354 @@ class Payload(BaseModel):
     assert _errors(exc_info) == [(("structure", "atoms", "B1", "Multiplicity"), "value_error")]
 
 
-def test_phase_structure_does_not_modify_caller_atoms():
-    """Canonicalization replaces the atom in the structure; the caller's Atom is untouched."""
-    atom = Atom.model_validate({"element": "C", "x": 0.3333333, "y": 0.6666667, "z": 0.25,
-                                "ADP": "Uiso", "Uiso": 0.01})
-    phase = PhaseStructure.model_validate({
-        "phase_name": "test",
+def test_phase_holds_the_callers_atoms_unchanged():
+    """Validation never changes a value, so the validated phase holds the caller's atom as given."""
+    atom = Atom[RefinableParameter].model_validate({"element": "C", "x": [1 / 3, False], "y": [2 / 3, False], "z": [0.25, False],
+                                "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]})
+    phase = Phase[RefinableParameter].model_validate({
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {"C1": atom},
     })
-    assert (atom.x, atom.y) == (0.3333333, 0.6666667)
-    assert (phase.atoms["C1"].x, phase.atoms["C1"].y) == (1 / 3, 2 / 3)
-    assert phase.atoms["C1"] is not atom
+    assert phase.atoms["C1"] is atom
+
+
+# --- Phase[P]: the phase block (re/03b; A93-A96, A100, A105) -----------------
+
+from powderline.schema_core import (  # noqa: E402
+    RESERVED_PHASE_FIELDS,
+    BoundedRefinableParameter,
+    CoreModel,
+)
+
+RP, BRP = RefinableParameter, BoundedRefinableParameter
+
+
+def _bounded(d: dict, lo=None, hi=None) -> dict:
+    """The phase dict with every [value, flag] made [value, flag, lo, hi]."""
+    def conv(v):
+        if isinstance(v, list):
+            return [*v, lo, hi]
+        if isinstance(v, dict):
+            return {k: conv(x) for k, x in v.items()}
+        return v
+    return conv(d)
+
+
+@pytest.mark.parametrize("space_group, cell, xyz", [
+    ("P m -3 m", (4.0, 4.0, 4.0, 90, 90, 90), (0.1, 0.2, 0.3)),
+    ("C 1 2/m 1", (9.0, 5.0, 7.0, 90, 105.0, 90), (0.1, 0.2, 0.3)),
+    ("P 1 21/c 1", (5.0, 6.0, 7.0, 90, 98.0, 90), (0.1, 0.2, 0.3)),
+    ("P 1 1 21/a", (5.0, 6.0, 7.0, 90, 90, 98.0), (0.1, 0.2, 0.3)),
+    ("A 1 1 2/a", (5.0, 6.0, 7.0, 90, 90, 98.0), (0.1, 0.2, 0.3)),
+    ("C c 1 1", (5.0, 6.0, 7.0, 98.0, 90, 90), (0.1, 0.2, 0.3)),
+    ("P 1 c 1", (5.0, 6.0, 7.0, 90, 98.0, 90), (0.1, 0.2, 0.3)),
+    ("R -3 m:H", (4.0, 4.0, 20.0, 90, 90, 120), (0.1, 0.2, 0.3)),
+    ("R -3 m:R", (5.0, 5.0, 5.0, 70.0, 70.0, 70.0), (0.1, 0.2, 0.3)),
+    ("F d -3 m:2", (8.0, 8.0, 8.0, 90, 90, 90), (0.125, 0.125, 0.125)),
+    ("F d -3 m:1", (8.0, 8.0, 8.0, 90, 90, 90), (0.0, 0.0, 0.0)),
+    ("P 63/m m c", (3.2, 3.2, 5.2, 90, 90, 120), (1 / 3, 2 / 3, 0.25)),
+])
+def test_phase_canonical_space_group_accepted(space_group, cell, xyz):
+    """Canonical names validate, incl. non-standard settings, ':R' and both origins (A105)."""
+    d = {"space_group": space_group,
+         "unit_cell": dict(zip(("a", "b", "c", "alpha", "beta", "gamma"), ([v, False] for v in cell))),
+         "atoms": {"A1": {"element": "Fe", **{k: [v, False] for k, v in zip("xyz", xyz)},
+                          "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    assert Phase[RP].model_validate(d).space_group == space_group
+
+
+@pytest.mark.parametrize("symbol, message", [
+    ("Pm-3m", "space group 'Pm-3m' is not in the canonical form; write 'P m -3 m'"),
+    ("p m -3 m", "space group 'p m -3 m' is not in the canonical form; write 'P m -3 m'"),
+    ("C2/m", "space group 'C2/m' does not state its unique axis or cell choice (gemmi would read it as "
+             "'C 1 2/m 1'); write the setting you mean: unique axis b: 'C 1 2/m 1', 'A 1 2/m 1', "
+             "'I 1 2/m 1', 'F 1 2/m 1'; unique axis c: 'A 1 1 2/m', 'B 1 1 2/m', 'I 1 1 2/m'; "
+             "unique axis a: 'B 2/m 1 1', 'C 2/m 1 1', 'I 2/m 1 1'"),
+    ("C 2/m", "space group 'C 2/m' does not state its unique axis or cell choice (gemmi would read it as "
+              "'C 1 2/m 1'); write the setting you mean: unique axis b: 'C 1 2/m 1', 'A 1 2/m 1', "
+              "'I 1 2/m 1', 'F 1 2/m 1'; unique axis c: 'A 1 1 2/m', 'B 1 1 2/m', 'I 1 1 2/m'; "
+              "unique axis a: 'B 2/m 1 1', 'C 2/m 1 1', 'I 2/m 1 1'"),
+    ("P 21/c", "space group 'P 21/c' does not state its unique axis or cell choice (gemmi would read it as "
+               "'P 1 21/c 1'); write the setting you mean: unique axis b: 'P 1 21/c 1', 'P 1 21/n 1', "
+               "'P 1 21/a 1'; unique axis c: 'P 1 1 21/a', 'P 1 1 21/n', 'P 1 1 21/b'; "
+               "unique axis a: 'P 21/b 1 1', 'P 21/n 1 1', 'P 21/c 1 1'"),
+    ("Pc", "space group 'Pc' does not state its unique axis or cell choice (gemmi would read it as "
+           "'P 1 c 1'); write the setting you mean: unique axis b: 'P 1 c 1', 'P 1 n 1', 'P 1 a 1'; "
+           "unique axis c: 'P 1 1 a', 'P 1 1 n', 'P 1 1 b'; unique axis a: 'P b 1 1', 'P n 1 1', 'P c 1 1'"),
+    ("P121/c1", "space group 'P121/c1' is not in the canonical form; write 'P 1 21/c 1'"),
+    ("R-3m:H", "space group 'R-3m:H' is not in the canonical form; write 'R -3 m:H'"),
+    ("R -3 m", "space group 'R -3 m' does not name its setting; write 'R -3 m:H' (hexagonal axes) "
+               "or 'R -3 m:R' (rhombohedral axes)"),
+    ("Fd-3m", "space group 'Fd-3m' has two origin choices; write 'F d -3 m:1' or 'F d -3 m:2'"),
+    ("F d -3 m", "space group 'F d -3 m' has two origin choices; write 'F d -3 m:1' or 'F d -3 m:2'"),
+    ("P2_1/c", "unrecognized space-group symbol 'P2_1/c'; write gemmi's canonical name "
+               "(e.g. 'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2')"),
+])
+def test_phase_non_canonical_space_group_rejected(symbol, message):
+    """Any other spelling is an error at space_group naming the canonical form (A105)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["space_group"] = symbol
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("space_group",), "value_error")]
+    assert exc_info.value.errors()[0]["msg"] == "Value error, " + message
+
+
+def test_canonical_space_group_every_gemmi_name_round_trips():
+    """gemmi's xhm() names are unique over its table and each validates as itself (A105)."""
+    import gemmi
+    from powderline.symmetry import canonical_space_group
+
+    names = [sg.xhm() for sg in gemmi.spacegroup_table()]
+    assert len(names) == len(set(names)) == 564
+    assert all(canonical_space_group(n).xhm() == n for n in names)
+
+
+def test_canonical_space_group_names_match_the_committed_list():
+    """The accepted spellings are gemmi's names, pinned: a gemmi change that renames, adds or
+    drops one fails here before it can invalidate recipes (gemmi is pinned exactly; review B4).
+    On a deliberate gemmi upgrade, regenerate the file and record the change in SCHEMA_HISTORY."""
+    import gemmi
+
+    committed = (Path(__file__).parent / "data" / "canonical_space_groups.txt").read_text(encoding="utf-8")
+    assert [sg.xhm() for sg in gemmi.spacegroup_table()] == committed.splitlines()
+
+
+@pytest.mark.parametrize("field", RESERVED_PHASE_FIELDS)
+def test_phase_reserved_field_cannot_be_redeclared(field):
+    """An engine subclass may not redefine space_group, unit_cell or atoms (A93)."""
+    with pytest.raises(TypeError) as exc_info:
+        type("EnginePhase", (Phase[RP],), {"__annotations__": {field: int}, "__module__": __name__})
+    assert str(exc_info.value) == (f"EnginePhase redeclares the core phase field(s) {field}; "
+                                   "core owns space_group, unit_cell and atoms (A93)")
+
+
+def test_phase_reserved_fields_guarded_below_an_engine_subclass():
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    with pytest.raises(TypeError, match=r"^Child redeclares the core phase field\(s\) atoms;"):
+        class Child(EnginePhase):
+            atoms: dict
+
+
+def test_phase_reserved_members_are_core_validators_private_attributes_and_methods():
+    """Pinned, so a new core validator or method is seen to be reserved too (review A1)."""
+    from powderline.schema_core import _reserved_phase_members
+
+    assert _reserved_phase_members() == {"_parameter_type_chosen", "_space_group", "_sites_check", "_sites",
+                                         "_warnings", "site", "warnings"}
+
+
+@pytest.mark.parametrize("name, body", [
+    ("_space_group", "@field_validator('space_group')\n@classmethod\ndef _space_group(cls, v):\n    return v"),
+    ("_sites_check", "@model_validator(mode='after')\ndef _sites_check(self):\n    return self"),
+    ("site", "def site(self, label):\n    return None"),
+    ("_sites", "_sites: dict = PrivateAttr(default_factory=dict)"),
+])
+def test_phase_core_validator_or_method_cannot_be_reused(name, body):
+    """A same-named engine validator would silently replace core's (pydantic collects them by name)."""
+    namespace = {"field_validator": field_validator, "model_validator": model_validator,
+                 "PrivateAttr": PrivateAttr, "Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n    scale: RP\n" + "\n".join(
+        "    " + line for line in body.splitlines())
+    with pytest.raises(TypeError) as exc_info:
+        exec(source, namespace)
+    assert str(exc_info.value) == (
+        f"EnginePhase reuses the core phase name(s) {name}; a same-named validator, method or "
+        "private attribute would replace core's silently; rename it")
+
+
+_OPEN_TYPE = ("has no parameter type: subclass Phase[RefinableParameter] (no bounds) or "
+              "Phase[BoundedRefinableParameter] (bounds); a deliberately generic subclass declares "
+              "Generic[P] and is parametrized before use")
+
+
+def test_phase_without_parameter_type_cannot_validate():
+    """Unparametrized, one phase could mix [value, flag] and [value, flag, min, max] (review A2)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [4.15692, False, 4.0, 4.3]
+    with pytest.raises(TypeError) as exc_info:
+        Phase.model_validate(d)
+    assert str(exc_info.value) == f"Phase {_OPEN_TYPE}"
+
+
+def test_engine_subclass_must_choose_a_parameter_type():
+    with pytest.raises(TypeError) as exc_info:
+        class EnginePhase(Phase):
+            pass
+    assert str(exc_info.value) == f"EnginePhase {_OPEN_TYPE}"
+
+
+def test_generic_engine_subclass_validates_once_parametrized():
+    from typing import Generic
+
+    from powderline.schema_core import P
+
+    class EnginePhase(Phase[P], Generic[P]):
+        scale: P
+
+    d = {**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}
+    with pytest.raises(TypeError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert str(exc_info.value) == f"EnginePhase {_OPEN_TYPE}"
+    assert EnginePhase[RP].model_validate(d).scale.model_dump() == [1.0, True]
+
+
+def test_phase_engine_subclass_must_keep_extra_forbid():
+    with pytest.raises(TypeError) as exc_info:
+        class EnginePhase(Phase[RP]):
+            model_config = ConfigDict(extra="allow")
+    assert str(exc_info.value) == "EnginePhase must keep extra='forbid' (A19)"
+
+
+def test_phase_engine_validators_with_their_own_names_run_with_core_rules():
+    """An engine adds its own rule (gsasii rejects origin 1, EB-03) without replacing core's."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+        @field_validator("space_group")
+        @classmethod
+        def _gsasii_origin(cls, v):
+            if v.endswith(":1"):
+                raise ValueError("gsasii: origin choice 1 is not supported")
+            return v
+
+    d = {**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}
+    d["space_group"] = "Pm-3m"
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert exc_info.value.errors()[0]["msg"] == (
+        "Value error, space group 'Pm-3m' is not in the canonical form; write 'P m -3 m'")
+
+
+def test_phase_engine_subclass_adds_flat_fields_and_keeps_core_validation():
+    """The gsasii shape: engine fields flat in the phase; core rules still run; locs nest."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    d = _valid_pmm_lab6_phase_dict()
+    phase = EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert phase.scale.model_dump() == [1.0, True]
+    d["atoms"]["B1"]["x"] = [0.4999999, False]
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert _errors(exc_info) == [(("atoms", "B1"), "value_error")]  # the core symmetry rule runs
+    d["atoms"]["B1"]["x"] = [0.5, False]
+    d["atoms"]["B1"]["Multiplicity"] = 12
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert _errors(exc_info) == [(("atoms", "B1", "Multiplicity"), "value_error")]
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert _errors(exc_info) == [(("scale",), "missing")]
+
+
+def test_phase_has_no_phase_name():
+    """The phase name is the key of the payload's phases dict (A100)."""
+    d = {"phase_name": "LaB6", **_valid_pmm_lab6_phase_dict()}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("phase_name",), "extra_forbidden")]
+
+
+def test_atom_occupancy_required():
+    """No default: occupancy must be stated (A96)."""
+    d = _valid_pmm_lab6_phase_dict()
+    del d["atoms"]["La1"]["occupancy"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("atoms", "La1", "occupancy"), "missing")]
+
+
+@pytest.mark.parametrize("field", ["Multiplicity", "Uiso", "Uaniso"])
+def test_atom_optional_fields_are_never_null(field):
+    """A field that may be left out is never null (A96); leaving it out is the way."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"][field] = None
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("atoms", "B1", field), "value_error")]
+    assert exc_info.value.errors()[0]["msg"] == f"Value error, {field} must not be null; leave it out instead"
+
+
+@pytest.mark.parametrize("param", [[None, False], [0.5, None]])
+def test_phase_parameter_value_and_flag_never_null(param):
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"]["z"] = param
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    slot = "value" if param[0] is None else "refine_flag"
+    assert _errors(exc_info) == [(("atoms", "B1", "z", slot), "float_type" if slot == "value" else "bool_type")]
+
+
+def test_phase_dump_round_trips_and_leaves_absent_fields_out():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"]["Multiplicity"] = 6
+    phase = Phase[RP].model_validate(d)
+    dump = phase.model_dump(mode="json")
+    assert dump == d
+    assert "Uaniso" not in dump["atoms"]["La1"] and "Multiplicity" not in dump["atoms"]["La1"]
+    assert Phase[RP].model_validate_json(phase.model_dump_json()).model_dump() == phase.model_dump()
+
+
+def test_phase_json_schema_names_and_no_null():
+    """Readable $defs (no 'Atom_RefinableParameter_'); optional fields are not nullable (A96)."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    schema = EnginePhase.model_json_schema()
+    assert sorted(schema["$defs"]) == ["Atom", "RefinableParameter", "UanisoTensor", "UnitCell"]
+    atom = schema["$defs"]["Atom"]
+    assert atom["required"] == ["element", "x", "y", "z", "occupancy", "ADP"]
+    assert atom["properties"]["Uiso"] == {"$ref": "#/$defs/RefinableParameter", "unit": "angstrom^2",
+                                          "description": "Isotropic ADP; required when ADP is 'Uiso', else left out"}
+    assert atom["properties"]["Multiplicity"]["type"] == "integer"
+    assert "null" not in json.dumps(schema)
+    assert schema["$defs"]["RefinableParameter"]["prefixItems"] == [{"type": "number"}, {"type": "boolean"}]
+
+
+def test_phase_json_schema_two_parameter_types_in_one_document_stay_distinct():
+    """If two parametrizations ever share a document, the names fall back and the refs stay right."""
+    class Both(CoreModel):
+        g: Phase[RP]
+        t: Phase[BRP]
+
+    defs = Both.model_json_schema()["$defs"]
+    atom_refs = {k: v["properties"]["atoms"]["additionalProperties"]["$ref"].rsplit("/", 1)[1]
+                 for k, v in defs.items() if "Phase" in k}
+    assert len(set(atom_refs.values())) == 2
+    for name, ref in atom_refs.items():
+        expected = "BoundedRefinableParameter" if "Bounded" in name else "RefinableParameter"
+        assert defs[ref]["properties"]["x"]["$ref"] == f"#/$defs/{expected}"
+
+
+def test_phase_rejects_bounds_where_the_parameter_type_has_none():
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [4.15692, False, 4.0, 4.3]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("unit_cell", "a"), "value_error")]
+    assert "bounds are not supported" in exc_info.value.errors()[0]["msg"]
+
+
+def test_phase_value_rules_act_on_value():
+    """Cell, occupancy and element rules read .value; each error at its own field (A70)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [-4.0, False]
+    d["atoms"]["La1"]["occupancy"] = [1.5, False]
+    d["atoms"]["B1"]["element"] = "b"
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("unit_cell", "a"), "value_error"),
+                                 (("atoms", "La1", "occupancy"), "value_error"),
+                                 (("atoms", "B1", "element"), "value_error")]
+    assert [e["msg"] for e in exc_info.value.errors()] == [
+        "Value error, cell length a must be positive, got -4.0",
+        "Value error, occupancy must be between 0 and 1 inclusive, got 1.5",
+        "Value error, element 'b': write the element symbol as 'B'",
+    ]
 
 
 # --- numbers are JSON numbers: no strings, no booleans (A80) -----------------
@@ -1415,11 +1739,15 @@ def test_phase_structure_does_not_modify_caller_atoms():
 
 
 def _cell(**kw):
-    return {"a": 4.0, "b": 4.0, "c": 4.0, "alpha": 90, "beta": 90, "gamma": 90, **kw}
+    base = {"a": [4.0, False], "b": [4.0, False], "c": [4.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]}
+    base.update(kw)
+    return base
 
 
 def _atom(**kw):
-    return {"element": "Na", "x": 0.1, "y": 0.2, "z": 0.3, "ADP": "Uiso", "Uiso": 0.01, **kw}
+    base = {"element": "Na", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+    base.update(kw)
+    return base
 
 
 def _xrd(**kw):
@@ -1432,9 +1760,6 @@ def _xrd(**kw):
     ("BoundedRefinableParameter.value", lambda v: BoundedRefinableParameter.model_validate([v, True, None, None]), ("value",)),
     ("BoundedRefinableParameter.min", lambda v: BoundedRefinableParameter.model_validate([1.0, True, v, None]), ("min",)),
     ("BoundedRefinableParameter.max", lambda v: BoundedRefinableParameter.model_validate([0.5, True, None, v]), ("max",)),
-    ("StructureRefinableParameter.value", lambda v: StructureRefinableParameter.model_validate([v, True]), ("value",)),
-    ("StructureBoundedRefinableParameter.value",
-     lambda v: StructureBoundedRefinableParameter.model_validate([v, True, None, None]), ("value",)),
     ("FitRange.min", lambda v: FitRange.model_validate([v, None]), ("min",)),
     ("FitRange.max", lambda v: FitRange.model_validate([None, v]), ("max",)),
     ("XRDData.tth", lambda v: XRDData.model_validate(_xrd(tth=[v, 20.0])), ("tth", 0)),
@@ -1442,12 +1767,13 @@ def _xrd(**kw):
     ("XRDData.Itth_weights", lambda v: XRDData.model_validate(_xrd(Itth_weights=[v, 1.0])), ("Itth_weights", 0)),
     ("ChebyshevBackground.coefficients",
      lambda v: ChebyshevBackground(num_coefficients=1, coefficients=[v], refine_flag=False), ("coefficients", 0)),
-    *[(f"UnitCell.{k}", (lambda k: lambda v: UnitCell.model_validate(_cell(**{k: v})))(k), (k,))
+    *[(f"UnitCell.{k}", (lambda k: lambda v: UnitCell[RefinableParameter].model_validate(_cell(**{k: [v, False]})))(k), (k, "value"))
       for k in ("a", "b", "c", "alpha", "beta", "gamma")],
-    *[(f"Atom.{k}", (lambda k: lambda v: Atom.model_validate(_atom(**{k: v})))(k), (k,))
+    *[(f"Atom.{k}", (lambda k: lambda v: Atom[RefinableParameter].model_validate(_atom(**{k: [v, False]})))(k), (k, "value"))
       for k in ("x", "y", "z", "occupancy", "Uiso")],
-    ("Atom.Uaniso", lambda v: Atom.model_validate(_atom(ADP="Uaniso", Uiso=None, Uaniso={
-        "U11": v, "U22": 0.01, "U33": 0.01, "U12": 0.0, "U13": 0.0, "U23": 0.0})), ("Uaniso", "U11")),
+    ("Atom.Uaniso", lambda v: Atom[RefinableParameter].model_validate({
+        "element": "Na", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False], "ADP": "Uaniso",
+        "Uaniso": {"U11": [v, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0.0, False], "U13": [0.0, False], "U23": [0.0, False]}}), ("Uaniso", "U11", "value")),
 ]
 _FLOAT_IDS = [f[0] for f in _NUMERIC_FIELDS]
 
@@ -1473,14 +1799,14 @@ def test_numeric_field_accepts_numbers(label, build, loc, good):
 def test_numeric_json_strings_rejected():
     """From JSON too: a quoted number is not a number."""
     with pytest.raises(ValidationError) as exc_info:
-        Atom.model_validate_json(json.dumps(_atom(x="0.25")))
-    assert _errors(exc_info) == [(("x",), "float_type")]
-    assert Atom.model_validate_json(json.dumps(_atom(x=1))).x == 1.0
+        Atom[RefinableParameter].model_validate_json(json.dumps(_atom(x=["0.25", False])))
+    assert _errors(exc_info) == [(("x", "value"), "float_type")]
+    assert Atom[RefinableParameter].model_validate_json(json.dumps(_atom(x=[1, False]))).x.value == 1.0
 
 
 @pytest.mark.parametrize("good", [4, 4.0, np.int64(4), np.float64(4.0)])
 def test_integer_fields_accept_whole_numbers(good):
-    assert Atom.model_validate(_atom(Multiplicity=good)).Multiplicity == 4
+    assert Atom[RefinableParameter].model_validate(_atom(Multiplicity=good)).Multiplicity == 4
     assert ChebyshevBackground(num_coefficients=good, coefficients=[0.0] * 4, refine_flag=False).num_coefficients == 4
 
 
@@ -1489,7 +1815,7 @@ def test_integer_fields_accept_whole_numbers(good):
 ])
 def test_integer_fields_reject_fractions_strings_and_booleans(bad, error_type):
     with pytest.raises(ValidationError) as exc_info:
-        Atom.model_validate(_atom(Multiplicity=bad))
+        Atom[RefinableParameter].model_validate(_atom(Multiplicity=bad))
     assert _errors(exc_info) == [(("Multiplicity",), error_type)]
     with pytest.raises(ValidationError) as exc_info:
         ChebyshevBackground(num_coefficients=bad, coefficients=[0.0] * 4, refine_flag=False)
@@ -1497,4 +1823,720 @@ def test_integer_fields_reject_fractions_strings_and_booleans(bad, error_type):
 
 
 def test_integer_json_whole_float_accepted():
-    assert Atom.model_validate_json(json.dumps(_atom(Multiplicity=4.0))).Multiplicity == 4
+    assert Atom[RefinableParameter].model_validate_json(json.dumps(_atom(Multiplicity=4.0))).Multiplicity == 4
+
+
+# --- flag and bound rules F1-F4 (re/03b; A95, A98, A104, A106, A108) ---------
+
+_CELL_NAMES = ("a", "b", "c", "alpha", "beta", "gamma")
+_U_NAMES = ("U11", "U22", "U33", "U12", "U13", "U23")
+_N = [None, None]
+
+
+def _cellp(values, flags=(False,) * 6, bounds=None):
+    """unit_cell dict; with ``bounds`` (a dict of name -> (min, max), default open) 4-element lists."""
+    if bounds is None:
+        return {n: [v, f] for n, v, f in zip(_CELL_NAMES, values, flags)}
+    return {n: [v, f, *bounds.get(n, _N)] for n, v, f in zip(_CELL_NAMES, values, flags)}
+
+
+def _atomp(xyz, flags=(False,) * 3, bounds=None, uaniso=None, element="O"):
+    """atom dict; ``uaniso`` = {U: [value, flag(, min, max)]} switches ADP to Uaniso."""
+    tail = (lambda n: list(bounds.get(n, _N))) if bounds is not None else (lambda n: [])
+    d = {"element": element, **{k: [v, f, *tail(k)] for k, v, f in zip("xyz", xyz, flags)},
+         "occupancy": [1.0, False, *tail("occupancy")]}
+    if uaniso is None:
+        d.update(ADP="Uiso", Uiso=[0.01, False, *tail("Uiso")])
+    else:
+        d.update(ADP="Uaniso", Uaniso=uaniso)
+    return d
+
+
+def _phasep(space_group, cell, atoms):
+    return {"space_group": space_group, "unit_cell": cell, "atoms": atoms}
+
+
+def _errs(exc_info) -> list:
+    """(location, message without pydantic's prefix) of every error."""
+    return [(e["loc"], e["msg"].removeprefix("Value error, ")) for e in exc_info.value.errors()]
+
+
+_GENERAL = (0.1234, 0.2345, 0.3456)
+
+# (space group, cell values, members after the first of each tie group, fixed angles)
+_CELL_SYSTEMS = [
+    ("P m -3 m", (4, 4, 4, 90, 90, 90), ["b", "c"], ["alpha", "beta", "gamma"]),
+    ("P 4/m m m", (4, 4, 6, 90, 90, 90), ["b"], ["alpha", "beta", "gamma"]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), ["b"], ["alpha", "beta", "gamma"]),
+    ("R -3 m:H", (4, 4, 20, 90, 90, 120), ["b"], ["alpha", "beta", "gamma"]),
+    ("R -3 m:R", (5, 5, 5, 70, 70, 70), ["b", "c", "beta", "gamma"], []),
+    ("P m m m", (4, 5, 6, 90, 90, 90), [], ["alpha", "beta", "gamma"]),
+    ("C 1 2/m 1", (9, 5, 7, 90, 105, 90), [], ["alpha", "gamma"]),
+    ("P 1 c 1", (5, 6, 7, 90, 98, 90), [], ["alpha", "gamma"]),     # Pc, b-unique (A102)
+    ("P 1 1 m", (5, 6, 7, 90, 90, 98), [], ["alpha", "beta"]),      # Pm, c-unique
+    ("C m 1 1", (5, 6, 7, 98, 90, 90), [], ["beta", "gamma"]),      # Cm, a-unique
+    ("C 1 c 1", (5, 6, 7, 90, 98, 90), [], ["alpha", "gamma"]),     # Cc
+    ("P -1", (5, 6, 7, 80, 85, 95), [], []),
+]
+
+
+@pytest.mark.parametrize("sg, cell, _tied, fixed", _CELL_SYSTEMS, ids=[c[0] for c in _CELL_SYSTEMS])
+def test_cell_flags_consistent_accepted(sg, cell, _tied, fixed):
+    """Every free cell parameter refined, every fixed one not: valid in every crystal system."""
+    flags = tuple(n not in fixed for n in _CELL_NAMES)
+    Phase[RP].model_validate(_phasep(sg, _cellp(cell, flags), {"A": _atomp(_GENERAL)}))
+
+
+_CELL_SYSTEMS_WITH_RULES = [c for c in _CELL_SYSTEMS if c[2] or c[3]]  # P -1 has nothing to violate
+
+
+@pytest.mark.parametrize("sg, cell, tied, fixed", _CELL_SYSTEMS_WITH_RULES,
+                         ids=[c[0] for c in _CELL_SYSTEMS_WITH_RULES])
+def test_cell_flag_rules_f1_f2(sg, cell, tied, fixed):
+    """Only the first member of each tie group refined (F1) and every fixed angle refined (F2):
+    one error at each fixed angle, then one at every member whose flag differs (review N1)."""
+    flags = tuple(n not in tied for n in _CELL_NAMES)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep(sg, _cellp(cell, flags), {"A": _atomp(_GENERAL)}))
+    assert [loc for loc, _m in _errs(exc_info)] == [("unit_cell", n) for n in fixed + tied]
+
+
+def test_cell_flag_messages_name_the_group_and_the_fix():
+    d = _phasep("P m -3 m", _cellp((4, 4, 4, 90, 90, 90), (True, False, True, False, False, True)),
+                {"A": _atomp(_GENERAL)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [
+        (("unit_cell", "gamma"), "cubic cell ('P m -3 m'): gamma is fixed by symmetry (= 90); "
+                                 "set its refine flag to false"),
+        (("unit_cell", "b"), "cubic cell ('P m -3 m'): a, b, c are one parameter; "
+                             "set the same refine flag on all three"),
+    ]
+
+
+def test_rhombohedral_cell_ties_lengths_and_angles():
+    d = _phasep("R -3 m:R", _cellp((5, 5, 5, 70, 70, 70), (False, False, False, True, True, False)),
+                {"A": _atomp(_GENERAL)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [
+        (("unit_cell", "gamma"), "trigonal cell ('R -3 m:R'): alpha, beta, gamma are one parameter; "
+                                 "set the same refine flag on all three"),
+    ]
+
+
+def test_independent_groups_may_differ_f3():
+    """F3: orthorhombic a refined, b and c fixed; general-position x refined, y and z fixed."""
+    d = _phasep("P m m m", _cellp((4, 5, 6, 90, 90, 90), (True, False, False, False, False, False)),
+                {"A": _atomp(_GENERAL, (True, False, False))})
+    Phase[RP].model_validate(d)
+
+
+@pytest.mark.parametrize("sg, cell, xyz, flags, expected", [
+    ("P m -3 m", (4, 4, 4, 90, 90, 90), (0, 0, 0), (True, False, False),
+     [("x", "atom 'A' (multiplicity 1 in 'P m -3 m'): x is fixed by symmetry (= 0); "
+            "set its refine flag to false")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 3, 2 / 3, 0.25), (False, True, False),
+     [("y", "atom 'A' (multiplicity 2 in 'P 63/m m c'): y is fixed by symmetry (= 2/3); "
+            "set its refine flag to false")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, False, False),
+     [("y", "atom 'A' (multiplicity 6 in 'P 63/m m c'): x, y are one parameter (y = 2x); "
+            "set the same refine flag on both")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, True, True),
+     [("z", "atom 'A' (multiplicity 6 in 'P 63/m m c'): z is fixed by symmetry (= 1/4); "
+            "set its refine flag to false")]),
+    ("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.6, 0.3), (False, True, True),
+     [("y", "atom 'A' (multiplicity 4 in 'P -4 21 m'): x, y are one parameter (y = x + 1/2); "
+            "set the same refine flag on both")]),
+    ("R -3 m:R", (5, 5, 5, 70, 70, 70), (0.1, 0.1, 0.1), (True, False, True),
+     [("y", "atom 'A' (multiplicity 2 in 'R -3 m:R'): x, y, z are one parameter; "
+            "set the same refine flag on all three")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, True, False), []),
+    ("P 1 c 1", (5, 6, 7, 90, 98, 90), _GENERAL, (True, True, True), []),
+])
+def test_site_coordinate_flag_rules(sg, cell, xyz, flags, expected):
+    d = _phasep(sg, _cellp(cell), {"A": _atomp(xyz, flags)})
+    if not expected:
+        Phase[RP].model_validate(d)
+        return
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", name), message) for name, message in expected]
+
+
+def _u(values, flags=(False,) * 6, bounds=None):
+    """Uaniso dict; with ``bounds`` (name -> (min, max), default open) 4-element lists."""
+    tail = (lambda n: list(bounds.get(n, _N))) if bounds is not None else (lambda n: [])
+    return {n: [v, f, *tail(n)] for n, v, f in zip(_U_NAMES, values, flags)}
+
+
+def test_uij_flag_rules_several_groups_at_one_site():
+    """6h in P6_3/mmc: U11 | U22=2*U12 | U33 free groups, U13 and U23 fixed (0)."""
+    values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
+    ok = _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u(values, (True, True, False, True, False, False)), element="C")
+    Phase[RP].model_validate(_phasep("P 63/m m c", _cellp((3, 3, 5, 90, 90, 120)), {"C": ok}))
+    bad = _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u(values, (False, True, False, False, True, False)), element="C")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P 63/m m c", _cellp((3, 3, 5, 90, 90, 120)), {"C": bad}))
+    context = "atom 'C' (multiplicity 6 in 'P 63/m m c')"
+    assert _errs(exc_info) == [
+        (("atoms", "C", "Uaniso", "U13"), f"{context}: U13 is fixed by symmetry (= 0); set its refine flag to false"),
+        (("atoms", "C", "Uaniso", "U12"), f"{context}: U22, U12 are one parameter (U12 = U22/2); "
+                                          "set the same refine flag on both"),
+    ]
+
+
+def test_uij_negative_relation_group():
+    """P-42_1m (0.1, 0.4, 0.3): U13 and U23 are one parameter with U23 = -U13."""
+    values = (0.01, 0.01, 0.012, 0.001, 0.002, -0.002)
+    a = _atomp((0.1, 0.4, 0.3), uaniso=_u(values, (False, False, False, False, True, False)))
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P -4 21 m", _cellp((5, 5, 4, 90, 90, 90)), {"A": a}))
+    assert _errs(exc_info) == [
+        (("atoms", "A", "Uaniso", "U23"), "atom 'A' (multiplicity 4 in 'P -4 21 m'): U13, U23 are one "
+                                          "parameter (U23 = -U13); set the same refine flag on both"),
+    ]
+
+
+def test_co_located_atoms_are_independent():
+    """A104: atoms on the same site keep their own flags; nothing ties them."""
+    cell = _cellp((4, 5, 6, 90, 90, 90))
+    atoms = {"Li": _atomp(_GENERAL, (True, True, True), element="Li"),
+             "Mg": _atomp(_GENERAL, (False, False, False), element="Mg")}
+    phase = Phase[RP].model_validate(_phasep("P m m m", cell, atoms))
+    assert phase.atoms["Li"].x.refine_flag is True and phase.atoms["Mg"].x.refine_flag is False
+
+
+def test_flag_and_value_problems_reported_together():
+    """One ValidationError lists the cell, coordinate and Uij rule violations (A70)."""
+    cell = _cellp((3, 3, 5, 90, 90, 120), (True, False, False, False, False, False))
+    atoms = {"A": _atomp((1 / 3, 2 / 3, 0.25), (True, False, False)),
+             "B": _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u((0.01, 0.012, 0.009, 0.006, 0, 0),
+                                                         (False, False, False, False, False, True))),
+             "C": _atomp(_GENERAL, element="Fe") | {"Multiplicity": 4}}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P 63/m m c", cell, atoms))
+    assert [loc for loc, _m in _errs(exc_info)] == [
+        ("unit_cell", "b"), ("atoms", "A", "x"), ("atoms", "B", "Uaniso", "U23"), ("atoms", "C", "Multiplicity")]
+
+
+# --- F4: bounds follow the tie (affine; A98, A108) and A106 -------------------
+
+_HEX = (3, 3, 5, 90, 90, 120)
+
+
+def _bounded_phase(sg, cell, xyz, flags, bounds, **kw):
+    return _phasep(sg, _cellp(cell, bounds={}), {"A": _atomp(xyz, flags, bounds=bounds, **kw)})
+
+
+@pytest.mark.parametrize("xyz, x_bounds, y_bounds", [
+    ((0.1, 0.6, 0.3), (0.0, 0.2), (0.5, 0.7)),        # y = x + 1/2
+    ((0.1, 0.4, 0.3), (0.0, 0.2), (0.3, 0.5)),        # y = -x + 1/2: swapped
+    ((0.1, -0.4, 0.3), (0.0, 0.2), (-0.5, -0.3)),     # y = x - 1/2: the stated translate counts
+    ((0.1, 0.4, 0.3), (0.0, None), (None, 0.5)),      # open ends map to the matching side
+    ((0.1, 0.4, 0.3), (None, 0.2), (0.3, None)),
+    ((0.1, 0.4, 0.3), (None, None), (None, None)),
+])
+def test_affine_bounds_follow_the_tie_p_421m_4e(xyz, x_bounds, y_bounds):
+    """Review B1: at P-42_1m 4e equal bounds would be wrong; the affine map is right."""
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), xyz, (True, True, False),
+                       {"x": x_bounds, "y": y_bounds})
+    phase = Phase[BRP].model_validate(d)
+    assert phase.atoms["A"].y.model_dump()[2:] == list(y_bounds)
+
+
+def test_affine_bounds_p42mnm_4f():
+    """P4_2/mnm (0.3, 0.7, 0): y = -x + 1; z fixed (A106: no bounds)."""
+    d = _bounded_phase("P 42/m n m", (5, 5, 3, 90, 90, 90), (0.3, 0.7, 0.0), (True, True, False),
+                       {"x": (0.25, 0.35), "y": (0.65, 0.75)})
+    Phase[BRP].model_validate(d)
+    d["atoms"]["A"]["y"][2:] = [0.25, 0.35]  # equal bounds: wrong for an affine tie
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", "y"), "value (0.7) is above max (0.35)")]
+
+
+def test_bounds_not_following_the_tie_rejected_at_the_member():
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                       {"x": (0.0, 0.2), "y": (0.3, 0.51)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", "y"),
+                                "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
+                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.3, 0.51]")]
+
+
+def test_bounds_open_side_must_match():
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                       {"x": (0.0, 0.2), "y": (None, 0.5)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info)[0][1].endswith("write [0.3, 0.5], not [null, 0.5]")
+
+
+def test_tied_coordinate_bounds_read_within_6_decimals():
+    """A121 (replaces A115's exact tied bounds): a tied member's bounds are derived from the first
+    member's like its value; 4e-6 off is read as [0.3, 0.5], 1e-5 off is an error giving them."""
+    def phase(y_bounds):
+        return _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                              {"x": (0.0, 0.2), "y": y_bounds})
+
+    assert Phase[BRP].model_validate(phase((0.300004, 0.5))).atoms["A"].y.model_dump() == [0.4, True, 0.3, 0.5]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase((0.30001, 0.5)))
+    assert _errs(exc_info) == [(("atoms", "A", "y"),
+                                "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
+                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.30001, 0.5]")]
+
+
+def test_tied_uij_bounds_factor_two():
+    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01]; within 1e-6 A^2 read as those (A98,
+    A121), further off an error giving them."""
+    values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
+    flags = (True, True, True, True, False, False)
+
+    def phase(u12_bounds):
+        bounds = {"U22": (0.0, 0.02), "U12": u12_bounds}
+        a = _atomp((1 / 6, 1 / 3, 0.25), bounds={}, uaniso=_u(values, flags, bounds), element="C")
+        return _phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a})
+
+    assert Phase[BRP].model_validate(phase((0.0, 0.01))).atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
+    assert Phase[BRP].model_validate(phase((0.0, 0.0100009))).atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase((0.0, 0.010002)))
+    assert _errs(exc_info) == [(("atoms", "C", "Uaniso", "U12"),
+                                "atom 'C' (multiplicity 6 in 'P 63/m m c'): the bounds of U12 must follow "
+                                "U12 = U22/2 from the bounds of U22 [0.0, 0.02]: write [0.0, 0.01], "
+                                "not [0.0, 0.010002]")]
+
+
+def test_tied_cell_bounds_follow_the_first_member():
+    """Cell ties are equalities: a member's bounds are the first member's, within CELL_TOL (1e-9, relative
+    on lengths; A77, A123), and the model holds them exactly; further off is an error giving them."""
+    def phase(b_max):
+        cell = _cellp((4, 4, 4, 90, 90, 90), (True, True, True, False, False, False),
+                      {"a": (3.9, 4.2), "b": (3.9, b_max), "c": (3.9, 4.2)})
+        return _phasep("P m -3 m", cell, {"A": _atomp(_GENERAL, bounds={})})
+
+    for b_max in (4.2 + 1e-15, 4.200000001):
+        assert Phase[BRP].model_validate(phase(b_max)).unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase(4.20001))
+    assert _errs(exc_info) == [(("unit_cell", "b"),
+                                "cubic cell ('P m -3 m'): the bounds of b must follow b = a from the bounds "
+                                "of a [3.9, 4.2]: write [3.9, 4.2], not [3.9, 4.20001]")]
+
+
+def test_symmetry_fixed_parameters_have_no_bounds_a106():
+    """A fixed parameter must have null bounds; a refine flag on it is F2 (two errors, one field)."""
+    cell = _cellp((4, 4, 4, 90, 90, 90), bounds={"alpha": (89.0, 91.0)})
+    atom = _atomp((0.0, 0.0, 0.0), (True, False, False), bounds={"x": (-0.1, 0.1)},
+                  uaniso=_u((0.01, 0.01, 0.01, 0.0, 0.0, 0.0), bounds={"U12": (None, 0.001)}), element="La")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(_phasep("P m -3 m", cell, {"La": atom}))
+    context = "atom 'La' (multiplicity 1 in 'P m -3 m')"
+    assert _errs(exc_info) == [
+        (("unit_cell", "alpha"), "cubic cell ('P m -3 m'): alpha is fixed by symmetry (= 90); "
+                                 "give it no bounds (min and max null)"),
+        (("atoms", "La", "x"), f"{context}: x is fixed by symmetry (= 0); set its refine flag to false"),
+        (("atoms", "La", "x"), f"{context}: x is fixed by symmetry (= 0); give it no bounds (min and max null)"),
+        (("atoms", "La", "Uaniso", "U12"), f"{context}: U12 is fixed by symmetry (= 0); "
+                                           "give it no bounds (min and max null)"),
+    ]
+
+
+# --- names and cell bound domain (re/03b review C5, C6) ----------------------
+
+
+_NAME_RULE = "must start with a letter and contain only ASCII letters, digits and '_' (e.g. 'O1', 'LaB6_a')"
+
+
+@pytest.mark.parametrize("label, message", [
+    ("", "a name must not be empty or blank"),
+    ("  ", "a name must not be empty or blank"),
+    ("O.1", f"name 'O.1' {_NAME_RULE}"),
+    (" O1", f"name ' O1' {_NAME_RULE}"),
+    ("O 1", f"name 'O 1' {_NAME_RULE}"),
+    ("O-1", f"name 'O-1' {_NAME_RULE}"),
+    ("1O", f"name '1O' {_NAME_RULE}"),
+    ("_O1", f"name '_O1' {_NAME_RULE}"),
+    ("Oé", f"name 'Oé' {_NAME_RULE}"),
+    ("O/1", f"name 'O/1' {_NAME_RULE}"),
+])
+def test_atom_label_follows_the_name_rule(label, message):
+    """Atom labels: a letter, then ASCII letters, digits or '_' (every engine can use it; review C6)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"][label] = d["atoms"].pop("B1")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", label, "[key]"), message)]
+
+
+def test_atom_labels_following_the_rule_accepted():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B_site2"] = d["atoms"].pop("B1")
+    assert "B_site2" in Phase[RP].model_validate(d).atoms
+
+
+def test_names_unique_ignoring_case():
+    from powderline.schema_core import check_names_unique_ignoring_case
+
+    check_names_unique_ignoring_case(["LaB6", "Si", "Al2O3"], "phase")
+    with pytest.raises(ValueError) as exc_info:
+        check_names_unique_ignoring_case(["LaB6", "Si", "lab6"], "phase")
+    assert str(exc_info.value) == "phase 'LaB6' and 'lab6' differ only in case; rename one"
+
+
+@pytest.mark.parametrize("label, message", [
+    ("None", "name 'None' is a Python keyword; choose another name"),
+    ("class", "name 'class' is a Python keyword; choose another name"),
+    ("O" * 65, f"name {'O' * 20!r}... has 65 characters; the limit is 64"),
+])
+def test_atom_label_is_an_identifier_of_bounded_length(label, message):
+    """Names are Python identifiers (no keywords) and at most 64 characters (file names)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"][label] = d["atoms"].pop("B1")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", label, "[key]"), message)]
+
+
+def test_atom_label_of_64_characters_accepted():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B" * 64] = d["atoms"].pop("B1")
+    assert "B" * 64 in Phase[RP].model_validate(d).atoms
+
+
+def test_core_name_json_schema_constrains_every_key():
+    import keyword
+
+    from powderline.schema_core import NAME_PATTERN
+
+    atoms = Phase[RP].model_json_schema()["properties"]["atoms"]
+    assert atoms["propertyNames"] == {"pattern": NAME_PATTERN, "maxLength": 64,
+                                      "not": {"enum": keyword.kwlist}}
+    assert atoms["additionalProperties"] == {"$ref": "#/$defs/Atom"}
+    assert "patternProperties" not in atoms
+
+
+@pytest.mark.parametrize("name, bounds, message", [
+    ("a", (0.0, 10.0), "cell length a: min must be positive (a cell length is), got 0.0; use null for no lower bound"),
+    ("c", (-1.0, None), "cell length c: min must be positive (a cell length is), got -1.0; use null for no lower bound"),
+    ("beta", (0.0, 120.0), "cell angle beta: min must be between 0 and 180 degrees (a cell angle is), got 0.0; "
+                           "use null for no min bound"),
+    ("beta", (90.0, 180.0), "cell angle beta: max must be between 0 and 180 degrees (a cell angle is), got 180.0; "
+                            "use null for no max bound"),
+])
+def test_cell_bounds_lie_in_the_cell_domain(name, bounds, message):
+    """A stated bound outside where a cell parameter exists is an error (lengths > 0, angles in (0, 180))."""
+    values = (9.0, 5.0, 7.0, 90, 105.0, 90)
+    cell = _cellp(values, flags=(True, True, True, False, True, False), bounds={name: bounds})
+    d = _phasep("C 1 2/m 1", cell, {"O": _atomp(_GENERAL, bounds={})})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("unit_cell", name), message)]
+
+
+def test_cell_open_bounds_and_positive_bounds_accepted():
+    values = (9.0, 5.0, 7.0, 90, 105.0, 90)
+    cell = _cellp(values, flags=(True, True, True, False, True, False),
+                  bounds={"a": (8.0, 10.0), "b": (None, 6.0), "beta": (95.0, 115.0)})
+    phase = Phase[BRP].model_validate(_phasep("C 1 2/m 1", cell, {"O": _atomp(_GENERAL, bounds={})}))
+    assert phase.unit_cell.a.model_dump() == [9.0, True, 8.0, 10.0]
+
+
+# --- non-positive-definite Uaniso (A118) -------------------------------------
+
+
+def _p1_uaniso_phase(u):
+    keys = ("U11", "U22", "U33", "U12", "U13", "U23")
+    atom = {"element": "O", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False],
+            "ADP": "Uaniso", "Uaniso": {k: [v, False] for k, v in zip(keys, u)}}
+    return {"space_group": "P 1",
+            "unit_cell": {k: [v, False] for k, v in zip(_CELL_NAMES, (5.0, 6.0, 7.0, 80.0, 85.0, 95.0))},
+            "atoms": {"O1": atom}}
+
+
+def test_uaniso_not_positive_definite_warns_and_keeps_the_values():
+    """A118: informative, never an error or a change; the same recipe gives the same warning again."""
+    d = _p1_uaniso_phase((0.01, 0.01, 0.01, 0.02, 0.0, 0.0))  # Uij matrix eigenvalues -0.01, 0.01, 0.03
+    phase = Phase[RP].model_validate(d)
+    assert phase.model_dump() == d
+    expected = [{"code": "uaniso_not_positive_definite",
+                 "message": "atom 'O1' (multiplicity 1 in 'P 1'): Uaniso is not positive definite (principal "
+                            "mean-square displacements -0.0112, 0.00981, 0.0288 A^2), so it describes no thermal "
+                            "ellipsoid; it is used as stated",
+                 "field_path": "atoms.O1.Uaniso"}]
+    assert phase.warnings() == expected
+    assert Phase[RP].model_validate(phase.model_dump()).warnings() == expected
+
+
+def test_uaniso_positive_definite_gives_no_warning():
+    phase = Phase[RP].model_validate(_p1_uaniso_phase((0.01, 0.012, 0.009, 0.002, -0.001, 0.0005)))
+    assert phase.warnings() == []
+
+
+from powderline.schema_core import _principal_msd  # noqa: E402
+from powderline.symmetry import _metric, check_cell  # noqa: E402
+
+
+def _isotropic_uij(cell, u_iso):
+    """U^ij of an isotropic U in ``cell``: u_iso * G*^ij / (a*_i a*_j)."""
+    g = np.linalg.inv(_metric(cell))
+    rec = np.sqrt(np.diag(g))
+    u = u_iso * g / np.outer(rec, rec)
+    return (u[0, 0], u[1, 1], u[2, 2], u[0, 1], u[0, 2], u[1, 2])
+
+
+@pytest.mark.parametrize("cell", [(5.0, 6.0, 7.0, 80.0, 85.0, 95.0), (3.2, 3.2, 5.2, 90.0, 90.0, 120.0)])
+def test_principal_mean_square_displacements_are_cartesian(cell):
+    """A118 (re/03b PR review N4): the warning gives the Cartesian principal values; an isotropic U has
+    three equal ones in any cell, although its Uij matrix does not (hexagonal U12 = U11/2)."""
+    assert np.allclose(_principal_msd(cell, _isotropic_uij(cell, -0.01)), -0.01)
+
+
+def test_uaniso_not_positive_definite_isotropic_hexagonal_message():
+    """N4: a negative isotropic tensor on hexagonal axes reports -0.01 three times, not the Uij matrix's
+    -0.015, -0.01, -0.005."""
+    d = _p1_uaniso_phase(_isotropic_uij((3.2, 3.2, 5.2, 90.0, 90.0, 120.0), -0.01))
+    d["unit_cell"] = {k: [v, False] for k, v in zip(_CELL_NAMES, (3.2, 3.2, 5.2, 90.0, 90.0, 120.0))}
+    (warning,) = Phase[RP].model_validate(d).warnings()
+    assert "principal mean-square displacements -0.01, -0.01, -0.01 A^2" in warning["message"]
+
+
+def test_uaniso_semidefinite_always_warns():
+    """N4: a zero principal value is <= 0 whatever the floating-point noise (rank-1 tensor)."""
+    for v in (0.01, 0.03, 0.07, 0.11, 0.013):
+        (warning,) = Phase[RP].model_validate(_p1_uaniso_phase((v,) * 6)).warnings()
+        assert warning["code"] == "uaniso_not_positive_definite"
+
+
+
+# --- one rule for symmetry-determined values (A121; re/03b PR review S1, S3, Q1) ----------------
+
+_HEX_CELL = (3.2, 3.2, 5.2, 90.0, 90.0, 120.0)
+_SPECIAL_VALUE_CASES = [
+    # (case, space group, cell, stated xyz, model xyz or the error) -- the table in SCHEMA_HISTORY
+    ("fixed 1/2 written 0.4999999", "P m -3 m", (4.0, 4.0, 4.0, 90.0, 90.0, 90.0), (0.4999999, 0.0, 0.0),
+     "write x = 0.5"),
+    ("fixed 1/3 written 0.333333", "P 63/m m c", _HEX_CELL, (0.333333, 0.666667, 0.25), (1 / 3, 2 / 3, 0.25)),
+    ("fixed 1/3 written to 13 digits", "P 63/m m c", _HEX_CELL, (0.3333333333333, 0.6666666666667, 0.25),
+     (1 / 3, 2 / 3, 0.25)),
+    ("ideal C14 6h (x, 2x - 1, 1/4)", "P 63/m m c", _HEX_CELL, (0.833333, 0.666667, 0.25),
+     (0.833333, float(2 * Fraction(0.833333) - 1), 0.25)),
+    ("y = 2x written 0.2000001", "P 6/m m m", _HEX_CELL, (0.1, 0.2000001, 0.0), (0.1, 0.2, 0.0)),
+    ("y = x/2 of a 6-decimal x", "P 6/m m m", _HEX_CELL, (0.333333, 0.166667, 0.0),
+     (0.333333, float(Fraction(0.333333) / 2), 0.0)),
+    ("y = x + 1/3 written 0.4", "R -3 m:H", (4.0, 4.0, 20.0, 90.0, 90.0, 120.0), (0.066667, 0.4, 0.166667),
+     (0.066667, float(Fraction(0.066667) + Fraction(1, 3)), 1 / 6)),
+]
+
+
+@pytest.mark.parametrize("case, sg, cell, xyz, expected", _SPECIAL_VALUE_CASES, ids=[c[0] for c in _SPECIAL_VALUE_CASES])
+def test_symmetry_determined_values_follow_one_rule(case, sg, cell, xyz, expected):
+    """A121: a constant with a decimal form is exact; a third is read from 6 decimals; a value derived from
+    another stated value is read within 6 decimals; the model holds the derived value, and its dump
+    validates as itself."""
+    d = {"space_group": sg, "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in cell))),
+         "atoms": {"A": {"element": "O", **{k: [v, False] for k, v in zip("xyz", xyz)},
+                         "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    if isinstance(expected, str):
+        with pytest.raises(ValidationError) as exc_info:
+            Phase[RP].model_validate(d)
+        assert exc_info.value.errors()[0]["msg"].endswith(expected)
+        return
+    phase = Phase[RP].model_validate(d)
+    assert tuple(getattr(phase.atoms["A"], k).value for k in "xyz") == expected
+    assert phase.warnings() == []
+    assert Phase[RP].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_equal_ties_are_named_in_the_message():
+    """N3: an equal tie is a relation too (12j (1/2, y, y): z = y)."""
+    d = {"space_group": "P m -3 m", "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in (4.0, 4.0, 4.0, 90, 90, 90)))),
+         "atoms": {"A": {"element": "O", "x": [0.4999999, False], "y": [0.2, False], "z": [0.2, False],
+                         "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A"), "atom 'A' (multiplicity 12 in 'P m -3 m'): (0.4999999, 0.2, 0.2) is "
+                                                "1e-07 from a special position, not on it (x = 1/2, z = y); write x = 0.5")]
+
+
+def test_cell_holds_the_first_members_values():
+    """A123: tied cell values within CELL_TOL are the first member's in the model (b = a exactly), and fixed
+    angles are exact; the error states the stated values and gives the ones to write."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["b"] = [4.15692 * (1 + 5e-10), False]
+    d["unit_cell"]["gamma"] = [90 + 5e-10, False]
+    cell = Phase[RP].model_validate(d).unit_cell
+    assert (cell.b.value, cell.gamma.value) == (4.15692, 90.0)
+    d["unit_cell"]["b"] = [4.15692 * (1 + 5e-9), False]
+    d["unit_cell"]["gamma"] = [90.1, False]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("unit_cell",), "unit cell is inconsistent with 'P m -3 m' (cubic): stated "
+                                                f"b = {4.15692 * (1 + 5e-9)!r}, gamma = 90.1, but by symmetry "
+                                                "gamma = 90, b = a; write b = 4.15692, gamma = 90.0")]
+
+
+def test_fixed_cell_angles_are_exact_in_every_setting():
+    """A123: every gemmi setting's fixed angles are 90, or 120 for gamma on hexagonal axes; a cell built
+    from them passes the metric check (A77)."""
+    import gemmi
+
+    from powderline.schema_core import _fixed_cell_angle
+    from powderline.symmetry import cell_tie_groups
+
+    for sg in gemmi.spacegroup_table():
+        ties = cell_tie_groups(sg.xhm())
+        cell = {"a": 5.1, "b": 6.2, "c": 7.3, "alpha": 81.0, "beta": 86.0, "gamma": 97.0}
+        for group in ties.groups:
+            for member in group.members[1:]:
+                cell[member] = cell[group.members[0]]
+        cell.update({name: float(_fixed_cell_angle(ties, name)) for name in ties.fixed})
+        check_cell(sg.xhm(), tuple(cell[k] for k in _CELL_NAMES))
+
+
+def test_tied_values_and_bounds_derived_together_stay_ordered():
+    """N1: a member's value and bounds are both derived from the first member's, so a value at its bound
+    stays within it, and the dump validates."""
+    cell = {k: [*v, None, None] for k, v in _R3M_CELL.items()}
+    atom = {"element": "O", "x": [0.2, False, 0.0, 0.2], "y": [0.5333333333333334, False, 0.333333, 0.533334],
+            "z": [0.166667, False, None, None], "occupancy": [1.0, False, None, None],
+            "ADP": "Uiso", "Uiso": [0.01, False, None, None]}
+    phase = Phase[BRP].model_validate({"space_group": "R -3 m:H", "unit_cell": cell, "atoms": {"O1": atom}})
+    y = phase.atoms["O1"].y
+    assert y.min <= y.value <= y.max
+    assert Phase[BRP].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_uij_within_floating_point_precision_held_exactly():
+    """N2: no message without a value to write; the model holds the derived tensor."""
+    keys = ("U11", "U22", "U33", "U12", "U13", "U23")
+    values = (0.01, 0.01 + 9.5e-13, 0.02, 0.005 - 9.5e-13, 0.0, 0.0)
+    d = {"space_group": "P 6/m m m", "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in _HEX_CELL))),
+         "atoms": {"A": {"element": "O", "x": [0.0, False], "y": [0.0, False], "z": [0.0, False],
+                         "occupancy": [1.0, False], "ADP": "Uaniso", "Uaniso": {k: [v, False] for k, v in zip(keys, values)}}}}
+    u = Phase[RP].model_validate(d).atoms["A"].Uaniso
+    assert (u.U22.value, u.U12.value) == (0.01, 0.005)
+
+
+# --- names (A112 amended: atom labels unique ignoring case; re/03b PR review N8) ----------------
+
+
+def test_atom_labels_unique_ignoring_case():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["la1"] = d["atoms"]["La1"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "la1"), "atom labels 'La1' and 'la1' differ only in case; rename one")]
+
+
+# --- engine subclass guard layers (A122; re/03b PR review S2, N5) -------------------------------
+
+
+def test_phase_parameter_type_must_be_a_core_parameter_type():
+    from typing import Generic
+
+    from powderline.schema_core import P
+
+    with pytest.raises(TypeError, match=r"the parameter type must be RefinableParameter or BoundedRefinableParameter, "
+                                        r"not <class 'float'>"):
+        Phase[float]
+
+    class EnginePhase(Phase[P], Generic[P]):
+        pass
+
+    with pytest.raises(TypeError, match="not <class 'int'>"):
+        EnginePhase[int]
+
+
+def test_phase_mixin_cannot_replace_a_core_validator():
+    """A mixin placed before Phase is collected first by pydantic; its same-named validator would win."""
+    from pydantic import BaseModel
+
+    class Mixin(BaseModel):
+        @field_validator("space_group", check_fields=False)
+        @classmethod
+        def _space_group(cls, v):
+            return v
+
+    class PlainMixin:
+        @model_validator(mode="after")
+        def _sites_check(self):
+            return self
+
+    for mixin, name in ((Mixin, "_space_group"), (PlainMixin, "_sites_check")):
+        with pytest.raises(TypeError, match=f"^{mixin.__name__} reuses the core phase name\\(s\\) {name};"):
+            type("EnginePhase", (mixin, Phase[RP]), {"__module__": __name__})
+
+
+def test_phase_mixin_cannot_redeclare_a_core_field():
+    from pydantic import BaseModel
+
+    class Mixin(BaseModel):
+        space_group: str = "P 1"
+
+    with pytest.raises(TypeError, match=r"^Mixin redeclares the core phase field\(s\) space_group;"):
+        class EnginePhase(Mixin, Phase[RP]):
+            pass
+
+
+@pytest.mark.parametrize("name, body", [
+    ("_engine_wrap", "@model_validator(mode='wrap')\n@classmethod\ndef _engine_wrap(cls, data, handler):\n    return handler(data)"),
+    ("_engine_before", "@model_validator(mode='before')\n@classmethod\ndef _engine_before(cls, data):\n    return data"),
+    ("_snap", "@field_validator('atoms', mode='before')\n@classmethod\ndef _snap(cls, v):\n    return v"),
+    ("_all", "@field_validator('*', mode='wrap')\n@classmethod\ndef _all(cls, v, handler):\n    return handler(v)"),
+    ("_sg", "@field_validator('space_group', mode='plain')\n@classmethod\ndef _sg(cls, v):\n    return v"),
+])
+def test_phase_validators_that_could_rewrite_the_recipe_rejected(name, body):
+    """A122: a 'before', 'wrap' or 'plain' validator could rewrite the recipe before core reads it (e.g.
+    round 0.4999999 to 0.5, A115) or skip core's validation."""
+    namespace = {"field_validator": field_validator, "model_validator": model_validator, "Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n    scale: RP\n" + "\n".join("    " + line for line in body.splitlines())
+    with pytest.raises(TypeError, match=f"^EnginePhase: validator\\(s\\) {name} must be 'after' validators"):
+        exec(source, namespace)
+
+
+def test_phase_engine_before_validator_on_its_own_field_allowed():
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+        @field_validator("scale", mode="before")
+        @classmethod
+        def _scale_shape(cls, v):
+            return v
+
+        @model_validator(mode="after")
+        def _engine_check(self):
+            return self
+
+    assert EnginePhase.model_validate({**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}).scale.value == 1.0
+
+
+@pytest.mark.parametrize("name, body", [
+    ("__init__", "def __init__(self, **data):\n    super().__init__(**data)"),
+    ("model_post_init", "def model_post_init(self, context):\n    pass"),
+    ("model_validate", "@classmethod\ndef model_validate(cls, obj, **kw):\n    return cls.model_construct(**obj)"),
+    ("__get_pydantic_core_schema__", "@classmethod\ndef __get_pydantic_core_schema__(cls, source, handler):\n    return handler(source)"),
+    ("__pydantic_init_subclass__", "@classmethod\ndef __pydantic_init_subclass__(cls, **kw):\n    pass"),
+])
+def test_phase_entry_points_cannot_be_overridden(name, body):
+    """A122: an override could skip or replace core's validation without reusing a core name."""
+    namespace = {"Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n" + "\n".join("    " + line for line in body.splitlines())
+    with pytest.raises(TypeError, match=f"^EnginePhase defines {name}; a phase model may not override"):
+        exec(source, namespace)
+
+
+def test_phase_guard_sees_a_replaced_core_validator():
+    """A122 layer 2: whatever the route, every core validator must still be core's own function."""
+    import dataclasses
+
+    class EnginePhase(Phase[RP]):
+        pass
+
+    validators = EnginePhase.__pydantic_decorators__.field_validators
+    validators["_space_group"] = dataclasses.replace(validators["_space_group"], func=lambda cls, v: v)
+    with pytest.raises(TypeError, match=r"^EnginePhase replaces the core validator\(s\) _space_group"):
+        EnginePhase.__pydantic_init_subclass__()
diff --git a/tests/test_symmetry_characterization.py b/tests/test_symmetry_characterization.py
index 185b1b7..d988e89 100644
--- a/tests/test_symmetry_characterization.py
+++ b/tests/test_symmetry_characterization.py
@@ -184,3 +184,131 @@ def test_committed_examples_agree_with_gsasii():
                 assert site.multiplicity == G2spc.SytSym(list(xyz), sgdata)[1]
                 checked += 1
     assert checked >= 20
+
+
+# --- coupling groups vs GSAS-II, exhaustive (re/03b; A94, A95, A98) ----------
+#
+# Every distinct site stabilizer met on the 1/24 grid, in every gemmi setting
+# GSAS-II reads (522: all ':R' settings and every non-standard monoclinic and
+# orthorhombic setting; origin-1 settings skipped, EB-03): the tie groups of
+# coordinates and Uij (partition, fixed set) and each group's relation
+# coefficients against GSAS-II's GetCSxinel/GetCSuinel ids and multipliers.
+# Devkit probe: probes/re03b_review_symmetry_probe.py (review S2).
+
+from powderline.symmetry import coupling_groups  # noqa: E402
+from symmetry_sites import distinct_special_sites  # noqa: E402
+
+#: GSAS-II sites it reads wrongly (core is right there). Points in 1/24 units.
+#: EB-40: R-centred 2-fold sites GSAS-II calls general ('1', doubled
+#: multiplicity). EB-05: sites it cannot name ('sp'; GetCSxinel raises).
+#: Each must STILL differ: if one starts to agree, a GSAS-II upgrade fixed it,
+#: and EB-40/EB-05 and the re/04 gateway check need revisiting.
+GSASII_DEFECTS = {
+    ("R 3 2:H", (0, 8, 4)): ("1", 18), ("R 3 2:H", (0, 16, 4)): ("1", 18),
+    ("R 3 2:H", (16, 0, 8)): ("1", 18),
+    ("R -3 m:H", (0, 8, 4)): ("1", 36), ("R -3 m:H", (0, 16, 4)): ("1", 36),
+    ("R -3 m:H", (16, 0, 8)): ("1", 36),
+    ("R -3 c:H", (0, 8, 10)): ("1", 36), ("R -3 c:H", (0, 16, 10)): ("1", 36),
+    ("R -3 c:H", (16, 0, 2)): ("1", 36),
+    ("R -3 m:R", (0, 12, 0)): ("sp", 3),
+    ("P 4 3 2", (0, 1, 0)): ("sp", 6),
+    ("F 4 3 2", (0, 1, 0)): ("sp", 24), ("F 4 3 2", (0, 1, 12)): ("sp", 24),
+    ("I 4 3 2", (0, 1, 0)): ("sp", 12),
+    ("P n -3 n:2", (6, 0, 6)): ("sp", 12),
+    ("F m -3 c", (6, 1, 6)): ("sp", 48), ("F m -3 c", (6, 1, 18)): ("sp", 48),
+}
+
+
+def _gsas_symbol_any_setting(sg):
+    """Like ``_gsas_symbol``, also for ':R' and spacing variants GSAS-II reads (review probe)."""
+    x = np.array([0.1234, 0.2345, 0.3456])
+    ref = _orbit(_expanded_ops(sg), x)
+    parts = sg.hm.split()
+    candidates = [sg.hm + " R"] if sg.ext == "R" else []
+    candidates += [sg.hm, G2spc.StandardizeSpcName(sg.short_name()),
+                   G2spc.StandardizeSpcName(sg.hm.replace(" ", ""))]
+    if len(parts) == 4 and parts[1] == "1" and parts[3] == "1":
+        candidates.append(f"{parts[0]} {parts[2]}")
+    for cand in candidates:
+        try:
+            err, sgdata = G2spc.SpcGroup(cand)
+        except Exception:  # noqa: BLE001 - GSAS-II raises on some spellings
+            continue
+        if err:
+            continue
+        theirs = [np.array(e[0]) % 1.0 for e in G2spc.GenAtom(x, sgdata, All=False)]
+        if len(theirs) == len(ref) and all(any(_same_mod1(p, q) for q in theirs) for p in ref):
+            return cand, sgdata
+    return None, None
+
+
+def _gsas_ties(ids, multipliers, names):
+    """GSAS-II constraint ids + multipliers -> ({members: relative multipliers}, fixed names)."""
+    groups: dict[int, list[int]] = {}
+    for j, gid in enumerate(ids):
+        if gid != 0:
+            groups.setdefault(gid, []).append(j)
+    ties = {tuple(names[j] for j in members): tuple(multipliers[j] / multipliers[members[0]] for j in members)
+            for members in groups.values()}
+    return ties, tuple(n for n, gid in zip(names, ids) if gid == 0)
+
+
+def _core_ties(ties):
+    return ({g.members: tuple(float(k) for k in g.coefficients) for g in ties.groups}, ties.fixed)
+
+
+def _same_ties(ours, theirs) -> bool:
+    (og, of), (tg, tf) = ours, theirs
+    return of == tf and og.keys() == tg.keys() and all(
+        all(abs(a - b) < 1e-9 for a, b in zip(og[k], tg[k])) for k in og)
+
+
+@pytest.fixture(scope="module")
+def coupling_comparison():
+    """Compare every distinct special site; returns (settings, sites compared, disagreements)."""
+    settings, sites, disagreements = 0, 0, {}
+    for sg in gemmi.spacegroup_table():
+        if sg.ext == "1":
+            continue  # GSAS-II has no origin-1 settings (EB-03)
+        _symbol, sgdata = _gsas_symbol_any_setting(sg)
+        if sgdata is None:
+            continue  # 9 settings GSAS-II cannot express
+        settings += 1
+        name = sg.xhm()
+        for point in distinct_special_sites(sg):
+            x = [v / 24 for v in point]
+            sites += 1
+            site, ties = analyze_site(name, x), coupling_groups(name, x)
+            sitesym, mult = G2spc.SytSym(x, sgdata)[0:2]
+            ours = {"multiplicity": site.multiplicity,
+                    "xyz": _core_ties(ties.xyz), "uij": _core_ties(ties.uij)}
+            try:
+                theirs = {"multiplicity": mult,
+                          "xyz": _gsas_ties(*G2spc.GetCSxinel(sitesym)[:2], ("x", "y", "z")),
+                          "uij": _gsas_ties(*G2spc.GetCSuinel(sitesym)[:2],
+                                            ("U11", "U22", "U33", "U12", "U13", "U23"))}
+            except KeyError:  # GSAS-II cannot name the site ('sp', EB-05)
+                disagreements[(name, point)] = (sitesym, mult)
+                continue
+            if not (ours["multiplicity"] == theirs["multiplicity"]
+                    and _same_ties(ours["xyz"], theirs["xyz"]) and _same_ties(ours["uij"], theirs["uij"])):
+                disagreements[(name, point)] = (sitesym, mult)
+    return settings, sites, disagreements
+
+
+def test_coupling_groups_match_gsasii_where_it_reads_the_site(coupling_comparison):
+    """Partition, fixed set, one DOF per group and relation coefficients agree with GSAS-II."""
+    settings, sites, disagreements = coupling_comparison
+    assert settings == 522
+    assert sites == 2928  # 2,920 GSAS-II names + 8 it cannot ('sp')
+    unexpected = {k: v for k, v in disagreements.items() if k not in GSASII_DEFECTS}
+    assert not unexpected, f"new disagreements with GSAS-II (escalate, A35): {unexpected}"
+
+
+def test_known_gsasii_site_defects_still_differ(coupling_comparison):
+    """The 17 known GSAS-II defects (EB-40, EB-05) are still there, exactly as recorded."""
+    _settings, _sites, disagreements = coupling_comparison
+    assert {k: disagreements.get(k) for k in GSASII_DEFECTS} == GSASII_DEFECTS
+    for (name, point), (sitesym, mult) in GSASII_DEFECTS.items():
+        core = analyze_site(name, [v / 24 for v in point]).multiplicity
+        assert sitesym == "sp" or mult == 2 * core, (name, point)
diff --git a/tests/test_symmetry_core.py b/tests/test_symmetry_core.py
index 58bf81b..b530d2a 100644
--- a/tests/test_symmetry_core.py
+++ b/tests/test_symmetry_core.py
@@ -250,3 +250,176 @@ def test_is_group_detects_closure():
 def test_ambiguous_band_message_names_the_special_position():
     with pytest.raises(SymmetryError, match=r"from the special position \(1/3, 2/3, 1/4\) \(multiplicity 2\)"):
         analyze_site("P 63/m m c", (0.3333, 0.6667, 0.25))
+
+
+# --- tie groups: coupling_groups, cell_tie_groups (re/03b; A94, A95, A98, A102) ---
+
+import gemmi  # noqa: E402
+import numpy as np  # noqa: E402
+
+from powderline import symmetry as sym  # noqa: E402
+from powderline.symmetry import cell_constraints, cell_tie_groups, coupling_groups  # noqa: E402
+from symmetry_sites import distinct_special_sites  # noqa: E402
+
+_UIJ = ("U11", "U22", "U33", "U12", "U13", "U23")
+
+
+def _ties(ties):
+    """Ties -> ({members: (coefficients, offsets)}, fixed), with exact Fractions."""
+    return {g.members: (g.coefficients, g.offsets) for g in ties.groups}, ties.fixed
+
+
+def test_coupling_groups_are_one_dof_affine_relations_in_every_setting():
+    """All 564 gemmi settings (incl. origin 1 and ':R'), every distinct special site on the
+    1/24 grid: the fixed sets match analyze_site; moving the site along any coordinate group's
+    relation keeps it fixed by the whole stabilizer; a Uij tensor built along any Uij group's
+    relation is invariant under it. Proves each group is one DOF with the right relation."""
+    settings = sites = groups = 0
+    for sg in gemmi.spacegroup_table():
+        name = sg.xhm()
+        ops = sym._expanded_ops(sg)
+        settings += 1
+        for point in distinct_special_sites(sg):
+            x = np.array(point) / 24
+            stab = [(R, t) for R, t in ops if np.all(np.abs(sym._wrap_symmetric(R @ x + t - x)) < 1e-9)]
+            site, ties = analyze_site(name, x), coupling_groups(name, x)
+            sites += 1
+            assert set(ties.xyz.fixed) == {a for a, c in zip("xyz", site.axes) if c == "FIXED"}
+            assert set(ties.uij.fixed) == {u for u, c in zip(_UIJ, site.adp) if c == "FIXED"}
+            for g in ties.xyz.groups:
+                groups += 1
+                moved = np.array(site.canonical)
+                rep = moved["xyz".index(g.members[0])] + 0.0123
+                for member, k, c in zip(g.members, g.coefficients, g.offsets):
+                    moved["xyz".index(member)] = float(k) * rep + float(c)
+                worst = max(np.max(np.abs(sym._wrap_symmetric(R @ moved + t - moved))) for R, t in stab)
+                assert worst < 1e-12, (name, point, g)
+            for g in ties.uij.groups:
+                assert set(g.offsets) == {0}
+                u = np.zeros(6)
+                for member, k in zip(g.members, g.coefficients):
+                    u[_UIJ.index(member)] = float(k) * 0.01
+                tensor = sym._sym_from_vec(u)
+                assert max(np.max(np.abs(R @ tensor @ R.T - tensor)) for R, _t in stab) < 1e-12, (name, point, g)
+    assert (settings, sites, groups) == (564, 3451, 2792)
+
+
+@pytest.mark.parametrize("space_group, xyz, expected", [
+    # review B1: affine ties; the offset follows the stated lattice translate
+    ("P -4 21 m", (0.1, 0.6, 0.3), {("x", "y"): ((1, 1), (0, Fraction(1, 2))), ("z",): ((1,), (0,))}),
+    ("P -4 21 m", (0.1, 0.4, 0.3), {("x", "y"): ((1, -1), (0, Fraction(1, 2))), ("z",): ((1,), (0,))}),
+    ("P -4 21 m", (0.1, -0.4, 0.3), {("x", "y"): ((1, 1), (0, Fraction(-1, 2))), ("z",): ((1,), (0,))}),
+    ("P 42/m n m", (0.3, 0.7, 0.0), {("x", "y"): ((1, -1), (0, 1))}),
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25), {("x", "y"): ((1, 2), (0, 0))}),
+    ("R -3 m:H", (0.1, -0.1, 0.3), {("x", "y"): ((1, -1), (0, 0)), ("z",): ((1,), (0,))}),
+    ("P m -3 m", (0.5, 0.5, 0.2021), {("z",): ((1,), (0,))}),
+    ("R -3 m:R", (0.1, 0.1, 0.1), {("x", "y", "z"): ((1, 1, 1), (0, 0, 0))}),
+])
+def test_coupling_groups_coordinate_relations(space_group, xyz, expected):
+    groups, _fixed = _ties(coupling_groups(space_group, xyz).xyz)
+    assert groups == expected
+
+
+@pytest.mark.parametrize("space_group, xyz, expected_groups, expected_fixed", [
+    # several coupled Uij groups at one site; factor-2 and negative relations
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25),
+     {("U11",): ((1,), (0,)), ("U22", "U12"): ((1, Fraction(1, 2)), (0, 0)), ("U33",): ((1,), (0,))},
+     ("U13", "U23")),
+    ("P 6/m m m", (1 / 3, 2 / 3, 0.0),
+     {("U11", "U22", "U12"): ((1, 1, Fraction(1, 2)), (0, 0, 0)), ("U33",): ((1,), (0,))}, ("U13", "U23")),
+    ("P -4 21 m", (0.1, 0.4, 0.3),
+     {("U11", "U22"): ((1, 1), (0, 0)), ("U33",): ((1,), (0,)), ("U12",): ((1,), (0,)),
+      ("U13", "U23"): ((1, -1), (0, 0))}, ()),
+    ("P m -3 m", (0.0, 0.0, 0.0), {("U11", "U22", "U33"): ((1, 1, 1), (0, 0, 0))}, ("U12", "U13", "U23")),
+])
+def test_coupling_groups_uij_relations(space_group, xyz, expected_groups, expected_fixed):
+    assert _ties(coupling_groups(space_group, xyz).uij) == (expected_groups, expected_fixed)
+
+
+@pytest.mark.parametrize("space_group, xyz, text", [
+    ("P -4 21 m", (0.1, 0.6, 0.3), "y = x + 1/2"),
+    ("P -4 21 m", (0.1, 0.4, 0.3), "y = -x + 1/2"),
+    ("P 42/m n m", (0.3, 0.7, 0.0), "y = -x + 1"),
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25), "y = 2x"),
+    ("R -3 m:R", (0.1, 0.1, 0.1), ""),
+])
+def test_tie_group_relations_text(space_group, xyz, text):
+    assert coupling_groups(space_group, xyz).xyz.groups[0].relations_text() == text
+
+
+def test_tie_group_relations_text_uij():
+    ties = coupling_groups("P 63/m m c", (1 / 6, 1 / 3, 0.25)).uij
+    assert ties.group_of("U12").relations_text() == "U12 = U22/2"
+    assert coupling_groups("P -4 21 m", (0.1, 0.4, 0.3)).uij.group_of("U23").relations_text() == "U23 = -U13"
+    assert ties.group_of("U13") is None
+
+
+def test_coupling_groups_ambiguous_position_raises():
+    with pytest.raises(SymmetryError, match="without being on it"):
+        coupling_groups("P 63/m m c", (0.3333, 0.6667, 0.25))
+
+
+_ALL = ("a", "b", "c", "alpha", "beta", "gamma")
+
+
+@pytest.mark.parametrize("space_group, groups, fixed, system, axis", [
+    ("F m -3 m", [("a", "b", "c")], ("alpha", "beta", "gamma"), "cubic", None),
+    ("I 41/a m d:2", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "tetragonal", None),
+    ("P 63/m m c", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "hexagonal", None),
+    ("R -3 m:H", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "trigonal", None),
+    ("R -3 m:R", [("a", "b", "c"), ("alpha", "beta", "gamma")], (), "trigonal", None),
+    ("R 3:R", [("a", "b", "c"), ("alpha", "beta", "gamma")], (), "trigonal", None),
+    ("P m m m", [("a",), ("b",), ("c",)], ("alpha", "beta", "gamma"), "orthorhombic", None),
+    ("C 1 2/m 1", [("a",), ("b",), ("c",), ("beta",)], ("alpha", "gamma"), "monoclinic", "b"),
+    ("P 1 c 1", [("a",), ("b",), ("c",), ("beta",)], ("alpha", "gamma"), "monoclinic", "b"),
+    ("C c 1 1", [("a",), ("b",), ("c",), ("alpha",)], ("beta", "gamma"), "monoclinic", "a"),
+    ("P 1 1 m", [("a",), ("b",), ("c",), ("gamma",)], ("alpha", "beta"), "monoclinic", "c"),
+    ("P -1", [("a",), ("b",), ("c",), ("alpha",), ("beta",), ("gamma",)], (), "triclinic", None),
+])
+def test_cell_tie_groups(space_group, groups, fixed, system, axis):
+    ties = cell_tie_groups(space_group)
+    assert [g.members for g in ties.groups] == groups
+    assert ties.fixed == fixed
+    assert (ties.crystal_system, ties.unique_axis) == (system, axis)
+    assert all(set(g.coefficients) == {1} and set(g.offsets) == {0} for g in ties.groups)
+
+
+def test_cell_tie_groups_every_setting_agree_with_the_metric():
+    """Every gemmi setting: each name is in one group or fixed; changing a whole group together
+    keeps a symmetric cell symmetric, changing one member alone (or a fixed angle) breaks it;
+    off ':R', the groups agree with cell_constraints."""
+    for sg in gemmi.spacegroup_table():
+        name = sg.xhm()
+        ties = cell_tie_groups(name)
+        names = [m for g in ties.groups for m in g.members] + list(ties.fixed)
+        assert sorted(names) == sorted(_ALL), name
+        rots = [R for R, _t in sym._expanded_ops(sg)]
+        g0 = sym._metric((5.1, 6.2, 7.3, 81.0, 86.0, 97.0))
+        cell = dict(zip(_ALL, sym._cell_from_metric(sum(R.T @ g0 @ R for R in rots) / len(rots))))
+        check_cell(name, tuple(cell.values()))
+        for group in ties.groups:
+            together = {k: v + (0.01 if k in group.members else 0.0) for k, v in cell.items()}
+            check_cell(name, tuple(together.values()))
+            if len(group.members) > 1:
+                alone = {k: v + (0.01 if k == group.members[-1] else 0.0) for k, v in cell.items()}
+                with pytest.raises(SymmetryError, match="inconsistent"):
+                    check_cell(name, tuple(alone.values()))
+        for angle in ties.fixed:
+            with pytest.raises(SymmetryError, match="inconsistent"):
+                check_cell(name, tuple(v + (0.01 if k == angle else 0.0) for k, v in cell.items()))
+        if sg.ext != "R":
+            rules = cell_constraints(name)
+            assert [g.members for g in ties.groups if g.members[0] in "abc"] == list(rules.length_groups)
+            assert (ties.fixed, ties.unique_axis) == (rules.fixed_angles, rules.unique_axis)
+
+
+def test_cell_constraints_keeps_its_rhombohedral_refusal():
+    """Deliberate change #2 stands: legacy callers rely on cell_constraints refusing ':R'."""
+    with pytest.raises(SymmetryError, match="rhombohedral ':R' setting are not implemented"):
+        cell_constraints("R -3 m:R")
+    assert [g.members for g in cell_tie_groups("R -3 m:R").groups] == [("a", "b", "c"), ("alpha", "beta", "gamma")]
+
+
+def test_cell_tie_groups_require_an_explicit_setting():
+    with pytest.raises(SymmetryError, match="rhombohedral; specify the setting"):
+        cell_tie_groups("R -3 m")
diff --git a/tests/test_topas_symmetry.py b/tests/test_topas_symmetry.py
index 71deb03..8b71a24 100644
--- a/tests/test_topas_symmetry.py
+++ b/tests/test_topas_symmetry.py
@@ -45,6 +45,46 @@ def test_monoclinic_unique_a_and_c():
     assert sym.cell_constraints("P 1 1 2/m").free_angles == ("gamma",)
 
 
+# Mirror-only groups (Pm, Pc, Cm, Cc: no proper 2-fold, the axis is the mirror
+# normal) and 2-fold groups, in all three unique-axis settings and several cell
+# choices (A102: these four groups raised "could not determine the monoclinic
+# unique axis" before).
+@pytest.mark.parametrize("space_group, axis", [
+    ("P 1 m 1", "b"), ("P 1 1 m", "c"), ("P m 1 1", "a"),
+    ("P 1 c 1", "b"), ("P 1 n 1", "b"), ("P 1 1 a", "c"), ("P 1 1 n", "c"),
+    ("P b 1 1", "a"), ("P c 1 1", "a"),
+    ("C 1 m 1", "b"), ("A 1 1 m", "c"), ("B m 1 1", "a"), ("I 1 m 1", "b"),
+    ("C 1 c 1", "b"), ("I 1 a 1", "b"), ("A 1 1 a", "c"), ("I 1 1 b", "c"),
+    ("B b 1 1", "a"), ("C c 1 1", "a"),
+    ("P 1 2 1", "b"), ("P 1 1 2", "c"), ("P 2 1 1", "a"),
+    ("P 1 21/c 1", "b"), ("P 1 1 21/a", "c"), ("P 21/b 1 1", "a"),
+    ("C 1 2/c 1", "b"), ("I 1 2/a 1", "b"), ("A 1 1 2/a", "c"), ("B 2/b 1 1", "a"),
+])
+def test_monoclinic_unique_axis_every_setting(space_group, axis):
+    r = sym.cell_constraints(space_group)
+    free_angle = {"a": "alpha", "b": "beta", "c": "gamma"}[axis]
+    assert r.crystal_system == "monoclinic"
+    assert r.unique_axis == axis
+    assert r.length_groups == (("a",), ("b",), ("c",))
+    assert r.free_angles == (free_angle,)
+    assert r.fixed_angles == tuple(a for a in ("alpha", "beta", "gamma") if a != free_angle)
+
+
+def test_monoclinic_unique_axis_all_gemmi_settings():
+    """Every monoclinic setting in gemmi's table: the axis is the H-M symbol's non-'1' slot."""
+    import gemmi
+
+    checked = 0
+    for sg in gemmi.spacegroup_table():
+        if sg.crystal_system_str() != "monoclinic":
+            continue
+        slots = sg.hm.split()[1:]
+        expected = "abc"[[i for i, s in enumerate(slots) if s != "1"][0]]
+        assert sym.cell_constraints(sg.xhm()).unique_axis == expected, sg.xhm()
+        checked += 1
+    assert checked == 115
+
+
 def test_tetragonal_hexagonal_ortho_triclinic():
     assert sym.cell_constraints("P 4/m m m").length_groups == (("a", "b"), ("c",))
     hexr = sym.cell_constraints("P 6/m m m")