diff --git a/docs/advanced/fault-mechanics-examples.md b/docs/advanced/fault-mechanics-examples.md
new file mode 100644
index 000000000..f8bf4d053
--- /dev/null
+++ b/docs/advanced/fault-mechanics-examples.md
@@ -0,0 +1,354 @@
+---
+title: "Fault Mechanics Teaching Examples"
+---
+
+# Fault Mechanics: Teaching Examples
+
+Three worked examples built on [split-node faults](split-node-faults.md),
+each a single short script (in `figures/fault-examples/`, sharing one
+harness `common.py`). All run in minutes on a laptop: the meshes are
+modest, because a zero-thickness fault needs no thin feature resolved.
+
+## The fault-strength ladder
+
+One fault, one far-field shear drive ($\tau_\infty = 1$ resolved on the
+fault plane), and the whole constitutive ladder — the slip-rate profile
+$V(s)$ tells each law's story:
+
+![The fault-strength ladder](figures/fault-examples/ladder.png)
+
+The right-hand column shows the shear-stress field $\sigma_{xy}$ for
+each rung (colour range $0 \to 2\tau_\infty$, white at the far-field
+value): a slipping fault shadows itself with a stress drop and
+concentrates stress at its tips, in proportion to how much of
+$\tau_\infty$ its law lets go; the stuck fault leaves the field
+untouched.
+
+- **Frictionless** — the free crack: full stress drop, elliptical
+  profile (the dashed shape), slip vanishing at the unsplit tips.
+- **Viscous, $\eta_f = \eta/a$** — the natural interface-viscosity
+  scale: the fault slips at roughly half its free rate.
+- **Coulomb, weak** ($\mu\sigma_n < \tau_\infty$) — slides at the
+  reduced stress drop $\tau_\infty - \mu\sigma_n$, profile still
+  elliptical: the constant-strength crack.
+- **Rate-and-state** — at steady state, a velocity-dependent strength
+  between the Coulomb end-members.
+- **Coulomb, strong** ($\mu\sigma_n > \tau_\infty$) — stuck: creep at
+  the regularisation velocity, invisible at plot scale.
+
+Script: `figures/fault-examples/ladder.py`.
+
+## The Mohr circle, measured by faults
+
+All the stress-plane figures below use the **geological sign
+convention**: compression positive, tension on the negative axis. (The
+solver's tractions are tension-positive; only the plots flip.) There is
+no confining pressure in these problems: the walls prescribe velocity
+and the flow is incompressible, so pressure exists only up to the
+nullspace constant and the solver's gauge centres the Mohr circle on
+the origin — which is exactly why the tensile sector is reachable.
+
+A *welded* split fault (interface dashpot with large $\eta_f$) does not
+perturb the flow — the welded limit recovers the uncut continuum — but
+its machinery still reports the tractions across it: the no-opening
+constraint's reaction gives $\sigma_n$, and the dashpot law reads the
+signed shear traction off its own slip, $\tau = \eta_f V$. Each fault
+orientation is therefore a passive stress probe, and sweeping the
+orientation through $180°$ traces the full Mohr circle of the ambient
+stress state:
+
+![Mohr circle from welded faults](figures/fault-examples/mohr-circle.png)
+
+The boundary condition is Dirichlet velocity on all four walls,
+imposing the homogeneous flow $\mathbf v = (a(x-\tfrac12) +
+\gamma(y-\tfrac12),\; -a(y-\tfrac12))$ with $a = 0.5$, $\gamma = 1$
+— a pure-shear (stretching) part plus a simple-shear part. Stress sees
+only the symmetric gradient, so this is equivalent to pure shear of
+magnitude $R = \eta\sqrt{4a^2+\gamma^2}$ with principal axes at
+$22.5°$ to the box: deliberately not axis-aligned, so the circle's
+orientation must be measured, not guessed. Because the linear flow is
+an exact homogeneous Stokes solution, the stress is uniform to the
+walls and every probe samples the same state; the pressure gauge (the
+nullspace constant) sets the circle's centre. The probes (labelled by
+fault angle)
+land on that circle, centred at the (gauge-fixed) mean pressure. The
+classical double-angle rule is the labels' spacing: $22.5°$ of fault
+rotation moves a probe $45°$ around the circle, and $180°$ of rotation
+closes it.
+
+Script: `figures/fault-examples/mohr_circle.py`.
+
+The measured points land on the circle too neatly to teach from a
+static figure — the lesson is in the *construction*. The animated
+version rotates the fault through $180°$ while its probe sweeps the
+full circle at $2\theta$, one welded-fault solve per frame:
+
+![Building the Mohr circle](figures/fault-examples/mohr-circle-build.gif)
+
+Script: `figures/fault-examples/mohr_animate.py`.
+
+### The circle meets the friction envelope
+
+Give the rotating fault Coulomb friction (reaction-fed normal stress)
+and the probe can no longer go everywhere the ambient stress points.
+Three regimes appear in one sweep:
+
+![Coulomb fault vs the Mohr circle](figures/fault-examples/mohr-friction.png)
+
+- **Stuck** (circles): the ambient resolved stress lies inside the
+  envelope $|\tau| < \mu\sigma$ — the fault transmits it and the
+  probe sits on the Mohr circle;
+- **Sliding** (squares): the ambient stress would exceed the envelope —
+  the fault slips, drops the shear traction to its strength, and the
+  probe is pinned to the yield line;
+- **Held shut** ($\sigma < 0$, grey crosses): bare friction has no
+  strength under tension — a real fault would OPEN, and no static
+  solution exists. The bilateral no-opening constraint manufactures one
+  by gluing the surfaces together (a tensile reaction), so the solver
+  still converges; the probes ride the axis at $\tau = 0$, but they
+  are marked unphysical. The tell, in any real model, is the sign of
+  the recovered normal traction.
+
+The shear traction here is read from the Coulomb law at the measured
+slip rate — which is exact in every regime, because the regularised
+law *is* the traction the fault carries. The animated build shows the
+switch happening as the fault rotates, with the slip sense drawn as
+half-arrows when it unlocks:
+
+![A frictional fault against the Mohr circle](figures/fault-examples/mohr-friction-build.gif)
+
+Script: `figures/fault-examples/mohr_friction.py`.
+
+### Cohesion keeps more of the circle
+
+Add cohesion — the envelope becomes $\tau = \pm(C + \mu\sigma)$ —
+and strength survives into MILD tension, declining along the envelope
+and reaching zero at $\sigma = -C/\mu$. Stuck arcs now survive
+around **both** principal poles, with envelope-pinned sliding between;
+beyond the cutoff the fault is in the same held-shut (unphysical)
+regime as the cohesionless case, just pushed further into tension.
+
+![Cohesive Mohr-Coulomb fault](figures/fault-examples/mohr-cohesion.png)
+
+The cohesive law is not a canned option — it is registered as a sympy
+expression in the canonical interface symbols, which is the intended
+extension path for any fault rheology:
+
+```python
+V = fault_contact.slip_rate
+S = fault_contact.normal_stress          # reaction-fed, clamped >= 0
+law = fault_contact.SymbolicFaultLaw(
+    (C + mu * S) * (2 / sympy.pi) * sympy.atan(V / V0))
+```
+
+![Cohesion keeps more of the circle](figures/fault-examples/mohr-cohesion-build.gif)
+
+Script: `figures/fault-examples/mohr_cohesion.py`.
+
+### The graded fault: depth-dependent stress along one surface
+
+Add a modest hydrostatic load (constant density, closed box — the flow
+is untouched, pressure absorbs gravity exactly) and the per-node
+character of the stress recovery becomes visible: every fault node sits
+at its own depth, so a single welded fault contributes a **streak** of
+probes, not a point. The streak is horizontal (only the pressure part
+of $\sigma$ varies along the fault), longest for the vertical fault,
+and collapses to a dot for the horizontal one:
+
+![The graded fault](figures/fault-examples/mohr-graded.png)
+
+Points are coloured by depth; the grey circles are the Mohr circles of
+the shallowest, central, and deepest fault points. Nothing here is
+averaged — $\sigma_n$ comes from the constraint reaction de-smeared
+node by node, $\tau$ from the weld's own law at each node — which is
+exactly the machinery that lets a friction law feel depth-dependent
+strength along a single fault (the locking-depth structure of a
+seismogenic zone). The closed-box pressure gauge is re-anchored in the
+plot so $p = 0$ at the top surface; the shift is the analytically known
+$\rho g H/2$.
+
+Script: `figures/fault-examples/mohr_graded.py`.
+
+## Orientation and slip: the circle's other face
+
+The same orientation sweep with *frictionless* faults under pure shear.
+Now each fault drops whatever shear stress is resolved on its plane, so
+the peak slip rate follows $|\cos 2\theta|$ — the slip-rate reading of
+the Mohr circle. A fault at $45°$ to the shear plane feels no resolved
+shear and barely slips; the aligned fault slips fully:
+
+![Orientation vs slip](figures/fault-examples/orientations.png)
+
+Script: `figures/fault-examples/orientations.py`.
+
+## Interacting faults: stress transfer on the Mohr plane
+
+Two faults via `add_fault`'s network form: the *source* slips freely,
+the *receiver* is welded — the passive probe from the Mohr examples.
+Differencing two solves on the same mesh gives the classical Coulomb
+stress transfer, and the receiver's probes show it in the diagram
+students already know: each node's point MOVES, and its colour is its
+own $\Delta$CFF ($\mu' = 0.4$, King's value):
+
+![En echelon interaction](figures/fault-examples/interacting-faults.png)
+
+The receiver sits in the source's along-strike tip lobe, and the
+friction bookkeeping is dressed so the crossing is visible: a declared
+confining pressure $P_0 = 1$ puts the whole circle in compression, and
+a cohesive envelope $\tau = \pm(C + \mu'\sigma)$ with $C = 0.75$
+passes just below the ambient cloud. Neither constant changes
+$\Delta$CFF — they only place the failure line where the physics can
+reach it. The loaded near-tip nodes then cross into the shaded failure
+region while the far end barely moves. Rotating the regional
+compression axis (the boundary velocities rotate with it) relocates
+the ambient cloud around the circle, and what rotation controls is the
+MARGIN to the envelope. (Fields here and below are P0 cell stress on
+the split mesh's true connectivity, linear colour at $\pm 1$ — see
+the California example for why.)
+
+![Rotating the regional stress](figures/fault-examples/interacting-rotation.png)
+
+Two gauge points, handled explicitly in the scripts because a closed
+velocity-driven box fixes pressure only up to a constant: differenced
+fields are anchored to zero in the far field (a slip event changes
+nothing far away), and each solve's absolute probe pressures are
+anchored to the analytic ambient state. Both constants are printed,
+never silently absorbed.
+
+Script: `figures/fault-examples/interacting_faults.py`.
+
+### A schematic southern California
+
+The San Andreas as ONE continuous dextral trace with a smooth tanh
+S-bend — the Big Bend, the smoothed version of a left-stepping
+stepover, restraining under right-lateral slip. The Garlock, three
+East California Shear Zone strands and a San Jacinto-like fault are
+welded as probes — all inboard, in the continental crust. The drive is
+right-lateral simple shear parallel to the plate boundary (~N40W),
+which resolves dextral on the NW-striking faults and sinistral on the
+Garlock, exactly the real senses; the slip arrows on the map are drawn
+from the *measured* jump, not assumed:
+
+![Schematic southern California](figures/fault-examples/california.png)
+
+The curved trace is sampled as a polyline, and the fault carries the
+smooth curve's **analytic normal**
+(`add_fault_bc(..., normal=...)`). This matters: with the default
+facet-averaged normals a sampled curve develops slip notches and
+stress sawteeth at every sampling kink — roughness that *grows* under
+refinement, because the constraint direction itself zig-zags (see the
+practical notes in the split-node fault guide). With the analytic
+normal the trace slips smoothly through the bend.
+
+One trunk-spanning event, and the map teaches by geography: the
+restraining bend fills with strong compression — $\Delta$CFF deeply
+negative in a bowtie exactly where the Transverse Ranges belong. The
+neighbours give three verdicts: the parallel San Jacinto is deeply
+relaxed ($\Delta$CFF $-0.4$, its cloud retreating into the safe
+wedge); the conjugate Garlock and the distant ECSZ strands are mildly
+loaded ($+0.05$ to $+0.06$). (Schematic geometry, not to scale; same
+$P_0 = 1$, $C = 0.75$ envelope dressing.)
+
+Script: `figures/fault-examples/california.py`.
+
+### A branching rupture on an intersecting network
+
+Real trace sets cross and branch, and the split-node pipeline refuses
+shared vertices — so intersecting geometry goes through
+`uw.meshing.prepare_fault_network` first, which converts every
+junction (X crossing, T abutment, near-miss) to the offset-junction
+form: the traces stop short of the intersection, leaving a ligament of
+intact material about a cell across, with angle-corrected pull-backs
+and a printed report of every action. Here the raw input genuinely
+intersects — a dextral trunk, a splay branching off its midpoint, and
+a conjugate crossing it — and the trunk + splay rupture together while
+the conjugate sits welded:
+
+![Branching rupture](figures/fault-examples/branching.png)
+
+The brightest features are the **junction plugs**: the intact
+ligaments take the concentrated load shed by their slipped neighbours
+on both sides, which is exactly where a through-going event would
+break next. The ligament approximation is measured, not asserted: at a
+T-junction the branch's slip profile is *identical* at two mesh
+resolutions for a fixed plug size, and its peak slip changes by only a
+few percent between ligaments of one and two cells (the study is
+recorded in the developer notes). Keep ligaments at one to two local
+cell sizes.
+
+Script: `figures/fault-examples/branching.py`.
+
+And the question the offset form begs — what does interrupting a fault
+cost? — has a measured answer. The same network prepared two ways
+(`through=["Trunk"]` keeps the trunk continuous, so the conjugate
+yields on both sides of the crossing; the default cuts both):
+
+![Continuous vs interrupted](figures/fault-examples/branching-compare.png)
+
+The through-going trunk slips slightly *more* than it would alone (the
+slipping splay feeds it); cutting it at the crossing pins it locally
+and costs about a quarter of its peak slip — but the profiles converge
+away from the junction, so an interruption's reach is the segment
+scale, not the system scale. T abutments never cut the through-going
+trace; declare master faults with `through=` where a crossing must not
+either.
+
+Script: `figures/fault-examples/branching_compare.py`.
+
+### A true Y-branch, and which continuity to declare
+
+A genuine three-arm branch can be decomposed two ways: trunk
+continuous with the splay abutting (A), or the *bent* west-arm-plus-
+splay fault continuous with the east arm abutting (B). Running both,
+with the gap swept in A:
+
+![The true branch, bracketed](figures/fault-examples/true-branch.png)
+
+Two conclusions. The **gap is second-order**: A at 1h, 2h and 4h
+ligaments overlays on every arm except the splay's near-junction toe,
+which simply moves with the trimmed tip. The **decomposition is
+first-order**: B is a different mechanical system, because the
+continuous bent fault LOCKS at its 33-degree kink — slip through a
+kink is geometrically incompatible with the no-opening constraint
+(the same mechanism that makes sampled curves rough, here as genuine
+physics) — so both trunk arms lose a third of their slip and pinch to
+zero at the branch point. The rule for real networks: **declare the
+straightest path continuous; never route continuity around a
+corner.** The energetically sensible decomposition (A) is admissible
+for the true junction and differs from it only in the splay's
+ligament-scale toe.
+
+The stress fields make the distinction physical. With the trunk
+continuous, the stress shadow runs straight through the junction and
+the branch point carries no feature at all — the junction is
+mechanically invisible. With continuity routed around the bend, the
+locked kink acts as a barrier: both arms' shadows terminate against it
+and load the corner, the classic signature of a rupture-arresting
+bend:
+
+![The branch point in stress](figures/fault-examples/true-branch-stress.png)
+
+Script: `figures/fault-examples/true_branch.py`.
+
+## What these models are, and are not
+
+For the static problem, incompressible linear elasticity and Stokes
+are the same mathematics (displacement ↔ velocity, shear modulus ↔
+viscosity), so every stress pattern here is exactly the elastic
+$\nu = 1/2$ pattern with slip rate standing in for coseismic slip.
+What is deliberately absent: depth and half-space geometry (these are
+plane-strain boxes with velocity-driven walls — no free-surface
+amplification), topography, gravity except where stated (the graded
+fault), compressibility ($\nu \ne 1/2$ shifts normal-stress lobes
+modestly), and postseismic processes of any kind. The slipping faults
+are completely weak during their event (frictionless: the full
+ambient resolved shear drops); because the problem is linear,
+$\Delta$CFF scales essentially linearly with the dropped stress, so
+the transfer maps read as stress change per unit stress drop. A
+partial-drop event is the Coulomb rung applied to the source fault.
+
+## Where next
+
+Remaining extensions on the same harness: tip-to-tip vs overlapped
+en echelon arrangements side by side, a denser fault network, and the
+graded (gravity-loaded) versions of the interaction cases.
diff --git a/docs/advanced/figures/fault-examples/.gitignore b/docs/advanced/figures/fault-examples/.gitignore
new file mode 100644
index 000000000..04a1f04a5
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/.gitignore
@@ -0,0 +1,2 @@
+_*.png
+*.log
diff --git a/docs/advanced/figures/fault-examples/_california_probes.npz b/docs/advanced/figures/fault-examples/_california_probes.npz
new file mode 100644
index 000000000..6c0bef08f
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_california_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/_interacting_probes.npz b/docs/advanced/figures/fault-examples/_interacting_probes.npz
new file mode 100644
index 000000000..e0a3b4c70
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_interacting_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/_mohr_cohesion_probes.npz b/docs/advanced/figures/fault-examples/_mohr_cohesion_probes.npz
new file mode 100644
index 000000000..85e285682
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_mohr_cohesion_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/_mohr_friction_probes.npz b/docs/advanced/figures/fault-examples/_mohr_friction_probes.npz
new file mode 100644
index 000000000..d6fd0213a
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_mohr_friction_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/_mohr_graded_probes.npz b/docs/advanced/figures/fault-examples/_mohr_graded_probes.npz
new file mode 100644
index 000000000..95ff368ed
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_mohr_graded_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/_mohr_probes.npz b/docs/advanced/figures/fault-examples/_mohr_probes.npz
new file mode 100644
index 000000000..129bd50ff
Binary files /dev/null and b/docs/advanced/figures/fault-examples/_mohr_probes.npz differ
diff --git a/docs/advanced/figures/fault-examples/branching-compare.png b/docs/advanced/figures/fault-examples/branching-compare.png
new file mode 100644
index 000000000..58deb39fa
Binary files /dev/null and b/docs/advanced/figures/fault-examples/branching-compare.png differ
diff --git a/docs/advanced/figures/fault-examples/branching.png b/docs/advanced/figures/fault-examples/branching.png
new file mode 100644
index 000000000..67c4ca9c3
Binary files /dev/null and b/docs/advanced/figures/fault-examples/branching.png differ
diff --git a/docs/advanced/figures/fault-examples/branching.py b/docs/advanced/figures/fault-examples/branching.py
new file mode 100644
index 000000000..f55ac9405
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/branching.py
@@ -0,0 +1,178 @@
+"""A branching rupture: intersecting fault traces and their Delta CFF.
+
+The raw geometry INTERSECTS: a dextral trunk, a splay branching off its
+midpoint at ~30 degrees (a T junction), and a conjugate fault crossing
+it outright (an X junction). ``prepare_fault_network`` converts both to
+offset-junction form automatically (angle-corrected ligaments, loudly),
+which is what makes the set splittable at all. The trunk and the splay
+then rupture TOGETHER (frictionless) while the conjugate is welded as a
+receiver, and the map shows Delta CFF on trunk-parallel planes — with
+zooms at the two junctions, where the ligament-scale stress transfer
+lives. Measured ligament sensitivity for this representation:
+~/+Simulations/fault_junction_ligament/ (the branch response is
+converged for a given plug size; ligaments of 1-2 local cells).
+"""
+import os
+import time
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+from underworld3.meshing.surfaces import prepare_fault_network
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+MU_P = 0.4
+H = 0.012
+LIG_F = 1.5
+
+# raw, INTERSECTING traces — the preparer makes them legal
+TREND = np.degrees(np.arctan2(0.10, 0.70))          # trunk trend ~8 deg
+M_RAW = ("Trunk", np.array([[0.15, 0.45], [0.85, 0.55]]))
+S_RAW = ("Splay", np.array([[0.50, 0.50], [0.80, 0.76]]))     # T at trunk
+C_RAW = ("Conj", np.array([[0.30, 0.33], [0.42, 0.64]]))      # X crossing
+
+prepared, report = prepare_fault_network(
+    [M_RAW, S_RAW, C_RAW], spacing=H, ligament=LIG_F, verbose=True)
+names = [n for n, _ in prepared]
+SLIP = [n for n in names if n.startswith(("Trunk", "Splay"))]
+WELD = [n for n in names if n.startswith("Conj")]
+ETA_WELD = 200.0 * common.ETA / 0.2
+
+T_J = np.array([0.50, 0.50])                        # the T junction
+X_J = M_RAW[1][0] + (M_RAW[1][1] - M_RAW[1][0]) * 0.293   # approx X point
+
+
+def solve_state(child, free):
+    stokes = common.stokes_on(child,
+                              common.boundary_simple_shear(child, TREND))
+    for n in names:
+        stokes.add_fault_bc(0.0 if (free and n in SLIP) else ETA_WELD,
+                            boundary=n)
+    fault_contact.solve_with_fault(stokes, picard=2)
+    x, y = child.X
+    v, p = stokes.Unknowns.u, stokes.Unknowns.p
+    comps = {}
+    for cname, expr in (
+            ("sxx", -p.sym[0] + 2 * common.ETA * v.sym[0].diff(x)),
+            ("syy", -p.sym[0] + 2 * common.ETA * v.sym[1].diff(y)),
+            ("sxy", common.ETA * (v.sym[0].diff(y) + v.sym[1].diff(x)))):
+        s_var = uw.discretisation.MeshVariable(
+            f"{cname}_{'a' if free else 'b'}", child, 1, degree=0,
+            continuous=False)
+        proj = uw.systems.Projection(child, s_var)
+        proj.uw_function = expr
+        proj.smoothing = 0.0
+        proj.solve()
+        row = common.split_mesh_cell_rows(child, s_var)
+        comps[cname] = np.asarray(s_var.data[:, 0])[row].copy()
+    return stokes, comps
+
+
+t0 = time.perf_counter()
+child = common.base_mesh(H).add_fault(prepared)
+s1, c1 = solve_state(child, free=True)
+print(f"[timing] slipping solve: {time.perf_counter() - t0:.1f} s",
+      flush=True)
+for n in SLIP:
+    coords, jumps, normals = fault_contact.fault_pair_jumps(
+        s1, n, s1._rotated_freeslip_info)
+    tang = np.column_stack([-normals[:, 1], normals[:, 0]])
+    V = np.einsum("ij,ij->i", jumps, tang)
+    print(f"  {n:8s} peak slip {np.abs(V).max():.4f}", flush=True)
+t0 = time.perf_counter()
+_s0, c0 = solve_state(child, free=False)
+print(f"[timing] welded solve: {time.perf_counter() - t0:.1f} s",
+      flush=True)
+
+# Delta CFF on trunk-parallel receiver planes
+beta = np.radians(TREND)
+nx, ny = -np.sin(beta), np.cos(beta)
+tx, ty = np.cos(beta), np.sin(beta)
+
+
+def resolve(c):
+    s_nn = c["sxx"] * nx * nx + 2 * c["sxy"] * nx * ny + c["syy"] * ny * ny
+    s_t = (c["sxx"] * tx * nx + c["sxy"] * (tx * ny + ty * nx)
+           + c["syy"] * ty * ny)
+    return s_nn, s_t
+
+
+nn0, t_0 = resolve(c0)
+nn1, t_1 = resolve(c1)
+tau_dir = np.sign(np.median(t_0))
+dcff = tau_dir * (t_1 - t_0) + MU_P * (nn1 - nn0)
+
+pts, faces = common.split_mesh_cell_render(child)
+fc = np.asarray(faces).reshape(-1, 4)[:, 1:]
+cent = np.asarray(pts)[fc].mean(axis=1)
+dcff, gauge = common.far_field_anchor(
+    cent, dcff, [p for _n, p in prepared], cut=0.18)
+print(f"far-field gauge removed: {gauge:+.4f}", flush=True)
+
+# ---- renders: the map and the two junction zooms ---------------------------
+COLOUR = {"Trunk": "black", "Splay": "black", "Conj": "#6a1b9a"}
+
+
+def render(png, scale, focal):
+    pvm = pv.PolyData(np.asarray(pts, dtype=float),
+                      faces=np.asarray(faces, dtype=np.int64))
+    pvm.cell_data["dcff"] = dcff
+    pl = pv.Plotter(off_screen=True, window_size=(900, 850))
+    pl.set_background("white")
+    pl.add_mesh(pvm, scalars="dcff", cmap="RdBu_r", clim=(-1.0, 1.0),
+                lighting=False, show_scalar_bar=False)
+    for n, p in prepared:
+        line = pv.lines_from_points(
+            np.column_stack([p, np.full(len(p), 1e-3)]))
+        pl.add_mesh(line, color=COLOUR[n.split("_")[0]],
+                    line_width=5 if n.startswith("Trunk") else 4,
+                    lighting=False)
+    pl.view_xy()
+    pl.camera.parallel_projection = True
+    pl.camera.parallel_scale = scale
+    pl.camera.focal_point = (focal[0], focal[1], 0.0)
+    pl.screenshot(png)
+    pl.close()
+    return png
+
+
+map_png = render(os.path.join(D, "_branching_map.png"), 0.42, (0.5, 0.52))
+tz_png = render(os.path.join(D, "_branching_tzoom.png"), 0.075, T_J)
+xz_png = render(os.path.join(D, "_branching_xzoom.png"), 0.075, X_J)
+
+fig = plt.figure(figsize=(12.6, 6.4))
+gs = fig.add_gridspec(2, 3, width_ratios=[2.1, 1.0, 0.05])
+axm = fig.add_subplot(gs[:, 0])
+axm.imshow(plt.imread(map_png))
+axm.set_xticks([])
+axm.set_yticks([])
+axm.set_title(r"$\Delta$CFF on trunk-parallel planes ($\mu' = 0.4$): "
+              "trunk + splay rupture together,\nconjugate welded; "
+              "junctions are auto-converted offset ligaments", fontsize=9.5)
+for row, (png, label) in enumerate(
+        ((tz_png, "the branch point (T): splay fed through the ligament"),
+         (xz_png, "the crossing (X): four tips, one intact plug"))):
+    ax = fig.add_subplot(gs[row, 1])
+    ax.imshow(plt.imread(png))
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_title(label, fontsize=8.5)
+
+from matplotlib import cm, colors as mcolors
+sm = cm.ScalarMappable(norm=mcolors.Normalize(-1, 1), cmap="RdBu_r")
+cax = fig.add_subplot(gs[:, 2])
+fig.colorbar(sm, cax=cax, label=r"$\Delta$CFF (per unit stress drop)")
+fig.suptitle("A branching rupture on an intersecting fault network",
+             fontsize=11.5)
+fig.tight_layout()
+out = os.path.join(D, "branching.png")
+fig.savefig(out, dpi=200)
+print("wrote", out, flush=True)
diff --git a/docs/advanced/figures/fault-examples/branching_compare.py b/docs/advanced/figures/fault-examples/branching_compare.py
new file mode 100644
index 000000000..6f59e7d72
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/branching_compare.py
@@ -0,0 +1,205 @@
+"""What does interrupting the trunk cost? Continuous vs cut at the
+junction, against the isolated trunk.
+
+Same network as ``branching.py`` (trunk + splay slipping, conjugate
+welded), prepared two ways:
+
+- ``through=["Trunk"]`` — the trunk is the MASTER: never cut; the
+  conjugate yields on both sides of the crossing and the splay is
+  trimmed where it abuts (T junctions never cut the through-going
+  trace).
+- default — the X crossing cuts both traces, so the trunk is
+  interrupted mid-length by the junction plug.
+
+The isolated continuous trunk (no other faults) is the reference
+profile. The comparison answers: how much slip does the interruption
+forfeit, and what does it do to the Delta CFF field?
+"""
+import os
+import time
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+from underworld3.meshing.surfaces import prepare_fault_network
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+MU_P = 0.4
+H = 0.012
+LIG_F = 1.5
+TREND = np.degrees(np.arctan2(0.10, 0.70))
+M_RAW = ("Trunk", np.array([[0.15, 0.45], [0.85, 0.55]]))
+S_RAW = ("Splay", np.array([[0.50, 0.50], [0.80, 0.76]]))
+C_RAW = ("Conj", np.array([[0.30, 0.33], [0.42, 0.64]]))
+T_HAT = (M_RAW[1][1] - M_RAW[1][0])
+T_HAT = T_HAT / np.linalg.norm(T_HAT)
+ETA_WELD = 200.0 * common.ETA / 0.2
+
+
+def run_case(tag, faults, weld_names, want_field):
+    child = common.base_mesh(H).add_fault(faults)
+    names = [n for n, _ in faults]
+
+    def one_state(free):
+        stokes = common.stokes_on(
+            child, common.boundary_simple_shear(child, TREND))
+        for n in names:
+            stokes.add_fault_bc(
+                0.0 if (free and n not in weld_names) else ETA_WELD,
+                boundary=n)
+        fault_contact.solve_with_fault(stokes, picard=2)
+        return stokes
+
+    t0 = time.perf_counter()
+    s1 = one_state(True)
+    # trunk slip vs GLOBAL trunk arc length, across however many pieces
+    ss, vv = [], []
+    for n in names:
+        if not n.startswith("Trunk"):
+            continue
+        coords, jumps, normals = fault_contact.fault_pair_jumps(
+            s1, n, s1._rotated_freeslip_info)
+        tang = np.column_stack([-normals[:, 1], normals[:, 0]])
+        ss.append((coords - M_RAW[1][0]) @ T_HAT)
+        vv.append(np.abs(np.einsum("ij,ij->i", jumps, tang)))
+    s_all = np.concatenate(ss)
+    v_all = np.concatenate(vv)
+    order = np.argsort(s_all)
+    profile = (s_all[order], v_all[order])
+
+    dcff_pack = None
+    if want_field:
+        def stress(stokes, tagc):
+            x, y = child.X
+            v, p = stokes.Unknowns.u, stokes.Unknowns.p
+            comps = {}
+            for cname, expr in (
+                    ("sxx", -p.sym[0] + 2 * common.ETA * v.sym[0].diff(x)),
+                    ("syy", -p.sym[0] + 2 * common.ETA * v.sym[1].diff(y)),
+                    ("sxy", common.ETA * (v.sym[0].diff(y)
+                                          + v.sym[1].diff(x)))):
+                s_var = uw.discretisation.MeshVariable(
+                    f"{cname}_{tagc}", child, 1, degree=0,
+                    continuous=False)
+                proj = uw.systems.Projection(child, s_var)
+                proj.uw_function = expr
+                proj.smoothing = 0.0
+                proj.solve()
+                row = common.split_mesh_cell_rows(child, s_var)
+                comps[cname] = np.asarray(s_var.data[:, 0])[row].copy()
+            return comps
+
+        c1 = stress(s1, "a")
+        s0 = one_state(False)
+        c0 = stress(s0, "b")
+        beta = np.radians(TREND)
+        nx, ny = -np.sin(beta), np.cos(beta)
+        tx, ty = np.cos(beta), np.sin(beta)
+
+        def resolve(c):
+            s_nn = (c["sxx"] * nx * nx + 2 * c["sxy"] * nx * ny
+                    + c["syy"] * ny * ny)
+            s_t = (c["sxx"] * tx * nx + c["sxy"] * (tx * ny + ty * nx)
+                   + c["syy"] * ty * ny)
+            return s_nn, s_t
+
+        nn0, t_0 = resolve(c0)
+        nn1, t_1 = resolve(c1)
+        dcff = np.sign(np.median(t_0)) * (t_1 - t_0) + MU_P * (nn1 - nn0)
+        pts, faces = common.split_mesh_cell_render(child)
+        fc = np.asarray(faces).reshape(-1, 4)[:, 1:]
+        cent = np.asarray(pts)[fc].mean(axis=1)
+        dcff, gauge = common.far_field_anchor(
+            cent, dcff, [p for _n, p in faults], cut=0.18)
+        print(f"[{tag}] gauge {gauge:+.4f}", flush=True)
+        dcff_pack = (pts, faces, dcff)
+
+    print(f"[{tag}] trunk peak slip {profile[1].max():.4f} "
+          f"({time.perf_counter() - t0:.1f} s)", flush=True)
+    return profile, dcff_pack, faults
+
+
+# case i: trunk through-going (master)
+prep_i, _ = prepare_fault_network(
+    [(n, p.copy()) for n, p in (M_RAW, S_RAW, C_RAW)], spacing=H,
+    ligament=LIG_F, through=["Trunk"], verbose=True)
+weld_i = [n for n, _p in prep_i if n.startswith("Conj")]
+prof_i, field_i, faults_i = run_case("through", prep_i, weld_i, True)
+
+# case ii: default — the crossing cuts the trunk
+prep_ii, _ = prepare_fault_network(
+    [(n, p.copy()) for n, p in (M_RAW, S_RAW, C_RAW)], spacing=H,
+    ligament=LIG_F, verbose=True)
+weld_ii = [n for n, _p in prep_ii if n.startswith("Conj")]
+prof_ii, field_ii, faults_ii = run_case("cut", prep_ii, weld_ii, True)
+
+# reference: the trunk alone
+prof_ref, _, _ = run_case("isolated", [("Trunk", M_RAW[1].copy())],
+                          [], False)
+
+
+def render(pack, faults, png):
+    pts, faces, dcff = pack
+    pvm = pv.PolyData(np.asarray(pts, dtype=float),
+                      faces=np.asarray(faces, dtype=np.int64))
+    pvm.cell_data["dcff"] = dcff
+    pl = pv.Plotter(off_screen=True, window_size=(900, 850))
+    pl.set_background("white")
+    pl.add_mesh(pvm, scalars="dcff", cmap="RdBu_r", clim=(-1.0, 1.0),
+                lighting=False, show_scalar_bar=False)
+    for n, p in faults:
+        line = pv.lines_from_points(
+            np.column_stack([p, np.full(len(p), 1e-3)]))
+        pl.add_mesh(line, color=("#6a1b9a" if n.startswith("Conj")
+                                 else "black"),
+                    line_width=5 if n.startswith("Trunk") else 4,
+                    lighting=False)
+    pl.view_xy()
+    pl.camera.parallel_projection = True
+    pl.camera.parallel_scale = 0.42
+    pl.camera.focal_point = (0.5, 0.52, 0.0)
+    pl.screenshot(png)
+    pl.close()
+    return png
+
+
+png_i = render(field_i, faults_i, os.path.join(D, "_bcmp_through.png"))
+png_ii = render(field_ii, faults_ii, os.path.join(D, "_bcmp_cut.png"))
+
+fig = plt.figure(figsize=(13.0, 5.4))
+gs = fig.add_gridspec(1, 4, width_ratios=[1.35, 1.0, 1.0, 0.05])
+axp = fig.add_subplot(gs[0, 0])
+axp.plot(*prof_ref, "k--", lw=1.3, label="trunk alone (continuous)")
+axp.plot(*prof_i, "o-", ms=2.5, lw=1.0, color="#1565c0",
+         label="network, trunk through-going")
+axp.plot(*prof_ii, "o-", ms=2.5, lw=1.0, color="#e65100",
+         label="network, trunk cut at the crossing")
+axp.set_xlabel("arc length along the trunk")
+axp.set_ylabel("|slip|")
+axp.set_title("what the interruption costs the trunk", fontsize=10)
+axp.legend(fontsize=8)
+for png, col, title in ((png_i, 1, "trunk through-going"),
+                        (png_ii, 2, "trunk cut at the crossing")):
+    ax = fig.add_subplot(gs[0, col])
+    ax.imshow(plt.imread(png))
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_title(title, fontsize=10)
+from matplotlib import cm, colors as mcolors
+sm = cm.ScalarMappable(norm=mcolors.Normalize(-1, 1), cmap="RdBu_r")
+cax = fig.add_subplot(gs[0, 3])
+fig.colorbar(sm, cax=cax, label=r"$\Delta$CFF")
+fig.suptitle("Continuous vs interrupted: the same network, two "
+             "junction policies", fontsize=11.5)
+fig.tight_layout()
+out = os.path.join(D, "branching-compare.png")
+fig.savefig(out, dpi=200)
+print("wrote", out, flush=True)
diff --git a/docs/advanced/figures/fault-examples/california.png b/docs/advanced/figures/fault-examples/california.png
new file mode 100644
index 000000000..cec34eec6
Binary files /dev/null and b/docs/advanced/figures/fault-examples/california.png differ
diff --git a/docs/advanced/figures/fault-examples/california.py b/docs/advanced/figures/fault-examples/california.py
new file mode 100644
index 000000000..953714bcd
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/california.py
@@ -0,0 +1,334 @@
+"""A schematic southern California: the San Andreas with a smooth
+restraining bend (the Big Bend), read by its neighbours.
+
+Geography (schematic, not to scale, x = east / y = north): the SAN
+ANDREAS is ONE continuous dextral trace with a smooth tanh S-bend — the
+smoothed version of a left-stepping stepover. Under right-lateral shear
+the bend is RESTRAINING: the bend zone is where the TRANSVERSE RANGES
+belong, right beside the Garlock. The GARLOCK (resolving sinistral —
+the real sense, from the kinematics), three EAST CALIFORNIA SHEAR ZONE
+strands and a SAN JACINTO-like fault sit inboard as welded probes.
+
+The curved trace is sampled as a polyline, and the fault's constraint
+frame uses the curve's ANALYTIC normal (``add_fault_bc(normal=...)``).
+Without it the per-node normal averages the adjacent facet normals and
+zig-zags at the sampling kinks; the no-opening constraint then forbids
+smooth slip past each kink — sawtooth tractions that GROW under mesh
+refinement (measured: ~/+Simulations/curved_fault_roughness/). With the
+analytic normal the polyline behaves as the smooth fault it represents.
+
+The San Andreas slips freely under right-lateral simple shear parallel
+to the plate-boundary trend; the slip half-arrows on the map come from
+the MEASURED jump. Field: Delta CFF on boundary-parallel planes, P0
+(cell) stress — continuous-P1 projection of the rough near-fault stress
+rings at the node scale (measured) — rendered on the split mesh's true
+connectivity.
+"""
+import os
+import time
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import sympy
+import pyvista as pv
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+MU_P = 0.4
+TAU0 = 1.0
+TREND = 132.0                 # plate-boundary trend (~N42W), degrees CCW of E
+ETA_WELD = 200.0 * common.ETA / 0.2
+P0 = 1.0
+COH = 0.75
+
+# One continuous dextral trace with a smooth restraining bend: the
+# centreline runs along the trend from A, offset by a tanh step of
+# BEND_W toward the SW (the CCW normal) — an S in map view, stepping
+# LEFT, so right-lateral slip must converge through the bend. Max
+# deviation from the trend: atan(BEND_W / (2 LAM)) ~ 30 degrees, about
+# the real Big Bend.
+_A = np.array([0.88, 0.06])
+_t = np.array([np.cos(np.radians(TREND)), np.sin(np.radians(TREND))])
+_n = np.array([-_t[1], _t[0]])                  # CCW normal (points SW)
+S_END = 0.94
+BEND_W = 0.07                                   # total SW offset
+BEND_S0 = 0.45                                  # bend centre, arc parameter
+LAM = 0.06                                      # bend half-width
+
+
+def _w(s):
+    return 0.5 * BEND_W * (1.0 + np.tanh((s - BEND_S0) / LAM))
+
+
+def saf_trace(n_seg=47):
+    """The smooth trace sampled as a polyline (kinks land on mesh
+    vertices; the analytic normal makes them harmless)."""
+    s = np.linspace(0.0, S_END, n_seg + 1)
+    return _A + np.outer(s, _t) + np.outer(_w(s), _n)
+
+
+def saf_normal(child):
+    """The EXACT unit-normal direction of the smooth trace as a sympy
+    row matrix in mesh coordinates: with X(s) = A + s t + w(s) n and
+    s(X) = (X - A).t, the tangent is t + w'(s) n and the normal its
+    quarter turn, n - w'(s) t (normalisation is the caller's)."""
+    x, y = child.X
+    s = (x - _A[0]) * _t[0] + (y - _A[1]) * _t[1]
+    wp = (0.5 * BEND_W / LAM) * (1 - sympy.tanh((s - BEND_S0) / LAM) ** 2)
+    return sympy.Matrix([[_n[0] - wp * _t[0], _n[1] - wp * _t[1]]])
+
+
+SAF_PTS = saf_trace()
+
+MINORS = {
+    "Garlock": np.array([[0.52, 0.44], [0.80, 0.53]]),
+    "E1": np.array([[0.62, 0.64], [0.56, 0.78]]),
+    "E2": np.array([[0.72, 0.62], [0.66, 0.76]]),
+    "E3": np.array([[0.81, 0.68], [0.75, 0.82]]),
+    "SJF": np.array([[0.84, 0.24], [0.70, 0.38]]),
+}
+GROUPS = (("Garlock (sinistral)", ("Garlock",), "#6a1b9a"),
+          ("ECSZ, 3 strands (dextral)", ("E1", "E2", "E3"), "#1a6b1a"),
+          ("San Jacinto (dextral)", ("SJF",), "#e65100"))
+COLOUR = {"Garlock": "#6a1b9a", "E1": "#1a6b1a", "E2": "#1a6b1a",
+          "E3": "#1a6b1a", "SJF": "#e65100"}
+
+
+def build_and_solve(trunk_free):
+    faults = [("SAF", SAF_PTS)] + [(k, v) for k, v in MINORS.items()]
+    child = common.base_mesh(0.012).add_fault(faults)
+    stokes = common.stokes_on(child,
+                              common.boundary_simple_shear(child, TREND,
+                                                           TAU0))
+    # the analytic normal in BOTH states, so the slipping and welded
+    # solves share one constraint frame and difference cleanly
+    stokes.add_fault_bc(0 if trunk_free else ETA_WELD, boundary="SAF",
+                        normal=saf_normal(child))
+    for k in MINORS:
+        stokes.add_fault_bc(ETA_WELD, boundary=k)
+    fault_contact.solve_with_fault(stokes, picard=2)
+    probes = {}
+    for k, pts in MINORS.items():
+        _s, _xy, sig, tau = common.probe_nodes(stokes, k, pts[1] - pts[0],
+                                               ETA_WELD)
+        probes[k] = (sig, tau)
+    return child, stokes, probes
+
+
+def stress_components(child, stokes, tag):
+    x, y = child.X
+    v = stokes.Unknowns.u
+    p = stokes.Unknowns.p
+    exprs = dict(
+        sxx=-p.sym[0] + 2 * common.ETA * v.sym[0].diff(x),
+        syy=-p.sym[0] + 2 * common.ETA * v.sym[1].diff(y),
+        sxy=common.ETA * (v.sym[0].diff(y) + v.sym[1].diff(x)))
+    out = {}
+    for name, expr in exprs.items():
+        # P0 (cell) stress: projecting the rough near-fault stress onto
+        # CONTINUOUS P1 rings at the node scale (measured: residual rms
+        # 0.26 at half-wavelength h/2); cellwise averages are honest and
+        # pixel-scale at this resolution.
+        s_var = uw.discretisation.MeshVariable(f"{name}_{tag}", child, 1,
+                                               degree=0, continuous=False)
+        proj = uw.systems.Projection(child, s_var)
+        proj.uw_function = expr
+        proj.smoothing = 0.0
+        proj.solve()
+        row = common.split_mesh_cell_rows(child, s_var)
+        out[name] = np.asarray(s_var.data[:, 0])[row].copy()
+    return out
+
+
+cache = os.path.join(D, "_california_probes.npz")
+if os.path.exists(cache):
+    data = dict(np.load(cache, allow_pickle=True))
+    print("loaded cached run")
+else:
+    t_wall = time.perf_counter()
+    child, s1, probes1 = build_and_solve(trunk_free=True)
+    print(f"[timing] slipping solve + probes: "
+          f"{time.perf_counter() - t_wall:.1f} s")
+    t_wall = time.perf_counter()
+    s_saf, V_saf = common.slip_vs_position(
+        s1, _t, centre=_A + 0.47 * _t, name="SAF")
+    comp1 = stress_components(child, s1, "a")
+
+    s0 = common.stokes_on(child,
+                          common.boundary_simple_shear(child, TREND,
+                                                       TAU0))
+    s0.add_fault_bc(ETA_WELD, boundary="SAF", normal=saf_normal(child))
+    for k in MINORS:
+        s0.add_fault_bc(ETA_WELD, boundary=k)
+    fault_contact.solve_with_fault(s0, picard=2)
+    comp0 = stress_components(child, s0, "b")
+    print(f"[timing] welded solve + all projections: "
+          f"{time.perf_counter() - t_wall:.1f} s")
+    probes0 = {}
+    for k, pts in MINORS.items():
+        _s, _xy, sig, tau = common.probe_nodes(s0, k, pts[1] - pts[0],
+                                               ETA_WELD)
+        probes0[k] = (sig, tau)
+
+    # Delta CFF on boundary-parallel planes (per cell)
+    beta = np.radians(TREND)
+    nx, ny = -np.sin(beta), np.cos(beta)
+    tx, ty = np.cos(beta), np.sin(beta)
+
+    def resolve(c):
+        s_nn = (c["sxx"] * nx * nx + 2 * c["sxy"] * nx * ny
+                + c["syy"] * ny * ny)
+        s_t = (c["sxx"] * tx * nx + c["sxy"] * (tx * ny + ty * nx)
+               + c["syy"] * ty * ny)
+        return s_nn, s_t
+
+    nn0, t0 = resolve(comp0)
+    nn1, t1 = resolve(comp1)
+    tau_dir = np.sign(np.median(t0))
+    _pts, _faces = common.split_mesh_cell_render(child)
+    # cell centroids, for the far-field gauge anchor
+    fc = np.asarray(_faces).reshape(-1, 4)[:, 1:]
+    _cent = np.asarray(_pts)[fc].mean(axis=1)
+    data = dict(field_dcff=tau_dir * (t1 - t0) + MU_P * (nn1 - nn0),
+                field_points=_pts, field_faces=_faces,
+                field_centroids=_cent, saf_v=V_saf)
+    for k in MINORS:
+        data[f"{k}_sig0"], data[f"{k}_tau0"] = probes0[k]
+        data[f"{k}_sig1"], data[f"{k}_tau1"] = probes1[k]
+    np.savez(cache, **data)
+    data = dict(np.load(cache, allow_pickle=True))
+
+v_med = float(np.median(data["saf_v"]))
+# dextral: with the tangent pointing NW and the split's Plus side on
+# its LEFT (SW, the Pacific side), a POSITIVE jump (v+ - v-) along +t
+# means the Pacific side moves NW relative to North America.
+sense = "right-lateral" if v_med > 0 else "LEFT-LATERAL?!"
+print(f"SAF slip: median tangential jump {v_med:+.3f} ({sense})")
+
+# ---- the field render ------------------------------------------------------
+dcff_field, GAUGE_C = common.far_field_anchor(
+    data["field_centroids"], data["field_dcff"],
+    [SAF_PTS[:26], SAF_PTS[24:]] + list(MINORS.values()), cut=0.18)
+print(f"far-field gauge constant removed: {GAUGE_C:+.4f}")
+pvm = pv.PolyData(np.asarray(data["field_points"], dtype=float),
+                  faces=np.asarray(data["field_faces"], dtype=np.int64))
+pvm.cell_data["dcff"] = dcff_field
+pl = pv.Plotter(off_screen=True, window_size=(1000, 950))
+pl.set_background("white")
+pl.add_mesh(pvm, scalars="dcff", cmap="RdBu_r", clim=(-1.0, 1.0),
+            show_edges=False, lighting=False,
+            scalar_bar_args=dict(title="dCFF", color="black"))
+
+
+def polyline(pts):
+    return pv.lines_from_points(
+        np.column_stack([pts, np.full(len(pts), 0.001)]))
+
+
+pl.add_mesh(polyline(SAF_PTS), color="black", line_width=5.0,
+            lighting=False)
+for k, pts in MINORS.items():
+    pl.add_mesh(polyline(pts), color=COLOUR[k], line_width=4.0,
+                lighting=False)
+
+# measured slip sense, half-arrows either side of the southern leg
+mid = _A + 0.20 * _t
+sense_sign = np.sign(v_med)
+for pm in (+1.0, -1.0):
+    base = mid + pm * 0.05 * _n - pm * sense_sign * 0.06 * _t
+    pl.add_arrows(np.array([np.append(base, 0.002)]),
+                  np.array([np.append(pm * sense_sign * _t, 0.0)]),
+                  mag=0.11, color="black")
+
+pl.add_point_labels(
+    np.array([[0.30, 0.44, 0.002], [0.86, 0.12, 0.002],
+              [0.68, 0.50, 0.002], [0.60, 0.82, 0.002],
+              [0.84, 0.20, 0.002], [0.40, 0.24, 0.002]]),
+    ["San Andreas (N)", "San Andreas (S)", "Garlock", "ECSZ",
+     "San Jacinto", "Transverse Ranges\n(restraining bend)"],
+    font_size=20, text_color="black", shape=None, always_visible=True,
+    show_points=False)
+
+pl.view_xy()
+pl.camera.parallel_projection = True
+pl.camera.parallel_scale = 0.48
+pl.camera.focal_point = (0.48, 0.44, 0.0)
+field_png = os.path.join(D, "_california_field.png")
+pl.screenshot(field_png)
+pl.close()
+
+# ---- the figure: field + one Mohr panel per fault group --------------------
+fig = plt.figure(figsize=(13.2, 6.6))
+gs = fig.add_gridspec(3, 3, width_ratios=[2.6, 1.15, 0.06])
+
+axf = fig.add_subplot(gs[:, 0])
+axf.imshow(plt.imread(field_png))
+axf.set_xticks([])
+axf.set_yticks([])
+axf.set_title(r"$\Delta$CFF on boundary-parallel planes ($\mu' = 0.4$);"
+              "\nthe San Andreas slips (right-lateral) through its "
+              "restraining bend, neighbours welded as probes\n"
+              "(schematic geometry, not to scale)",
+              fontsize=9)
+
+for row, (label, members, col) in enumerate(GROUPS):
+    ax = fig.add_subplot(gs[row, 1])
+    ss = np.linspace(-0.4, P0 + 1.9, 80)
+    strength = np.maximum(COH + MU_P * ss, 0.0)
+    for sgn in (+1, -1):
+        ax.plot(ss, sgn * strength, "-", color="0.4", lw=0.9)
+    ax.fill_between(ss, strength, 2.6, color="#c62828", alpha=0.06, lw=0)
+    ax.fill_between(ss, -strength, -2.6, color="#c62828", alpha=0.06,
+                    lw=0)
+    tt = np.linspace(0, 2 * np.pi, 150)
+    ax.plot(P0 + TAU0 * np.cos(tt), TAU0 * np.sin(tt), "-", color="0.88",
+            lw=0.7)
+    medians = []
+    for k in members:
+        t_hat = MINORS[k][1] - MINORS[k][0]
+        c0 = float(np.median(data[f"{k}_sig0"])
+                   - common.ambient_sigma_n_simple(TREND, t_hat, TAU0))
+        sig0 = data[f"{k}_sig0"] - c0
+        tau0 = data[f"{k}_tau0"]
+        sig1 = data[f"{k}_sig1"] - c0 - GAUGE_C / MU_P
+        tau1 = data[f"{k}_tau1"]
+        tau_dir = np.sign(np.median(tau0))
+        dcff = tau_dir * (tau1 - tau0) + MU_P * (sig1 - sig0)
+        medians.append(np.median(dcff))
+        sc0, sc1 = P0 - sig0, P0 - sig1
+        ax.scatter(sc0, tau0, s=9, facecolors="none", edgecolors="0.6",
+                   linewidths=0.7)
+        for j in range(0, len(sc0), 3):
+            ax.annotate("", xytext=(sc0[j], tau0[j]),
+                        xy=(sc1[j], tau1[j]),
+                        arrowprops=dict(arrowstyle="->", lw=0.45,
+                                        color="0.6"))
+        pts = ax.scatter(sc1, tau1, c=dcff, cmap="RdBu_r", s=16,
+                         vmin=-0.3, vmax=0.3, zorder=5,
+                         edgecolors="0.3", linewidths=0.2)
+    ax.axhline(0, color="0.92", lw=0.5)
+    ax.set_aspect("equal")
+    ax.set_xlim(-0.4, P0 + 1.9)
+    ax.set_ylim(-1.7, 1.7)
+    ax.tick_params(labelsize=7)
+    for spine in ax.spines.values():
+        spine.set_color(col)
+        spine.set_linewidth(1.8)
+    ax.set_title(f"{label}: median $\\Delta$CFF "
+                 f"{np.median(medians):+.2f}", fontsize=8.5, color=col)
+
+cax = fig.add_subplot(gs[:, 2])
+fig.colorbar(pts, cax=cax, label=r"node $\Delta$CFF")
+fig.suptitle("A San Andreas slip event (Big Bend), read by its "
+             "neighbours", fontsize=11.5)
+fig.tight_layout()
+out = os.path.join(D, "california.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
diff --git a/docs/advanced/figures/fault-examples/common.py b/docs/advanced/figures/fault-examples/common.py
new file mode 100644
index 000000000..d55abe74d
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/common.py
@@ -0,0 +1,326 @@
+"""Shared harness for the split-node fault teaching examples.
+
+One base mesh, re-faulted per case (the non-cumulative add_fault
+pattern); P2 velocity / P0 discontinuous pressure per the fault
+pressure-space ruling; slip and traction read through the DOF pairing.
+Run inside the fault-split-node worktree env with its bin on PATH.
+"""
+import numpy as np
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+ETA = 1.0
+CENTRE = np.array([0.5, 0.5])
+
+
+def base_mesh(cell_size=0.04):
+    return uw.meshing.UnstructuredSimplexBox(cellSize=cell_size)
+
+
+def fault_segment(angle_deg, half_length=0.2, centre=CENTRE):
+    t = np.array([np.cos(np.radians(angle_deg)),
+                  np.sin(np.radians(angle_deg))])
+    return np.array([centre - half_length * t, centre + half_length * t])
+
+
+def split_with_fault(mesh, points, name="Fault"):
+    return mesh.add_fault((name, points))
+
+
+def stokes_on(child, drive, name="Fault"):
+    """Stokes with the wall drive on all four walls; fault BC added by
+    the caller. Variable names are derived from the mesh instance so
+    repeated calls on fresh children never collide."""
+    tag = f"f{stokes_on.counter}"
+    stokes_on.counter += 1
+    v = uw.discretisation.MeshVariable(f"V_{tag}", child, child.dim,
+                                       degree=2)
+    p = uw.discretisation.MeshVariable(f"P_{tag}", child, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(child, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = ETA
+    stokes.bodyforce = [0.0, 0.0]
+    for wall in ("Bottom", "Top", "Left", "Right"):
+        stokes.add_dirichlet_bc(drive, wall)
+    # all-Dirichlet walls leave the pressure level to the solver unless
+    # the constant nullspace is declared — without it, two solves with
+    # different fault laws land on DIFFERENT gauges and any differenced
+    # quantity (Delta CFF above all) inherits a spurious constant
+    stokes.petsc_use_pressure_nullspace = True
+    stokes.tolerance = 1e-6
+    return stokes
+
+
+stokes_on.counter = 0
+
+
+def simple_shear(child, rate=1.0):
+    """v = (rate (y - 1/2), 0): sigma_xy = ETA * rate everywhere."""
+    x, y = child.X
+    return (rate * (y - 0.5), 0.0)
+
+
+def shear_plus_stretch(child, a=0.5, gamma=1.0):
+    """v = (a(x-c) + gamma(y-c), -a(y-c)): deviatoric stress
+    [[2 eta a, eta gamma], [eta gamma, -2 eta a]], Mohr radius
+    eta sqrt(4 a^2 + gamma^2)."""
+    x, y = child.X
+    return (a * (x - 0.5) + gamma * (y - 0.5), -a * (y - 0.5))
+
+
+def slip_profile(stokes, name="Fault"):
+    return fault_contact.fault_slip(stokes, name,
+                                    stokes._rotated_freeslip_info)
+
+
+def normal_traction(stokes, name="Fault"):
+    return fault_contact.fault_normal_traction(
+        stokes, name, stokes._rotated_freeslip_info)
+
+
+def inner(s, fraction=0.6):
+    """Mask selecting the central `fraction` of the along-fault range —
+    tip fields carry the crack singularity, the middle is the gauge."""
+    lo = s.min() + (1 - fraction) / 2 * (s.max() - s.min())
+    hi = s.max() - (1 - fraction) / 2 * (s.max() - s.min())
+    return (s >= lo) & (s <= hi)
+
+
+def slip_vs_position(stokes, tangent, centre=CENTRE, name="Fault"):
+    """(s, V) read through the pairing with EXACT positions: s is the
+    signed along-fault coordinate of each pair about the fault centre,
+    V the signed tangential jump. `fault_slip`'s arc-length origin sits
+    at the first PAIR, not the tip, so profiles built from it are offset
+    by half a node — this is the plotting-grade version."""
+    coords, jumps, _normals = fault_contact.fault_pair_jumps(
+        stokes, name, stokes._rotated_freeslip_info)
+    t = np.asarray(tangent, dtype=float)
+    t = t / np.linalg.norm(t)
+    s = (coords - centre) @ t
+    V = jumps @ t
+    order = np.argsort(s)
+    return s[order], V[order]
+
+
+def pure_shear_drive(child, phi_deg, tau0=1.0):
+    """Uniform pure shear with the COMPRESSION axis at ``phi_deg`` to x:
+    sigma' = tau0 (e_perp e_perp - e_phi e_phi), i.e. sigma'_xx =
+    -tau0 cos 2phi and sigma'_xy = -tau0 sin 2phi. (Check: compression
+    at phi = 45 deg gives sigma_xy = -tau0; a plane of strike
+    phi - 45 deg carries the full resolved shear.) Irrotational
+    velocity field, imposed as Dirichlet on all walls — rotating phi
+    rotates the whole regional stress field."""
+    x, y = child.X
+    two_phi = 2.0 * np.radians(phi_deg)
+    exx = -tau0 * np.cos(two_phi) / (2.0 * ETA)
+    exy = -tau0 * np.sin(two_phi) / (2.0 * ETA)
+    return (exx * (x - 0.5) + exy * (y - 0.5),
+            exy * (x - 0.5) - exx * (y - 0.5))
+
+
+def boundary_simple_shear(child, trend_deg, rate=1.0):
+    """RIGHT-LATERAL simple shear parallel to a plate-boundary trend:
+    v = rate ((X - c) . n) t with t the boundary-parallel direction and
+    n its CCW normal — material on the +n side moves along +t, which an
+    observer on the fault sees moving to the RIGHT (dextral). Resolved
+    shear tau0 = ETA * rate on boundary-parallel planes."""
+    x, y = child.X
+    t = np.array([np.cos(np.radians(trend_deg)),
+                  np.sin(np.radians(trend_deg))])
+    n = np.array([-t[1], t[0]])
+    s = (x - 0.5) * n[0] + (y - 0.5) * n[1]
+    return (rate * s * t[0], rate * s * t[1])
+
+
+def ambient_sigma_n_simple(trend_deg, tangent, tau0=1.0):
+    """Analytic ambient normal stress (tension-positive) on a plane of
+    direction ``tangent`` under boundary_simple_shear(trend):
+    sigma_nn = -tau0 sin 2(theta - trend)."""
+    theta = np.degrees(np.arctan2(tangent[1], tangent[0]))
+    return -tau0 * np.sin(2.0 * np.radians(theta - trend_deg))
+
+
+def probe_nodes(stokes, name, tangent, eta_weld):
+    """Per-node stress probes on a WELDED fault: along-fault coordinate,
+    position, signed normal traction (tension-positive, as measured) and
+    signed shear traction from the weld's own law tau = eta_f V.
+
+    Works with SEVERAL law-carrying faults on one mesh: the interface
+    assembler holds every fault's nodes, so this fault's are selected
+    through its OWN pairing (the plus points), never by position."""
+    from underworld3.utilities.rotated_bc import _point_coord
+
+    assembler = fault_contact._InterfaceAssembler(stokes, include=(name,))
+    sig_all = assembler.nodal_normal_traction(
+        stokes, stokes._rotated_freeslip_info["reaction"])
+    plus = set(stokes.mesh._fault_point_pairs[name].values())
+
+    dm = stokes.dm
+    dim = stokes.mesh.dim
+    csec = dm.getCoordinateSection()
+    cvec = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dim)
+    v0, v1 = dm.getDepthStratum(0)
+    rows = [(np.asarray(_point_coord(dm, dim, cvec, csec, v0, v1, q)),
+             sig_all[k]) for q, k in assembler._points.items()
+            if q in plus]
+    xy_sig = np.array([r[0] for r in rows])
+    sig = np.array([r[1] for r in rows])
+
+    t = np.asarray(tangent, dtype=float)
+    t = t / np.linalg.norm(t)
+    order_sig = np.argsort(xy_sig @ t)
+    xy_sig, sig = xy_sig[order_sig], sig[order_sig]
+
+    coords, jumps, _normals = fault_contact.fault_pair_jumps(
+        stokes, name, stokes._rotated_freeslip_info)
+    s = coords @ t
+    order = np.argsort(s)
+    V = (jumps @ t)[order]
+    assert len(sig) == len(V), "pair-node sets disagree"
+    assert np.allclose(coords[order], xy_sig), "node ordering disagrees"
+    return (s[order], coords[order], sig, eta_weld * V)
+
+
+def mohr_probe(theta, a_rate=0.5, gamma=1.0, eta_weld=None,
+               half_length=0.2, cell_size=0.04):
+    """One welded-fault stress probe: (sigma_n, tau_signed) at fault
+    angle `theta` under the shear_plus_stretch drive. The weld's own
+    law reads the shear traction (tau = eta_f V); the no-opening
+    reaction reads the normal traction."""
+    if eta_weld is None:
+        eta_weld = 200.0 * ETA / half_length
+    child = split_with_fault(base_mesh(cell_size),
+                             fault_segment(theta, half_length))
+    stokes = stokes_on(child, shear_plus_stretch(child, a_rate, gamma))
+    stokes.add_fault_bc(eta_weld, boundary="Fault")
+    fault_contact.solve_with_fault(stokes, picard=2)
+    s, V, _leak = slip_profile(stokes)
+    s_n, sig = normal_traction(stokes)
+    tau = eta_weld * float(np.median(V[inner(s)]))
+    sigma_n = float(np.median(sig[inner(s_n)]))
+    return sigma_n, tau
+
+
+def ambient_sigma_n(phi_deg, tangent, tau0=1.0):
+    """The analytic ambient normal stress (tension-positive) on a plane
+    of tangent direction ``tangent`` under pure_shear_drive(phi):
+    sigma_nn = tau0 cos 2(phi - theta). Used to anchor a probe set's
+    absolute pressure gauge, which a closed-box solve does not fix."""
+    theta = np.degrees(np.arctan2(tangent[1], tangent[0]))
+    return tau0 * np.cos(2.0 * np.radians(phi_deg - theta))
+
+
+def far_field_anchor(points, dcff, segments, cut=0.3):
+    """Gauge the DIFFERENCED stress to the physics: a slip event changes
+    nothing far from the faults, so the far-field median of Delta CFF is
+    the spurious pressure-gauge constant between the two solves. Returns
+    (anchored dcff, the constant) — apply c / mu' to the probes' sigma."""
+    p = np.asarray(points, dtype=float)[:, :2]
+    far = np.ones(len(p), dtype=bool)
+    for seg in segments:
+        a, b = np.asarray(seg[0]), np.asarray(seg[-1])
+        t = b - a
+        L = np.linalg.norm(t)
+        t = t / L
+        s = np.clip((p - a) @ t, 0.0, L)
+        far &= np.linalg.norm(p - (a + s[:, None] * t), axis=1) > cut
+    c = float(np.median(np.asarray(dcff)[far]))
+    return np.asarray(dcff) - c, c
+
+
+def signed_log(x, linthresh=0.02):
+    """Symmetric log transform for signed stress-change fields: linear
+    inside |x| < linthresh, logarithmic beyond — the near-fault values
+    saturate any linear colour scale and hide the far-field lobes."""
+    x = np.asarray(x, dtype=float)
+    return np.sign(x) * np.log10(1.0 + np.abs(x) / linthresh)
+
+
+def signed_log_annotations(values, linthresh=0.02):
+    """Scalar-bar tick positions/labels in transformed units."""
+    return {float(np.sign(v) * np.log10(1.0 + abs(v) / linthresh)):
+            f"{v:+.2f}" if v else "0" for v in values}
+
+
+def dedupe_average(points, values, decimals=9):
+    """Merge geometrically coincident points, averaging their values —
+    for RENDERING split-mesh fields only. The split mesh carries
+    coincident duplicated nodes along each fault; a Delaunay of the raw
+    cloud picks sides arbitrarily and paints alternating plus/minus
+    values along the trace (beading). Averaging collapses the jump in a
+    one-node strip that the drawn fault line covers."""
+    pts = np.asarray(points, dtype=float)
+    vals = np.asarray(values, dtype=float)
+    key = np.round(pts[:, :2], decimals)
+    _uniq, inverse, counts = np.unique(key, axis=0, return_inverse=True,
+                                       return_counts=True)
+    sums = np.zeros(len(counts))
+    np.add.at(sums, inverse, vals)
+    first = np.full(len(counts), -1, dtype=int)
+    for i, g in enumerate(inverse):
+        if first[g] < 0:
+            first[g] = i
+    return pts[first], sums / counts
+
+
+def split_mesh_cell_render(child):
+    """Points (mesh vertices) + faces (true cell connectivity) for
+    rendering CELL data on a split mesh. Node-order mapping is trivial
+    (v - vS) because the points ARE the vertices; pair cell values via
+    split_mesh_cell_rows."""
+    dm = child.dm
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    faces = []
+    for c in range(cS, cE):
+        closure, _ = dm.getTransitiveClosure(c)
+        tri = [int(p) - vS for p in closure if vS <= int(p) < vE]
+        faces.extend([3, *tri])
+    return (np.column_stack([X, np.zeros(len(X))]),
+            np.asarray(faces, dtype=np.int64))
+
+
+def split_mesh_cell_rows(child, var):
+    """Data-row index of a P0 variable for each cell, in plex cell
+    order (rank of the combined-section offsets)."""
+    dm = child.dm
+    sec = dm.getLocalSection()
+    cS, cE = dm.getHeightStratum(0)
+    offs = np.array([sec.getFieldOffset(c, var.field_id)
+                     for c in range(cS, cE)])
+    row = np.empty(len(offs), dtype=np.int64)
+    row[np.argsort(offs)] = np.arange(len(offs))
+    return row
+
+
+def split_mesh_faces(child, var):
+    """The mesh's own triangulation as a pyvista faces array, indexed in
+    ``var``'s DOF order (P1 vertex variable). Rendering a split-mesh
+    field through delaunay_2d of the DOF cloud is WRONG twice over: the
+    coincident fault pairs get arbitrary side-picking, and unconstrained
+    Delaunay edges hop across a curved trace — both paint beading along
+    the fault. The true connectivity keeps the two sheets separate and
+    renders the jump sharply."""
+    dm = child.dm
+    sec = dm.getLocalSection()
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    fid = var.field_id
+    # getFieldOffset indexes the COMBINED local vector; the variable's
+    # own rows are the RANKS of those offsets (dof order = offset order)
+    offs = np.array([sec.getFieldOffset(v, fid) for v in range(vS, vE)])
+    row = np.empty(len(offs), dtype=np.int64)
+    row[np.argsort(offs)] = np.arange(len(offs))
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    assert np.allclose(np.asarray(var.coords)[row], X), \
+        "variable DOF order does not match the offset ranking"
+    faces = []
+    for c in range(cS, cE):
+        closure, _ = dm.getTransitiveClosure(c)
+        tri = [int(row[int(p) - vS]) for p in closure
+               if vS <= int(p) < vE]
+        faces.extend([3, *tri])
+    return np.asarray(faces, dtype=np.int64)
diff --git a/docs/advanced/figures/fault-examples/interacting-faults.png b/docs/advanced/figures/fault-examples/interacting-faults.png
new file mode 100644
index 000000000..0720487f7
Binary files /dev/null and b/docs/advanced/figures/fault-examples/interacting-faults.png differ
diff --git a/docs/advanced/figures/fault-examples/interacting-rotation.png b/docs/advanced/figures/fault-examples/interacting-rotation.png
new file mode 100644
index 000000000..0498ad47b
Binary files /dev/null and b/docs/advanced/figures/fault-examples/interacting-rotation.png differ
diff --git a/docs/advanced/figures/fault-examples/interacting_faults.py b/docs/advanced/figures/fault-examples/interacting_faults.py
new file mode 100644
index 000000000..7e4bc647e
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/interacting_faults.py
@@ -0,0 +1,251 @@
+"""Interacting faults, King-style: stress transfer read on the Mohr plane.
+
+Two en echelon faults (right-stepping, overlapping). The SOURCE slips
+freely; the RECEIVER is welded — a passive per-node stress probe, the
+instrument built in the Mohr examples. Two solves on the SAME mesh:
+
+  (0) both faults welded          -> the ambient regional state
+  (1) source slips, receiver weld -> the perturbed state
+
+The difference is the classical Coulomb stress transfer:
+
+- the FIELD: Delta CFF = tau_dir * d sigma_xy + mu' * d sigma_yy on
+  receiver-parallel planes (King's mu' = 0.4), the familiar lobes;
+- ON the receiver: each node's probe MOVES in the (sigma, tau) plane,
+  and the displacement decomposes the CFF change into its shear and
+  normal(unclamping) parts — Coulomb stress transfer in the diagram
+  students already know how to read.
+
+Rotating the regional compression axis phi (the boundary velocities
+rotate with it) changes the interaction pattern; the phi sweep shows
+the receiver cloud pushed toward failure under one orientation and
+away under another.
+"""
+import os
+import time
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+import underworld3.visualisation as vis
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+MU_P = 0.4                              # King's effective friction
+TAU0 = 1.0
+ETA_WELD = 200.0 * common.ETA / 0.18
+PHIS = (20.0, 45.0, 70.0)               # regional compression axis
+
+SOURCE = np.array([[0.22, 0.46], [0.58, 0.46]])
+# The receiver sits in the source's ALONG-STRIKE tip lobe, where the
+# transfer is strongly positive at its near end and fades along it.
+RECEIVER = np.array([[0.65, 0.44], [0.86, 0.44]])
+T_HAT = np.array([1.0, 0.0])
+
+# The friction bookkeeping is dressed with a declared confining
+# pressure and cohesion — NEITHER changes Delta CFF (both are
+# constants under differencing), they only place the failure envelope
+# where the teaching needs it: P0 shifts the whole circle into
+# compression (no tensile regime anywhere), and the cohesive envelope
+# tau = +-(C + mu' sigma) arcs over it with the phi = 45 receiver
+# ambient sitting ~0.15 below the line, so the loaded nodes CROSS.
+P0 = 1.0
+COH = 0.75
+
+
+def solve_pair(phi, source_free):
+    child = common.base_mesh(0.016).add_fault(
+        [("Source", SOURCE), ("Receiver", RECEIVER)])
+    stokes = common.stokes_on(child, common.pure_shear_drive(child, phi,
+                                                             TAU0))
+    stokes.add_fault_bc(0 if source_free else ETA_WELD, boundary="Source")
+    stokes.add_fault_bc(ETA_WELD, boundary="Receiver")
+    fault_contact.solve_with_fault(stokes, picard=2)
+    s, xy, sig, tau = common.probe_nodes(stokes, "Receiver", T_HAT,
+                                         ETA_WELD)
+    return child, stokes, (s, xy, sig, tau)
+
+
+def stress_fields(child, stokes):
+    """sigma_xy and sigma_yy (full stress, pressure included) projected
+    to continuous P1 — the components CFF on horizontal planes needs."""
+    x, y = child.X
+    v = stokes.Unknowns.u
+    p = stokes.Unknowns.p
+    out = []
+    for name, expr in (("sxy", common.ETA * (v.sym[0].diff(y)
+                                             + v.sym[1].diff(x))),
+                       ("syy", -p.sym[0] + 2 * common.ETA
+                        * v.sym[1].diff(y))):
+        # P0 cell stress: continuous-P1 projection rings at node scale
+        # near the fault (see california.py)
+        s_var = uw.discretisation.MeshVariable(
+            f"{name}_{stress_fields.counter}", child, 1, degree=0,
+            continuous=False)
+        proj = uw.systems.Projection(child, s_var)
+        proj.uw_function = expr
+        proj.smoothing = 0.0
+        proj.solve()
+        row = common.split_mesh_cell_rows(child, s_var)
+        out.append(np.asarray(s_var.data[:, 0])[row].copy())
+    stress_fields.counter += 1
+    return out, s_var                    # arrays share the P1 layout
+
+
+stress_fields.counter = 0
+
+cache = os.path.join(D, "_interacting_probes.npz")
+if os.path.exists(cache):
+    data = dict(np.load(cache, allow_pickle=True))
+    print("loaded cached sweep")
+else:
+    data = {}
+    for phi in PHIS:
+        t_wall = time.perf_counter()
+        _c0, s0, probe0 = solve_pair(phi, source_free=False)
+        child, s1, probe1 = solve_pair(phi, source_free=True)
+        data[f"probe0_{phi}"] = np.array(probe0[0]), probe0[1], probe0[2], \
+            probe0[3]
+        data[f"p0_s_{phi}"], data[f"p0_xy_{phi}"] = probe0[0], probe0[1]
+        data[f"p0_sig_{phi}"], data[f"p0_tau_{phi}"] = probe0[2], probe0[3]
+        data[f"p1_sig_{phi}"], data[f"p1_tau_{phi}"] = probe1[2], probe1[3]
+        if phi == 45.0:
+            # the Delta CFF FIELD needs both solves' stress components on
+            # one mesh: redo the welded reference ON the slipping child
+            (sxy1, syy1), s_var = stress_fields(child, s1)
+            s0b = common.stokes_on(child, common.pure_shear_drive(
+                child, phi, TAU0))
+            s0b.add_fault_bc(ETA_WELD, boundary="Source")
+            s0b.add_fault_bc(ETA_WELD, boundary="Receiver")
+            fault_contact.solve_with_fault(s0b, picard=2)
+            (sxy0, syy0), _ = stress_fields(child, s0b)
+            tau_dir = np.sign(np.median(data[f"p0_tau_{phi}"]))
+            dcff = tau_dir * (sxy1 - sxy0) + MU_P * (syy1 - syy0)
+            _pts, _faces = common.split_mesh_cell_render(child)
+            data["field_points"] = _pts
+            data["field_faces"] = _faces
+            data["field_dcff"] = dcff
+        print(f"phi {phi}: receiver ambient tau "
+              f"{np.median(data[f'p0_tau_{phi}']):+.3f}, sigma_n "
+              f"{np.median(data[f'p0_sig_{phi}']):+.3f}  "
+              f"[{time.perf_counter() - t_wall:.1f} s]")
+    np.savez(cache, **{k: v for k, v in data.items()
+                       if not k.startswith("probe0")})
+    data = dict(np.load(cache, allow_pickle=True))
+
+# ---- figure A: the field + the receiver's Mohr move (phi = 45) -----------
+# gauge the difference to the far field (see common.far_field_anchor)
+_fc = np.asarray(data["field_faces"]).reshape(-1, 4)[:, 1:]
+_cent = np.asarray(data["field_points"])[_fc].mean(axis=1)
+dcff_field, GAUGE_C = common.far_field_anchor(
+    _cent, data["field_dcff"], (SOURCE, RECEIVER))
+print(f"far-field gauge constant removed: {GAUGE_C:+.4f}")
+pvm = pv.PolyData(np.asarray(data["field_points"], dtype=float),
+                  faces=np.asarray(data["field_faces"], dtype=np.int64))
+pvm.cell_data["dcff"] = dcff_field
+pl = pv.Plotter(off_screen=True, window_size=(1050, 820))
+pl.set_background("white")
+# linear colour scale with generous limits (the gate-study
+# convention): pale far field, graded lobes
+pl.add_mesh(pvm, scalars="dcff", cmap="RdBu_r", clim=(-1.0, 1.0),
+            show_edges=False, lighting=False,
+            scalar_bar_args=dict(title="dCFF", color="black"))
+for pts, col, w in ((SOURCE, "black", 4.0), (RECEIVER, "#1a6b1a", 4.0)):
+    line = pv.Line(tuple(pts[0]) + (0.001,), tuple(pts[1]) + (0.001,))
+    pl.add_mesh(line, color=col, line_width=w, lighting=False)
+pl.view_xy()
+pl.camera.parallel_projection = True
+pl.camera.parallel_scale = 0.33
+pl.camera.focal_point = (0.5, 0.5, 0.0)
+field_png = os.path.join(D, "_interacting_field.png")
+pl.screenshot(field_png)
+pl.close()
+
+
+def mohr_panel(ax, phi, legend=False):
+    # anchor the welded probes to the analytic ambient for this drive,
+    # the after-probes to the far-field-anchored difference on top
+    c0 = float(np.median(data[f"p0_sig_{phi}"])
+               - common.ambient_sigma_n(phi, T_HAT, TAU0))
+    sig0 = data[f"p0_sig_{phi}"] - c0
+    tau0 = data[f"p0_tau_{phi}"]
+    sig1 = data[f"p1_sig_{phi}"] - c0 - GAUGE_C / MU_P
+    tau1 = data[f"p1_tau_{phi}"]
+    tau_dir = np.sign(np.median(tau0))
+    dcff = tau_dir * (tau1 - tau0) + MU_P * (sig1 - sig0)
+    # geo convention, with the declared confining pressure superposed
+    sc0, sc1 = P0 - sig0, P0 - sig1
+    ss = np.linspace(-0.4, P0 + 1.8, 90)
+    strength = np.maximum(COH + MU_P * ss, 0.0)
+    for sgn in (+1, -1):
+        ax.plot(ss, sgn * strength, "-", color="0.35", lw=1.1,
+                label=(r"envelope $\tau = \pm(C + \mu'\sigma)$"
+                       if sgn > 0 and legend else None))
+    ax.fill_between(ss, strength, 2.4, color="#c62828", alpha=0.06,
+                    lw=0)
+    ax.fill_between(ss, -strength, -2.4, color="#c62828", alpha=0.06,
+                    lw=0)
+    tt = np.linspace(0, 2 * np.pi, 200)
+    ax.plot(P0 + TAU0 * np.cos(tt), TAU0 * np.sin(tt), "-",
+            color="0.85", lw=0.8,
+            label="regional circle" if legend else None)
+    ax.scatter(sc0, tau0, s=16, facecolors="none", edgecolors="0.55",
+               linewidths=1.0,
+               label="receiver nodes, before" if legend else None)
+    for k in range(0, len(sc0), 2):
+        ax.annotate("", xytext=(sc0[k], tau0[k]), xy=(sc1[k], tau1[k]),
+                    arrowprops=dict(arrowstyle="->", lw=0.6,
+                                    color="0.65"))
+    pts = ax.scatter(sc1, tau1, c=dcff, cmap="RdBu_r", s=26,
+                     vmin=-0.4, vmax=0.4, zorder=5, edgecolors="0.3",
+                     linewidths=0.3,
+                     label="after (colour: dCFF)" if legend else None)
+    ax.axhline(0, color="0.9", lw=0.5)
+    ax.set_xlim(-0.4, P0 + 1.8)
+    ax.set_ylim(-1.75, 1.75)
+    ax.set_aspect("equal")
+    ax.set_title(rf"$\phi = {phi:.0f}°$  "
+                 rf"(median dCFF {np.median(dcff):+.2f})", fontsize=9)
+    ax.set_xlabel(r"$\sigma$ (compression +, $P_0 = 1$)", fontsize=8)
+    return pts
+
+
+fig = plt.figure(figsize=(11.5, 4.9))
+axf = fig.add_subplot(1, 2, 1)
+axf.imshow(plt.imread(field_png))
+axf.set_xticks([])
+axf.set_yticks([])
+axf.set_title(r"$\Delta$CFF field ($\mu' = 0.4$), source slips freely;"
+              "\nreceiver (green) welded as a probe", fontsize=9)
+axm = fig.add_subplot(1, 2, 2)
+pts = mohr_panel(axm, 45.0, legend=True)
+axm.set_ylabel(r"$\tau$", fontsize=9)
+axm.legend(fontsize=7, loc="lower right")
+fig.colorbar(pts, ax=axm, label=r"node $\Delta$CFF", shrink=0.8)
+fig.suptitle("En echelon interaction: the receiver's probes move in the "
+             "Mohr plane", fontsize=11)
+fig.tight_layout()
+out = os.path.join(D, "interacting-faults.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
+
+# ---- figure B: rotate the regional stress --------------------------------
+fig, axes = plt.subplots(1, len(PHIS), figsize=(11.5, 4.2),
+                         sharey=True)
+for ax, phi in zip(axes, PHIS):
+    pts = mohr_panel(ax, phi, legend=(phi == PHIS[0]))
+axes[0].set_ylabel(r"$\tau$", fontsize=9)
+axes[0].legend(fontsize=6.5, loc="lower right")
+fig.colorbar(pts, ax=axes, label=r"node $\Delta$CFF", shrink=0.8)
+fig.suptitle("Rotating the regional compression axis changes the "
+             "interaction", fontsize=11)
+out = os.path.join(D, "interacting-rotation.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
diff --git a/docs/advanced/figures/fault-examples/ladder.png b/docs/advanced/figures/fault-examples/ladder.png
new file mode 100644
index 000000000..1b9292773
Binary files /dev/null and b/docs/advanced/figures/fault-examples/ladder.png differ
diff --git a/docs/advanced/figures/fault-examples/ladder.py b/docs/advanced/figures/fault-examples/ladder.py
new file mode 100644
index 000000000..8dd1d67b9
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/ladder.py
@@ -0,0 +1,130 @@
+"""The fault-strength ladder: one fault, one drive, four laws.
+
+A horizontal fault under far-field simple shear (resolved shear stress
+tau_infty = eta * rate = 1 on the fault plane), solved with each rung of
+the constitutive ladder. Left: the slip profiles V(s), with the exact
+zero-slip tips appended (positions read through the DOF pairing — the
+generic fault_slip arc-length starts at the first pair, not the tip).
+Right: the shear-stress field sigma_xy for each rung, stacked for
+context — the stress drop shadows the fault where it slips, and the
+welded/stuck rungs leave the far-field stress untouched.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+import underworld3.visualisation as vis
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+SIGMA_N = 2.0                       # prescribed normal stress for friction
+
+segment = common.fault_segment(0.0, half_length=HALF)
+runs = []
+
+
+def render_shear_stress(stokes, child, tag):
+    """sigma_xy projected to continuous P1 (smoothing 0), rendered as a
+    cropped planform panel with the fault trace overlaid."""
+    x, y = child.X
+    v = stokes.Unknowns.u
+    s_var = uw.discretisation.MeshVariable(f"Sxy_{tag}", child, 1, degree=1)
+    proj = uw.systems.Projection(child, s_var)
+    proj.uw_function = common.ETA * (v.sym[0].diff(y) + v.sym[1].diff(x))
+    proj.smoothing = 0.0
+    proj.solve()
+
+    pv_m = vis.meshVariable_to_pv_mesh_object(s_var)
+    pv_m.point_data["S"] = np.asarray(s_var.data[:, 0])
+    pl = pv.Plotter(off_screen=True, window_size=(560, 340))
+    pl.set_background("white")
+    pl.add_mesh(pv_m, scalars="S", cmap="RdBu_r", clim=(0.0, 2.0),
+                show_edges=False, lighting=False, show_scalar_bar=False)
+    trace = pv.Line((0.5 - HALF, 0.5, 0.001), (0.5 + HALF, 0.5, 0.001))
+    pl.add_mesh(trace, color="black", line_width=2.5, lighting=False)
+    pl.view_xy()
+    pl.camera.parallel_projection = True
+    pl.camera.parallel_scale = 0.26
+    pl.camera.focal_point = (0.5, 0.5, 0.0)
+    out = os.path.join(D, f"_ladder_stress_{tag}.png")
+    pl.screenshot(out)
+    pl.close()
+    return out
+
+
+def solve_case(label, register, tag):
+    child = common.split_with_fault(common.base_mesh(0.04), segment)
+    stokes = common.stokes_on(child, common.simple_shear(child))
+    register(stokes)
+    fault_contact.solve_with_fault(stokes, picard=2)
+    s, V = common.slip_vs_position(stokes, tangent=(1.0, 0.0))
+    # the unsplit tips carry exactly zero slip by construction
+    s = np.concatenate([[-HALF], s, [HALF]])
+    V = np.concatenate([[0.0], V, [0.0]])
+    panel = render_shear_stress(stokes, child, tag)
+    runs.append((label, s, np.abs(V), panel))
+    print(f"{label:34s} peak slip {np.abs(V).max():.4f}")
+
+
+solve_case("frictionless",
+           lambda st: st.add_fault_bc(0, boundary="Fault"), "free")
+solve_case(r"viscous, $\eta_f = \eta/a$",
+           lambda st: st.add_fault_bc(common.ETA / HALF, boundary="Fault"),
+           "visc")
+solve_case(r"Coulomb, $\mu\sigma_n = 0.6 < \tau_\infty$",
+           lambda st: fault_contact.add_coulomb_fault_bc(
+               st, 0.3, "Fault", sigma_n=SIGMA_N, V0=1e-4), "weak")
+solve_case(r"rate-state (steady, $f_{ss}\sigma_n \approx 0.86$)",
+           lambda st: fault_contact.add_rate_state_fault_bc(
+               st, 0.42, "Fault", a=0.02, b=0.01, V0=1e-3, Dc=1e-2,
+               sigma_n=SIGMA_N), "rs")
+solve_case(r"Coulomb, $\mu\sigma_n = 1.2 > \tau_\infty$ (stuck)",
+           lambda st: fault_contact.add_coulomb_fault_bc(
+               st, 0.6, "Fault", sigma_n=SIGMA_N, V0=1e-4), "stuck")
+
+colors = ["#c62828", "#e57373", "#d9960a", "#4a7bf7", "#555555"]
+
+fig = plt.figure(figsize=(9.8, 6.2))
+gs = gridspec.GridSpec(len(runs), 2, width_ratios=[1.7, 1.0],
+                       wspace=0.12, hspace=0.15)
+
+ax = fig.add_subplot(gs[:, 0])
+for (label, s, V, _panel), col in zip(runs, colors):
+    ax.plot(s, V, ".-", ms=3.5, lw=1.0, color=col, label=label)
+ss = np.linspace(-HALF, HALF, 200)
+ax.plot(ss, np.sqrt(np.maximum(HALF**2 - ss**2, 0)) / HALF
+        * runs[0][2].max(), "k--", lw=0.8,
+        label="elliptical profile (shape)")
+ax.set_xlabel("position along the fault $s$")
+ax.set_ylabel("slip rate $|V(s)|$")
+ax.set_title("The fault-strength ladder: one fault, four laws "
+             r"($\tau_\infty = 1$)")
+ax.legend(fontsize=8, loc="upper right")
+ax.set_xlim(-HALF * 1.15, HALF * 1.15)
+
+for k, ((label, _s, _V, panel), col) in enumerate(zip(runs, colors)):
+    axi = fig.add_subplot(gs[k, 1])
+    axi.imshow(plt.imread(panel))
+    axi.set_xticks([])
+    axi.set_yticks([])
+    for spine in axi.spines.values():
+        spine.set_color(col)
+        spine.set_linewidth(2.2)
+    if k == 0:
+        axi.set_title(r"shear stress $\sigma_{xy}$ (0 → 2, "
+                      r"white $= \tau_\infty$)", fontsize=8)
+
+fig.tight_layout()
+out = os.path.join(D, "ladder.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
diff --git a/docs/advanced/figures/fault-examples/mohr-circle-build.gif b/docs/advanced/figures/fault-examples/mohr-circle-build.gif
new file mode 100644
index 000000000..1ae195223
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-circle-build.gif differ
diff --git a/docs/advanced/figures/fault-examples/mohr-circle.png b/docs/advanced/figures/fault-examples/mohr-circle.png
new file mode 100644
index 000000000..da35e6ea9
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-circle.png differ
diff --git a/docs/advanced/figures/fault-examples/mohr-cohesion-build.gif b/docs/advanced/figures/fault-examples/mohr-cohesion-build.gif
new file mode 100644
index 000000000..7f65e260a
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-cohesion-build.gif differ
diff --git a/docs/advanced/figures/fault-examples/mohr-cohesion.png b/docs/advanced/figures/fault-examples/mohr-cohesion.png
new file mode 100644
index 000000000..46354fe38
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-cohesion.png differ
diff --git a/docs/advanced/figures/fault-examples/mohr-friction-build.gif b/docs/advanced/figures/fault-examples/mohr-friction-build.gif
new file mode 100644
index 000000000..c1b8e3a22
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-friction-build.gif differ
diff --git a/docs/advanced/figures/fault-examples/mohr-friction.png b/docs/advanced/figures/fault-examples/mohr-friction.png
new file mode 100644
index 000000000..1dd769024
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-friction.png differ
diff --git a/docs/advanced/figures/fault-examples/mohr-graded.png b/docs/advanced/figures/fault-examples/mohr-graded.png
new file mode 100644
index 000000000..e6edcafc8
Binary files /dev/null and b/docs/advanced/figures/fault-examples/mohr-graded.png differ
diff --git a/docs/advanced/figures/fault-examples/mohr_animate.py b/docs/advanced/figures/fault-examples/mohr_animate.py
new file mode 100644
index 000000000..ba47c43de
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/mohr_animate.py
@@ -0,0 +1,129 @@
+"""The Mohr circle, built frame by frame as the fault rotates.
+
+The teaching version of mohr_circle.py: the left panel shows the fault
+physically rotating in the box; the right panel shows its stress probe
+sweeping around the Mohr circle at TWICE the rate — the double-angle
+rule as motion, not as a formula. Each frame is a full welded-fault
+solve (the probes are measured, not drawn), assembled into a GIF.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+A_RATE, GAMMA = 0.5, 1.0
+R_ANALYTIC = common.ETA * np.sqrt(4 * A_RATE**2 + GAMMA**2)
+STEP = 7.5
+angles = np.arange(0.0, 180.0 + 1e-9, STEP)
+
+# The sweep is 25 welded-fault solves; cache it so iterating on the
+# animation's look does not re-measure the physics.
+cache = os.path.join(D, "_mohr_probes.npz")
+if os.path.exists(cache):
+    probes = np.load(cache)["probes"]
+    assert len(probes) == len(angles)
+    print(f"loaded {len(probes)} cached probes")
+else:
+    probes = []
+    for theta in angles:
+        sigma_n, tau = common.mohr_probe(theta, A_RATE, GAMMA,
+                                         half_length=HALF)
+        probes.append((theta, sigma_n, tau))
+        print(f"theta {theta:6.1f}: sigma_n {sigma_n:8.4f}  "
+              f"tau {tau:8.4f}")
+    probes = np.array(probes)
+    np.savez(cache, probes=probes)
+centre = float(np.mean(probes[:, 1]))
+# GEOLOGICAL convention on the stress plane: compression positive.
+# The left panel's traction vector stays in physical (tension-positive)
+# components; only the Mohr diagram flips.
+cg = -centre
+scg = -probes[:, 1]
+
+frames = []
+for k in range(len(probes)):
+    theta, sig_k, tau_k = probes[k]
+    fig, (axl, axr) = plt.subplots(
+        1, 2, figsize=(9.6, 4.6),
+        gridspec_kw=dict(width_ratios=[1.0, 1.25]))
+
+    # ---- left: the fault in the box -------------------------------------
+    axl.add_patch(plt.Rectangle((0, 0), 1, 1, fill=False, lw=1.0,
+                                edgecolor="0.4"))
+    t = np.array([np.cos(np.radians(theta)), np.sin(np.radians(theta))])
+    n = np.array([-t[1], t[0]])
+    c = common.CENTRE
+    axl.plot([c[0] - HALF * t[0], c[0] + HALF * t[0]],
+             [c[1] - HALF * t[1], c[1] + HALF * t[1]],
+             "-", color="#c62828", lw=2.5)
+    axl.annotate("", xytext=c, xy=c + 0.14 * n,
+                 arrowprops=dict(arrowstyle="->", lw=1.0, color="0.35"))
+    axl.text(*(c + 0.18 * n), r"$\hat n$", fontsize=9, ha="center",
+             color="0.35")
+    # the traction vector on the fault plane, from the MEASURED probe:
+    # purely normal (aligned with n-hat) exactly at the principal
+    # orientations — the same instant the probe crosses tau = 0
+    T = sig_k * n + tau_k * t
+    scale = 0.16 / R_ANALYTIC
+    axl.annotate("", xytext=c, xy=c + scale * T,
+                 arrowprops=dict(arrowstyle="-|>", lw=2.2,
+                                 color="#4a7bf7"))
+    axl.text(0.06, 0.9, rf"$\theta = {theta:.1f}°$", fontsize=12)
+    axl.text(0.06, 0.135, r"$\sigma\cdot\hat n$: traction on the plane",
+             fontsize=9, color="#4a7bf7", transform=axl.transAxes)
+    if abs(tau_k) < 0.05 * R_ANALYTIC:
+        axl.text(0.5, 0.06, "principal orientation: traction ∥ normal",
+                 fontsize=10, color="#c62828", ha="center",
+                 transform=axl.transAxes)
+    axl.set_xlim(-0.06, 1.06)
+    axl.set_ylim(-0.06, 1.06)
+    axl.set_aspect("equal")
+    axl.set_xticks([])
+    axl.set_yticks([])
+    axl.set_title("the (welded) fault rotates ...", fontsize=10)
+
+    # ---- right: the probe sweeps the circle, twice as fast --------------
+    tt = np.linspace(0, 2 * np.pi, 300)
+    axr.plot(cg + R_ANALYTIC * np.cos(tt), R_ANALYTIC * np.sin(tt),
+             "-", color="0.75", lw=0.9)
+    axr.axhline(0, color="0.8", lw=0.6)
+    axr.axvline(cg, color="0.8", lw=0.6)
+    axr.plot([cg - R_ANALYTIC, cg + R_ANALYTIC], [0, 0], "D",
+             ms=5, color="0.3", zorder=4)
+    axr.text(cg + R_ANALYTIC, -0.16 * R_ANALYTIC,
+             "principal\nstresses", fontsize=7, ha="center", va="top",
+             color="0.3")
+    axr.plot(scg[:k + 1], probes[:k + 1, 2], "o", ms=5,
+             mfc="none", mec="#c62828", mew=1.2)
+    axr.plot([cg, -sig_k], [0.0, tau_k], "-",
+             color="#4a7bf7", lw=1.2)
+    axr.plot([-sig_k], [tau_k], "o", ms=9, color="#c62828", zorder=5)
+    axr.text(0.04, 0.94, r"... its stress probe sweeps at $2\theta$",
+             fontsize=10, transform=axr.transAxes)
+    axr.set_xlabel(r"normal stress $\sigma$ (compression positive)")
+    axr.set_ylabel(r"shear traction $\tau$")
+    axr.set_xlim(cg - 1.35 * R_ANALYTIC, cg + 1.35 * R_ANALYTIC)
+    axr.set_ylim(-1.35 * R_ANALYTIC, 1.35 * R_ANALYTIC)
+    axr.set_aspect("equal")
+
+    fig.suptitle("Building the Mohr circle with a rotating fault",
+                 fontsize=11)
+    fig.tight_layout()
+    frame = os.path.join(D, f"_mohr_frame_{k:03d}.png")
+    fig.savefig(frame, dpi=110)
+    plt.close(fig)
+    frames.append(frame)
+
+images = [Image.open(f) for f in frames]
+out = os.path.join(D, "mohr-circle-build.gif")
+images[0].save(out, save_all=True, append_images=images[1:] +
+               [images[-1]] * 6,          # hold the completed circle
+               duration=280, loop=0)
+print("wrote", out, f"({len(frames)} frames)")
diff --git a/docs/advanced/figures/fault-examples/mohr_circle.py b/docs/advanced/figures/fault-examples/mohr_circle.py
new file mode 100644
index 000000000..f670ea0f2
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/mohr_circle.py
@@ -0,0 +1,87 @@
+"""The Mohr circle, measured by faults.
+
+A WELDED split fault transmits the full stress across itself, so it is
+a passive stress probe: the no-opening constraint's reaction gives the
+normal traction sigma_n, and the stiff interface dashpot reads the
+shear traction off its own law, tau = eta_f V. Sweeping the fault
+orientation theta and plotting (−sigma_n, |tau|) traces the Mohr
+circle of the ambient stress state — measured by the machinery itself,
+against the analytic circle of the imposed flow.
+
+Boundary conditions: Dirichlet velocity on all four walls imposing
+the homogeneous flow v = (a(x−c) + gamma(y−c), −a(y−c)) — a PURE-SHEAR
+(irrotational stretching) part a plus a SIMPLE-SHEAR part gamma.
+Stress sees only the symmetric gradient, so the state is equivalent to
+pure shear of magnitude R = eta sqrt(4 a^2 + gamma^2) with principal
+axes at 22.5 degrees to the box (deliberately not axis-aligned: the
+circle's orientation must be measured, not guessed). The linear flow
+is an exact homogeneous Stokes solution — constant stress, no wall
+boundary layers — and the centre sits at the (gauge-fixed) mean
+pressure, which the fit reports rather than assumes.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+A_RATE, GAMMA = 0.5, 1.0
+ETA_WELD = 200.0 * common.ETA / HALF        # welded: slip ~ tau/eta_f -> 0
+R_ANALYTIC = common.ETA * np.sqrt(4 * A_RATE**2 + GAMMA**2)
+
+angles = np.arange(0.0, 180.0 - 1e-9, 22.5)
+points = []
+for theta in angles:
+    sigma_n, tau = common.mohr_probe(theta, A_RATE, GAMMA,
+                                     eta_weld=ETA_WELD, half_length=HALF)
+    points.append((theta, sigma_n, tau))
+    print(f"theta {theta:5.1f}: sigma_n {sigma_n:8.4f}  tau {tau:7.4f}")
+
+points = np.array(points)
+# GEOLOGICAL sign convention for the stress plane: compression positive,
+# tension on the negative axis (the solver's tractions are
+# tension-positive; only the plot flips).
+points[:, 1] *= -1.0
+
+# circle fit: centre c on the sigma axis, radius R, from the probes
+sig, tau = points[:, 1], points[:, 2]
+c0 = float(np.mean(sig))
+for _ in range(60):                          # two-parameter Gauss fit
+    r = np.sqrt((sig - c0) ** 2 + tau ** 2)
+    R0 = r.mean()
+    c0 -= float(np.mean((c0 - sig) * (1 - R0 / np.maximum(r, 1e-30))))
+print(f"fit: centre {c0:.4f}, radius {R0:.4f} "
+      f"(analytic radius {R_ANALYTIC:.4f})")
+
+fig, ax = plt.subplots(figsize=(6.8, 4.8))
+tt = np.linspace(0, 2 * np.pi, 300)
+ax.plot(c0 + R_ANALYTIC * np.cos(tt), R_ANALYTIC * np.sin(tt), "k-",
+        lw=1.0, label=f"analytic circle, $R = {R_ANALYTIC:.3f}$")
+ax.plot(c0 + R0 * np.cos(tt), R0 * np.sin(tt), "--", lw=0.9,
+        color="#4a7bf7", label=f"fit through the probes, $R = {R0:.3f}$")
+ax.plot(sig, tau, "o", ms=6, color="#c62828", zorder=5,
+        label="welded-fault probes")
+ax.axvline(c0, color="0.6", lw=0.6)
+for theta, sg, tu in points:
+    ax.annotate(f"{theta:.0f}°", (sg, tu), textcoords="offset points",
+                xytext=(6, 5), fontsize=8)
+ax.axhline(0, color="0.6", lw=0.6)
+ax.set_xlabel(r"normal stress $\sigma$ (compression positive)")
+ax.set_ylabel(r"shear traction $\tau$")
+ax.set_title("The Mohr circle, measured by welded split-node faults")
+ax.set_aspect("equal")
+ax.legend(fontsize=8, loc="center")
+fig.tight_layout()
+out = os.path.join(D, "mohr-circle.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
+
+assert abs(R0 - R_ANALYTIC) < 0.06 * R_ANALYTIC, "radius off by > 6%"
diff --git a/docs/advanced/figures/fault-examples/mohr_cohesion.py b/docs/advanced/figures/fault-examples/mohr_cohesion.py
new file mode 100644
index 000000000..720f9870d
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/mohr_cohesion.py
@@ -0,0 +1,211 @@
+"""Cohesive Mohr-Coulomb: strength survives into the tensile sector.
+
+The cohesive sequel to mohr_friction: the fault's yield envelope is
+tau = +-(C + mu sigma) (compression positive), declining through mild
+tension and reaching ZERO at sigma = -C/mu. Three physical regimes and
+one UNPHYSICAL one appear as the fault rotates:
+
+- stuck (on the circle) — now around BOTH principal poles, because
+  cohesion holds shear through mild tension;
+- sliding, pinned to the declining envelope;
+- HELD SHUT — beyond sigma = -C/mu the strength is zero and the normal
+  stress is tensile: a real fault would OPEN, no static solution
+  exists, and the bilateral no-opening constraint manufactures one by
+  gluing the surfaces together (a tensile constraint reaction). The
+  solver converges; the physics has failed. Detect it from the SIGN of
+  the recovered normal traction.
+
+The law is not a canned option — it is registered as a sympy
+expression in the canonical symbols, which is the whole design: a new
+fault rheology is four lines.
+
+All Mohr figures on this page use the GEOLOGICAL sign convention:
+compression positive, tension on the negative axis.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import sympy
+from PIL import Image
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+A_RATE, GAMMA = 0.5, 1.0
+MU, C, V0 = 0.6, 0.6, 1e-4
+R_ANALYTIC = common.ETA * np.sqrt(4 * A_RATE**2 + GAMMA**2)
+STEP = 7.5
+angles = np.arange(0.0, 180.0 + 1e-9, STEP)
+
+
+def register_cohesive_law(stokes):
+    """Mohr-Coulomb with cohesion as a symbolic law. normal_stress is
+    the SIGNED effective normal stress (reaction-fed; negative in
+    tension), and the strength clamp is the law's own: Max(0, C + mu s)
+    declines through mild tension and vanishes at s = -C/mu."""
+    V = fault_contact.slip_rate
+    S = fault_contact.normal_stress
+    law = fault_contact.SymbolicFaultLaw(
+        sympy.Max(C + MU * S, 0) * (2 / sympy.pi) * sympy.atan(V / V0))
+    fault_contact.add_frictionless_fault_bc(stokes, "Fault")
+    fault_contact._register_law(stokes, "Fault", law)
+
+
+cache = os.path.join(D, "_mohr_cohesion_probes.npz")
+if os.path.exists(cache):
+    probes = np.load(cache)["probes"]
+    assert len(probes) == len(angles)
+    print(f"loaded {len(probes)} cached probes")
+else:
+    rows = []
+    for theta in angles:
+        child = common.split_with_fault(
+            common.base_mesh(0.04), common.fault_segment(theta, HALF))
+        stokes = common.stokes_on(
+            child, common.shear_plus_stretch(child, A_RATE, GAMMA))
+        register_cohesive_law(stokes)
+        fault_contact.solve_with_fault(stokes, picard=3)
+        s, V, _leak = common.slip_profile(stokes)
+        s_n, sig = common.normal_traction(stokes)
+        v_med = float(np.median(V[common.inner(s)]))
+        sigma_n = float(np.median(sig[common.inner(s_n)]))
+        strength = max(C + MU * (-sigma_n), 0.0)
+        tau = strength * (2 / np.pi) * np.arctan(v_med / V0)
+        rows.append((theta, sigma_n, tau, v_med))
+        print(f"theta {theta:6.1f}: sigma_n {sigma_n:8.4f}  "
+              f"tau {tau:8.4f}  V {v_med:9.5f}")
+    probes = np.array(rows)
+    np.savez(cache, probes=probes)
+
+# GEO convention for plotting: compression positive
+sc = -probes[:, 1]
+tau = probes[:, 2]
+# beyond sigma = -C/mu the strength is zero and the fault is in
+# tension: it would open — the constraint holds it shut (unphysical)
+held_shut = sc < -C / MU + 1e-6
+sliding = (np.abs(probes[:, 3]) > 5 * V0) & ~held_shut
+
+
+def draw_stress_plane(ax):
+    tt = np.linspace(0, 2 * np.pi, 300)
+    ax.plot(R_ANALYTIC * np.cos(tt), R_ANALYTIC * np.sin(tt),
+            "-", color="0.8", lw=0.9,
+            label="ambient stress (welded circle)")
+    s_env = np.linspace(-C / MU, 1.5 * R_ANALYTIC, 60)
+    for sgn in (+1, -1):
+        ax.plot(s_env, sgn * (C + MU * s_env), "--", color="0.35",
+                lw=1.0, label=(r"envelope $\tau = \pm(C + \mu\sigma)$,"
+                               r" zero at $\sigma = -C/\mu$"
+                               if sgn > 0 else None))
+    ax.axvspan(-1.6 * R_ANALYTIC, -C / MU, color="0.92", zorder=0)
+    ax.text(-1.5 * R_ANALYTIC, 1.1 * R_ANALYTIC,
+            "fault would open:\nno static solution\n(held shut by the\n"
+            "no-opening constraint)", fontsize=7.5, va="top",
+            color="0.35")
+    ax.axhline(0, color="0.85", lw=0.6)
+    ax.axvline(0, color="0.85", lw=0.6)
+    ax.set_xlabel(r"normal stress $\sigma$ (compression positive)")
+    ax.set_ylabel(r"shear traction $\tau$")
+    ax.set_xlim(-1.6 * R_ANALYTIC, 1.6 * R_ANALYTIC)
+    ax.set_ylim(-1.35 * R_ANALYTIC, 1.35 * R_ANALYTIC)
+    ax.set_aspect("equal")
+
+
+fig, ax = plt.subplots(figsize=(7.6, 5.4))
+draw_stress_plane(ax)
+stuck = ~sliding & ~held_shut
+ax.plot(sc[stuck], tau[stuck], "o", ms=7, color="#c62828",
+        label="stuck: on the circle", zorder=5)
+ax.plot(sc[sliding], tau[sliding], "s", ms=6, color="#d9960a",
+        label="sliding: on the envelope", zorder=5)
+ax.plot(sc[held_shut], tau[held_shut], "x", ms=8, mew=2.0,
+        color="0.45", label="held shut (unphysical)", zorder=5)
+ax.legend(fontsize=8, loc="lower right")
+ax.set_title(rf"Cohesive Mohr-Coulomb fault, $C = {C}$, $\mu = {MU}$")
+fig.tight_layout()
+out = os.path.join(D, "mohr-cohesion.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
+
+# ---- the animated build ------------------------------------------------------
+frames = []
+for k in range(len(probes)):
+    theta, sig_k, tau_k, v_k = probes[k]
+    shut_k = bool(held_shut[k])
+    slide_k = (abs(v_k) > 5 * V0) and not shut_k
+    fig, (axl, axr) = plt.subplots(
+        1, 2, figsize=(9.6, 4.6),
+        gridspec_kw=dict(width_ratios=[1.0, 1.25]))
+
+    axl.add_patch(plt.Rectangle((0, 0), 1, 1, fill=False, lw=1.0,
+                                edgecolor="0.4"))
+    t = np.array([np.cos(np.radians(theta)), np.sin(np.radians(theta))])
+    n = np.array([-t[1], t[0]])
+    c = common.CENTRE
+    axl.plot([c[0] - HALF * t[0], c[0] + HALF * t[0]],
+             [c[1] - HALF * t[1], c[1] + HALF * t[1]],
+             "-", color="#c62828", lw=2.5)
+    T = sig_k * n + tau_k * t
+    scale = 0.16 / R_ANALYTIC
+    axl.annotate("", xytext=c, xy=c + scale * T,
+                 arrowprops=dict(arrowstyle="-|>", lw=2.2,
+                                 color="#4a7bf7"))
+    if slide_k:
+        off = 0.035 * n
+        sgn = np.sign(v_k)
+        for pm in (+1, -1):
+            axl.annotate("", xytext=c + pm * off - pm * sgn * 0.09 * t,
+                         xy=c + pm * off + pm * sgn * 0.09 * t,
+                         arrowprops=dict(arrowstyle="->", lw=1.4,
+                                         color="#d9960a"))
+    axl.text(0.06, 0.9, rf"$\theta = {theta:.1f}°$", fontsize=12)
+    status, scol = (("HELD SHUT (unphysical)", "0.45") if shut_k
+                    else ("SLIDING", "#d9960a") if slide_k
+                    else ("stuck", "#c62828"))
+    axl.text(0.06, 0.82, status, fontsize=10, color=scol)
+    axl.set_xlim(-0.06, 1.06)
+    axl.set_ylim(-0.06, 1.06)
+    axl.set_aspect("equal")
+    axl.set_xticks([])
+    axl.set_yticks([])
+    axl.set_title(rf"cohesive fault, $C = {C}$, $\mu = {MU}$ ...",
+                  fontsize=10)
+
+    draw_stress_plane(axr)
+    axr.legend(fontsize=7, loc="lower right")
+    stuck_prev = (~sliding & ~held_shut)[:k + 1]
+    slide_prev = sliding[:k + 1]
+    shut_prev = held_shut[:k + 1]
+    axr.plot(sc[:k + 1][stuck_prev], tau[:k + 1][stuck_prev], "o", ms=5,
+             mfc="none", mec="#c62828", mew=1.2)
+    axr.plot(sc[:k + 1][slide_prev], tau[:k + 1][slide_prev], "s", ms=5,
+             mfc="none", mec="#d9960a", mew=1.2)
+    axr.plot(sc[:k + 1][shut_prev], tau[:k + 1][shut_prev], "x", ms=6,
+             mew=1.6, color="0.45")
+    mark, mcol = (("x", "0.45") if shut_k else
+                  ("s", "#d9960a") if slide_k else ("o", "#c62828"))
+    axr.plot([sc[k]], [tau[k]], mark, ms=9, mew=2.2, color=mcol,
+             zorder=6)
+    axr.set_title("... strength declines to zero, then the fault "
+                  "would open", fontsize=10)
+
+    fig.suptitle("Cohesion keeps more of the Mohr circle", fontsize=11)
+    fig.tight_layout()
+    frame = os.path.join(D, f"_mohrc_frame_{k:03d}.png")
+    fig.savefig(frame, dpi=110)
+    plt.close(fig)
+    frames.append(frame)
+
+images = [Image.open(f) for f in frames]
+out = os.path.join(D, "mohr-cohesion-build.gif")
+images[0].save(out, save_all=True,
+               append_images=images[1:] + [images[-1]] * 6,
+               duration=280, loop=0)
+print("wrote", out, f"({len(frames)} frames)")
diff --git a/docs/advanced/figures/fault-examples/mohr_friction.py b/docs/advanced/figures/fault-examples/mohr_friction.py
new file mode 100644
index 000000000..a4731bbaf
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/mohr_friction.py
@@ -0,0 +1,204 @@
+"""The Mohr circle meets the friction envelope.
+
+The frictional sequel to mohr_circle/mohr_animate: the same rotating
+fault, but now carrying Coulomb friction with reaction-fed normal
+stress. Three regimes appear as the fault rotates:
+
+- STUCK — the ambient resolved stress lies inside the envelope
+  |tau| < mu |sigma_n| (compressive side): the fault transmits the
+  full stress and its probe sits ON the Mohr circle;
+- SLIDING — the ambient stress would exceed the envelope: the fault
+  slips, drops the shear traction to its strength, and the probe is
+  pinned to the yield line tau = ±mu |sigma_n|;
+- HELD SHUT — under tensile normal stress bare friction has no
+  strength: a real fault would OPEN, no static solution exists, and
+  the bilateral no-opening constraint manufactures one by gluing the
+  surfaces (tensile reaction). The solver converges; the physics has
+  failed. The probes ride the axis at tau = 0, marked as unphysical.
+
+sigma_n comes from the no-opening constraint's reaction; tau is read
+from the Coulomb law at the measured slip rate — exact in both
+regimes, because the regularised law IS the traction the fault
+carries. Outputs: a static summary figure and the animated build.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+from PIL import Image
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+A_RATE, GAMMA = 0.5, 1.0
+MU, V0 = 0.7, 1e-4
+R_ANALYTIC = common.ETA * np.sqrt(4 * A_RATE**2 + GAMMA**2)
+STEP = 7.5
+angles = np.arange(0.0, 180.0 + 1e-9, STEP)
+
+cache = os.path.join(D, "_mohr_friction_probes.npz")
+if os.path.exists(cache):
+    probes = np.load(cache)["probes"]
+    assert len(probes) == len(angles)
+    print(f"loaded {len(probes)} cached probes")
+else:
+    rows = []
+    for theta in angles:
+        child = common.split_with_fault(
+            common.base_mesh(0.04), common.fault_segment(theta, HALF))
+        stokes = common.stokes_on(
+            child, common.shear_plus_stretch(child, A_RATE, GAMMA))
+        fault_contact.add_coulomb_fault_bc(stokes, MU, "Fault",
+                                           sigma_n="reaction", V0=V0)
+        fault_contact.solve_with_fault(stokes, picard=3)
+        s, V, _leak = common.slip_profile(stokes)
+        s_n, sig = common.normal_traction(stokes)
+        v_med = float(np.median(V[common.inner(s)]))
+        sigma_n = float(np.median(sig[common.inner(s_n)]))
+        sigma_eff = max(-sigma_n, 0.0)
+        tau = MU * sigma_eff * (2 / np.pi) * np.arctan(v_med / V0)
+        rows.append((theta, sigma_n, tau, v_med))
+        print(f"theta {theta:6.1f}: sigma_n {sigma_n:8.4f}  "
+              f"tau {tau:8.4f}  V {v_med:9.5f}")
+    probes = np.array(rows)
+    np.savez(cache, probes=probes)
+
+centre = 0.0                        # the welded sweep's measured gauge
+# GEOLOGICAL convention on the stress plane: compression positive.
+scg = -probes[:, 1]
+# bare friction: strength vanishes the moment the stress turns tensile
+held_shut = scg < -1e-6
+sliding = (np.abs(probes[:, 3]) > 5 * V0) & ~held_shut
+
+
+def draw_stress_plane(ax):
+    tt = np.linspace(0, 2 * np.pi, 300)
+    ax.plot(centre + R_ANALYTIC * np.cos(tt), R_ANALYTIC * np.sin(tt),
+            "-", color="0.8", lw=0.9,
+            label="ambient stress (welded circle)")
+    ss = np.linspace(0, 1.35 * R_ANALYTIC, 50)
+    for sgn in (+1, -1):
+        ax.plot(ss, sgn * MU * ss, "--", color="0.35", lw=1.0,
+                label=(r"friction envelope $\tau = \pm\mu\sigma$"
+                       if sgn > 0 else None))
+    ax.axhline(0, color="0.85", lw=0.6)
+    ax.axvline(centre, color="0.85", lw=0.6)
+    ax.axvspan(-1.6 * R_ANALYTIC, 0, color="0.92", zorder=0)
+    ax.text(-1.45 * R_ANALYTIC, 1.1 * R_ANALYTIC,
+            "fault would open:\nno static solution\n(held shut by the\n"
+            "no-opening constraint)", fontsize=7.5, va="top",
+            color="0.35")
+    ax.set_xlabel(r"normal stress $\sigma$ (compression positive)")
+    ax.set_ylabel(r"shear traction $\tau$")
+    ax.set_xlim(centre - 1.5 * R_ANALYTIC, centre + 1.5 * R_ANALYTIC)
+    ax.set_ylim(-1.35 * R_ANALYTIC, 1.35 * R_ANALYTIC)
+    ax.set_aspect("equal")
+
+
+# ---- the static summary -----------------------------------------------------
+fig, ax = plt.subplots(figsize=(7.2, 5.4))
+draw_stress_plane(ax)
+stuck = ~sliding & ~held_shut
+ax.plot(scg[stuck], probes[stuck, 2], "o", ms=7,
+        color="#c62828", label="stuck: on the circle", zorder=5)
+ax.plot(scg[sliding], probes[sliding, 2], "s", ms=6,
+        color="#d9960a", label="sliding: on the envelope", zorder=5)
+ax.plot(scg[held_shut], probes[held_shut, 2], "x", ms=8, mew=2.0,
+        color="0.45", label="held shut (unphysical)", zorder=5)
+ax.legend(fontsize=8, loc="upper left")
+ax.set_title(rf"Coulomb fault probes, $\mu = {MU}$: "
+             "the stress switches to the yield envelope")
+fig.tight_layout()
+out = os.path.join(D, "mohr-friction.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
+
+# ---- the animated build ------------------------------------------------------
+frames = []
+for k in range(len(probes)):
+    theta, sig_k, tau_k, v_k = probes[k]
+    shut_k = bool(held_shut[k])
+    slide_k = (abs(v_k) > 5 * V0) and not shut_k
+    fig, (axl, axr) = plt.subplots(
+        1, 2, figsize=(9.6, 4.6),
+        gridspec_kw=dict(width_ratios=[1.0, 1.25]))
+
+    axl.add_patch(plt.Rectangle((0, 0), 1, 1, fill=False, lw=1.0,
+                                edgecolor="0.4"))
+    t = np.array([np.cos(np.radians(theta)), np.sin(np.radians(theta))])
+    n = np.array([-t[1], t[0]])
+    c = common.CENTRE
+    axl.plot([c[0] - HALF * t[0], c[0] + HALF * t[0]],
+             [c[1] - HALF * t[1], c[1] + HALF * t[1]],
+             "-", color="#c62828", lw=2.5)
+    axl.annotate("", xytext=c, xy=c + 0.14 * n,
+                 arrowprops=dict(arrowstyle="->", lw=1.0, color="0.35"))
+    axl.text(*(c + 0.18 * n), r"$\hat n$", fontsize=9, ha="center",
+             color="0.35")
+    T = sig_k * n + tau_k * t
+    scale = 0.16 / R_ANALYTIC
+    axl.annotate("", xytext=c, xy=c + scale * T,
+                 arrowprops=dict(arrowstyle="-|>", lw=2.2,
+                                 color="#4a7bf7"))
+    if slide_k:
+        # half-arrows for the slip sense
+        off = 0.035 * n
+        sgn = np.sign(v_k)
+        for pm in (+1, -1):
+            axl.annotate("", xytext=c + pm * off - pm * sgn * 0.09 * t,
+                         xy=c + pm * off + pm * sgn * 0.09 * t,
+                         arrowprops=dict(arrowstyle="->", lw=1.4,
+                                         color="#d9960a"))
+    axl.text(0.06, 0.9, rf"$\theta = {theta:.1f}°$", fontsize=12)
+    status, scol = (("HELD SHUT (unphysical)", "0.45") if shut_k
+                    else ("SLIDING", "#d9960a") if slide_k
+                    else ("stuck", "#c62828"))
+    axl.text(0.06, 0.82, status, fontsize=10, color=scol)
+    axl.text(0.06, 0.135, r"$\sigma\cdot\hat n$: traction on the plane",
+             fontsize=9, color="#4a7bf7", transform=axl.transAxes)
+    axl.set_xlim(-0.06, 1.06)
+    axl.set_ylim(-0.06, 1.06)
+    axl.set_aspect("equal")
+    axl.set_xticks([])
+    axl.set_yticks([])
+    axl.set_title(rf"Coulomb fault, $\mu = {MU}$, rotating ...",
+                  fontsize=10)
+
+    draw_stress_plane(axr)
+    axr.legend(fontsize=7, loc="upper left")
+    stuck_prev = (~sliding & ~held_shut)[:k + 1]
+    slide_prev = sliding[:k + 1]
+    shut_prev = held_shut[:k + 1]
+    axr.plot(scg[:k + 1][stuck_prev], probes[:k + 1][stuck_prev, 2],
+             "o", ms=5, mfc="none", mec="#c62828", mew=1.2)
+    axr.plot(scg[:k + 1][slide_prev], probes[:k + 1][slide_prev, 2],
+             "s", ms=5, mfc="none", mec="#d9960a", mew=1.2)
+    axr.plot(scg[:k + 1][shut_prev], probes[:k + 1][shut_prev, 2],
+             "x", ms=6, mew=1.6, color="0.45")
+    mark, mcol = (("x", "0.45") if shut_k else
+                  ("s", "#d9960a") if slide_k else ("o", "#c62828"))
+    axr.plot([-sig_k], [tau_k], mark, ms=9, mew=2.2, color=mcol,
+             zorder=6)
+    axr.set_title("... its traction cannot leave the envelope",
+                  fontsize=10)
+
+    fig.suptitle("A frictional fault against the Mohr circle",
+                 fontsize=11)
+    fig.tight_layout()
+    frame = os.path.join(D, f"_mohrf_frame_{k:03d}.png")
+    fig.savefig(frame, dpi=110)
+    plt.close(fig)
+    frames.append(frame)
+
+images = [Image.open(f) for f in frames]
+out = os.path.join(D, "mohr-friction-build.gif")
+images[0].save(out, save_all=True,
+               append_images=images[1:] + [images[-1]] * 6,
+               duration=280, loop=0)
+print("wrote", out, f"({len(frames)} frames)")
diff --git a/docs/advanced/figures/fault-examples/mohr_graded.py b/docs/advanced/figures/fault-examples/mohr_graded.py
new file mode 100644
index 000000000..c2d1fde97
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/mohr_graded.py
@@ -0,0 +1,130 @@
+"""The graded fault: depth-dependent strength sampled along one fault.
+
+Gravity joins the Mohr experiment. With constant density and closed
+(velocity-Dirichlet) walls the flow is untouched — pressure absorbs the
+body force exactly — but the WELDED fault's per-node probes now sample
+the hydrostatic gradient: every node sits at its own depth, so each
+fault orientation contributes a horizontal STREAK of points in the
+(sigma, tau) plane rather than a single value. The streak is longest
+for the vertical fault (largest depth range along the fault), a single
+dot for the horizontal one, and the whole cloud scatters about the
+family of Mohr circles between the shallowest and deepest fault points.
+
+The per-node sampling is native: sigma_n comes from the no-opening
+reaction de-smeared NODE BY NODE, and tau from the weld's own law
+tau = eta_f V(s) at each node — nothing is averaged.
+
+Gauge: a closed box fixes pressure only up to a constant (the solver
+uses a mean-zero gauge). The plot re-anchors it so p = 0 at the top
+surface — the shift is exactly rho g H / 2, known analytically, and is
+applied to the plotted sigma only.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+import underworld3 as uw
+from underworld3.utilities import fault_contact
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+A_RATE, GAMMA = 0.5, 1.0
+RHO_G = 0.75                       # modest: streaks visible, circle intact
+ETA_WELD = 200.0 * common.ETA / HALF
+R_ANALYTIC = common.ETA * np.sqrt(4 * A_RATE**2 + GAMMA**2)
+
+angles = np.arange(0.0, 180.0 - 1e-9, 22.5)
+
+cache = os.path.join(D, "_mohr_graded_probes.npz")
+if os.path.exists(cache):
+    d = np.load(cache)
+    theta_all, y_all, sig_all, tau_all = (d["theta"], d["y"], d["sig"],
+                                          d["tau"])
+    print(f"loaded {len(sig_all)} cached node probes")
+else:
+    theta_all, y_all, sig_all, tau_all = [], [], [], []
+    for theta in angles:
+        child = common.split_with_fault(
+            common.base_mesh(0.04), common.fault_segment(theta, HALF))
+        stokes = common.stokes_on(
+            child, common.shear_plus_stretch(child, A_RATE, GAMMA))
+        stokes.bodyforce = [0.0, -RHO_G]
+        stokes.add_fault_bc(ETA_WELD, boundary="Fault")
+        fault_contact.solve_with_fault(stokes, picard=2)
+
+        # per-NODE probes, matched by the along-fault coordinate
+        coords, jumps, normals = fault_contact.fault_pair_jumps(
+            stokes, "Fault", stokes._rotated_freeslip_info)
+        t_hat = np.array([np.cos(np.radians(theta)),
+                          np.sin(np.radians(theta))])
+        s_v = (coords - common.CENTRE) @ t_hat
+        order_v = np.argsort(s_v)
+        V = (jumps @ t_hat)[order_v]
+        y = coords[order_v, 1]
+        s_n, sig = common.normal_traction(stokes)
+        assert len(sig) == len(V), "pair-node sets disagree"
+        mid = common.inner(s_v[order_v])
+        theta_all.extend([theta] * int(mid.sum()))
+        y_all.extend(y[mid])
+        sig_all.extend(sig[mid])
+        tau_all.extend(ETA_WELD * V[mid])
+        print(f"theta {theta:6.1f}: {int(mid.sum())} nodes, "
+              f"sigma_n [{sig[mid].min():.3f}, {sig[mid].max():.3f}]")
+    theta_all, y_all, sig_all, tau_all = (np.array(theta_all),
+                                          np.array(y_all),
+                                          np.array(sig_all),
+                                          np.array(tau_all))
+    np.savez(cache, theta=theta_all, y=y_all, sig=sig_all, tau=tau_all)
+
+# GEO convention + the top-zero pressure anchor (mean-zero solver gauge
+# shifted by the known rho g H / 2)
+sc = -sig_all + RHO_G * 0.5
+depth = 1.0 - y_all
+
+fig, ax = plt.subplots(figsize=(7.8, 5.6))
+# the family of circles between the shallowest and deepest fault points:
+# fault nodes span y in [0.3, 0.7] -> pressure rho g (1 - y)
+tt = np.linspace(0, 2 * np.pi, 300)
+for pshift, style in ((RHO_G * 0.3, ":"), (RHO_G * 0.5, "-"),
+                      (RHO_G * 0.7, ":")):
+    ax.plot(pshift + R_ANALYTIC * np.cos(tt), R_ANALYTIC * np.sin(tt),
+            style, color="0.75", lw=0.9,
+            label=("Mohr circles: shallowest / centre / deepest"
+                   if style == "-" else None))
+ax.axhline(0, color="0.85", lw=0.6)
+ax.axvline(0, color="0.85", lw=0.6)
+
+pts = ax.scatter(sc, tau_all, c=depth, cmap="viridis", s=22, zorder=5,
+                 edgecolors="none")
+fig.colorbar(pts, ax=ax, label="depth below surface", shrink=0.8)
+
+# annotate one streak: the vertical fault has the largest depth range
+vert = theta_all == 90.0
+if vert.any():
+    ax.annotate("one fault (90°):\na streak, not a point",
+                xy=(sc[vert].min(), tau_all[vert].mean()),
+                xytext=(-1.30, -1.30), fontsize=8, ha="left",
+                arrowprops=dict(arrowstyle="->", lw=0.8, color="0.3"))
+flat = theta_all == 0.0
+if flat.any():
+    ax.annotate("horizontal fault (0°):\none depth, one point",
+                xy=(sc[flat].mean(), tau_all[flat].mean()),
+                xytext=(-1.15, 1.22), fontsize=8, ha="center",
+                arrowprops=dict(arrowstyle="->", lw=0.8, color="0.3"))
+
+ax.set_xlabel(r"normal stress $\sigma$ (compression positive, "
+              r"$p = 0$ at the surface)")
+ax.set_ylabel(r"shear traction $\tau$")
+ax.set_title(rf"The graded fault: hydrostatic load $\rho g = {RHO_G}$, "
+             "per-node probes")
+ax.set_aspect("equal")
+ax.legend(fontsize=8, loc="center")
+fig.tight_layout()
+out = os.path.join(D, "mohr-graded.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
diff --git a/docs/advanced/figures/fault-examples/orientations.png b/docs/advanced/figures/fault-examples/orientations.png
new file mode 100644
index 000000000..ae9ebd2a1
Binary files /dev/null and b/docs/advanced/figures/fault-examples/orientations.png differ
diff --git a/docs/advanced/figures/fault-examples/orientations.py b/docs/advanced/figures/fault-examples/orientations.py
new file mode 100644
index 000000000..4b2e9c148
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/orientations.py
@@ -0,0 +1,62 @@
+"""Fault orientation vs slip: the Mohr circle's other face.
+
+The same orientation sweep as the Mohr demo, but with FRICTIONLESS
+faults under pure simple shear: each fault drops the shear stress
+resolved on its own plane, so the peak slip rate follows the resolved
+shear tau(theta) = tau_infty cos(2 theta) — the slip-rate version of
+reading the Mohr circle. Faults near 45 degrees to the shear plane
+barely slip; the fault aligned with it slips fully.
+"""
+import os
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+
+import underworld3 as uw
+
+import common
+
+D = os.path.dirname(os.path.abspath(__file__))
+HALF = 0.2
+
+angles = np.arange(0.0, 90.0 + 1e-9, 15.0)
+peaks, profiles = [], []
+for theta in angles:
+    child = common.split_with_fault(
+        common.base_mesh(0.04), common.fault_segment(theta, HALF))
+    stokes = common.stokes_on(child, common.simple_shear(child))
+    stokes.add_fault_bc(0, boundary="Fault")
+    stokes.solve(verbose=False)
+    s, V, leak = common.slip_profile(stokes)
+    assert np.abs(leak).max() < 1e-10
+    peaks.append(np.abs(V).max())
+    profiles.append((theta, s - s.min() - HALF, np.abs(V)))
+    print(f"theta {theta:5.1f}: peak slip {peaks[-1]:.4f}")
+
+peaks = np.array(peaks)
+
+fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10.4, 4.4))
+cmap = plt.cm.magma
+for (theta, s, V) in profiles:
+    ax1.plot(s, V, ".-", ms=3, lw=0.9, color=cmap(theta / 120.0),
+             label=f"{theta:.0f}°")
+ax1.set_xlabel("position along the fault $s$")
+ax1.set_ylabel("slip rate $|V(s)|$")
+ax1.set_title("frictionless slip profiles by orientation")
+ax1.legend(fontsize=8, title="fault angle", ncol=2)
+
+tt = np.linspace(0, 90, 200)
+ax2.plot(tt, np.abs(np.cos(np.radians(2 * tt))) * peaks[0], "k-",
+         lw=1.0, label=r"$|\cos 2\theta|$ (resolved shear)")
+ax2.plot(angles, peaks, "o", ms=6, color="#c62828",
+         label="measured peak slip")
+ax2.set_xlabel(r"fault angle $\theta$ to the shear plane")
+ax2.set_ylabel("peak slip rate")
+ax2.set_title("peak slip follows the resolved shear stress")
+ax2.legend(fontsize=8)
+fig.tight_layout()
+out = os.path.join(D, "orientations.png")
+fig.savefig(out, dpi=200)
+print("wrote", out)
diff --git a/docs/advanced/figures/fault-examples/true-branch-stress.png b/docs/advanced/figures/fault-examples/true-branch-stress.png
new file mode 100644
index 000000000..d33cdb1f2
Binary files /dev/null and b/docs/advanced/figures/fault-examples/true-branch-stress.png differ
diff --git a/docs/advanced/figures/fault-examples/true-branch.png b/docs/advanced/figures/fault-examples/true-branch.png
new file mode 100644
index 000000000..e8e918d00
Binary files /dev/null and b/docs/advanced/figures/fault-examples/true-branch.png differ
diff --git a/docs/advanced/figures/fault-examples/true_branch.py b/docs/advanced/figures/fault-examples/true_branch.py
new file mode 100644
index 000000000..8036821e0
--- /dev/null
+++ b/docs/advanced/figures/fault-examples/true_branch.py
@@ -0,0 +1,240 @@
+"""A true Y-branch, bracketed: does the near-miss tributary capture it?
+
+A genuine branch (three arms meeting at a point) cannot be split — but
+it can be DECOMPOSED two ways, and the pair brackets the truth:
+
+- A: the TRUNK is continuous (west + east arms as one fault); the
+  splay abuts, stopping a ligament short.
+- B: the BENT fault is continuous (west arm + splay as one deliberately
+  kinked polyline — the kink response is the physics, so no smoothed
+  normal); the east arm abuts.
+
+Each decomposition welds a different pair of arms through the junction
+and feeds the third across a ligament. If both give the same slip on
+every arm at a small gap, the offset representation reproduces the true
+branch; sweeping the gap in decomposition A shows how close "close by"
+has to be. All three arms slip freely under the same drive.
+"""
+import os
+import time
+
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+from underworld3.meshing.surfaces import prepare_fault_network
+from underworld3.utilities import fault_contact
+
+import common
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+H = 0.012
+MU_P = 0.4
+TREND = np.degrees(np.arctan2(0.10, 0.70))
+
+J = np.array([0.50, 0.50])                       # the branch point
+W_END = np.array([0.15, 0.45])
+E_END = np.array([0.85, 0.55])
+S_END = np.array([0.80, 0.76])
+ARMS = {"west": (W_END - J) / np.linalg.norm(W_END - J),
+        "east": (E_END - J) / np.linalg.norm(E_END - J),
+        "splay": (S_END - J) / np.linalg.norm(S_END - J)}
+
+
+def decomposition(kind, lig):
+    if kind == "A":                              # trunk continuous
+        faults = [("Trunk", np.array([W_END, E_END])),
+                  ("Splay", np.array([J, S_END]))]
+        through = ["Trunk"]
+    else:                                        # bent fault continuous
+        faults = [("Bent", np.array([W_END, J, S_END])),
+                  ("East", np.array([J, E_END]))]
+        through = ["Bent"]
+    return prepare_fault_network(faults, spacing=H, ligament=lig,
+                                 through=through, verbose=False)
+
+
+ETA_WELD = 200.0 * common.ETA / 0.2
+
+
+def _stress_p0(child, stokes, tagc):
+    x, y = child.X
+    v, p = stokes.Unknowns.u, stokes.Unknowns.p
+    comps = {}
+    for cname, expr in (
+            ("sxx", -p.sym[0] + 2 * common.ETA * v.sym[0].diff(x)),
+            ("syy", -p.sym[0] + 2 * common.ETA * v.sym[1].diff(y)),
+            ("sxy", common.ETA * (v.sym[0].diff(y) + v.sym[1].diff(x)))):
+        s_var = uw.discretisation.MeshVariable(f"{cname}_{tagc}", child, 1,
+                                               degree=0, continuous=False)
+        proj = uw.systems.Projection(child, s_var)
+        proj.uw_function = expr
+        proj.smoothing = 0.0
+        proj.solve()
+        row = common.split_mesh_cell_rows(child, s_var)
+        comps[cname] = np.asarray(s_var.data[:, 0])[row].copy()
+    return comps
+
+
+def run(tag, prepared, want_field=False):
+    child = common.base_mesh(H).add_fault(prepared)
+    stokes = common.stokes_on(
+        child, common.boundary_simple_shear(child, TREND))
+    for n, _p in prepared:
+        stokes.add_fault_bc(0, boundary=n)
+    t0 = time.perf_counter()
+    fault_contact.solve_with_fault(stokes, picard=2)
+
+    field = None
+    if want_field:
+        c1 = _stress_p0(child, stokes, f"a{run.n}")
+        s0 = common.stokes_on(
+            child, common.boundary_simple_shear(child, TREND))
+        for n, _p in prepared:
+            s0.add_fault_bc(ETA_WELD, boundary=n)
+        fault_contact.solve_with_fault(s0, picard=2)
+        c0 = _stress_p0(child, s0, f"b{run.n}")
+        run.n += 1
+        beta = np.radians(TREND)
+        nx, ny = -np.sin(beta), np.cos(beta)
+        tx, ty = np.cos(beta), np.sin(beta)
+
+        def resolve(c):
+            s_nn = (c["sxx"] * nx * nx + 2 * c["sxy"] * nx * ny
+                    + c["syy"] * ny * ny)
+            s_t = (c["sxx"] * tx * nx + c["sxy"] * (tx * ny + ty * nx)
+                   + c["syy"] * ty * ny)
+            return s_nn, s_t
+
+        nn0, t_0 = resolve(c0)
+        nn1, t_1 = resolve(c1)
+        dcff = np.sign(np.median(t_0)) * (t_1 - t_0) + MU_P * (nn1 - nn0)
+        pts, faces = common.split_mesh_cell_render(child)
+        fc = np.asarray(faces).reshape(-1, 4)[:, 1:]
+        cent = np.asarray(pts)[fc].mean(axis=1)
+        dcff, gauge = common.far_field_anchor(
+            cent, dcff, [p for _n, p in prepared], cut=0.18)
+        print(f"[{tag}] gauge {gauge:+.4f}", flush=True)
+        field = (pts, faces, dcff)
+    arms = {k: ([], []) for k in ARMS}
+    for n, _p in prepared:
+        coords, jumps, normals = fault_contact.fault_pair_jumps(
+            stokes, n, stokes._rotated_freeslip_info)
+        if not len(coords):
+            continue
+        tang = np.column_stack([-normals[:, 1], normals[:, 0]])
+        V = np.abs(np.einsum("ij,ij->i", jumps, tang))
+        R = coords - J
+        # classify each pair node by the arm it lies along
+        proj = {k: R @ t for k, t in ARMS.items()}
+        dist2 = {k: np.einsum("ij,ij->i", R - np.outer(
+            np.clip(proj[k], 0, None), ARMS[k]),
+            R - np.outer(np.clip(proj[k], 0, None), ARMS[k]))
+            for k in ARMS}
+        best = np.argmin(np.vstack([dist2[k] for k in ARMS]), axis=0)
+        for i, k in enumerate(ARMS):
+            sel = best == i
+            arms[k][0].extend(proj[k][sel])
+            arms[k][1].extend(V[sel])
+    out = {}
+    for k in ARMS:
+        s = np.asarray(arms[k][0])
+        v = np.asarray(arms[k][1])
+        order = np.argsort(s)
+        out[k] = (s[order], v[order])
+    print(f"[{tag}] peaks " + "  ".join(
+        f"{k} {out[k][1].max():.4f}" for k in ARMS)
+        + f"  ({time.perf_counter() - t0:.1f} s)", flush=True)
+    return out, field, prepared
+
+
+run.n = 0
+
+cases = [("A, gap 1h", "A", 1.0, "#1565c0", "-"),
+         ("A, gap 2h", "A", 2.0, "#64b5f6", "--"),
+         ("A, gap 4h", "A", 4.0, "#b3d7f7", ":"),
+         ("B, gap 1h", "B", 1.0, "#c62828", "-")]
+profiles, fields = {}, {}
+for tag, kind, lig, _c, _ls in cases:
+    prepared, _rep = decomposition(kind, lig)
+    want = tag in ("A, gap 1h", "B, gap 1h")
+    profiles[tag], field, prep = run(tag, prepared, want_field=want)
+    if field is not None:
+        fields[tag] = (field, prep)
+
+fig, axes = plt.subplots(1, 3, figsize=(13.2, 4.3), sharey=True)
+for ax, arm in zip(axes, ("west", "east", "splay")):
+    for tag, _k, _l, col, ls in cases:
+        s, v = profiles[tag][arm]
+        ax.plot(s, v, ls, lw=1.4, color=col, label=tag)
+    ax.set_title(f"the {arm} arm", fontsize=10.5)
+    ax.set_xlabel("distance from the branch point")
+axes[0].set_ylabel("|slip|")
+axes[0].legend(fontsize=8, title="decomposition, ligament")
+fig.suptitle(
+    "One true Y-branch, two decompositions: continuous-trunk (A) vs "
+    "continuous-bend (B).\nAgreement between A and B at small gap = the "
+    "near-miss tributary reproduces the true branch", fontsize=10.5)
+fig.tight_layout()
+out = os.path.join(D, "true-branch.png")
+fig.savefig(out, dpi=200)
+print("wrote", out, flush=True)
+
+# ---- the stress maps: the kink-lock made visible ---------------------------
+
+
+def render(field, prepared, png, scale, focal):
+    pts, faces, dcff = field
+    pvm = pv.PolyData(np.asarray(pts, dtype=float),
+                      faces=np.asarray(faces, dtype=np.int64))
+    pvm.cell_data["dcff"] = dcff
+    pl = pv.Plotter(off_screen=True, window_size=(850, 800))
+    pl.set_background("white")
+    pl.add_mesh(pvm, scalars="dcff", cmap="RdBu_r", clim=(-1.0, 1.0),
+                lighting=False, show_scalar_bar=False)
+    for n, p in prepared:
+        line = pv.lines_from_points(
+            np.column_stack([p, np.full(len(p), 1e-3)]))
+        pl.add_mesh(line, color="black", line_width=4, lighting=False)
+    pl.view_xy()
+    pl.camera.parallel_projection = True
+    pl.camera.parallel_scale = scale
+    pl.camera.focal_point = (focal[0], focal[1], 0.0)
+    pl.screenshot(png)
+    pl.close()
+    return png
+
+
+panels = []
+for tag, sub in (("A, gap 1h", "a"), ("B, gap 1h", "b")):
+    field, prep = fields[tag]
+    panels.append((render(field, prep, os.path.join(
+        D, f"_tb_map_{sub}.png"), 0.40, (0.5, 0.55)),
+        f"{tag.split(',')[0]}: "
+        + ("trunk continuous" if sub == "a" else "bend continuous")))
+    panels.append((render(field, prep, os.path.join(
+        D, f"_tb_zoom_{sub}.png"), 0.09, J),
+        "the branch point"))
+
+fig = plt.figure(figsize=(12.8, 11.6))
+gs = fig.add_gridspec(2, 3, width_ratios=[1.25, 1.0, 0.05])
+for k, (png, title) in enumerate(panels):
+    ax = fig.add_subplot(gs[k // 2, k % 2])
+    ax.imshow(plt.imread(png))
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_title(title, fontsize=10.5)
+from matplotlib import cm, colors as mcolors
+sm = cm.ScalarMappable(norm=mcolors.Normalize(-1, 1), cmap="RdBu_r")
+cax = fig.add_subplot(gs[:, 2])
+fig.colorbar(sm, cax=cax, label=r"$\Delta$CFF (per unit stress drop)")
+fig.suptitle("The same Y-branch, two continuity choices: "
+             r"$\Delta$CFF on trunk-parallel planes", fontsize=12)
+fig.tight_layout()
+out2 = os.path.join(D, "true-branch-stress.png")
+fig.savefig(out2, dpi=200)
+print("wrote", out2, flush=True)
diff --git a/docs/advanced/index.md b/docs/advanced/index.md
index eaf2d99b3..5ede20451 100644
--- a/docs/advanced/index.md
+++ b/docs/advanced/index.md
@@ -103,6 +103,8 @@ multigrid-preconditioning
 solver-iteration-callbacks
 complex-rheologies
 vep-transverse-isotropy-faults
+split-node-faults
+fault-mechanics-examples
 custom-meshes
 curved-boundary-conditions
 mesh-adaptation
diff --git a/docs/advanced/split-node-faults.md b/docs/advanced/split-node-faults.md
new file mode 100644
index 000000000..4eadbeba2
--- /dev/null
+++ b/docs/advanced/split-node-faults.md
@@ -0,0 +1,300 @@
+---
+title: "Split-Node Faults: Zero-Thickness Frictional Surfaces"
+---
+
+# Split-Node Faults
+
+A fault, mechanically, is a surface across which the velocity field jumps:
+slip, not strain. Underworld3 can represent a fault exactly that way — the
+mesh nodes along a conforming fault surface are duplicated so the two
+sides share no degrees of freedom, the two coincident copies are tied by a
+strong no-opening constraint, and the tangential jump (the slip rate)
+either emerges freely or is governed by a friction law. There is no weak
+layer, no viscosity contrast, and no band width to resolve: the fault has
+genuinely zero thickness, and the surrounding mesh can be uniform.
+
+This is one of two fault representations in Underworld3, and they are
+complementary rather than competing:
+
+- **Split-node surface** (this page) — the fault is a sharp interface.
+  The right tool when slip is the quantity of interest: earthquake-cycle
+  models, stress transfer, plate-boundary-style discontinuities.
+- **[Finite-width TI weak zone](vep-transverse-isotropy-faults.md)** —
+  the fault is a thin volume with anisotropic rheology. The right tool
+  when the fault-zone width is itself constitutive (rate-and-state
+  linked to a physical gouge width), or when the same fault must appear
+  as a damage zone for another equation (e.g. porous flow).
+
+## Quick start (2-D)
+
+A fault is a polyline with both tips strictly inside the domain. One call
+places its points onto mesh vertices, cuts the mesh so the fault becomes
+a conforming facet chain, and splits it:
+
+```python
+import numpy as np
+import underworld3 as uw
+
+mesh = uw.meshing.UnstructuredSimplexBox(cellSize=0.05)
+fault_points = np.array([[0.3, 0.4], [0.7, 0.6]])
+
+child = mesh.add_fault(("Fault", fault_points))
+```
+
+`child` is a new, standalone mesh carrying boundaries `FaultPlus` and
+`FaultMinus` — two geometrically coincident copies of the fault — plus
+the record of which degree of freedom pairs with which. The source mesh
+is untouched: when the fault moves, call `add_fault` again on the base
+mesh at the new position (nothing is cumulative).
+
+A frictionless (perfectly slippery) fault is then a one-line boundary
+condition, and the solve is an ordinary `solve()`:
+
+```python
+v = uw.discretisation.MeshVariable("V", child, child.dim, degree=2)
+p = uw.discretisation.MeshVariable("P", child, 1, degree=0,
+                                   continuous=False)
+stokes = uw.systems.Stokes(child, velocityField=v, pressureField=p)
+stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+
+x, y = child.X
+for wall in ("Bottom", "Top", "Left", "Right"):
+    stokes.add_dirichlet_bc((y - 0.5, 0.0), wall)   # far-field shear
+
+stokes.add_fault_bc(0, boundary="Fault")            # frictionless
+stokes.solve()
+```
+
+The no-opening constraint $[\mathbf v]\cdot\hat n = 0$ is always imposed
+strongly (the measured normal jump is machine zero), and with `conds = 0`
+the shear traction on the fault is exactly zero, so slip develops freely
+— the stress-driven crack. Read the slip through the pairing:
+
+```python
+from underworld3.utilities import fault_contact
+
+s, V, leak = fault_contact.fault_slip(
+    stokes, "Fault", stokes._rotated_freeslip_info)
+# s: along-fault coordinate; V: slip rate; leak: normal jump (~1e-17)
+```
+
+```{warning}
+Always read fault quantities through the pairing-based helpers
+(`fault_slip`, `fault_pair_jumps`, `fault_normal_traction`). The two
+sides of the fault are *geometrically coincident*, so any query by
+coordinate — `uw.function.evaluate` included — sees one side only and
+silently averages or picks arbitrarily.
+```
+
+## Quick start (3-D)
+
+In 3-D the fault is a triangulated patch whose rim stays strictly inside
+the domain. `uw.meshing.BoxInternalPatch` embeds a planar polygon patch
+conformingly in a simplex box (a disc is a many-sided polygon), and
+`split_fault` does the rest:
+
+The preferred input is a `uw.meshing.FaultSurface` — the object names
+the patch, its rim polygon becomes the conforming embed, and it rides
+onto the split mesh so the constraint frame can come from the surface's
+own face normals:
+
+```python
+from underworld3.utilities.fault_split import split_fault
+
+fault = uw.meshing.FaultSurface("Fault", points)     # or .from_vtk(...)
+fault.triangulate()
+mesh = uw.meshing.BoxInternalPatch(cellSize=0.05, patch_points=fault,
+                                   patch_cellSize=0.02)
+child = split_fault(mesh, "Fault")
+...
+stokes.add_fault_bc(0, boundary="Fault", normal="surface")
+```
+
+The surface must be planar for now (`rim_polygon` refuses otherwise —
+a genuinely curved sheet waits on the discrete-entity embed). A raw
+`(N, 3)` polygon via `patch_points=` still works for quick setups:
+
+```python
+patch = np.array([[0.5, 0.3, 0.3], [0.5, 0.7, 0.3],
+                  [0.5, 0.7, 0.7], [0.5, 0.3, 0.7]])
+mesh = uw.meshing.BoxInternalPatch(cellSize=0.05, patch_points=patch,
+                                   patch_name="Fault")
+child = split_fault(mesh, "Fault")
+```
+
+Everything downstream is identical to 2-D — `add_fault_bc`, `solve()`,
+and the law functions below all work unchanged. In 3-D the slip is an
+in-plane vector; read it with `fault_pair_jumps`:
+
+```python
+coords, jumps, normals = fault_contact.fault_pair_jumps(
+    stokes, "Fault", stokes._rotated_freeslip_info)
+leak = np.einsum("ij,ij->i", jumps, normals)        # ~ machine zero
+slip_vec = jumps - leak[:, None] * normals           # the slip vectors
+```
+
+## The fault laws
+
+The tangential condition on the fault is an interface constitutive law
+$\tau(V, \sigma_n, \theta)$ relating the shear traction to the slip rate
+$V$, the effective normal stress $\sigma_n$, and (for rate-and-state) the
+state variable $\theta$. Laws are sympy expressions; their consistent
+Newton tangents are derived symbolically, so every law converges with
+full Newton — none of them is Picard-limited.
+
+| law | call | condition |
+|-----|------|-----------|
+| frictionless | `stokes.add_fault_bc(0, boundary="Fault")` | $\tau = 0$ |
+| viscous | `stokes.add_fault_bc(eta_f, boundary="Fault")` | $\tau = \eta_f V$ |
+| Coulomb | `fault_contact.add_coulomb_fault_bc(stokes, mu, "Fault", sigma_n="reaction", V0=1e-5)` | $\tau = \mu\,\sigma_n\,\tfrac{2}{\pi}\arctan(V/V_0)$ |
+| rate-and-state | `fault_contact.add_rate_state_fault_bc(stokes, f0, "Fault", a=..., b=..., V0=..., Dc=...)` | regularised arcsinh form, ageing law |
+
+Notes on each:
+
+- **Viscous**: `eta_f` is a viscosity per unit length — the
+  zero-thickness limit of a shear band is $\eta_f = \eta_{\rm band}/w$
+  with the *band's own* (weak-zone) viscosity over its width. Small
+  `eta_f` approaches the frictionless crack; large `eta_f` *welds* the
+  fault — and welding recovers the uncut continuum exactly, because the
+  law penalises only the jump. The natural scale is $\eta/a$ (bulk
+  viscosity over fault half-length), at which the fault slips at roughly
+  half its free rate.
+- **Coulomb**: `sigma_n` may be a prescribed number or `"reaction"`, in
+  which case the effective normal stress is recovered from the
+  no-opening constraint's own reaction — no auxiliary projection, and
+  compressive stress generated by the flow feeds straight into the
+  frictional strength. The reaction-fed value is SIGNED: where it turns
+  tensile the strength is zero, and a real fault would OPEN — the
+  bilateral no-opening constraint holds it shut instead (a tensile
+  reaction), so check the sign of `fault_normal_traction` before
+  trusting results on faults that see tension. `V0` is the regularisation velocity: choose it
+  well below the slip rates the flow produces. Below it the fault sticks
+  (creep $\sim V_0$); above it the traction saturates at
+  $\mu\,\sigma_n$ and the fault slides at constant stress drop.
+- **Rate-and-state**: the state $\theta$ advances *between* solves by
+  the ageing law $\dot\theta = 1 - V\theta/D_c$, integrated exactly over
+  the interval. Nonlinear fault solves go through `solve_with_fault`,
+  and a time loop alternates solve and state update:
+
+```python
+fault_contact.add_rate_state_fault_bc(
+    stokes, 0.6, "Fault", a=0.015, b=0.010, V0=1e-6, Dc=1e-2)
+
+for step in range(n_steps):
+    result = fault_contact.solve_with_fault(stokes, picard=2)
+    monitor = fault_contact.update_fault_state(
+        stokes, "Fault", dt, solve_result=result)
+    # monitor -> 1.0 as the fault approaches steady state (theta V = Dc)
+```
+
+The recovered normal traction along the fault (also the quantity a
+Coulomb law reads when `sigma_n="reaction"`):
+
+```python
+s, sigma_nn = fault_contact.fault_normal_traction(
+    stokes, "Fault", stokes._rotated_freeslip_info)
+# negative in compression; in 3-D the first return is pair coordinates
+```
+
+## Prescribed (kinematic) slip
+
+Because the two sides are ordinary named boundaries, a *prescribed* slip
+distribution is just Dirichlet data — no law involved. The slip must
+taper to zero at the tips (2-D) or rim (3-D), which stay unsplit:
+
+```python
+import sympy
+
+x, y = child.X
+u = ((x - cx) * tx + (y - cy) * ty) / half_length     # along-fault coord
+taper = sympy.sqrt(sympy.Max(1 - u**2, 0))            # elliptical profile
+
+stokes.add_dirichlet_bc((vx_bg + s0 / 2 * taper * tx,
+                         vy_bg + s0 / 2 * taper * ty), "FaultPlus")
+stokes.add_dirichlet_bc((vx_bg - s0 / 2 * taper * tx,
+                         vy_bg - s0 / 2 * taper * ty), "FaultMinus")
+```
+
+The elliptical taper is the constant-stress-drop crack profile; because
+it vanishes at the tips, the shared tip vertex receives the same value
+from both sides and no special treatment is needed.
+
+## Practical notes
+
+- **Pressure space**: use P2 velocity with P0 *discontinuous* pressure
+  on split meshes. A continuous pressure space smears the pressure jump
+  across the fault and measurably pollutes the near-fault stress.
+- **Solvers**: split meshes carry no geometric-multigrid tail (the
+  coarse levels never contain the fault), so the velocity block takes
+  its algebraic-multigrid default. Set accuracy with
+  `stokes.tolerance = ...` — never raw `ksp_rtol`, which the solver
+  configuration overrides silently.
+- **Conditioning**: the contact formulation is dramatically better
+  conditioned than a thin weak inclusion of the same fault — there is
+  no thin feature and no viscosity contrast for the Schur complement
+  to fight (measured: 10 outer iterations vs 147 for a $10^{-4}$
+  contrast band on the same mesh).
+- **Curved faults need their analytic normal**: a curved trace is
+  sampled as a polyline, and by default each fault node's normal is the
+  average of its adjacent facet normals — exact on a straight fault, but
+  zig-zagging at the sampling kinks of a curve. The no-opening
+  constraint then forbids smooth slip past each kink, producing slip
+  notches and normal-traction sawteeth that *grow* under mesh
+  refinement. Pass the smooth curve's normal instead:
+
+  ```python
+  x, y = mesh.X
+  # e.g. a circular arc about (cx, cy): the radial direction
+  stokes.add_fault_bc(0, boundary="Arc",
+                      normal=sympy.Matrix([[x - cx, y - cy]]))
+  ```
+
+  Same conventions as `add_rotated_freeslip_bc`: a sympy `1×dim` matrix
+  in `mesh.X` (need not be unit length; it is normalised per node and
+  sign-aligned to the split's Plus→Minus orientation), or a constant
+  array. For a **digitized trace with no analytic formula** — real
+  mapped faults — pass `normal="trace"`: the smoothed normal is built
+  from the fault's own control polyline (central-difference tangents at
+  the control points, tangent angle interpolated along each segment),
+  which `add_fault` stores on the mesh. Every fault-law variant
+  (`add_coulomb_fault_bc`, `add_rate_state_fault_bc`, ...) accepts the
+  same `normal=` argument, and the slip/traction diagnostics read the
+  same frame automatically. Measured on a sampled circular arc: the
+  smooth normal reduces the kink sawtooth by an order of magnitude and
+  restores convergence under refinement. On straight faults it changes
+  nothing — omit it. And a deliberately *kinked* fault should not be
+  smoothed: there the kink response is the physics.
+- **Moving faults**: re-derive, don't update. Cut and split again from
+  the static base mesh at the new fault position; transfer fields with
+  the standard re-adaptation machinery.
+- **Networks**: pass a list of faults to `add_fault`. Segments must not
+  share vertices — represent a branch or crossing as offset segments
+  separated by a ligament of one or two cell sizes.
+- **Parallel**: `add_fault` / `split_fault` REDISTRIBUTE first, in
+  both 2-D and 3-D: the fault's cell star (plus one growth layer — a
+  thin skin, not the refined band) is gathered onto the rank that
+  already owns most of it, everything else stays with the
+  load-balanced partition, and the split then runs with serial
+  topology at any rank count. In 2-D the move happens only when the
+  cut chain actually touches the partition seam, and a network passed
+  to one `add_fault` call is redistributed ONCE, keyed on all its
+  faults together — which is also what keeps every fault's pairing
+  valid, since a pairing cannot yet migrate through a redistribution.
+  In 3-D the move is unconditional. The cost is a bounded imbalance on
+  the fault-owning rank (measured ~1.8x at np = 8 on a graded box).
+  One current exception follows from the pairing rule: adding several
+  faults ONE SPLIT AT A TIME in parallel is refused when a later fault
+  needs redistribution — pass the whole network to one `add_fault`
+  call (2-D), or split 3-D networks in serial. All refusals are
+  collective and name the actual problem.
+
+## Current limitations
+
+Refused loudly rather than mishandled: closed-loop faults (rings,
+spheres); faults that reach the domain boundary (daylighting); junctions
+sharing vertices; 3-D multi-fault networks in parallel (the pairing does
+not yet migrate through the redistribution). The design
+documents in `docs/developer/design/` (`SPLIT_NODE_FAULT_METHOD_2026-08`
+and `FAULT_CONTACT_DEPLOYMENT_2026-08`) record the method, the
+validation benchmarks, and the roadmap for these extensions.
diff --git a/docs/developer/ai-notes/fault-teaching-examples-handoff-2026-08.md b/docs/developer/ai-notes/fault-teaching-examples-handoff-2026-08.md
new file mode 100644
index 000000000..d7c810ff5
--- /dev/null
+++ b/docs/developer/ai-notes/fault-teaching-examples-handoff-2026-08.md
@@ -0,0 +1,224 @@
+# Fault-mechanics teaching examples: curation handoff
+
+Written 2026-08-05 for the session curating the teaching materials.
+Everything described here is committed and pushed on
+`origin/feature/fault-split-node` (through the commit adding this
+file). Read this document first; every path below is repo-relative on
+that branch.
+
+## The one critical dependency
+
+**These examples run ONLY on `feature/fault-split-node`.** They are
+built on the split-node fault capability (`fault_split.py`,
+`fault_contact.py`, the pair blocks in `rotated_bc.py`), which is not
+on `development` yet. Curate the *placement and prose* freely, but the
+examples cannot execute from any other branch, and they should not be
+merged into user-facing docs ahead of the capability itself. The
+figures, however, are committed PNGs/GIFs — prose pages that embed
+them render fine anywhere.
+
+## Where everything is
+
+- **Page**: `docs/advanced/fault-mechanics-examples.md` (in the
+  `docs/advanced` toctree). Nine figures + three animations, each
+  with a short teaching narrative and a closing "what these models
+  are, and are not" caveat section.
+- **Scripts, figures, caches**: `docs/advanced/figures/fault-examples/`
+  — one Python script per example, committed output PNG/GIF alongside,
+  probe caches as `_*.npz` (committed: they let anyone re-style every
+  figure and both animations without re-running ~100 solves).
+  `_*.png` frame intermediates and `*.log` files are gitignored.
+- **Shared harness**: `figures/fault-examples/common.py` — every
+  example builds on it (see contracts below).
+- **Companion user documentation**: `docs/advanced/split-node-faults.md`
+  (the API guide the examples assume) and the method/benchmark
+  write-up `docs/developer/design/SPLIT_NODE_FAULT_METHOD_2026-08.md`
+  (with its own figure set under
+  `docs/developer/design/figures/split-node-faults/` — cetz sources,
+  generators, and PNGs for the split anatomy, pair transform, mesh
+  stack, and grid hierarchy; those serve the method paper / blog
+  posts rather than the teaching page).
+
+## The example inventory (teaching order)
+
+1. **`ladder.py` → `ladder.png`** — *the fault-strength ladder.* One
+   fault, one shear drive, five solves down the constitutive ladder
+   (frictionless / viscous eta/a / Coulomb-weak / rate-state /
+   Coulomb-stuck), slip profiles against the elliptical crack shape,
+   plus a stacked column of per-rung shear-stress panels. Teaches: what
+   an interface law IS. ~5 solves.
+2. **`mohr_circle.py` → `mohr-circle.png`** — welded faults as passive
+   stress probes trace the Mohr circle (fitted radius 1.411 vs analytic
+   sqrt(2)). Teaches: the probe instrument + the circle exists.
+3. **`mohr_animate.py` → `mohr-circle-build.gif`** — the circle built
+   frame by frame as the fault rotates; the measured traction vector
+   snaps to the fault normal at the principal orientations, flagged on
+   both panels. Teaches: the 2-theta rule as motion. 25 solves, cached.
+4. **`mohr_friction.py` → `mohr-friction.png` + `-build.gif`** — give
+   the rotating fault Coulomb friction: stuck probes reproduce the
+   circle, sliding probes pin to the envelope, tensile probes are
+   HELD SHUT (unphysical — the bilateral constraint glues an opening
+   fault; the tell is the sign of the normal traction). Teaches: the
+   yield envelope truncates the circle.
+5. **`mohr_cohesion.py` → `mohr-cohesion.png` + `-build.gif`** —
+   cohesion: strength declines through mild tension to zero at
+   sigma = -C/mu; stuck arcs at both poles; the law is registered as a
+   four-line sympy expression (the extension path for any rheology).
+6. **`mohr_graded.py` → `mohr-graded.png`** — hydrostatic load: each
+   welded fault becomes a depth-coloured STREAK spanning the family of
+   Mohr circles between its shallowest and deepest points. Teaches:
+   per-node stress recovery = depth-dependent strength along one fault.
+7. **`orientations.py` → `orientations.png`** — frictionless faults at
+   swept orientations: peak slip follows |cos 2 theta| with an exact
+   zero at 45 degrees. Teaches: resolved stress controls slip.
+8. **`interacting_faults.py` → `interacting-faults.png` +
+   `interacting-rotation.png`** — King-style stress transfer: the
+   source slips, the receiver is welded in the source's along-strike
+   tip lobe. Delta CFF as a field (linear RdBu_r at +-1, P0 cells)
+   AND as the receiver's probe cloud moving in the Mohr plane, with
+   the loaded near-tip nodes CROSSING the cohesive envelope into the
+   shaded failure zone while the far end retreats. The friction
+   dressing (P0 = 1 confining pressure, C = 0.75 cohesion) enters the
+   ENVELOPE only, never Delta CFF — both docs say so explicitly. The
+   rotation sweep's message: the regional stress orientation controls
+   the MARGIN to the envelope (grazing at phi = 20, crossing at 45,
+   parked safe at 70). 6 solves at h = 0.016, 13-18 s each.
+9. **`california.py` → `california.png`** — schematic southern
+   California: the San Andreas as ONE continuous dextral trace with a
+   smooth tanh S-bend (the Big Bend — the smoothed stepover; left
+   step = restraining). The curved trace is sampled as a polyline and
+   carries the smooth curve's ANALYTIC NORMAL via
+   `add_fault_bc(..., normal=...)` — the capability that made curved
+   traces viable (see the rendering/roughness rules below). The
+   restraining bend fills with strong compression: a dCFF bowtie
+   exactly where the Transverse Ranges belong — the model puts the
+   mountains where the mountains are. Garlock (resolves sinistral
+   from the kinematics), three ECSZ strands and a San Jacinto
+   analogue welded as probes, all inboard. Verdicts: SJF relaxed
+   (-0.41), Garlock and ECSZ mildly loaded (+0.05/+0.06); slip
+   arrows from the MEASURED jump (+0.242 right-lateral — a
+   continuous trace slips more than the two offset segments did).
+   ~50 s of compute at h = 0.012. The capstone.
+
+   RENDERING RULES the interaction fields obey: see the revised
+   field-rendering entry in the harness contracts below (P0 and P1
+   are both legitimate now — choose by physics; never Delaunay a
+   split-mesh DOF cloud; RdBu_r +-1 for dCFF, Oranges for strain
+   rate).
+
+## The harness contracts (`common.py`)
+
+- `base_mesh(h)` + `mesh.add_fault([...])`: one static base, re-faulted
+  per case (the non-cumulative pattern). Networks = list form;
+  segments must not share vertices (ligament >= 2h).
+- `stokes_on(child, drive)`: P2 velocity / P0 *discontinuous* pressure
+  (the fault pressure-space ruling), all-wall Dirichlet drive,
+  `petsc_use_pressure_nullspace = True`, `stokes.tolerance` (never raw
+  ksp_rtol).
+- Drives: `simple_shear`, `shear_plus_stretch(a, gamma)` (Mohr radius
+  eta sqrt(4a^2+gamma^2)), `pure_shear_drive(phi)` (phi = COMPRESSION
+  axis — an earlier sign error made it the extension axis; fixed),
+  `boundary_simple_shear(trend)` (right-lateral along a plate-boundary
+  trend; dextral verified from the measured jump).
+- **Read fault quantities through the DOF pairing only**
+  (`slip_vs_position`, `probe_nodes`, `fault_pair_jumps`): the two
+  sides are geometrically coincident — coordinate queries see one side.
+  `probe_nodes` selects the named fault's nodes via its own pairing
+  (several law-carrying faults share one assembler).
+- **Pressure-gauge discipline** (closed velocity-driven boxes fix
+  pressure only up to a per-solve constant; observed drifts up to
+  ~300 stress units on large slip events): differenced fields are
+  anchored with `far_field_anchor` (a slip event changes nothing far
+  away), absolute probe pressures with `ambient_sigma_n` /
+  `ambient_sigma_n_simple` (analytic ambient states). Every removed
+  constant is printed, never silently absorbed.
+- Field rendering (the standing rules, measured not guessed — REVISED
+  2026-08-07): render on the split mesh's TRUE connectivity via
+  `split_mesh_cell_render`/`split_mesh_cell_rows` (P0 cells) or
+  `split_mesh_faces` (P1 nodes). Never Delaunay the DOF point cloud of
+  a split mesh (coincident fault pairs + trace-crossing edges paint
+  false beading). BOTH projections are now legitimate: the old "never
+  P1" rule was calibrated against the kinked-normal sawtooth fields we
+  later cured at the source, and the split mesh's P1 space is
+  naturally discontinuous across faults (doubled nodes), so the jump
+  is representable. Choose by physics: P1 nodal for smooth fields
+  (dCFF away from tips renders smoothly, no triangle facets); P0 cells
+  where the field carries genuine cell-scale structure (yield-zone
+  boundaries, material interfaces — P1 blurs them by a node spacing;
+  measured side by side in
+  ~/+Simulations/fault_junction_rheology/p1-vs-p0.png). Recover
+  COMPONENTS and form invariants in numpy, never project an invariant
+  directly. Colour: linear RdBu_r at +-1 for dCFF; one-sided Oranges
+  on white for strain rate (maintainer convention — no dark
+  backgrounds, keep the mesh edges visible). (`signed_log` remains in
+  the harness but the maintainer rejected it for these figures.)
+- Curved faults carry their ANALYTIC NORMAL
+  (`add_fault_bc(..., normal=sympy 1×dim Matrix in mesh.X)`). The kink
+  roughness of a sampled curve was diagnosed (2026-08-05,
+  ~/+Simulations/curved_fault_roughness/): NOT the meshing, NOT the
+  integration — the default per-node normal AVERAGES the adjacent
+  facet normals and zig-zags at the sampling kinks, so the no-opening
+  constraint forbids smooth slip past each kink (sawteeth that GROW
+  under refinement). The analytic normal on the same kinked mesh cuts
+  the sawtooth 7-17x and restores h-convergence. Straight faults need
+  nothing (the average is exact there); a deliberately kinked fault
+  should NOT be given a smooth normal — the kink response is then the
+  physics.
+
+## Conventions (consistent across every figure)
+
+- Mohr planes in the GEOLOGICAL sign convention: compression positive,
+  tension on the negative axis (solver tractions are tension-positive;
+  only plots flip).
+- The interaction figures dress friction with a declared confining
+  pressure P0 = 1 and cohesion C = 0.75 (envelope
+  tau = +-(C + mu' sigma)); **neither enters Delta CFF** (constants
+  under differencing) — they place the failure line where teaching
+  needs it, and the pages say so.
+- mu' = 0.4 (King's value) for all Delta CFF.
+- Fields render in pyvista (RdBu_r, white background, lighting off);
+  line/scatter plots in matplotlib. Method-paper figures (cetz) use
+  sans labels (Noto Sans -> Helvetica fallback) at small sizes.
+
+## Regeneration
+
+Everything runs inside the worktree env, with its bin on PATH (the JIT
+needs mpicc):
+
+    cd <worktree>/docs/advanced/figures/fault-examples
+    PATH=<worktree>/.pixi/envs/runtime/bin:$PATH \
+        <worktree>/.pixi/envs/runtime/bin/python -u <script>.py
+
+With the committed `_*.npz` caches present, every script regenerates
+its figures/animations in seconds (plot-only). Delete a cache to
+re-measure. Measured costs on a laptop: ladder ~5 solves of ~30 s;
+each Mohr sweep 25 solves of ~30-60 s; the en echelon sweep 6 solves
+of 13-18 s (h = 0.016); California ~50 s total (h = 0.012: 37 s
+slipping solve, 11 s welded + projections). pyvista emits harmless
+`__del__` AttributeError noise at interpreter exit; ignore it.
+
+## Physics caveats (ready-made prose on the page)
+
+The page's closing section states: static incompressible elasticity
+and Stokes are the same mathematics, so these are exactly the elastic
+nu = 1/2 patterns with slip rate as coseismic slip; deliberately
+absent are depth/half-space geometry, topography, gravity (except the
+graded fault), compressibility, and postseismic processes; slipping
+faults are completely weak during their event, and Delta CFF scales
+linearly with the dropped stress (partial drop = the Coulomb rung on
+the source). Keep that section attached to wherever the interaction
+examples land.
+
+## Curation notes
+
+- If the examples move (e.g. into a tutorials tree), keep script +
+  figure + cache TOGETHER, and update the relative image paths in the
+  page. `common.py` must travel with the scripts.
+- Notebook conversion is mechanical: each script is linear
+  (setup -> sweep(cached) -> figures) and the caches make cells fast.
+- The animations are GIFs sized for docs (~200 KB); they embed with a
+  plain image directive.
+- Known remaining candidates (listed on the page): tip-to-tip vs
+  overlapped en echelon side by side, denser networks, gravity-loaded
+  interactions, and — further out — 3-D examples (the capability
+  exists: see `docs/advanced/split-node-faults.md`).
diff --git a/docs/developer/design/FAULT_CONTACT_DEPLOYMENT_2026-08.md b/docs/developer/design/FAULT_CONTACT_DEPLOYMENT_2026-08.md
new file mode 100644
index 000000000..c285c3569
--- /dev/null
+++ b/docs/developer/design/FAULT_CONTACT_DEPLOYMENT_2026-08.md
@@ -0,0 +1,227 @@
+# Split-node fault contacts: deployment design
+
+**Status**: agreed direction (maintainer + AI session, 2026-08-04). The
+backend primitives are prototyped and validated on `feature/fault-split-node`;
+this note records the architecture and the path from prototype to deployed
+capability. Companion study with all reference numbers:
+`~/+Simulations/fault_split_gate/`.
+
+## What exists and what it measured
+
+A fault as a **zero-thickness contact**: the mesh's nodes are duplicated along
+a conforming facet chain (`utilities/fault_split.py`), so continuous FE spaces
+jump across the fault and nowhere else; interface conditions act on the
+coincident DOF pairs through an orthogonal mean/jump extension of the rotated
+strong-BC machinery (`utilities/fault_contact.py`, pair blocks in
+`rotated_bc.build_rotation`).
+
+Validated so far, all at the fault-study resolution (13k cells):
+
+| what | result |
+|---|---|
+| Schur conditioning | 10 iterations vs the thin weak inclusion's 147, resolution-independent |
+| no-opening constraint | machine zero (5e-18) in every configuration tested |
+| frictionless (stress-driven) slip | elliptical to 1.35 % RMS; peak 92 % of the infinite-medium crack (finite box) |
+| viscous interface law τ = η_f·V | welded↔free family follows the crack compliance 1/(1 + 0.91 η_f a/η) |
+| welded limit | removes the fault (recovers the uncut continuum) — it penalises the JUMP only; the mean velocity is never constrained, so nothing becomes rigid |
+
+The Coulomb lobe geometry matches the inclusion representation across all
+three fault laws tried (prescribed slip, frictionless, viscous), with
+amplitudes ordered exactly by their slip.
+
+## The three-layer architecture (settled)
+
+1. **The fault manifold** — persistent, owns the physics identity. A genuine
+   lower-dimensional mesh (polyline in 2-D; the placed-surface branch's
+   pyvista triangulation in 3-D), **replicated on every rank**. Its NODES are
+   the Lagrangian markers of the fault: per-node internal state (rate-state
+   θ, slip history) and property fields live here — arc length is NOT a
+   material coordinate under fault deformation, nodes are. A network is a
+   set of manifold components plus a junction table.
+2. **The split bulk mesh** — ephemeral, rebuilt whenever the fault moves
+   (the non-cumulative `adapt` pattern: re-cut and re-split from the static
+   base). It carries only the **trace mapping**: the Minus→Plus point pairs
+   (`mesh._fault_point_pairs`, from the split's clone map — the sides are
+   coincident, so no coordinate query can ever recover the pairing), and
+   what derives from them (slip rows, normals, s-coordinates for sampling
+   against the manifold).
+3. **The constraint/constitutive layer** — the pair transform (no opening
+   strong; slip row free = frictionless, datum = prescribed jump-only slip,
+   linear operator = viscous, nonlinear relation = friction). Interface
+   operators assemble as slip-row trace-mass blocks; tips need no interface
+   BC because the jump space vanishes where the sides share a point.
+
+## Two entry paths, one backend
+
+- **(a) Submesh-surface path**: a persistent fault object supplies the
+  manifold and its data; the bulk mesh conforms to it and splits along it.
+  This is the natural interface for models where the fault is a first-class
+  design object (earthquake studies, faulted margins).
+- **(b) Ephemeral adapt-on-top path**: per step or per re-adaptation, the
+  manifold drives the refinement metric, the cut, and the split on a child of
+  the static base; fields and manifold state transfer across rebuilds
+  (bulk fields via the existing re-adaptation machinery, manifold state by
+  identity — it never lived on the bulk mesh).
+
+Both funnel through the same backend contract:
+
+    manifold → conforming labelled chain on the bulk mesh
+             → split (pairs recorded)
+             → trace mapping (pairs ↔ manifold nodes)
+             → interface laws on the pairs
+
+API sketch (interface-first discipline: land the signatures on `development`
+as stubs before the feature branch fills them):
+
+```python
+fault = uw.meshing.FaultSurface(name, geometry, properties=..., )   # layer 1
+child = mesh.add_fault(fault, ...)          # adapt→cut→split, or split-only
+stokes.add_fault_bc(law, fault.name)        # "free" | ("viscous", eta_f) | friction later
+```
+
+The manifold contract is a PROTOCOL, not one class (placed-surface
+session's counter-proposal, 2026-08-05, adopted): a fault manifold is
+anything with a ``name``, geometry, signed-distance/director sampling,
+and per-node ``point_data``. The concrete types are ``uw.meshing.Surface``
+(the 2-D polyline — what ``add_fault`` consumes today) and
+``uw.meshing.FaultSurface`` (the 3-D pyvista-triangulated sheet, which
+predates both branches and has no 2-D form). Documentation must not name
+``FaultSurface`` as "the" manifold object — the landed 2-D capability
+would then have none.
+
+## Parallel: the seam-vertex crossing rule (maintainer ruling, 2026-08-04)
+
+Never synchronise interior replicas across ranks. Instead **pin a mesh vertex
+exactly at every fault–seam crossing** (`pull_vertex_onto` is already
+collective and partition-consistent), and require crossings to be
+transversal. Then:
+
+- every fault facet, and every interior replica, is rank-local — the current
+  machinery applies unchanged;
+- the ONLY shared object is the crossing vertex, which needs one shared
+  replica pair: a single new star-forest entry per crossing, associated
+  deterministically by the key **(original root point, side)** — both ranks
+  compute the side identically because both hold the replicated manifold and
+  the chain-direction rule (lexicographically smaller tip first) is global;
+- replicas inherit the original's owner, so the pair blocks in Q stay inside
+  one rank's diagonal portion and the existing "pair straddles ranks" guard
+  remains an invariant, not a limitation.
+
+Still refused, deliberately: a fault running *along* a seam (facets on the
+seam), and junctions on a seam (first version). The current blanket seam
+refusal stays in place until this lands, and remains the fallback error.
+
+## Representation policy: the fault chooses its implementation per equation
+
+The fault object is the PHYSICAL entity; how an equation system feels it is
+a per-solver choice, and different equations on one model may choose
+differently — a sharp interface for Stokes, a damage zone for Darcy flow.
+The fault object supplies the ingredients; each solver picks its adapter:
+
+| representation | mechanism | status |
+|---|---|---|
+| **surface** (sharp contact) | split mesh + pair constraints, `add_fault_bc` | built (this branch) |
+| **volume** (weak zone / damage) | distance field from the same manifold → viscosity, damage, permeability k(d) | exists (`meshing/faults.py`: `compute_distance_field`, `create_weakness_function`) |
+| **TI weak zone** | director transfer from the manifold normals → `TransverseIsotropicFlowModel` | exists (`meshing/faults.py`: `transfer_normals`) |
+
+Composition across equations, two patterns:
+
+1. **Different meshes per continuity class (the default).** Stokes solves on
+   the split child; Darcy / thermal solve on the PARENT (continuous) with a
+   volume representation from the same manifold's distance field. No new
+   machinery — multi-mesh field transfer exists, and each equation gets a
+   mesh whose continuity matches its physics.
+2. **One shared split mesh (tight coupling only).** A solver that must NOT
+   see the slit needs a continuity (weld) constraint: jump = 0 on its field
+   across every pair. For Stokes this is the measured welded limit; for a
+   scalar system it is a small new piece (the pair transform on a scalar
+   field). Build it when a tightly coupled problem actually demands one
+   mesh; until then pattern 1 is simpler and exact.
+
+## Parallel robustness (measured, np = 3/4/5)
+
+`~/+Simulations/fault_split_gate/crossing_sweep.py`: nine fault geometries
+per rank count. 17/27 split cleanly (every success: zero star-forest drift,
+global Euler 0, conformity; one frictionless solve per np with machine-zero
+leak); every refusal was COLLECTIVE and categorised — three-rank corners on
+the line, and faults running along a seam. No hangs, no invalid meshes, no
+unclassified failures. The sweep also established the kink rule: EVERY
+polyline control point needs a vertex pulled onto it, interior kinks
+included — a kink is the same problem as a tip.
+
+## Crossing and branching faults: the three-level strategy
+
+Faults branch even where they cannot cross, and crossings evolve (an
+inactive crossing deforms into two abutments and reactivates). Three levels,
+each usable on its own; the approximate ones are legitimate models, not
+placeholders.
+
+- **J0 — offset junctions (available now).** A branch or crossing is a set
+  of DISJOINT segments separated by a ligament of one or two local h. Each
+  splits independently under the existing refusals; the intact ligament
+  transmits stress between them. Junction process zones are physical, the
+  error is ligament-scale and shrinks with the near-fault refinement.
+  Validation: the King two-fault interaction pattern. A crossing is two
+  offset abutments.
+- **J1 — true abutment, tip-on-fault (a refusal refinement).** Split the
+  through-going fault FIRST; the abutter's tip vertex then belongs to one
+  side's copy (the sector it approaches from), and the abutter splits as an
+  ordinary fault whose UNSPLIT tip sits on the master's slit. Tips are never
+  fan-walked, so the only change is the boundary-touching refusal learning
+  to distinguish, for tips only, a domain boundary from a prior fault's slit
+  (the labels tell them apart). Exact T kinematics: the master slips through
+  freely; branch slip tapers to zero over its last facet. This is the
+  locked-branch case — sufficient wherever the branch does not actively
+  partition slip.
+- **J2 — the exact d-sector split (scheduled).** A degree-d junction vertex
+  receives d sector copies (the fan walk opened at ALL incident fault
+  edges); branch compatibility — trunk slip partitioning onto splays — is a
+  TELESCOPING IDENTITY of sector differences around the vertex, so no cycle
+  constraint and no multiplier exists; per-branch no-opening plus per-branch
+  interface laws close the system, and a crossing is simply d = 4. New
+  pieces, all contained: the generalised fan walk, d−1 replicas per junction
+  vertex, per-branch pairing in the trace mapping, and a d-sector BC block
+  at junction nodes in place of the pair block. Acceptance test: the vector
+  sum of branch slips at the junction closes to machine precision — an
+  identity of the representation, not a physics tolerance. The ordinary
+  chain vertex is d = 2 and the tip is d = 1 under the same rule.
+
+Junctions stay OFF partition seams at every level, consistent with the
+seam-vertex crossing rule.
+
+## Staging
+
+1. **API layer + common backend, serial** — `FaultSurface`, `add_fault`,
+   `add_fault_bc`; docs; promote the module functions behind the methods.
+   Includes J0 (offset junctions) as a documented pattern with a two-fault
+   interaction test, and J1 (tip-on-fault abutment) as the refusal
+   refinement.
+2. **Parallel crossing rule** — the one-entry-per-crossing SF extension,
+   np=2–4 tests including a fault deliberately spanning two ranks.
+3. **Nonlinear interface laws** — regularised Coulomb with σ_n from the
+   normal-row reaction (Picard-lagged), tangent 2·(dτ/dV)·M rebuilt per
+   Newton iteration in the existing hook; oracle: at fixed τ the solution
+   must land on the measured compliance curve at the secant η_f = τ/V.
+   Then rate-state (arcsinh form; θ ODE on manifold nodes between steps).
+4. **Manifold state plumbing** — trace↔manifold sampling, the gather/reduce
+   collective for V and σ_n feeding the θ ODE, checkpointing via the
+   manifold object.
+
+Geometric multigrid is a separate track (split only the finest 1–2 levels;
+side-aware transfer at the single split/unsplit seam) and is not a
+prerequisite for any of the above — GAMG holds comfortably at current scale.
+
+## Traps already paid for (do not rediscover)
+
+- petsc4py `getLabel` on a missing name and `getStratumIS` on an empty
+  stratum return NULL-wrapping objects that SEGFAULT on first use — guard
+  with `hasLabel` / `getStratumSize`.
+- The rotated path's field copy-back dropped inhomogeneous essential values
+  (#497, fixed): essential DOFs are absent from the global vector. The tell
+  is the divergence theorem failing on a field diagnostic.
+- Never inject interface entries into the `ptap`-refreshed rotated operator —
+  add them to a copy; re-attach the null space on each rebuilt copy.
+- The pairing comes from the clone map only; coordinate matching is
+  impossible-by-construction at zero distance. Protect the property that the
+  two trace spaces are identical with exactly paired DOFs — losing it means
+  genuine mortar machinery.
diff --git a/docs/developer/design/SPLIT_NODE_FAULT_METHOD_2026-08.md b/docs/developer/design/SPLIT_NODE_FAULT_METHOD_2026-08.md
new file mode 100644
index 000000000..15fa3defb
--- /dev/null
+++ b/docs/developer/design/SPLIT_NODE_FAULT_METHOD_2026-08.md
@@ -0,0 +1,405 @@
+# Split-node faults: method and benchmarks
+
+Technical outline for publication drafting (2026-08). Companion to the
+architecture/deployment record in `FAULT_CONTACT_DEPLOYMENT_2026-08.md`;
+this document is the *method itself* — formulation, mesh operation, trace
+assembly, and the validation numbers — with the history and design
+rationale deliberately omitted. Figures in `figures/split-node-faults/`
+(cetz sources + generators alongside the committed PNGs).
+
+## 1. Method in one paragraph
+
+A fault is represented as a genuine velocity discontinuity: the mesh
+points interior to a conforming fault surface are duplicated so that the
+two sides share no degrees of freedom, and the coincident degree-of-freedom
+pairs are transformed, inside the existing rotated-constraint solver path,
+to mean and jump components in the local fault frame. The jump-normal
+component is constrained to zero (no opening, enforced to machine
+precision); the jump-tangential component — the slip rate $V$ — either
+stays free (a perfectly slippery fault, zero shear traction) or carries an
+interface constitutive law $\tau(V, \sigma_n, \theta)$ assembled on the
+fault trace with a consistent Newton tangent derived symbolically. The
+effective normal stress $\sigma_n$ is recovered from the constraint
+reaction, and rate-and-state state $\theta$ evolves between solves by an
+exactly integrated ageing law. No viscosity contrast, no thin layer, and
+no Lagrange multiplier field is introduced anywhere.
+
+## 2. Formulation
+
+### 2.1 The split function space
+
+Let $\Gamma$ be a chain of interior mesh facets (2-D) or a triangulated
+patch of interior faces (3-D). Duplicating every mesh point strictly
+interior to $\Gamma$ — vertices in 2-D; vertices, edges and the faces
+themselves in 3-D — and rewiring the cells on one side to the replicas
+makes every $C^0$ finite-element space discontinuous exactly across
+$\Gamma$ and continuous everywhere else. The chain endpoints (2-D) and the
+patch rim (3-D) are *not* duplicated: the field remains single-valued
+there, so any slip must taper to zero at the tips/rim, which is the
+physically correct crack condition and removes all special-casing at the
+front.
+
+![The split in 2-D](figures/split-node-faults/split-anatomy.png)
+
+*Fig. 1 — (a) the conforming labelled chain; (b) after the split
+(exploded for display — the copies are geometrically coincident). Filled
+red: original interior vertices (Plus side keeps them); open red: their
+replicas (Minus side rewired); black rings: the shared, unsplit tips.*
+
+![3-D components](figures/split-node-faults/split-components-3d.png)
+
+*Fig. 2 — the same operation one dimension up, rendered from an actual
+split mesh: the fault patch is doubled into two coincident triangulated
+copies (pulled apart along the normal for display), joined at the single
+shared rim.*
+
+### 2.2 The pair transform
+
+Each coincident pair $(v^+, v^-)$ carries $2\,d$ velocity unknowns
+($d$ the dimension). One orthogonal $2d \times 2d$ block per pair rotates
+them to mean and jump components in the fault frame
+$(\hat n, \hat t_1[, \hat t_2])$, with the frame built per node from the
+one-sided fault facet normals. The rotation rides the same machinery as
+rotated free-slip walls; the mean rows and the slip rows remain ordinary
+unknowns of the bulk momentum balance, and only the jump-normal row
+enters the constrained set.
+
+**The frame, not the mesh, sets a curved fault's smoothness.** The
+default per-node normal is the average of the adjacent facet normals —
+exact on a straight fault, but zig-zagging at the sampling kinks of a
+polyline-sampled curve. Slip past a kink is then geometrically
+incompatible with the no-opening constraint, and the solver answers with
+slip notches and normal-traction sawteeth locked to the kink positions
+that *grow* under refinement (the discretisation converges to the
+kinked-constraint problem, faithfully). A controlled experiment
+(circular arc, $78°$ total turn, $N = 2$–$24$ segments vs a straight
+control) exonerated both the meshing (near-trace cell quality is
+uncorrelated with the roughness; the straight cut is the worst-quality
+case yet perfectly smooth) and the constraint enforcement (leak
+$\le 10^{-17}$ throughout), and convicted the frame: supplying the
+smooth curve's analytic normal (`add_fault_bc(..., normal=...)`, same
+conventions as rotated free-slip walls) on the *same kinked mesh* cuts
+the traction sawtooth by $7$–$17\times$, makes it $h$-independent, and
+collapses the slip profiles of different samplings onto one smooth
+curve. Sampled curved faults should therefore always carry their
+analytic (or smoothed) normal; the facet-averaged default is for
+straight segments and genuinely kinked geometry.
+
+![Pair transform](figures/split-node-faults/pair-transform.png)
+
+*Fig. 3 — the rotated rows of one pair and their roles.*
+
+Key properties, all consequences of the transform being orthogonal and
+the constraint being strong:
+
+- **No opening to machine precision.** The jump-normal row is an
+  essential constraint with datum zero (a nonzero datum would be a
+  prescribed dilation). Measured leak: $10^{-18}$ or exactly zero in every
+  benchmark below.
+- **The reaction of the jump-normal row is the normal traction.** The
+  stashed bulk residual on the constrained rows, de-smeared by a positive
+  trace mass, gives $\sigma_{nn}$ per node with no auxiliary flux solve —
+  the same recovery as dynamic topography from rotated free-slip walls.
+- **The welded limit removes the fault.** Any law on the slip rows
+  penalises only the jump; the mean rows are never touched, so
+  $\tau/V \to \infty$ recovers the uncut continuum on the same mesh, not a
+  rigid inclusion.
+
+### 2.3 Interface constitutive laws
+
+A law is a sympy expression $\tau(V, \sigma_n, \theta)$ in three canonical
+symbols (slip rate, effective normal stress, state). The consistent
+tangent $\partial\tau/\partial V$ is produced by `sympy.diff` and both are
+lambdified once at registration — the same division of labour as the bulk
+constitutive models: the physics is symbolic, only the innermost
+quadrature evaluates compiled callables. Implemented members:
+
+| law | $\tau(V)$ | notes |
+|-----|-----------|-------|
+| frictionless | $0$ | slip row free; the stress-driven crack |
+| viscous | $\eta_f V$ | $\eta_f = \eta_{\rm layer}/w$: the equivalent weak *layer's own* viscosity over its width (not the background's) |
+| Coulomb | $\mu\,\sigma_n\,\tfrac{2}{\pi}\arctan(V/V_0)$ | regularised; $V_0$ well below flow rates ⇒ stick as creep $\sim V_0$ |
+| rate-and-state | $a\,\sigma_n \sinh^{-1}\!\big[\tfrac{V}{2V_0} e^{(f_0 + b\ln(V_0\theta/D_c))/a}\big]$ | arcsinh regularisation, smooth and odd in $V$ |
+
+The interface term $\int_\Gamma \tau(V)\,\delta V\,d\Gamma$ enters the
+rotated residual on the slip rows and its tangent
+$2\,(\partial\tau/\partial V)\,M$ ($M$ the trace mass) is rebuilt at every
+Newton iterate — full Newton in $V$. Two quantities are deliberately
+Picard-lagged, once per iterate: $\sigma_n$ (fed from the reaction; its
+derivative is nonlocal and non-stiff) and $\theta$ (state evolves between
+solves, not within one). In 3-D the traction is collinear with the slip,
+$\boldsymbol\tau = \tau(|V|)\,\hat V$, and the per-node $2\times 2$
+tangent block is
+
+$$\frac{\partial\tau}{\partial V}\,\hat V\hat V^{\mathsf T}
+  + \frac{\tau}{|V|}\left(I - \hat V\hat V^{\mathsf T}\right),$$
+
+regularised at $|V| \to 0$ by the laws' own smoothness (the arctan/asinh
+forms give $\tau/|V| \to \partial\tau/\partial V(0)$, so the zero-slip
+block is isotropic).
+
+### 2.4 State evolution and normal stress
+
+The ageing law $\dot\theta = 1 - V\theta/D_c$ is integrated exactly over
+each solve interval for piecewise-constant $V$:
+$\theta' = \theta e^{-x} + (D_c/V)(1 - e^{-x})$, $x = V\,\Delta t/D_c$,
+written with `expm1` so $V \to 0$ degrades smoothly to pure ageing.
+$\theta$ varies by orders of magnitude along a fault and enters laws only
+through $\ln\theta$, so the trace quadrature interpolates the *logarithm*
+— which is also what keeps a positive-only quantity positive under the
+quadratic shape functions (their undershoot sends a plainly interpolated
+$\theta$ negative). $\sigma_n$ is fed to the laws SIGNED (positive in
+compression); each law clamps its own strength at zero — bare friction
+at $\sigma = 0$, cohesion at $\sigma = -C/\mu$ — because where
+strength vanishes is constitutive. Where the strength is zero and the
+normal stress is tensile, a real fault would open: no static solution
+exists, and the bilateral no-opening constraint manufactures one by
+carrying a tensile reaction. The computed state is then unphysical,
+and the tell is the sign of the recovered normal traction. (A
+unilateral contact — opening allowed — is a complementarity problem,
+deferred.)
+
+## 3. The mesh operation
+
+![The stack-on progression](figures/split-node-faults/stack-progression.png)
+
+*Fig. 4 — where the split sits in the meshing pipeline. The base mesh is
+static and never carries the fault; adapt-on-top layers refine toward the
+fault manifold (a dashed geometric object until (d)); the finest child is
+cut so the fault becomes a conforming facet chain, and only then split.
+When the fault moves, the whole top of the stack is re-derived from the
+same base — the operation is non-cumulative by construction.*
+
+![The grid hierarchy](figures/split-node-faults/grid-hierarchy.png)
+
+*Fig. 5 — the same stack seen as a solver hierarchy. Below the base the
+refinement is STRUCTURED and exactly nested (each level is the regular
+refinement of the one beneath — the nesting in the drawing is generated,
+and verified, not sketched), so level transfers are lossless: perfect
+FMG. The adapted children above the base are non-nested, and their
+transfers are approximate — that is where the approximation begins. The
+cut + split working mesh sits on top of the stack but OUTSIDE the
+hierarchy: a cut is not a multigrid level, and no level below it ever
+carries the fault.*
+
+### 3.1 Input contract and provenance
+
+Input: a *conforming labelled facet set* — the fault's name labels
+interior facets whose two support cells flank it. Any generator that
+produces this contract feeds the split: `cut_along_lines` /
+`place_along_lines` in 2-D, a gmsh-embedded surface
+(`uw.meshing.BoxInternalPatch`) in 3-D, and the internal-boundary meshes
+(`BoxInternalBoundary`, `AnnulusInternalBoundary`, …) carry it natively.
+
+The split is a pure function of the source mesh (nothing cached, source
+untouched): a moving fault is re-cut and re-split from the static base,
+the same non-cumulative pattern as mesh adaptation. It returns two
+provenance maps — `point_map` (old point → new point) and `clone_map`
+(replica → original) — and the coincident pairing
+`mesh._fault_point_pairs[name]` built from `clone_map`. The pairing is
+the *only* source of the pair association: the two sides are
+geometrically coincident, so no coordinate query can ever recover it.
+
+### 3.2 2-D: the chain split
+
+A fresh plex is built with the chart grown: cells keep their source order
+(per-cell data stays aligned), replicas are appended to the vertex
+stratum, and the edge stratum is re-derived from the substituted cell
+list — an old facet is reused (labels intact) exactly where its vertex
+pair survived, and re-homed onto replicas where it did not. Side
+assignment walks the cut cell fan around each interior chain vertex;
+every fault facet's two supports must land on opposite sides
+(asserted, not assumed).
+
+### 3.3 3-D: the patch split
+
+The same operation one stratum deeper, with one structural change: rather
+than hand-wiring tetrahedral cone orientations, the substituted cells are
+built *uninterpolated* (vertex 4-tuples carry no orientation data) and
+`DMPlexInterpolate` derives faces and edges. Cell and vertex numbering
+are preserved (asserted), and every old face or edge is recovered in the
+new chart by joining (`DMPlexGetFullJoin`) its mapped vertex tuple; a
+tuple that no longer joins was re-homed, and its replacement is found by
+collapsing replicas back to originals — the 2-D re-derivation rule
+expressed through joins.
+
+Side assignment: an orientability propagation gives every patch face a
+consistent oriented triple (also proving the patch is one connected
+orientable sheet); the sign of
+$\det[\,b-a,\ c-a,\ d-a\,]$ classifies each fault face's two support
+cells ($d$ the cell's off-face vertex); and around each interior patch
+vertex the remaining star cells are flooded through shared non-fault
+faces — the patch must cut every such star into exactly two half-balls.
+
+Chart arithmetic (the structural test): with $F$ fault faces, $E_i$
+interior patch edges and $V_i$ interior patch vertices, the split adds
+exactly $(\Delta V, \Delta E, \Delta F) = (V_i, E_i, F)$ and the Euler
+characteristic changes by $V_i - E_i + F$ = the patch interior's own
+characteristic — $+1$ for any disc-like patch (2-D analogue: the slit
+disc, $\chi: 1 \to 0$; 3-D: $\chi: 1 \to 2$, a ball acquiring a lens
+cavity), independent of resolution.
+
+### 3.4 Refusals (all loud, all collective)
+
+| refused | reason |
+|---------|--------|
+| junction / non-manifold (three facets at an edge) | represent branches as offset segments (ligament of ~1–2 h) |
+| closed loop (2-D), pinched or non-orientable patch (3-D) | no tips / star not two half-balls |
+| single-facet chain; 3-D face with no interior vertex | the two copies would carry the same point tuple |
+| fault touching the domain boundary | daylighting needs a wall/fault constraint composition (see open questions) |
+| seam contact in 3-D; non-vertex seam crossings in 2-D | parallel rules below |
+
+### 3.5 Parallel
+
+2-D: a fault may cross a partition seam only *through a shared vertex
+pinned exactly at the crossing* (the cut machinery manufactures these);
+the crossing vertex's replica pair rides one extra star-forest entry,
+keyed on (original root, side), and both flanking facet fans stay
+rank-local. Everything else near a seam is refused, collectively (an
+`allgather` synchronises the verdict so every rank raises together; a
+seam verdict outranks the chain-fragment symptoms other ranks see).
+Swept at np = 3, 4, 5: 17/27 crossing configurations split cleanly; every
+refusal is collective and categorised (three-rank corners; fault running
+along a seam).
+
+The 3-D split requires the patch's whole cell star rank-interior (a 3-D
+seam crossing is a *curve* — a design of its own, deferred), but this is
+now satisfied **by construction** rather than demanded of the user:
+`split_fault` first REDISTRIBUTES the cut mesh with a shell partition
+that gathers the patch's cell star, plus one growth layer, onto the rank
+already owning most of it (SF-propagated marking, so cells touching a
+patch vertex without holding a labelled face are found; one growth layer
+is exactly sufficient because a point is shared iff its incident cells
+span ranks). Everything outside that thin skin keeps the load-balanced
+partition, so the imbalance is bounded by the star — measured $1.8\times$
+at np = 8 on a graded box, where the naive alternative (whole refined
+band on one rank) would be $\sim 3\times$. The default partitioner's
+balance cuts are otherwise ATTRACTED to the refined patch region, which
+made graded fault meshes refuse at every np before this. Split at
+np = 2–8 with identical pair topology to serial. Open: several 3-D
+faults on one parallel mesh (the pairing does not yet migrate through
+the redistribution; refused loudly).
+
+## 4. Trace assembly
+
+The interface residual and tangent are assembled on trace elements built
+from the doubled facets, with nodes = the coincident pairs (tips/rim
+enter with $V \equiv 0$ and receive no rows):
+
+| | 2-D | 3-D |
+|---|---|---|
+| element | P2 line (3 nodes) | P2 triangle (6 nodes) |
+| quadrature | 3-pt Gauss (degree 4) | 6-pt Dunavant (degree 4) |
+| slip rows/node | 1 | 2 (matching the pair block's $\hat t_1, \hat t_2$ — one shared frame authority) |
+| de-smear mass | lumped row-sum ($L/6, 2L/3, L/6$ — positive) | P1 sub-lumping ($A/12$ vertex, $A/4$ midpoint) |
+
+The 3-D mass choice is forced: the lumped (row-sum) P2 *triangle* mass
+has identically zero vertex rows, so the reaction de-smear divides by
+zero there; subdividing each straight P2 triangle into its four P1
+sub-triangles and lumping those gives every node a positive weight.
+
+## 5. Benchmarks
+
+All Stokes runs: P2 velocity / P0 discontinuous pressure (continuous
+pressure smears the cross-fault pressure jump), `stokes.tolerance`
+(never raw `ksp_rtol`), pressure nullspace attached, GAMG velocity
+block on split meshes.
+
+### 5.1 Conditioning: contact vs thin weak inclusion (2-D)
+
+Identical adapted mesh, identical solver configuration, the fault
+represented two ways:
+
+| arm | representation | outer Schur its | wall time |
+|-----|----------------|------------------|-----------|
+| A | one-element band, viscosity contrast $10^{-4}$ | 147 | ~100 s |
+| B | split-node, prescribed slip, **uniform viscosity** | 10 | ~6 s |
+
+Both arms: every sub-KSP genuinely converged (checked via
+`getConvergedReason`, not SNES status). The split's iteration count is
+resolution-independent (10 at both refinement levels). Well-posedness:
+$\int \nabla\!\cdot v \sim 2\times10^{-16}$; refinement moves stress
+stations < 1.1 %; tolerance $10^{-5} \to 10^{-7}$ moves them 0.01 %; P0
+pressure at the slit is a clean antisymmetric crack-tip dipole, no
+checkerboarding. The two representations are different boundary-value
+problems; their $\Delta$CFF *decay* families agree
+(1/.392/.164/.055 vs 1/.406/.171/.057 at 0.1/0.25/0.5/1 fault lengths)
+with amplitudes offset 6–9 %.
+
+### 5.2 The frictionless crack (2-D)
+
+Emergent slip under far-field shear: leak $5\times10^{-18}$; slip profile
+elliptical to 1.45 % RMS; peak slip 91 % of the infinite-medium value
+$\Delta\tau\,a/\eta$ (finite box, Dirichlet walls — below, as it must
+be); converged in one Newton increment.
+
+### 5.3 The viscous interface family (2-D)
+
+$\tau = \eta_f V$ swept over three decades: monotone from the
+frictionless crack to welded (peak slip 1 % of free at
+$\eta_f = 100\,\eta/a$), machine-zero opening throughout, following the
+crack compliance
+
+$$V/V_{\rm free} = \frac{1}{1 + 0.91\,\eta_f\,a/\eta},$$
+
+with the half-slip point at $\eta_f = \eta/a$ as dimensional analysis
+requires. The welded endmember's stress field is indistinguishable from
+the *uncut* continuum on the same mesh — the law penalises the jump only.
+
+### 5.4 Friction and state (2-D and 3-D)
+
+- Coulomb, sliding branch: constant-stress-drop behaviour (slip scales
+  with the excess of driving stress over strength); stick branch: creep
+  at the regularisation scale $V_0$. With $\sigma_n$ reaction-fed, the
+  recovered normal stress matches the driven compression.
+- Rate-and-state: from off-steady initial state, repeated solve/age
+  cycles drive the monitor $\theta V/D_c$ monotonically to 1.
+- Both re-verified in 3-D (regression-tested); the law layer itself is
+  dimension-blind.
+
+### 5.5 The penny-shaped crack (3-D)
+
+Circular frictionless crack, radius $a = 0.15$, in an $L^3$ box of
+uniform viscosity under uniform resolved shear $\tau$; oracle: the
+incompressible ($\nu = 1/2$) infinite-medium profile
+
+$$\Delta v(r) = \frac{8}{3\pi}\,\frac{\tau}{\eta}\sqrt{a^2 - r^2}.$$
+
+| box $L$ | $h$ | pairs | leak | peak/oracle | fitted amplitude | shape RMS |
+|--------|-----|-------|------|-------------|------------------|-----------|
+| 1.0 | 0.05 | 144 | 0 | 0.930 | 0.866 | 6.9 % |
+| 1.0 | 0.035 | 272 | 0 | 0.947 | 0.907 | 5.1 % |
+| 1.5 | 0.05 | 144 | $6\times10^{-19}$ | 0.941 | 0.879 | 6.6 % |
+
+Slip is parallel to the resolved shear everywhere (off-shear component
+$< 10^{-2}$ of peak), and the amplitude sits *below* the oracle and
+converges toward it from below under both mesh refinement and box
+growth — the correct sign for a finite Dirichlet box, which is stiffer
+than the infinite medium.
+
+## 6. Current limitations
+
+- One open chain (2-D) / one orientable disc-like patch (3-D) per label;
+  branches via offset segments.
+- No daylighting: the fault cannot reach the domain boundary.
+- No closed loops (ring/spherical slippery surfaces).
+- 3-D parallel: one fault per mesh (the star-gathering redistribution
+  does not yet migrate a prior fault's pairing); a fault larger than
+  one rank's memory needs the seam-curve design.
+- Split meshes carry no geometric-multigrid tail (coarse levels do not
+  carry the fault); GAMG is the velocity default.
+- Fault motion = re-cut + re-split from the base (fields transfer via
+  the re-adaptation machinery); no incremental update.
+
+## 7. Open design questions (under discussion)
+
+1. **API unification with bulk rheology** — fault laws as
+  constitutive-model-like objects with `Parameters`, assigned per fault,
+  rather than per-law `add_*_fault_bc` functions.
+2. **Closed-loop and daylighting interfaces** — the internal-boundary
+  meshes already carry the split's input contract (verified:
+  `AnnulusInternalBoundary`'s ring and `BoxInternalBoundary`'s spanning
+  surface are conforming labelled facet sets; each is refused only by a
+  topology rule, not by any plumbing gap). Loops need no-tip topology
+  plus the new nullspaces of a disconnected interior body; daylighting
+  needs the wall/fault constraint composition at the intersection.
diff --git a/docs/developer/design/figures/split-node-faults/generate-grid-hierarchy-data.py b/docs/developer/design/figures/split-node-faults/generate-grid-hierarchy-data.py
new file mode 100644
index 000000000..068202bd3
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/generate-grid-hierarchy-data.py
@@ -0,0 +1,47 @@
+"""Coarse FMG levels for the grid-hierarchy figure.
+
+The base mesh (h = 0.25 on a 2.0 x 1.0 domain) is the finest level of a
+geometric hierarchy built by STRUCTURED refinement: the coarse levels at
+h = 0.5 and h = 1.0 come from the same diagonal-split quad generator, so
+midpoint (regular) refinement of each level IS the next — the nesting is
+exact, and this script VERIFIES it (every coarse vertex coincides with a
+fine one) rather than assuming it.
+"""
+import json
+import os
+
+import numpy as np
+
+
+def level(h):
+    xs = np.arange(0.0, 2.0 + 1e-9, h)
+    ys = np.arange(0.0, 1.0 + 1e-9, h)
+    idx, pts = {}, []
+    for i, x in enumerate(xs):
+        for j, y in enumerate(ys):
+            idx[(i, j)] = len(pts)
+            pts.append([x, y])
+    tris = []
+    for i in range(len(xs) - 1):
+        for j in range(len(ys) - 1):
+            a, b = idx[(i, j)], idx[(i + 1, j)]
+            c, d = idx[(i + 1, j + 1)], idx[(i, j + 1)]
+            tris.extend([[a, b, c], [a, c, d]])
+    return dict(coords=pts, tris=tris)
+
+
+out = dict(coarse2=level(1.0), coarse1=level(0.5))
+
+# exact-nesting check: every coarse vertex is a fine vertex (bit-exact
+# up to the arange rounding), level by level down to the base
+fine = level(0.25)
+for name in ("coarse1", "coarse2"):
+    coarse_set = {tuple(np.round(p, 12)) for p in out[name]["coords"]}
+    fine_set = {tuple(np.round(p, 12)) for p in fine["coords"]}
+    assert coarse_set <= fine_set, f"{name} not nested in the base"
+print("nesting exact: coarse2 < coarse1 < base")
+here = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(here, "grid-hierarchy-data.json"), "w") as f:
+    json.dump(out, f)
+for name, p in out.items():
+    print(f"{name}: {len(p['coords'])} pts, {len(p['tris'])} tris")
diff --git a/docs/developer/design/figures/split-node-faults/generate-split-anatomy-data.py b/docs/developer/design/figures/split-node-faults/generate-split-anatomy-data.py
new file mode 100644
index 000000000..7e8d18ca2
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/generate-split-anatomy-data.py
@@ -0,0 +1,75 @@
+"""Geometry for the split-anatomy figure (cetz draws, Python computes).
+
+A small structured triangulation of [0,3] x [0,1] with a fault chain along
+y = 0.5 from (0.5, 0.5) to (2.5, 0.5): 4 fault edges, 3 interior vertices
+(duplicated by the split), 2 tips (shared). The "after" panel is EXPLODED
+for display — the Minus side translated down — because the real copies are
+geometrically coincident.
+"""
+import json
+import os
+
+H = 0.5
+NX, NY = 6, 2
+DELTA = 0.22          # display-only explosion offset
+
+verts = {}
+coords = []
+
+
+def vid(i, j):
+    if (i, j) not in verts:
+        verts[(i, j)] = len(coords)
+        coords.append([i * H, j * H])
+    return verts[(i, j)]
+
+
+tris = []
+for i in range(NX):
+    for j in range(NY):
+        a, b = vid(i, j), vid(i + 1, j)
+        c, d = vid(i + 1, j + 1), vid(i, j + 1)
+        tris.append([a, b, c])
+        tris.append([a, c, d])
+
+chain = [vid(i, 1) for i in range(1, 6)]      # (0.5,0.5) .. (2.5,0.5)
+tips = [chain[0], chain[-1]]
+interior = chain[1:-1]
+
+# Minus side = triangles whose centroid lies below the chain SEGMENT span;
+# triangles below y=0.5 but outside the span stay welded (no fault there).
+side = []
+for t in tris:
+    cx = sum(coords[v][0] for v in t) / 3.0
+    cy = sum(coords[v][1] for v in t) / 3.0
+    touches = any(v in chain for v in t)
+    side.append(-1 if (cy < 0.5 and touches and 0.5 < cx < 2.5) else +1)
+
+# Exploded positions: replicas of the interior chain vertices move down;
+# to keep the Minus flank rigid, the row below them (y = 0) within the span
+# moves too. Tips stay put — the lens pins there.
+exploded = [list(c) for c in coords]
+replicas = {}
+for v in interior:
+    replicas[v] = len(exploded)
+    exploded.append([coords[v][0], coords[v][1] - DELTA])
+moved_tris = []
+flank = set()
+for t, s in zip(tris, side):
+    if s < 0:
+        moved_tris.append([replicas.get(v, v) for v in t])
+        flank.update(v for v in t if v not in chain)
+    else:
+        moved_tris.append(list(t))
+for v in flank:
+    exploded[v][1] -= DELTA
+
+out = dict(coords=coords, exploded=exploded, tris=tris,
+           moved_tris=moved_tris, side=side, chain=chain, tips=tips,
+           interior=interior, replicas=replicas, delta=DELTA)
+here = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(here, "split-anatomy-data.json"), "w") as f:
+    json.dump(out, f)
+print("wrote split-anatomy-data.json:",
+      f"{len(coords)} verts, {len(tris)} tris, chain {len(chain)},",
+      f"replicas {len(replicas)}")
diff --git a/docs/developer/design/figures/split-node-faults/generate-stack-progression-data.py b/docs/developer/design/figures/split-node-faults/generate-stack-progression-data.py
new file mode 100644
index 000000000..34296cef5
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/generate-stack-progression-data.py
@@ -0,0 +1,130 @@
+"""Geometry for the stack-on progression figure (cetz draws, Python
+computes).
+
+Five panels from deterministic point sets over [0,2] x [0,1.2] with a
+slanted fault segment: (a) the static base mesh with the fault MANIFOLD
+overlaid (geometry only — not in the mesh); (b,c) two adapt-on-top
+layers, points graded toward the manifold; (d) the cut — vertices placed
+ON the segment so the fault becomes a conforming facet chain; (e) the
+split, exploded for display exactly as in split-anatomy.
+"""
+import json
+import os
+
+import numpy as np
+from scipy.spatial import Delaunay
+
+A = np.array([0.50, 0.32])
+B = np.array([1.50, 0.66])
+T = (B - A) / np.linalg.norm(B - A)
+N = np.array([-T[1], T[0]])
+LEN = float(np.linalg.norm(B - A))
+
+
+def seg_dist(p):
+    s = np.clip((p - A) @ T, 0.0, LEN)
+    return float(np.linalg.norm(p - (A + s * T)))
+
+
+def grid(h):
+    xs = np.arange(0.0, 2.0 + 1e-9, h)
+    ys = np.arange(0.0, 1.0 + 1e-9, h)
+    return np.array([[x, y] for x in xs for y in ys])
+
+
+def band(h, width):
+    """Refinement points near the fault, deliberately NOT conforming to it:
+    an axis-aligned lattice with deterministic jitter, restricted to the
+    distance band. A real adapted mesh refines TOWARD the line without
+    containing it — the conforming chain must be visibly the CUT's
+    contribution, not an accident of the refinement layout."""
+    out = []
+    xs = np.arange(0.06, 1.95, h)
+    ys = np.arange(0.05, 0.96, h)
+    for i, x in enumerate(xs):
+        for j, y in enumerate(ys):
+            q = np.array([
+                x + 0.33 * h * np.sin(12.9898 * i + 78.233 * j),
+                y + 0.33 * h * np.sin(39.3460 * i + 11.135 * j)])
+            if (seg_dist(q) < width
+                    and 0.03 < q[0] < 1.97 and 0.03 < q[1] < 0.97):
+                out.append(q)
+    return np.array(out)
+
+
+def dedup(points, spacing):
+    kept = []
+    for p in points:
+        if all(np.linalg.norm(p - q) > spacing for q in kept):
+            kept.append(p)
+    return np.array(kept)
+
+
+def triangulate(points):
+    tri = Delaunay(points)
+    return points, tri.simplices
+
+
+def pack(points, tris):
+    return dict(coords=points.tolist(), tris=tris.tolist())
+
+
+panels = {}
+
+# (a) base: coarse uniform
+base_pts = grid(0.25)
+panels["base"] = pack(*triangulate(base_pts))
+
+# (b) layer 1: base + a coarse band toward the manifold
+l1 = dedup(np.vstack([grid(0.25), band(0.125, 0.22)]), 0.07)
+panels["l1"] = pack(*triangulate(l1))
+
+# (c) layer 2: tighter band on top
+l2 = dedup(np.vstack([grid(0.25), band(0.125, 0.24), band(0.062, 0.10)]), 0.036)
+panels["l2"] = pack(*triangulate(l2))
+
+# (d) cut: clear a corridor around the segment, then place vertices ON it
+keep = np.array([p for p in l2 if seg_dist(p) > 0.048])
+on_seg = np.array([A + s * T for s in np.arange(0.0, LEN + 1e-9, 0.062)])
+cut_pts = np.vstack([keep, on_seg])
+cut_pts, cut_tris = triangulate(cut_pts)
+panels["cut"] = pack(cut_pts, cut_tris)
+chain = list(range(len(keep), len(cut_pts)))          # in s-order already
+
+# (e) split: explode the Minus flank (side of -N), tips pinned
+interior = chain[1:-1]
+tips = [chain[0], chain[-1]]
+side = []
+for t in cut_tris:
+    cen = cut_pts[t].mean(axis=0)
+    s = np.clip((cen - A) @ T, 0.0, LEN)
+    touches = any(v in chain for v in t)
+    inside = 0.0 < (cen - A) @ T < LEN
+    side.append(-1 if ((cen - (A + s * T)) @ N < 0 and touches and inside)
+                else +1)
+DELTA = 0.06
+exploded = [list(p) for p in cut_pts]
+replicas = {}
+for v in interior:
+    replicas[v] = len(exploded)
+    exploded.append(list(cut_pts[v] - DELTA * N))
+moved_tris, flank = [], set()
+for t, s in zip(cut_tris.tolist(), side):
+    if s < 0:
+        moved_tris.append([replicas.get(v, v) for v in t])
+        flank.update(v for v in t if v not in chain)
+    else:
+        moved_tris.append(list(t))
+for v in flank:
+    exploded[v] = list(np.array(exploded[v]) - DELTA * N)
+panels["split"] = dict(coords=exploded,
+                       tris=[list(t) for t in moved_tris], side=side)
+
+out = dict(panels=panels, chain=chain, tips=tips, interior=interior,
+           replicas={str(k): v for k, v in replicas.items()},
+           fault=[A.tolist(), B.tolist()], cut_side=side)
+here = os.path.dirname(os.path.abspath(__file__))
+with open(os.path.join(here, "stack-progression-data.json"), "w") as f:
+    json.dump(out, f)
+for name, p in panels.items():
+    print(f"{name}: {len(p['coords'])} pts, {len(p['tris'])} tris")
diff --git a/docs/developer/design/figures/split-node-faults/grid-hierarchy-data.json b/docs/developer/design/figures/split-node-faults/grid-hierarchy-data.json
new file mode 100644
index 000000000..d7d1d8a8c
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/grid-hierarchy-data.json
@@ -0,0 +1 @@
+{"coarse2": {"coords": [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0], [2.0, 0.0], [2.0, 1.0]], "tris": [[0, 2, 3], [0, 3, 1], [2, 4, 5], [2, 5, 3]]}, "coarse1": {"coords": [[0.0, 0.0], [0.0, 0.5], [0.0, 1.0], [0.5, 0.0], [0.5, 0.5], [0.5, 1.0], [1.0, 0.0], [1.0, 0.5], [1.0, 1.0], [1.5, 0.0], [1.5, 0.5], [1.5, 1.0], [2.0, 0.0], [2.0, 0.5], [2.0, 1.0]], "tris": [[0, 3, 4], [0, 4, 1], [1, 4, 5], [1, 5, 2], [3, 6, 7], [3, 7, 4], [4, 7, 8], [4, 8, 5], [6, 9, 10], [6, 10, 7], [7, 10, 11], [7, 11, 8], [9, 12, 13], [9, 13, 10], [10, 13, 14], [10, 14, 11]]}}
\ No newline at end of file
diff --git a/docs/developer/design/figures/split-node-faults/grid-hierarchy.png b/docs/developer/design/figures/split-node-faults/grid-hierarchy.png
new file mode 100644
index 000000000..43505a2fe
Binary files /dev/null and b/docs/developer/design/figures/split-node-faults/grid-hierarchy.png differ
diff --git a/docs/developer/design/figures/split-node-faults/grid-hierarchy.typ b/docs/developer/design/figures/split-node-faults/grid-hierarchy.typ
new file mode 100644
index 000000000..0f9a8a553
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/grid-hierarchy.typ
@@ -0,0 +1,148 @@
+// The grid hierarchy, vertical companion to stack-progression. Thesis:
+// the static base is itself the finest level of a geometric (FMG)
+// hierarchy; the adapt-on-top children EXTEND that hierarchy upward,
+// one level per doubling of resolution — and the cut + split mesh sits
+// on top of the stack but OUTSIDE the hierarchy: a cut is not a
+// multigrid level.
+#import "@preview/cetz:0.3.4"
+
+#set page(width: auto, height: auto, margin: 12pt)
+#set text(font: ("Noto Sans", "Helvetica", "Arial"), size: 5pt)
+
+#let stack = json("stack-progression-data.json")
+#let coarse = json("grid-hierarchy-data.json")
+
+#let mesh-fill = rgb("#eef3fa")
+#let mesh-fill-minus = rgb("#fce4ec")
+#let mesh-fill-plus = rgb("#dce8fc")
+#let mesh-stroke = rgb("#8899aa")
+#let fault-col = rgb("#c62828")
+#let arrow-col = rgb("#444444")
+#let approx-col = rgb("#b57500")
+
+#let PH = 1.0
+#let VGAP = 0.62
+#let panel-y(k) = k * (PH + VGAP)
+
+#let draw-mesh(y0, p, fills: none) = {
+  import cetz.draw: *
+  let P(v) = (p.coords.at(v).at(0), p.coords.at(v).at(1) + y0)
+  for (k, t) in p.tris.enumerate() {
+    let fill = if fills == none { mesh-fill } else { fills.at(k) }
+    line(P(t.at(0)), P(t.at(1)), P(t.at(2)), close: true,
+         fill: fill, stroke: (paint: mesh-stroke, thickness: 0.25pt))
+  }
+}
+
+#let draw-manifold(y0) = {
+  import cetz.draw: *
+  let a = stack.fault.at(0)
+  let b = stack.fault.at(1)
+  line((a.at(0), a.at(1) + y0), (b.at(0), b.at(1) + y0),
+       stroke: (paint: fault-col, thickness: 0.9pt, dash: "dashed"))
+}
+
+#let rise-arrow(k, label, col: rgb("#444444")) = {
+  import cetz.draw: *
+  let y = panel-y(k) + PH + 0.08
+  line((-0.35, y), (-0.35, y + VGAP - 0.16),
+       stroke: (paint: col, thickness: 0.8pt), mark: (end: ">"))
+  content((-0.52, y + (VGAP - 0.16) / 2), angle: 90deg,
+          text(size: 4.5pt, fill: col, label))
+}
+
+#let caption(k, body) = {
+  import cetz.draw: *
+  content((2.18, panel-y(k) + PH / 2), anchor: "west",
+          align(left, text(size: 4.5pt, body)))
+}
+
+#cetz.canvas(length: 1.5cm, {
+  import cetz.draw: *
+
+  // ---- the geometric hierarchy, bottom up --------------------------------
+  draw-mesh(panel-y(0), coarse.coarse2)
+  caption(0, [coarsest level\ (structured)])
+  rise-arrow(0, [refine ×2, nested])
+
+  draw-mesh(panel-y(1), coarse.coarse1)
+  caption(1, [coarse level\ (structured)])
+  rise-arrow(1, [refine ×2, nested])
+
+  draw-mesh(panel-y(2), stack.panels.base)
+  draw-manifold(panel-y(2))
+  caption(2, [the STATIC base\ (finest NESTED level;\ fault = geometry only)])
+  rise-arrow(2, [adapt, non-nested], col: approx-col)
+
+  draw-mesh(panel-y(3), stack.panels.l1)
+  draw-manifold(panel-y(3))
+  caption(3, [adapted child, layer 1])
+  rise-arrow(3, [adapt, non-nested], col: approx-col)
+
+  draw-mesh(panel-y(4), stack.panels.l2)
+  draw-manifold(panel-y(4))
+  caption(4, [adapted child, layer 2\ (finest mesh)])
+
+  // ---- the separator: everything above is NOT a level --------------------
+  let ysep = panel-y(5) - VGAP / 2 + 0.06
+  line((-0.7, ysep), (3.6, ysep),
+       stroke: (paint: arrow-col, thickness: 0.7pt, dash: "dashed"))
+  content((1.45, ysep + 0.11),
+          text(size: 4.5pt, style: "italic")[a cut is not a multigrid level])
+  {
+    let y = panel-y(4) + PH + 0.08
+    line((-0.35, y), (-0.35, panel-y(5) - 0.08),
+         stroke: (paint: arrow-col, thickness: 0.8pt), mark: (end: ">"))
+    content((-0.72, (y + panel-y(5)) / 2 - 0.04), angle: 90deg,
+            text(size: 4.5pt)[cut + split])
+  }
+
+  // ---- the working mesh on top -------------------------------------------
+  {
+    let y0 = panel-y(5) + 0.12
+    let fills = stack.cut_side.map(s => if s < 0 { mesh-fill-minus }
+                                        else { mesh-fill-plus })
+    draw-mesh(y0, stack.panels.cut, fills: fills)
+    let a = stack.fault.at(0)
+    let b = stack.fault.at(1)
+    let dx = b.at(0) - a.at(0)
+    let dy = b.at(1) - a.at(1)
+    let ln = calc.sqrt(dx * dx + dy * dy)
+    let nx = -dy / ln
+    let ny = dx / ln
+    let d = 0.022
+    line((a.at(0), a.at(1) + y0), (b.at(0), b.at(1) + y0),
+         stroke: (paint: white, thickness: 3pt))
+    for s in (-1.0, 1.0) {
+      line((a.at(0) + s * d * nx, a.at(1) + s * d * ny + y0),
+           (b.at(0) + s * d * nx, b.at(1) + s * d * ny + y0),
+           stroke: (paint: fault-col, thickness: 0.7pt))
+    }
+    for pt in (a, b) {
+      circle((pt.at(0), pt.at(1) + y0), radius: 0.032, fill: white,
+             stroke: (paint: black, thickness: 0.8pt))
+    }
+    content((2.18, y0 + PH / 2), anchor: "west",
+            align(left, text(size: 4.5pt)[the working mesh:\ split, top of
+              the stack,\ OUTSIDE the hierarchy]))
+  }
+
+  // ---- brackets: exact nesting below the base, approximate above ---------
+  {
+    let x = 3.72
+    let y0 = panel-y(0)
+    let y1 = panel-y(2) + PH
+    line((x, y0), (x + 0.1, y0), (x + 0.1, y1), (x, y1),
+         stroke: (paint: arrow-col, thickness: 0.7pt))
+    content((x + 0.28, (y0 + y1) / 2), angle: 90deg,
+            text(size: 4.5pt)[FMG hierarchy: structured refinement,
+              EXACTLY nested — level transfers are lossless])
+    let y2 = panel-y(3)
+    let y3 = panel-y(4) + PH
+    line((x, y2), (x + 0.1, y2), (x + 0.1, y3), (x, y3),
+         stroke: (paint: approx-col, thickness: 0.7pt))
+    content((x + 0.28, (y2 + y3) / 2), angle: 90deg,
+            text(size: 4.5pt, fill: approx-col)[adapted levels:
+              non-nested — transfers are APPROXIMATE])
+  }
+})
diff --git a/docs/developer/design/figures/split-node-faults/pair-transform.png b/docs/developer/design/figures/split-node-faults/pair-transform.png
new file mode 100644
index 000000000..1aee9129c
Binary files /dev/null and b/docs/developer/design/figures/split-node-faults/pair-transform.png differ
diff --git a/docs/developer/design/figures/split-node-faults/pair-transform.typ b/docs/developer/design/figures/split-node-faults/pair-transform.typ
new file mode 100644
index 000000000..68d6118fb
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/pair-transform.typ
@@ -0,0 +1,71 @@
+// The pair transform. Thesis: one orthogonal 2·dim block per coincident
+// DOF pair converts (v+, v-) to mean and jump components in the fault
+// frame; the no-opening constraint and the friction law each occupy
+// exactly their own rotated row(s), and everything else stays free.
+#import "@preview/cetz:0.3.4"
+
+#set page(width: auto, height: auto, margin: 12pt)
+#set text(font: ("Noto Sans", "Helvetica", "Arial"), size: 5pt)
+
+#let fault-col = rgb("#c62828")
+#let mean-bg = rgb("#dce8fc")
+#let jump-n-bg = rgb("#fef3c7")
+#let jump-t-bg = rgb("#fce4ec")
+#let row-stroke = rgb("#8899aa")
+
+#cetz.canvas(length: 1.35cm, {
+  import cetz.draw: *
+
+  let row(y, fill, label, role, name: none) = {
+    rect((3.1, y - 0.3), (6.4, y + 0.3), fill: fill,
+         stroke: (paint: row-stroke, thickness: 0.5pt), radius: 3pt)
+    content((4.75, y), label)
+    content((8.55, y), align(left, role))
+  }
+
+  // ---- left: the coincident pair with the fault frame --------------------
+  // fault trace through the pair
+  line((-0.4, 0.6), (2.0, 1.4), stroke: (paint: fault-col,
+       thickness: 1.0pt))
+  line((-0.4, 0.44), (2.0, 1.24), stroke: (paint: fault-col,
+       thickness: 1.0pt, dash: "densely-dashed"))
+  // the pair (drawn slightly apart; coincident in reality)
+  circle((0.8, 1.0), radius: 0.05, fill: fault-col, stroke: none)
+  circle((0.8, 0.84), radius: 0.05, fill: white,
+         stroke: (paint: fault-col, thickness: 0.9pt))
+  content((0.28, 1.28), text(size: 4.5pt)[$v^+$])
+  content((0.3, 0.52), text(size: 4.5pt)[$v^-$])
+  // frame at the pair
+  line((0.8, 1.0), (0.42, 2.0), stroke: (thickness: 0.8pt), mark: (end: ">"))
+  content((0.28, 2.2), $hat(n)$)
+  line((0.8, 1.0), (1.9, 1.44), stroke: (thickness: 0.8pt), mark: (end: ">"))
+  content((2.14, 1.56), $hat(t)_1$)
+  content((1.62, 0.92), text(size: 4.5pt, fill: rgb("#555555"))[($hat(t)_2$ in 3-D)])
+
+  content((0.8, -0.4), align(center, text(size: 4.5pt)[coincident pair
+    (2·dim DOFs), \ no shared unknowns]))
+
+  // arrow to the rotated rows
+  line((2.25, 0.65), (2.95, 0.65), stroke: (thickness: 0.9pt),
+       mark: (end: ">"))
+  content((2.6, 1.0), text(size: 4.5pt)[$Q$])
+
+  // ---- right: the rotated rows -------------------------------------------
+  content((4.75, 2.6), align(center)[rotated unknowns (per pair)])
+  content((8.55, 2.6), align(center)[role])
+
+  row(1.9, mean-bg, [$(v^+ + v^-) dot hat(n) slash sqrt(2)$],
+      text(size: 4.5pt)[free — bulk momentum])
+  row(1.1, mean-bg, [$(v^+ + v^-) dot hat(t) slash sqrt(2)$],
+      text(size: 4.5pt)[free — bulk momentum])
+  row(0.3, jump-n-bg, [$[v] dot hat(n) slash sqrt(2)$],
+      text(size: 4.5pt)[constrained $= 0$ — no opening; \ reaction $arrow.r sigma_n$])
+  row(-0.7, jump-t-bg, [$[v] dot hat(t) slash sqrt(2) = V slash sqrt(2)$],
+      text(size: 4.5pt)[the law: $integral_Gamma tau(V, sigma_n, theta)
+        thin delta V$; \ tangent $2 (diff tau slash diff V) M$ per iterate])
+
+  content((4.75, -1.65), align(center, text(size: 4.5pt)[
+    frictionless: slip row simply FREE (zero shear traction) \
+    3-D: two slip rows, collinear traction
+    $bold(tau) = tau(|V|) hat(V)$]))
+})
diff --git a/docs/developer/design/figures/split-node-faults/render-components-3d.py b/docs/developer/design/figures/split-node-faults/render-components-3d.py
new file mode 100644
index 000000000..30525fea8
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/render-components-3d.py
@@ -0,0 +1,95 @@
+"""3-D split components from the REAL mesh (pyvista; data-heavy, not cetz).
+
+Thesis: in 3-D the split doubles the interior of the PATCH — faces, edges
+and vertices — while the RIM (the patch boundary) stays single, the tip
+rule one dimension up. Rendered from an actual BoxInternalPatch +
+split_fault mesh: the two coincident face sets pulled apart along the
+normal for display, the shared rim drawn once, in black.
+
+Run inside the fault-split-node worktree env.
+"""
+import os
+
+import numpy as np
+import pyvista as pv
+
+import underworld3 as uw
+from underworld3.utilities.fault_split import split_fault
+
+pv.OFF_SCREEN = True
+D = os.path.dirname(os.path.abspath(__file__))
+
+PATCH = np.array([[0.5, 0.30, 0.30], [0.5, 0.70, 0.30],
+                  [0.5, 0.70, 0.70], [0.5, 0.30, 0.70]])
+mesh = uw.meshing.BoxInternalPatch(cellSize=0.12, patch_points=PATCH,
+                                   patch_name="FltA")
+child = split_fault(mesh, "FltA")
+dm = child.dm
+vS, vE = dm.getDepthStratum(0)
+X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 3)
+
+
+def side_faces(label):
+    value = int(child.boundaries[label].value)
+    faces = [int(p) for p in
+             dm.getLabel(label).getStratumIS(value).getIndices()]
+    polys, verts = [], {}
+    pts = []
+    for f in faces:
+        tri = [int(p) for p in dm.getTransitiveClosure(f)[0]
+               if vS <= int(p) < vE]
+        ids = []
+        for v in tri:
+            if v not in verts:
+                verts[v] = len(pts)
+                pts.append(X[v - vS])
+            ids.append(verts[v])
+        polys.extend([3] + ids)
+    return pv.PolyData(np.array(pts), faces=np.array(polys)), faces
+
+
+plus, plus_faces = side_faces("FltAPlus")
+minus, _ = side_faces("FltAMinus")
+
+# rim = edges of the plus face set used exactly once
+edge_use = {}
+for f in plus_faces:
+    for e in dm.getCone(f):
+        edge_use[int(e)] = edge_use.get(int(e), 0) + 1
+rim_lines = []
+rim_pts = []
+for e, n in edge_use.items():
+    if n == 1:
+        a, b = (int(q) for q in dm.getCone(e))
+        rim_lines.extend([2, len(rim_pts), len(rim_pts) + 1])
+        rim_pts.extend([X[a - vS], X[b - vS]])
+rim = pv.PolyData(np.array(rim_pts), lines=np.array(rim_lines))
+
+EPS = 0.05
+plus_e = plus.translate((+EPS, 0, 0))
+minus_e = minus.translate((-EPS, 0, 0))
+
+pl = pv.Plotter(off_screen=True, window_size=(1200, 950))
+pl.set_background("white")
+pl.add_mesh(plus_e, color="#dce8fc", show_edges=True, edge_color="#4a7bf7",
+            line_width=1.0, lighting=False, opacity=1.0)
+pl.add_mesh(minus_e, color="#fce4ec", show_edges=True, edge_color="#e57373",
+            line_width=1.0, lighting=False, opacity=1.0)
+pl.add_mesh(rim, color="black", line_width=3.5, lighting=False)
+box = pv.Box(bounds=(0, 1, 0, 1, 0, 1))
+pl.add_mesh(box.extract_all_edges(), color="#999999", line_width=0.8,
+            lighting=False)
+
+pl.add_point_labels(
+    np.array([[0.5 + EPS, 0.62, 0.76], [0.5 - EPS, 0.16, 0.30],
+              [0.5, 0.26, 0.78]]),
+    ["Plus copy (original points)", "Minus copy (replicas)",
+     "rim: single, shared"],
+    font_size=26, text_color="black", shape=None, always_visible=True,
+    show_points=False)
+
+pl.camera_position = [(1.75, -0.75, 1.25), (0.5, 0.5, 0.48), (0, 0, 1)]
+out = os.path.join(D, "split-components-3d.png")
+pl.screenshot(out)
+pl.close()
+print(f"wrote {out}")
diff --git a/docs/developer/design/figures/split-node-faults/split-anatomy-data.json b/docs/developer/design/figures/split-node-faults/split-anatomy-data.json
new file mode 100644
index 000000000..0b20373f2
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/split-anatomy-data.json
@@ -0,0 +1 @@
+{"coords": [[0.0, 0.0], [0.5, 0.0], [0.5, 0.5], [0.0, 0.5], [0.5, 1.0], [0.0, 1.0], [1.0, 0.0], [1.0, 0.5], [1.0, 1.0], [1.5, 0.0], [1.5, 0.5], [1.5, 1.0], [2.0, 0.0], [2.0, 0.5], [2.0, 1.0], [2.5, 0.0], [2.5, 0.5], [2.5, 1.0], [3.0, 0.0], [3.0, 0.5], [3.0, 1.0]], "exploded": [[0.0, 0.0], [0.5, -0.22], [0.5, 0.5], [0.0, 0.5], [0.5, 1.0], [0.0, 1.0], [1.0, -0.22], [1.0, 0.5], [1.0, 1.0], [1.5, -0.22], [1.5, 0.5], [1.5, 1.0], [2.0, -0.22], [2.0, 0.5], [2.0, 1.0], [2.5, -0.22], [2.5, 0.5], [2.5, 1.0], [3.0, 0.0], [3.0, 0.5], [3.0, 1.0], [1.0, 0.28], [1.5, 0.28], [2.0, 0.28]], "tris": [[0, 1, 2], [0, 2, 3], [3, 2, 4], [3, 4, 5], [1, 6, 7], [1, 7, 2], [2, 7, 8], [2, 8, 4], [6, 9, 10], [6, 10, 7], [7, 10, 11], [7, 11, 8], [9, 12, 13], [9, 13, 10], [10, 13, 14], [10, 14, 11], [12, 15, 16], [12, 16, 13], [13, 16, 17], [13, 17, 14], [15, 18, 19], [15, 19, 16], [16, 19, 20], [16, 20, 17]], "moved_tris": [[0, 1, 2], [0, 2, 3], [3, 2, 4], [3, 4, 5], [1, 6, 21], [1, 21, 2], [2, 7, 8], [2, 8, 4], [6, 9, 22], [6, 22, 21], [7, 10, 11], [7, 11, 8], [9, 12, 23], [9, 23, 22], [10, 13, 14], [10, 14, 11], [12, 15, 16], [12, 16, 23], [13, 16, 17], [13, 17, 14], [15, 18, 19], [15, 19, 16], [16, 19, 20], [16, 20, 17]], "side": [1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1], "chain": [2, 7, 10, 13, 16], "tips": [2, 16], "interior": [7, 10, 13], "replicas": {"7": 21, "10": 22, "13": 23}, "delta": 0.22}
\ No newline at end of file
diff --git a/docs/developer/design/figures/split-node-faults/split-anatomy.png b/docs/developer/design/figures/split-node-faults/split-anatomy.png
new file mode 100644
index 000000000..9a1048e43
Binary files /dev/null and b/docs/developer/design/figures/split-node-faults/split-anatomy.png differ
diff --git a/docs/developer/design/figures/split-node-faults/split-anatomy.typ b/docs/developer/design/figures/split-node-faults/split-anatomy.typ
new file mode 100644
index 000000000..13e9210c2
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/split-anatomy.typ
@@ -0,0 +1,90 @@
+// Split-node anatomy, 2-D. Thesis: splitting duplicates ONLY the interior
+// of the fault chain — cells on the Minus side rewire to replica vertices,
+// the tips stay shared, and the two copies are geometrically coincident
+// (the lower panel is exploded for display only).
+#import "@preview/cetz:0.3.4"
+
+#set page(width: auto, height: auto, margin: 12pt)
+#set text(font: ("Noto Sans", "Helvetica", "Arial"), size: 5pt)
+
+#let data = json("split-anatomy-data.json")
+
+#let mesh-fill-plus = rgb("#dce8fc")
+#let mesh-fill-minus = rgb("#fce4ec")
+#let mesh-stroke = rgb("#8899aa")
+#let fault-col = rgb("#c62828")
+#let replica-col = rgb("#c62828")
+#let tip-col = rgb("#1a1a1a")
+
+#let panel(origin-y, coords, tris, exploded: false) = {
+  import cetz.draw: *
+  let P(v) = (coords.at(v).at(0), coords.at(v).at(1) + origin-y)
+  // cells, painter's algorithm: fills first, then edges, then the fault
+  for (k, t) in tris.enumerate() {
+    let fill = if data.side.at(k) < 0 { mesh-fill-minus } else { mesh-fill-plus }
+    line(P(t.at(0)), P(t.at(1)), P(t.at(2)), close: true,
+         fill: fill, stroke: (paint: mesh-stroke, thickness: 0.3pt))
+  }
+  // fault facets: both copies carry the label
+  if exploded {
+    // Plus copy: original chain vertices
+    for i in range(data.chain.len() - 1) {
+      line(P(data.chain.at(i)), P(data.chain.at(i + 1)),
+           stroke: (paint: fault-col, thickness: 1.0pt))
+    }
+    // Minus copy: replicas where they exist, tips where shared
+    let lower(v) = if str(v) in data.replicas { data.replicas.at(str(v)) } else { v }
+    for i in range(data.chain.len() - 1) {
+      line(P(lower(data.chain.at(i))), P(lower(data.chain.at(i + 1))),
+           stroke: (paint: fault-col, thickness: 1.0pt, dash: "densely-dashed"))
+    }
+  } else {
+    for i in range(data.chain.len() - 1) {
+      line(P(data.chain.at(i)), P(data.chain.at(i + 1)),
+           stroke: (paint: fault-col, thickness: 0.9pt))
+    }
+  }
+  // vertices: interior chain (filled red), replicas (open red), tips (black ring)
+  for v in data.interior {
+    circle(P(v), radius: 0.045, fill: fault-col, stroke: none)
+  }
+  if exploded {
+    for (orig, rep) in data.replicas {
+      circle(P(rep), radius: 0.045, fill: white,
+             stroke: (paint: replica-col, thickness: 0.9pt))
+    }
+  }
+  for v in data.tips {
+    circle(P(v), radius: 0.055, fill: white,
+           stroke: (paint: tip-col, thickness: 1.0pt))
+    circle(P(v), radius: 0.02, fill: tip-col, stroke: none)
+  }
+}
+
+#cetz.canvas(length: 1.55cm, {
+  import cetz.draw: *
+
+  // ---- panel (a): the conforming labelled chain --------------------------
+  panel(2.1, data.coords, data.tris)
+  content((-0.35, 3.1), [(a)])
+  content((1.5, 1.78), align(center)[conforming chain — facets shared,
+    every FE space continuous])
+  content((3.35, 2.6), text(fill: fault-col)[$Gamma$])
+  content((0.5, 2.36), text(size: 4pt)[tip])
+  content((2.5, 2.36), text(size: 4pt)[tip])
+
+  // ---- panel (b): after the split (exploded for display) -----------------
+  panel(0.0, data.exploded, data.moved_tris, exploded: true)
+  content((-0.35, 1.0), [(b)])
+  content((1.5, -0.62), align(center)[split — interior vertices duplicated,
+    Minus cells rewired (exploded: the copies are coincident)])
+  content((3.42, 0.62), text(fill: fault-col, size: 4.5pt)[$Gamma^+$])
+  content((3.42, 0.13), text(fill: fault-col, size: 4.5pt)[$Gamma^-$])
+  // annotate one replica pair
+  line((1.5, 0.44), (1.75, 0.85), stroke: (paint: rgb("#555555"),
+       thickness: 0.3pt))
+  content((2.15, 0.95), text(size: 4pt)[$v^+$ (original)])
+  line((1.5, 0.24), (1.78, -0.12), stroke: (paint: rgb("#555555"),
+       thickness: 0.3pt))
+  content((2.2, -0.2), text(size: 4pt)[$v^-$ (replica)])
+})
diff --git a/docs/developer/design/figures/split-node-faults/split-components-3d.png b/docs/developer/design/figures/split-node-faults/split-components-3d.png
new file mode 100644
index 000000000..2f617522f
Binary files /dev/null and b/docs/developer/design/figures/split-node-faults/split-components-3d.png differ
diff --git a/docs/developer/design/figures/split-node-faults/stack-progression-data.json b/docs/developer/design/figures/split-node-faults/stack-progression-data.json
new file mode 100644
index 000000000..95728e0d4
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/stack-progression-data.json
@@ -0,0 +1 @@
+{"panels": {"base": {"coords": [[0.0, 0.0], [0.0, 0.25], [0.0, 0.5], [0.0, 0.75], [0.0, 1.0], [0.25, 0.0], [0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.25, 1.0], [0.5, 0.0], [0.5, 0.25], [0.5, 0.5], [0.5, 0.75], [0.5, 1.0], [0.75, 0.0], [0.75, 0.25], [0.75, 0.5], [0.75, 0.75], [0.75, 1.0], [1.0, 0.0], [1.0, 0.25], [1.0, 0.5], [1.0, 0.75], [1.0, 1.0], [1.25, 0.0], [1.25, 0.25], [1.25, 0.5], [1.25, 0.75], [1.25, 1.0], [1.5, 0.0], [1.5, 0.25], [1.5, 0.5], [1.5, 0.75], [1.5, 1.0], [1.75, 0.0], [1.75, 0.25], [1.75, 0.5], [1.75, 0.75], [1.75, 1.0], [2.0, 0.0], [2.0, 0.25], [2.0, 0.5], [2.0, 0.75], [2.0, 1.0]], "tris": [[5, 6, 0], [6, 1, 0], [1, 6, 2], [2, 6, 7], [10, 6, 5], [6, 10, 11], [36, 41, 42], [36, 42, 37], [29, 33, 34], [33, 29, 28], [19, 23, 24], [23, 19, 18], [29, 23, 28], [23, 29, 24], [27, 23, 22], [23, 27, 28], [10, 15, 11], [15, 16, 11], [25, 21, 20], [21, 25, 26], [21, 27, 22], [27, 21, 26], [15, 21, 16], [21, 15, 20], [14, 13, 18], [19, 14, 18], [8, 9, 4], [3, 8, 4], [8, 3, 2], [8, 2, 7], [14, 8, 13], [8, 14, 9], [6, 12, 7], [12, 6, 11], [12, 8, 7], [8, 12, 13], [41, 35, 40], [36, 35, 41], [38, 43, 44], [39, 38, 44], [43, 38, 42], [42, 38, 37], [38, 39, 34], [33, 38, 34], [31, 25, 30], [25, 31, 26], [35, 31, 30], [31, 35, 36], [17, 21, 22], [21, 17, 16], [17, 23, 18], [23, 17, 22], [16, 17, 11], [17, 12, 11], [13, 17, 18], [12, 17, 13], [32, 33, 28], [27, 32, 28], [38, 32, 37], [32, 38, 33], [32, 27, 26], [31, 32, 26], [32, 36, 37], [32, 31, 36]]}, "l1": {"coords": [[0.0, 0.0], [0.0, 0.25], [0.0, 0.5], [0.0, 0.75], [0.0, 1.0], [0.25, 0.0], [0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.25, 1.0], [0.5, 0.0], [0.5, 0.25], [0.5, 0.5], [0.5, 0.75], [0.5, 1.0], [0.75, 0.0], [0.75, 0.25], [0.75, 0.5], [0.75, 0.75], [0.75, 1.0], [1.0, 0.0], [1.0, 0.25], [1.0, 0.5], [1.0, 0.75], [1.0, 1.0], [1.25, 0.0], [1.25, 0.25], [1.25, 0.5], [1.25, 0.75], [1.25, 1.0], [1.5, 0.0], [1.5, 0.25], [1.5, 0.5], [1.5, 0.75], [1.5, 1.0], [1.75, 0.0], [1.75, 0.25], [1.75, 0.5], [1.75, 0.75], [1.75, 1.0], [2.0, 0.0], [2.0, 0.25], [2.0, 0.5], [2.0, 0.75], [2.0, 1.0], [0.31953359559193645, 0.31723472172969375], [0.31303285857749713, 0.3902818457329321], [0.40112641641921787, 0.1601718110651281], [0.46018194033900023, 0.33605841847717355], [0.420861698899182, 0.4498505847342716], [0.5194455208393414, 0.13774590580254747], [0.5963824093359145, 0.2772830700396335], [0.6449277462100486, 0.1954921839313474], [0.6466029544256464, 0.3954454028811464], [0.7170511345133341, 0.5743899419274434], [0.8486614419977793, 0.32767403175126375], [0.768800181675104, 0.3985534380085404], [0.8498901270905748, 0.5149751768661469], [0.9643374610623519, 0.3283971355725491], [0.8982745158659227, 0.4585754490015937], [0.8941586269392151, 0.6361254900858392], [1.0942906767003275, 0.5879233871031041], [1.0203857423805278, 0.6641989050670394], [1.1747475437780242, 0.3881798024236302], [1.2068412623489697, 0.5632991260940463], [1.1536099078288629, 0.7155166743252049], [1.3170703174828908, 0.4092561701130431], [1.2923784923284445, 0.6796410675428037], [1.4232493330090377, 0.5427740380799299], [1.434259556470117, 0.6337777124017565], [1.5330401466639405, 0.5910439567564151], [1.576271404847495, 0.676626239064144], [1.6475928681093808, 0.5509857681719257]], "tris": [[10, 47, 5], [47, 6, 5], [46, 7, 6], [7, 46, 49], [37, 38, 72], [21, 55, 16], [63, 21, 26], [32, 37, 72], [60, 23, 18], [12, 7, 49], [55, 56, 16], [56, 53, 16], [52, 15, 16], [47, 45, 6], [45, 46, 6], [33, 71, 38], [38, 71, 72], [21, 58, 55], [58, 63, 22], [58, 21, 63], [66, 63, 26], [67, 33, 28], [63, 61, 22], [64, 61, 63], [65, 29, 24], [29, 65, 28], [23, 65, 24], [65, 61, 64], [65, 67, 28], [67, 65, 64], [54, 60, 18], [54, 12, 53], [13, 54, 18], [12, 54, 13], [59, 56, 55], [59, 58, 22], [58, 59, 55], [53, 51, 16], [51, 52, 16], [70, 32, 72], [71, 70, 72], [66, 31, 32], [31, 66, 26], [27, 67, 64], [27, 64, 63], [66, 27, 63], [62, 65, 23], [65, 62, 61], [62, 23, 60], [62, 60, 22], [61, 62, 22], [56, 17, 53], [17, 54, 53], [51, 50, 52], [50, 47, 10], [15, 50, 10], [52, 50, 15], [48, 45, 47], [46, 48, 49], [45, 48, 46], [48, 12, 49], [12, 48, 53], [48, 51, 53], [69, 71, 33], [69, 70, 71], [67, 69, 33], [59, 57, 56], [57, 17, 56], [60, 57, 22], [57, 59, 22], [54, 57, 60], [17, 57, 54], [11, 50, 51], [48, 11, 51], [50, 11, 47], [11, 48, 47], [70, 68, 32], [69, 68, 70], [68, 66, 32], [68, 27, 66], [27, 68, 67], [68, 69, 67], [5, 1, 0], [6, 1, 5], [1, 7, 2], [7, 1, 6], [19, 14, 18], [14, 13, 18], [41, 35, 40], [35, 41, 36], [43, 37, 42], [37, 43, 38], [37, 41, 42], [41, 37, 36], [39, 43, 44], [43, 39, 38], [33, 39, 34], [39, 33, 38], [25, 21, 20], [21, 25, 26], [21, 15, 20], [15, 21, 16], [29, 33, 34], [33, 29, 28], [19, 23, 24], [23, 19, 18], [8, 12, 13], [12, 8, 7], [14, 8, 13], [8, 14, 9], [7, 8, 2], [8, 3, 2], [8, 9, 4], [3, 8, 4], [37, 31, 36], [32, 31, 37], [35, 31, 30], [31, 35, 36], [31, 25, 30], [25, 31, 26]]}, "l2": {"coords": [[0.0, 0.0], [0.0, 0.25], [0.0, 0.5], [0.0, 0.75], [0.0, 1.0], [0.25, 0.0], [0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.25, 1.0], [0.5, 0.0], [0.5, 0.25], [0.5, 0.5], [0.5, 0.75], [0.5, 1.0], [0.75, 0.0], [0.75, 0.25], [0.75, 0.5], [0.75, 0.75], [0.75, 1.0], [1.0, 0.0], [1.0, 0.25], [1.0, 0.5], [1.0, 0.75], [1.0, 1.0], [1.25, 0.0], [1.25, 0.25], [1.25, 0.5], [1.25, 0.75], [1.25, 1.0], [1.5, 0.0], [1.5, 0.25], [1.5, 0.5], [1.5, 0.75], [1.5, 1.0], [1.75, 0.0], [1.75, 0.25], [1.75, 0.5], [1.75, 0.75], [1.75, 1.0], [2.0, 0.0], [2.0, 0.25], [2.0, 0.5], [2.0, 0.75], [2.0, 1.0], [0.2887903891151294, 0.21450852528061756], [0.31953359559193645, 0.31723472172969375], [0.31303285857749713, 0.3902818457329321], [0.40112641641921787, 0.1601718110651281], [0.46018194033900023, 0.33605841847717355], [0.420861698899182, 0.4498505847342716], [0.4367741429853224, 0.5208487728687539], [0.5194455208393414, 0.13774590580254747], [0.5963824093359145, 0.2772830700396335], [0.5311877815210264, 0.4559399497334029], [0.5785509632482123, 0.5813166532798449], [0.6449277462100486, 0.1954921839313474], [0.6466029544256464, 0.3954454028811464], [0.7170511345133341, 0.5743899419274434], [0.7774879172627305, 0.20913852717711895], [0.8486614419977793, 0.32767403175126375], [0.768800181675104, 0.3985534380085404], [0.8498901270905748, 0.5149751768661469], [0.9643374610623519, 0.3283971355725491], [0.8982745158659227, 0.4585754490015937], [0.9756833429497374, 0.530935121726799], [0.8941586269392151, 0.6361254900858392], [1.0748316164629834, 0.2680085573100976], [1.034235657192865, 0.4463418566095085], [1.0942906767003275, 0.5879233871031041], [1.0203857423805278, 0.6641989050670394], [1.1012378625213965, 0.7590744610262158], [1.1747475437780242, 0.3881798024236302], [1.2068412623489697, 0.5632991260940463], [1.1536099078288629, 0.7155166743252049], [1.2230070839332015, 0.7979624367728774], [1.290985698639609, 0.33556936494748124], [1.3170703174828908, 0.4092561701130431], [1.315534034824884, 0.5100546557059643], [1.2923784923284445, 0.6796410675428037], [1.3380631297642265, 0.8412353236611331], [1.458144263922878, 0.46421383982230524], [1.4232493330090377, 0.5427740380799299], [1.434259556470117, 0.6337777124017565], [1.4481623965436305, 0.795768274658279], [1.5330401466639405, 0.5910439567564151], [1.576271404847495, 0.676626239064144], [1.555936794642852, 0.7594080545145628], [1.6475928681093808, 0.5509857681719257], [1.7154092416885238, 0.7159750393394728], [1.6644288750307592, 0.8104031967217026], [0.45178550303692505, 0.2806276877256089], [0.41471207197435017, 0.36828888060111414], [0.5141789381030697, 0.28854382037649234], [0.5432208859676612, 0.24658556087831623], [0.5730081756433625, 0.31681000000313964], [0.5363513282207418, 0.35464265691325153], [0.5764539798106127, 0.40170093266900303], [0.6288332661250889, 0.304596366542647], [0.6827448812731425, 0.2781871092301583], [0.6712597321949084, 0.36230196950123067], [0.6939193123630563, 0.442452720535922], [0.741632740009178, 0.33955374535127125], [0.7906279127453145, 0.3183578025511819], [0.8120706168043575, 0.3608066145758154], [0.7997718490116899, 0.4775972731622598], [0.8810829838775077, 0.3803236195123786], [0.8557967220152565, 0.4271599855739645], [0.9401973460068441, 0.49327461278056955], [0.9213335467688631, 0.5292287708914398], [0.9699553765136832, 0.41389823873381276], [0.998871769893107, 0.5941229256208547], [1.0320402319422028, 0.40388266920627247], [1.072385727136362, 0.47206788583058706], [1.0330923429410073, 0.560800813431626], [1.0976505729817487, 0.43285626310486514], [1.1333010366791199, 0.4683347964100676], [1.0935500726079763, 0.5307896116370941], [1.133688792638055, 0.6194374936993249], [1.190807212062948, 0.49831380232110645], [1.1576198645272908, 0.5335117260472655], [1.25520957322318, 0.599266466965241], [1.2182520973801223, 0.650463458421284], [1.2945598654701371, 0.5558870654905923], [1.3111430744077863, 0.6271127224734468], [1.3651444874568557, 0.5273877355914779], [1.365108378949352, 0.6138276949841849], [1.3529290775800764, 0.6902320655034216], [1.4185246517973717, 0.5880012531595007], [1.423265598361904, 0.6714986869029183], [1.5032293063670739, 0.5656852364019469], [1.4729080331432356, 0.6052128514169705], [1.493731836202584, 0.6495400788661496], [1.529603843202696, 0.6284224961214516], [1.5381166988694892, 0.7120255504647522]], "tris": [[10, 48, 5], [47, 7, 6], [55, 13, 51], [13, 55, 18], [21, 59, 20], [59, 21, 60], [32, 37, 88], [66, 23, 18], [59, 15, 20], [45, 6, 5], [48, 45, 5], [52, 48, 10], [15, 52, 10], [8, 7, 51], [13, 8, 51], [7, 50, 51], [47, 50, 7], [58, 66, 18], [55, 58, 18], [58, 55, 101], [103, 59, 60], [55, 54, 101], [89, 37, 38], [37, 89, 88], [90, 39, 34], [39, 90, 38], [90, 89, 38], [25, 67, 20], [67, 25, 26], [67, 21, 20], [72, 67, 26], [67, 72, 115], [29, 80, 34], [70, 23, 66], [23, 71, 24], [70, 71, 23], [56, 15, 59], [56, 52, 15], [91, 45, 48], [17, 58, 101], [61, 17, 101], [17, 61, 105], [114, 65, 22], [103, 16, 59], [56, 16, 99], [16, 56, 59], [16, 102, 99], [16, 103, 102], [103, 104, 102], [104, 61, 102], [104, 103, 60], [12, 55, 51], [12, 54, 55], [50, 12, 51], [54, 12, 50], [97, 54, 96], [97, 57, 101], [54, 97, 101], [89, 86, 88], [90, 86, 89], [87, 90, 34], [87, 86, 90], [21, 63, 60], [67, 63, 21], [108, 110, 22], [65, 108, 22], [108, 65, 109], [110, 68, 22], [127, 80, 28], [80, 75, 28], [75, 80, 29], [75, 29, 24], [71, 75, 24], [75, 74, 28], [74, 75, 71], [74, 71, 70], [56, 94, 52], [98, 100, 57], [57, 100, 101], [102, 100, 99], [100, 98, 99], [100, 61, 101], [61, 100, 102], [91, 46, 45], [46, 47, 6], [45, 46, 6], [111, 65, 114], [111, 70, 66], [109, 111, 66], [65, 111, 109], [95, 98, 57], [97, 95, 57], [95, 97, 96], [93, 95, 96], [94, 95, 93], [76, 72, 26], [76, 77, 72], [31, 76, 26], [77, 76, 31], [81, 31, 32], [81, 77, 31], [77, 27, 72], [63, 106, 60], [106, 63, 110], [106, 104, 60], [112, 67, 115], [112, 63, 67], [68, 112, 115], [63, 112, 110], [112, 68, 110], [64, 108, 109], [108, 64, 110], [64, 106, 110], [127, 84, 80], [80, 84, 34], [84, 87, 34], [87, 84, 33], [79, 127, 28], [113, 68, 115], [68, 113, 22], [113, 114, 22], [113, 117, 114], [74, 122, 28], [122, 79, 28], [118, 74, 70], [118, 122, 74], [122, 118, 73], [91, 11, 93], [11, 94, 93], [94, 11, 52], [52, 11, 48], [11, 91, 48], [53, 94, 56], [53, 56, 99], [98, 53, 99], [95, 53, 98], [53, 95, 94], [92, 46, 91], [92, 50, 47], [46, 92, 47], [132, 134, 33], [134, 87, 33], [87, 134, 86], [129, 132, 33], [84, 129, 33], [129, 84, 127], [134, 133, 86], [133, 134, 132], [133, 132, 131], [27, 119, 72], [119, 27, 73], [82, 130, 131], [130, 82, 32], [82, 81, 32], [62, 64, 109], [62, 109, 66], [58, 62, 66], [62, 17, 105], [17, 62, 58], [64, 107, 106], [106, 107, 104], [107, 62, 105], [62, 107, 64], [61, 107, 105], [104, 107, 61], [69, 118, 70], [69, 111, 114], [111, 69, 70], [117, 69, 114], [49, 92, 91], [49, 93, 96], [49, 91, 93], [54, 49, 96], [49, 54, 50], [92, 49, 50], [132, 83, 131], [129, 83, 132], [86, 85, 88], [133, 85, 86], [85, 32, 88], [85, 130, 32], [130, 85, 131], [85, 133, 131], [113, 116, 117], [116, 113, 115], [72, 116, 115], [119, 116, 72], [120, 119, 73], [120, 69, 117], [116, 120, 117], [120, 116, 119], [118, 120, 73], [69, 120, 118], [27, 123, 73], [78, 27, 77], [78, 123, 27], [126, 129, 127], [126, 83, 129], [121, 122, 73], [123, 121, 73], [122, 121, 79], [126, 128, 83], [128, 82, 131], [83, 128, 131], [78, 125, 123], [125, 126, 123], [82, 125, 81], [128, 125, 82], [125, 128, 126], [81, 125, 77], [125, 78, 77], [121, 124, 79], [79, 124, 127], [124, 126, 127], [126, 124, 123], [124, 121, 123], [5, 1, 0], [6, 1, 5], [1, 7, 2], [7, 1, 6], [19, 14, 18], [14, 13, 18], [41, 35, 40], [35, 41, 36], [43, 37, 42], [37, 43, 38], [37, 41, 42], [41, 37, 36], [39, 43, 44], [43, 39, 38], [19, 23, 24], [23, 19, 18], [14, 8, 13], [8, 14, 9], [7, 8, 2], [8, 3, 2], [8, 9, 4], [3, 8, 4], [31, 25, 30], [25, 31, 26], [35, 31, 30], [31, 35, 36], [37, 31, 36], [32, 31, 37]]}, "cut": {"coords": [[0.0, 0.0], [0.0, 0.25], [0.0, 0.5], [0.0, 0.75], [0.0, 1.0], [0.25, 0.0], [0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.25, 1.0], [0.5, 0.0], [0.5, 0.25], [0.5, 0.5], [0.5, 0.75], [0.5, 1.0], [0.75, 0.0], [0.75, 0.25], [0.75, 0.5], [0.75, 0.75], [0.75, 1.0], [1.0, 0.0], [1.0, 0.25], [1.0, 0.75], [1.0, 1.0], [1.25, 0.0], [1.25, 0.25], [1.25, 0.5], [1.25, 0.75], [1.25, 1.0], [1.5, 0.0], [1.5, 0.25], [1.5, 0.5], [1.5, 0.75], [1.5, 1.0], [1.75, 0.0], [1.75, 0.25], [1.75, 0.5], [1.75, 0.75], [1.75, 1.0], [2.0, 0.0], [2.0, 0.25], [2.0, 0.5], [2.0, 0.75], [2.0, 1.0], [0.2887903891151294, 0.21450852528061756], [0.31953359559193645, 0.31723472172969375], [0.31303285857749713, 0.3902818457329321], [0.40112641641921787, 0.1601718110651281], [0.420861698899182, 0.4498505847342716], [0.4367741429853224, 0.5208487728687539], [0.5194455208393414, 0.13774590580254747], [0.5963824093359145, 0.2772830700396335], [0.5311877815210264, 0.4559399497334029], [0.5785509632482123, 0.5813166532798449], [0.6449277462100486, 0.1954921839313474], [0.7170511345133341, 0.5743899419274434], [0.7774879172627305, 0.20913852717711895], [0.8486614419977793, 0.32767403175126375], [0.8498901270905748, 0.5149751768661469], [0.9643374610623519, 0.3283971355725491], [0.8941586269392151, 0.6361254900858392], [1.0748316164629834, 0.2680085573100976], [1.034235657192865, 0.4463418566095085], [1.0942906767003275, 0.5879233871031041], [1.0203857423805278, 0.6641989050670394], [1.1012378625213965, 0.7590744610262158], [1.1747475437780242, 0.3881798024236302], [1.1536099078288629, 0.7155166743252049], [1.2230070839332015, 0.7979624367728774], [1.290985698639609, 0.33556936494748124], [1.3170703174828908, 0.4092561701130431], [1.315534034824884, 0.5100546557059643], [1.2923784923284445, 0.6796410675428037], [1.3380631297642265, 0.8412353236611331], [1.458144263922878, 0.46421383982230524], [1.4232493330090377, 0.5427740380799299], [1.4481623965436305, 0.795768274658279], [1.5330401466639405, 0.5910439567564151], [1.576271404847495, 0.676626239064144], [1.555936794642852, 0.7594080545145628], [1.6475928681093808, 0.5509857681719257], [1.7154092416885238, 0.7159750393394728], [1.6644288750307592, 0.8104031967217026], [0.45178550303692505, 0.2806276877256089], [0.41471207197435017, 0.36828888060111414], [0.5432208859676612, 0.24658556087831623], [0.5764539798106127, 0.40170093266900303], [0.6288332661250889, 0.304596366542647], [0.6827448812731425, 0.2781871092301583], [0.6939193123630563, 0.442452720535922], [0.741632740009178, 0.33955374535127125], [0.7906279127453145, 0.3183578025511819], [0.8120706168043575, 0.3608066145758154], [0.7997718490116899, 0.4775972731622598], [0.8810829838775077, 0.3803236195123786], [0.9213335467688631, 0.5292287708914398], [0.9699553765136832, 0.41389823873381276], [0.998871769893107, 0.5941229256208547], [1.0320402319422028, 0.40388266920627247], [1.0330923429410073, 0.560800813431626], [1.0976505729817487, 0.43285626310486514], [1.1333010366791199, 0.4683347964100676], [1.133688792638055, 0.6194374936993249], [1.190807212062948, 0.49831380232110645], [1.2182520973801223, 0.650463458421284], [1.3651444874568557, 0.5273877355914779], [1.3529290775800764, 0.6902320655034216], [1.5032293063670739, 0.5656852364019469], [1.5381166988694892, 0.7120255504647522], [0.5, 0.32], [0.5586999101788221, 0.33995796946079954], [0.6173998203576444, 0.3599159389215991], [0.6760997305364665, 0.37987390838239865], [0.7347996407152888, 0.3998318778431982], [0.793499550894111, 0.41978984730399777], [0.8521994610729331, 0.4397478167647973], [0.9108993712517554, 0.4597057862255969], [0.9695992814305776, 0.4796637556863964], [1.0282991916094, 0.49962172514719594], [1.086999101788222, 0.5195796946079955], [1.1456990119670443, 0.539537664068795], [1.2043989221458662, 0.5594956335295946], [1.2630988323246886, 0.5794536029903942], [1.3217987425035107, 0.5994115724511937], [1.3804986526823328, 0.6193695419119932], [1.4391985628611552, 0.6393275113727928], [1.4978984730399774, 0.6592854808335924]], "tris": [[10, 47, 5], [46, 7, 6], [8, 7, 49], [13, 8, 49], [56, 15, 20], [56, 91, 16], [91, 56, 57], [21, 56, 20], [56, 21, 57], [44, 6, 5], [47, 44, 5], [50, 47, 10], [15, 50, 10], [81, 36, 37], [36, 81, 80], [81, 78, 80], [82, 38, 33], [38, 82, 37], [82, 81, 37], [81, 82, 78], [68, 28, 23], [60, 22, 18], [78, 77, 80], [66, 61, 25], [24, 61, 20], [61, 24, 25], [61, 21, 20], [100, 61, 66], [83, 44, 47], [56, 54, 15], [54, 50, 15], [54, 56, 16], [88, 54, 16], [117, 116, 96], [116, 94, 96], [94, 116, 115], [116, 117, 95], [92, 91, 57], [94, 92, 57], [92, 94, 115], [58, 95, 60], [58, 116, 95], [116, 58, 115], [28, 73, 33], [73, 28, 68], [99, 117, 118], [117, 99, 95], [22, 65, 23], [65, 68, 23], [126, 77, 78], [30, 69, 25], [69, 66, 25], [31, 74, 30], [31, 36, 80], [77, 31, 80], [74, 31, 75], [117, 62, 118], [62, 117, 96], [61, 59, 21], [94, 59, 96], [21, 59, 57], [59, 94, 57], [83, 45, 44], [45, 46, 6], [44, 45, 6], [50, 11, 47], [11, 83, 47], [7, 48, 49], [46, 48, 7], [13, 53, 18], [53, 13, 49], [73, 76, 33], [76, 73, 106], [101, 100, 66], [64, 65, 22], [64, 22, 60], [31, 107, 75], [107, 31, 77], [107, 125, 75], [126, 107, 77], [125, 107, 126], [98, 61, 100], [98, 59, 61], [62, 98, 100], [98, 62, 96], [59, 98, 96], [51, 54, 88], [84, 45, 83], [45, 84, 46], [84, 48, 46], [53, 55, 18], [55, 60, 18], [55, 58, 60], [55, 53, 89], [53, 52, 89], [84, 52, 48], [114, 92, 115], [114, 113, 92], [92, 90, 91], [113, 90, 92], [91, 90, 16], [90, 88, 16], [79, 82, 33], [76, 79, 33], [82, 79, 78], [119, 99, 118], [101, 119, 100], [62, 119, 118], [119, 62, 100], [64, 63, 102], [119, 63, 99], [97, 64, 60], [95, 97, 60], [99, 97, 95], [63, 97, 99], [97, 63, 64], [27, 73, 68], [73, 27, 106], [104, 67, 102], [67, 64, 102], [64, 67, 65], [27, 67, 104], [65, 67, 68], [67, 27, 68], [123, 124, 106], [124, 125, 106], [125, 124, 75], [69, 70, 66], [70, 26, 66], [74, 70, 30], [70, 69, 30], [120, 119, 101], [63, 120, 102], [120, 63, 119], [54, 85, 50], [51, 85, 54], [85, 11, 50], [12, 53, 49], [12, 52, 53], [48, 12, 49], [52, 12, 48], [55, 17, 58], [17, 55, 89], [113, 17, 89], [114, 17, 113], [32, 79, 76], [32, 125, 126], [32, 76, 106], [125, 32, 106], [27, 72, 106], [72, 27, 104], [72, 123, 106], [123, 72, 122], [72, 104, 122], [70, 71, 26], [71, 123, 122], [26, 71, 122], [103, 120, 101], [103, 101, 66], [26, 103, 66], [52, 86, 89], [112, 113, 89], [86, 112, 89], [112, 86, 111], [112, 90, 113], [90, 112, 88], [17, 93, 58], [93, 17, 114], [58, 93, 115], [93, 114, 115], [108, 126, 78], [108, 32, 126], [79, 108, 78], [32, 108, 79], [71, 105, 123], [124, 105, 75], [105, 124, 123], [105, 74, 75], [105, 70, 74], [105, 71, 70], [103, 121, 120], [104, 121, 122], [121, 26, 122], [121, 103, 26], [121, 104, 102], [120, 121, 102], [86, 110, 111], [110, 85, 51], [112, 87, 88], [87, 112, 111], [87, 51, 88], [87, 110, 51], [110, 87, 111], [109, 86, 52], [109, 110, 86], [109, 52, 84], [109, 84, 83], [11, 109, 83], [85, 109, 11], [110, 109, 85], [5, 1, 0], [6, 1, 5], [1, 7, 2], [7, 1, 6], [7, 8, 2], [8, 3, 2], [8, 9, 4], [3, 8, 4], [8, 14, 9], [14, 8, 13], [19, 14, 18], [14, 13, 18], [40, 34, 39], [34, 40, 35], [42, 36, 41], [36, 42, 37], [36, 40, 41], [40, 36, 35], [38, 42, 43], [42, 38, 37], [34, 30, 29], [30, 34, 35], [30, 24, 29], [24, 30, 25], [19, 22, 23], [22, 19, 18], [36, 31, 35], [31, 30, 35]]}, "split": {"coords": [[0.0, 0.0], [0.0, 0.25], [0.0, 0.5], [0.0, 0.75], [0.0, 1.0], [0.25, 0.0], [0.25, 0.25], [0.25, 0.5], [0.25, 0.75], [0.25, 1.0], [0.5, 0.0], [0.5, 0.25], [0.5, 0.5], [0.5, 0.75], [0.5, 1.0], [0.75, 0.0], [0.75, 0.25], [0.75, 0.5], [0.75, 0.75], [0.75, 1.0], [1.0, 0.0], [1.0, 0.25], [1.0, 0.75], [1.0, 1.0], [1.25, 0.0], [1.25, 0.25], [1.2693141639943222, 0.44319363531081724], [1.25, 0.75], [1.25, 1.0], [1.5, 0.0], [1.5, 0.25], [1.5, 0.5], [1.5, 0.75], [1.5, 1.0], [1.75, 0.0], [1.75, 0.25], [1.75, 0.5], [1.75, 0.75], [1.75, 1.0], [2.0, 0.0], [2.0, 0.25], [2.0, 0.5], [2.0, 0.75], [2.0, 1.0], [0.2887903891151294, 0.21450852528061756], [0.31953359559193645, 0.31723472172969375], [0.31303285857749713, 0.3902818457329321], [0.40112641641921787, 0.1601718110651281], [0.420861698899182, 0.4498505847342716], [0.4367741429853224, 0.5208487728687539], [0.5194455208393414, 0.13774590580254747], [0.6156965733302366, 0.22047670535045072], [0.5311877815210264, 0.4559399497334029], [0.5785509632482123, 0.5813166532798449], [0.6449277462100486, 0.1954921839313474], [0.7170511345133341, 0.5743899419274434], [0.7774879172627305, 0.20913852717711895], [0.8486614419977793, 0.32767403175126375], [0.8498901270905748, 0.5149751768661469], [0.9643374610623519, 0.3283971355725491], [0.8941586269392151, 0.6361254900858392], [1.0748316164629834, 0.2680085573100976], [1.0535498211871872, 0.3895354919203257], [1.0942906767003275, 0.5879233871031041], [1.0203857423805278, 0.6641989050670394], [1.1012378625213965, 0.7590744610262158], [1.1747475437780242, 0.3881798024236302], [1.1536099078288629, 0.7155166743252049], [1.2230070839332015, 0.7979624367728774], [1.290985698639609, 0.33556936494748124], [1.3170703174828908, 0.4092561701130431], [1.3348481988192062, 0.45324829101678155], [1.2923784923284445, 0.6796410675428037], [1.3380631297642265, 0.8412353236611331], [1.458144263922878, 0.46421383982230524], [1.4425634970033598, 0.4859676733907471], [1.4481623965436305, 0.795768274658279], [1.5523543106582627, 0.5342375920672323], [1.576271404847495, 0.676626239064144], [1.555936794642852, 0.7594080545145628], [1.6475928681093808, 0.5509857681719257], [1.7154092416885238, 0.7159750393394728], [1.6644288750307592, 0.8104031967217026], [0.45178550303692505, 0.2806276877256089], [0.41471207197435017, 0.36828888060111414], [0.5625350499619833, 0.18977919618913347], [0.5764539798106127, 0.40170093266900303], [0.6481474301194111, 0.24779000185346423], [0.7020590452674647, 0.22138074454097556], [0.6939193123630563, 0.442452720535922], [0.7609469040035002, 0.2827473806620885], [0.7906279127453145, 0.3183578025511819], [0.8313847807986797, 0.30400024988663266], [0.7997718490116899, 0.4775972731622598], [0.9003971478718299, 0.3235172548231958], [0.9213335467688631, 0.5292287708914398], [0.9892695405080054, 0.35709187404463], [0.998871769893107, 0.5941229256208547], [1.0320402319422028, 0.40388266920627247], [1.0330923429410073, 0.560800813431626], [1.116964736976071, 0.37604989841568237], [1.152615200673442, 0.4115284317208848], [1.133688792638055, 0.6194374936993249], [1.2101213760572702, 0.4415074376319237], [1.2182520973801223, 0.650463458421284], [1.3844586514511779, 0.4705813709022951], [1.3529290775800764, 0.6902320655034216], [1.522543470361396, 0.5088788717127641], [1.5381166988694892, 0.7120255504647522], [0.5, 0.32], [0.5586999101788221, 0.33995796946079954], [0.6173998203576444, 0.3599159389215991], [0.6760997305364665, 0.37987390838239865], [0.7347996407152888, 0.3998318778431982], [0.793499550894111, 0.41978984730399777], [0.8521994610729331, 0.4397478167647973], [0.9108993712517554, 0.4597057862255969], [0.9695992814305776, 0.4796637556863964], [1.0282991916094, 0.49962172514719594], [1.086999101788222, 0.5195796946079955], [1.1456990119670443, 0.539537664068795], [1.2043989221458662, 0.5594956335295946], [1.2630988323246886, 0.5794536029903942], [1.3217987425035107, 0.5994115724511937], [1.3804986526823328, 0.6193695419119932], [1.4391985628611552, 0.6393275113727928], [1.4978984730399774, 0.6592854808335924], [0.5780140741731443, 0.28315160477161677], [0.6367139843519666, 0.30310957423241636], [0.6954138945307887, 0.3230675436932159], [0.754113804709611, 0.3430255131540154], [0.8128137148884331, 0.362983482614815], [0.8715136250672553, 0.38294145207561453], [0.9302135352460775, 0.4028994215364141], [0.9889134454248998, 0.42285739099721364], [1.0476133556037222, 0.4428153604580132], [1.106313265782544, 0.4627733299188127], [1.1650131759613664, 0.48273129937961223], [1.2237130861401884, 0.5026892688404119], [1.2824129963190107, 0.5226472383012114], [1.3411129064978329, 0.5426052077620109], [1.399812816676655, 0.5625631772228105], [1.4585127268554774, 0.58252114668361]], "tris": [[10, 47, 5], [46, 7, 6], [8, 7, 49], [13, 8, 49], [56, 15, 20], [56, 91, 16], [91, 56, 57], [21, 56, 20], [56, 21, 57], [44, 6, 5], [47, 44, 5], [50, 47, 10], [15, 50, 10], [81, 36, 37], [36, 81, 80], [81, 78, 80], [82, 38, 33], [38, 82, 37], [82, 81, 37], [81, 82, 78], [68, 28, 23], [60, 22, 18], [78, 77, 80], [66, 61, 25], [24, 61, 20], [61, 24, 25], [61, 21, 20], [100, 61, 66], [83, 44, 47], [56, 54, 15], [54, 50, 15], [54, 56, 16], [88, 54, 16], [134, 133, 96], [133, 94, 96], [94, 133, 132], [116, 117, 95], [92, 91, 57], [94, 92, 57], [92, 94, 132], [58, 95, 60], [58, 116, 95], [116, 58, 115], [28, 73, 33], [73, 28, 68], [99, 117, 118], [117, 99, 95], [22, 65, 23], [65, 68, 23], [126, 77, 78], [30, 69, 25], [69, 66, 25], [31, 74, 30], [31, 36, 80], [77, 31, 80], [74, 31, 75], [134, 62, 135], [62, 134, 96], [61, 59, 21], [94, 59, 96], [21, 59, 57], [59, 94, 57], [83, 45, 44], [45, 46, 6], [44, 45, 6], [50, 11, 47], [11, 83, 47], [7, 48, 49], [46, 48, 7], [13, 53, 18], [53, 13, 49], [73, 76, 33], [76, 73, 106], [101, 100, 66], [64, 65, 22], [64, 22, 60], [31, 107, 75], [107, 31, 77], [107, 142, 75], [126, 107, 77], [142, 107, 126], [98, 61, 100], [98, 59, 61], [62, 98, 100], [98, 62, 96], [59, 98, 96], [51, 54, 88], [84, 45, 83], [45, 84, 46], [84, 48, 46], [53, 55, 18], [55, 60, 18], [55, 58, 60], [55, 53, 89], [53, 52, 89], [84, 52, 48], [131, 92, 132], [131, 130, 92], [92, 90, 91], [130, 90, 92], [91, 90, 16], [90, 88, 16], [79, 82, 33], [76, 79, 33], [82, 79, 78], [119, 99, 118], [101, 136, 100], [62, 136, 135], [136, 62, 100], [64, 63, 102], [119, 63, 99], [97, 64, 60], [95, 97, 60], [99, 97, 95], [63, 97, 99], [97, 63, 64], [27, 73, 68], [73, 27, 106], [104, 67, 102], [67, 64, 102], [64, 67, 65], [27, 67, 104], [65, 67, 68], [67, 27, 68], [123, 124, 106], [124, 125, 106], [142, 141, 75], [69, 70, 66], [70, 26, 66], [74, 70, 30], [70, 69, 30], [137, 136, 101], [63, 120, 102], [120, 63, 119], [54, 85, 50], [51, 85, 54], [85, 11, 50], [12, 53, 49], [12, 52, 53], [48, 12, 49], [52, 12, 48], [55, 17, 58], [17, 55, 89], [113, 17, 89], [114, 17, 113], [32, 79, 76], [32, 125, 126], [32, 76, 106], [125, 32, 106], [27, 72, 106], [72, 27, 104], [72, 123, 106], [123, 72, 122], [72, 104, 122], [70, 71, 26], [71, 140, 139], [26, 71, 139], [103, 137, 101], [103, 101, 66], [26, 103, 66], [52, 86, 89], [112, 113, 89], [86, 112, 89], [112, 86, 111], [129, 90, 130], [90, 129, 88], [17, 93, 58], [93, 17, 114], [58, 93, 115], [93, 114, 115], [108, 126, 78], [108, 32, 126], [79, 108, 78], [32, 108, 79], [71, 105, 140], [141, 105, 75], [105, 141, 140], [105, 74, 75], [105, 70, 74], [105, 71, 70], [103, 138, 137], [104, 121, 122], [138, 26, 139], [138, 103, 26], [121, 104, 102], [120, 121, 102], [86, 110, 111], [127, 85, 51], [129, 87, 88], [87, 129, 128], [87, 51, 88], [87, 127, 51], [127, 87, 128], [109, 86, 52], [109, 110, 86], [109, 52, 84], [109, 84, 83], [11, 109, 83], [85, 109, 11], [127, 109, 85], [5, 1, 0], [6, 1, 5], [1, 7, 2], [7, 1, 6], [7, 8, 2], [8, 3, 2], [8, 9, 4], [3, 8, 4], [8, 14, 9], [14, 8, 13], [19, 14, 18], [14, 13, 18], [40, 34, 39], [34, 40, 35], [42, 36, 41], [36, 42, 37], [36, 40, 41], [40, 36, 35], [38, 42, 43], [42, 38, 37], [34, 30, 29], [30, 34, 35], [30, 24, 29], [24, 30, 25], [19, 22, 23], [22, 19, 18], [36, 31, 35], [31, 30, 35]], "side": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}}, "chain": [109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126], "tips": [109, 126], "interior": [110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125], "replicas": {"110": 127, "111": 128, "112": 129, "113": 130, "114": 131, "115": 132, "116": 133, "117": 134, "118": 135, "119": 136, "120": 137, "121": 138, "122": 139, "123": 140, "124": 141, "125": 142}, "fault": [[0.5, 0.32], [1.5, 0.66]], "cut_side": [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}
\ No newline at end of file
diff --git a/docs/developer/design/figures/split-node-faults/stack-progression.png b/docs/developer/design/figures/split-node-faults/stack-progression.png
new file mode 100644
index 000000000..10b361a13
Binary files /dev/null and b/docs/developer/design/figures/split-node-faults/stack-progression.png differ
diff --git a/docs/developer/design/figures/split-node-faults/stack-progression.typ b/docs/developer/design/figures/split-node-faults/stack-progression.typ
new file mode 100644
index 000000000..e23da0524
--- /dev/null
+++ b/docs/developer/design/figures/split-node-faults/stack-progression.typ
@@ -0,0 +1,133 @@
+// The stack-on progression. Thesis: the base mesh is STATIC; refinement
+// layers stack toward the fault manifold; the cut and the split happen
+// only at the top of the stack — and when the fault moves, the whole top
+// is re-derived from the same base (nothing is cumulative).
+#import "@preview/cetz:0.3.4"
+
+#set page(width: auto, height: auto, margin: 12pt)
+#set text(font: ("Noto Sans", "Helvetica", "Arial"), size: 5pt)
+
+#let data = json("stack-progression-data.json")
+
+#let mesh-fill = rgb("#eef3fa")
+#let mesh-fill-minus = rgb("#fce4ec")
+#let mesh-fill-plus = rgb("#dce8fc")
+#let mesh-stroke = rgb("#8899aa")
+#let fault-col = rgb("#c62828")
+#let arrow-col = rgb("#444444")
+
+#let GAP = 0.72
+#let PW = 2.0
+
+#let panel-x(k) = k * (PW + GAP)
+
+#let draw-mesh(x0, p, fills: none) = {
+  import cetz.draw: *
+  let P(v) = (p.coords.at(v).at(0) + x0, p.coords.at(v).at(1))
+  for (k, t) in p.tris.enumerate() {
+    let fill = if fills == none { mesh-fill } else { fills.at(k) }
+    line(P(t.at(0)), P(t.at(1)), P(t.at(2)), close: true,
+         fill: fill, stroke: (paint: mesh-stroke, thickness: 0.25pt))
+  }
+}
+
+#let draw-manifold(x0, dash: "dashed") = {
+  import cetz.draw: *
+  let a = data.fault.at(0)
+  let b = data.fault.at(1)
+  line((a.at(0) + x0, a.at(1)), (b.at(0) + x0, b.at(1)),
+       stroke: (paint: fault-col, thickness: 0.9pt, dash: dash))
+}
+
+#let stage-arrow(k, label) = {
+  import cetz.draw: *
+  let x = panel-x(k) + PW + 0.06
+  line((x, 0.5), (x + GAP - 0.12, 0.5),
+       stroke: (paint: arrow-col, thickness: 0.8pt), mark: (end: ">"))
+  content((x + GAP / 2 - 0.06, 0.76), text(size: 4pt, label))
+}
+
+#cetz.canvas(length: 1.5cm, {
+  import cetz.draw: *
+
+  // ---- (a) static base + the fault MANIFOLD (geometry, not mesh) --------
+  draw-mesh(panel-x(0), data.panels.base)
+  draw-manifold(panel-x(0))
+  content((panel-x(0) + PW / 2, -0.32),
+          align(center, text(size: 4.5pt)[(a) static base +\ fault manifold]))
+
+  // ---- (b) layer 1 --------------------------------------------------------
+  draw-mesh(panel-x(1), data.panels.l1)
+  draw-manifold(panel-x(1))
+  content((panel-x(1) + PW / 2, -0.32),
+          align(center, text(size: 4.5pt)[(b) refined child,\ layer 1]))
+
+  // ---- (c) layer 2 --------------------------------------------------------
+  draw-mesh(panel-x(2), data.panels.l2)
+  draw-manifold(panel-x(2))
+  content((panel-x(2) + PW / 2, -0.32),
+          align(center, text(size: 4.5pt)[(c) refined child,\ layer 2]))
+
+  // ---- (d) the cut: a conforming labelled chain ---------------------------
+  draw-mesh(panel-x(3), data.panels.cut)
+  {
+    let p = data.panels.cut
+    let P(v) = (p.coords.at(v).at(0) + panel-x(3), p.coords.at(v).at(1))
+    for i in range(data.chain.len() - 1) {
+      line(P(data.chain.at(i)), P(data.chain.at(i + 1)),
+           stroke: (paint: fault-col, thickness: 1.0pt))
+    }
+  }
+  content((panel-x(3) + PW / 2, -0.32),
+          align(center, text(size: 4.5pt)[(d) cut: conforming\ facet chain]))
+
+  // ---- (e) the split: the double-line symbol ------------------------------
+  // The mesh stays in its true (unexploded) geometry — the copies ARE
+  // coincident — and the doubled surface is drawn as two thin parallel
+  // lines with white between, offset along the fault normal.
+  {
+    let x0 = panel-x(4)
+    let fills = data.cut_side.map(s => if s < 0 { mesh-fill-minus }
+                                       else { mesh-fill-plus })
+    draw-mesh(x0, data.panels.cut, fills: fills)
+    let a = data.fault.at(0)
+    let b = data.fault.at(1)
+    let dx = b.at(0) - a.at(0)
+    let dy = b.at(1) - a.at(1)
+    let ln = calc.sqrt(dx * dx + dy * dy)
+    let nx = -dy / ln
+    let ny = dx / ln
+    let d = 0.022
+    line((a.at(0) + x0, a.at(1)), (b.at(0) + x0, b.at(1)),
+         stroke: (paint: white, thickness: 3pt))
+    for s in (-1.0, 1.0) {
+      line((a.at(0) + s * d * nx + x0, a.at(1) + s * d * ny),
+           (b.at(0) + s * d * nx + x0, b.at(1) + s * d * ny),
+           stroke: (paint: fault-col, thickness: 0.7pt))
+    }
+    for pt in (a, b) {
+      circle((pt.at(0) + x0, pt.at(1)), radius: 0.032, fill: white,
+             stroke: (paint: black, thickness: 0.8pt))
+    }
+  }
+  content((panel-x(4) + PW / 2, -0.32),
+          align(center, text(size: 4.5pt)[(e) split: doubled surface,\
+            coincident sides]))
+
+  // arrows drawn LAST — panel fills would otherwise cover the labels
+  stage-arrow(0, [adapt])
+  stage-arrow(1, [adapt])
+  stage-arrow(2, [pull + cut])
+  stage-arrow(3, [split])
+
+  // ---- the non-cumulative loop --------------------------------------------
+  let y = -0.85
+  line((panel-x(4) + PW / 2, y + 0.12), (panel-x(4) + PW / 2, y),
+       (panel-x(0) + PW / 2, y), (panel-x(0) + PW / 2, y + 0.12),
+       stroke: (paint: arrow-col, thickness: 0.7pt, dash: "dashed"),
+       mark: (end: ">"))
+  content(((panel-x(0) + panel-x(4) + PW) / 2, y - 0.28),
+          text(size: 4.5pt)[the fault moves $arrow.r$ re-derive the whole
+            top from the SAME base — nothing is cumulative, the coarse
+            stack never carries the fault])
+})
diff --git a/docs/developer/design/mesh-reconnection-and-delaunay-adapt.md b/docs/developer/design/mesh-reconnection-and-delaunay-adapt.md
new file mode 100644
index 000000000..4f4a97a10
--- /dev/null
+++ b/docs/developer/design/mesh-reconnection-and-delaunay-adapt.md
@@ -0,0 +1,549 @@
+# Reconnection and Delaunay adapt-on-top
+
+Status: **investigation, 2-D prototype measured (2026-07-29).** Prototype and
+raw numbers in `~/+Simulations/mesh_reconnection_study/`. No `src/` change yet.
+
+## Why look at this
+
+`mesh.adapt()` refines by **subdivision** — newest-vertex bisection
+(`engine="nvb"`) or PETSc longest-edge (`engine="sbr"`). A subdivision engine
+decides *where the new point goes* and *how the cells reconnect* with a single
+rule and may never re-wire an existing simplex. Three limits follow: the
+conforming closure refines cells the metric never asked for (measured halo 45.8 %
+on the 3-D fault band); element shape is inherited from the base and can never be
+improved; and there is no coarsening and no anisotropy.
+
+The goal of adding reconnection is **usability, not mesh quality**. MMG/ParMmg
+(`mesh.remesh()`) already produces better-shaped elements than any local operator
+will, and we are not trying to beat it. What it costs is control: it repartitions
+the whole mesh, so every call destroys the decomposition, the point-SF, the MG
+hierarchy and the parent/child lineage, at a cost that scales with the whole mesh
+rather than the adapted region. A local, rank-respecting operator that carries
+some load imbalance is the better trade inside a running model.
+
+Two constraints that used to forbid non-nested adaptation are already lifted:
+custom-P MG transfers are built from **coordinates**, not nesting
+(`utilities/custom_mg.py:54,156,515`), and any conforming simplex mesh keeps the
+`exact` point-location capability. And `(coords, cells) → DMPlex → Mesh` is
+already a production path (`utilities/nvb.py:673`, driven from
+`discretisation_mesh.py:7296`).
+
+## Finding 1 — a flip cannot be a `DMPlexTransform` (confirmed)
+
+This was the assumption the whole parallel design rested on, so it was checked
+first. It holds.
+
+`DMPlexTransformGetCone_Internal`
+(`petsc/src/dm/impls/plex/transform/interface/plextransform.c:1443-1497`) finds
+every cone point of every produced point by **descending from the single source
+point `p`** (line 1463 `pp = p`; the loop at 1474-1490 walks `pcone[pcp]`), and
+identifies the new point as `(parent point, replica)` via
+`DMPlexTransformGetTargetPoint` at line 1495. A child's cone can therefore only
+reference points in the **source point's own transitive closure**. A 2↔3 flip
+produces tets using the apex of the *other* parent tet, outside that closure.
+The `celltransform` op signature (`dmplextransformimpl.h:22`) and the
+`offset[ct/rt][ctNew]` numbering scheme say the same thing: every new point
+belongs to exactly one old point. `DMPlexTransform` is structurally a
+**subdivision** framework.
+
+**Consequence.** The NVB Route-B precedent (`nvb_transform.c`, which inherits SF
+propagation and the parallel closure from PETSc) does not carry over. There is no
+C-transform fallback. The parallel route for reconnection must be
+**freeze the seam** — forbid any cavity containing a cell incident on a shared
+plex point, so every shared point is untouched, the point-SF is inherited
+verbatim, and each rank rebuilds its local DM alone. No cross-rank closure, no SF
+reconciliation, no collective fixpoint.
+
+## Finding 2 — reconnection repairs shape but not a bad point set
+
+The study set out to test a specific proposal: centroid (Alfeld) placement is
+cheap, local and closure-free, and was ruled a shallow tool only because of
+shape (3-D: max dihedral 179.6°, 70.7 % of cells below `q = 0.1`, manufactured
+Poisson error stalling at 0.119→0.122→0.124→0.124). The premise was that the
+1→3 star split is a bad *connectivity* choice, not a property of centroid
+*placement*, and that deciding connectivity afterwards by a Delaunay criterion
+would free the placement.
+
+**The premise is wrong.** Reconnection helps a great deal and is still not
+enough. 2-D, same size field, same P1 solver, only the engine differs; in-band
+interpolation error (no solve involved):
+
+| engine | h=0.08 | 0.04 | 0.02 | 0.01 | 0.005 |
+|---|---|---|---|---|---|
+| nvb (bisection) | 0.2819 | 0.1750 | 0.1029 | 0.0651 | **0.0524** |
+| centroid raw | 0.2819 | 0.2285 | 0.1843 | 0.1549 | **0.1469** |
+| centroid + flip | 0.2819 | 0.1827 | 0.1358 | 0.1171 | **0.1166** |
+
+Flips take centroid refinement from 8.06 % to **0.00 %** of cells below `q=0.1`,
+and the 99th-percentile max angle from 175.5° to 132.4°. The in-band FE error
+goes from *diverging* (0.898 → 1.374 with increasing DOFs) to flat (~0.78). But
+the plateau is still **2.2×** bisection's.
+
+### The structural reason, measured
+
+A centroid star split leaves the parent's three edges untouched, so an original
+edge inside a refined region can never be shortened by further centroid
+refinement. Survival of the 178 base edges inside the refinement band:
+
+| engine | surviving |
+|---|---|
+| centroid raw | **178/178 (100 %)** |
+| centroid + flip | 81/178 (46 %) |
+| nvb (bisection) | 42/178 (24 %) |
+
+A flip *can* remove such an edge — that is exactly why flips help — but only
+about half are removable, because a flip needs a convex quad and only exchanges
+one diagonal for another. Delaunay optimises connectivity **given the points**;
+centroid points are simply the wrong points.
+
+### A live measurement trap this exposed
+
+The production marking criterion is `h = sqrt(2A)` (`NVBMesh.centroids_h`). It is
+the right proxy for bisection, which shrinks area and diameter together, and a
+**misleading** one for any area-reducing split. On the centroid mesh the area
+proxy reads `h = 0.0102` while the median in-band **diameter is 0.0331** — a 3.2×
+overstatement. The size field is satisfied and the mesh is not resolved. Any
+future engine that is not pure bisection must mark on the diameter.
+
+## Finding 3 — the corrected design, and it is competitive
+
+Keep the part of the proposal that was right (closure-free placement) and fix the
+part that was wrong (place points that shorten diameters):
+
+> **`edge-split + flip`** — mark on the cell diameter; insert the midpoint of the
+> longest edge, splitting that edge in **both** incident cells; then run the
+> Delaunay flip pass.
+
+Splitting the shared edge in both incident cells is conforming by construction —
+no hanging node, so **no conforming closure and no LEPP chain**. Unlike bisection
+we never demand that the neighbour split its *own* preferred edge. The green
+cells this leaves are badly shaped, and repairing them is precisely the flip
+pass's job. In-band interpolation error:
+
+| engine | h=0.04 | 0.02 | 0.01 | 0.005 |
+|---|---|---|---|---|
+| nvb (bisection) | 0.1750 | 0.1029 | 0.0651 | 0.0524 |
+| **edge-split + flip** | **0.1136** | **0.0677** | 0.0626 | 0.0610 |
+
+and in-band FE error 0.089–0.18 against bisection's 0.23–0.58. Base-edge survival
+in the band is 22 %, matching bisection's 24 %.
+
+Marginal value of the flip pass on this engine, at the same size field:
+
+| h_near | cells no-flip → flip | in-band error no-flip → flip |
+|---|---|---|
+| 0.01 | 1935 → 1592 (**−18 %**) | 0.0670 → 0.0626 (**−7 %**) |
+| 0.005 | 4083 → 3376 (**−17 %**) | 0.0658 → 0.0610 (**−7 %**) |
+
+Fewer cells *and* lower error.
+
+## Correction — the earlier 2-D comparison was confounded
+
+The tables above compare engines at the same nominal `h_near`. **That is not a
+valid comparison** and the first version of this note drew a conclusion from it
+that does not survive.
+
+The engines mark on different quantities: NVB on `h = sqrt(2A)` / `(6V)^(1/3)`
+(its own `centroids_h`), edge-split on the **diameter**, which is always the
+larger number. The same nominal target therefore asks edge-split for a finer
+mesh. In 3-D the effect is severe — 36 569 tets against NVB's 9 780 for the same
+`h_near`. Error must be compared **at matched DOF**, not at matched nominal
+target.
+
+Re-run in 2-D with each engine's `h_near` bisected to land on ~1700 cells:
+
+| engine | h_near | cells | q_med | q<0.1 | ang p99 | in-band interp | in-band FE |
+|---|---|---|---|---|---|---|---|
+| nvb bisection | 0.0101 | 1718 | 0.862 | 0.00 % | 118.8 | 0.0666 | 0.2674 |
+| centroid raw | 0.0089 | 1704 | 0.592 | 11.09 % | 176.2 | 0.1525 | 1.2607 |
+| centroid + flip | 0.0089 | 1704 | 0.874 | 0.00 % | 132.9 | 0.1170 | 0.7858 |
+| edge-split, no flip | 0.0166 | 1716 | 0.855 | 0.00 % | 136.2 | 0.0725 | 0.1318 |
+| **edge-split + flip** | 0.0152 | 1676 | **0.890** | 0.00 % | **115.1** | **0.0620** | **0.0826** |
+
+The conclusions hold at matched DOF — edge-split + flip is 7 % better than NVB
+on interpolation error and **3.2× better** on in-band FE error — but they now
+rest on a fair comparison. Note also that in 2-D the flip pass is worth having:
+it improves interpolation error 14 % and FE error 37 % at equal cell count.
+
+## Finding 5 — 3-D: placement is the whole story, reconnection is not
+
+The 3-D case (unit box, `cellSize=0.4`, `refinement=1`, dipping fault at 60°,
+matching `~/+Simulations/nvb_3d_adapt_evaluation/`). Work-precision sweep,
+in-band FE error against cell count:
+
+| engine | observed rate | (P1 ideal in 3-D: `N^-0.67`) |
+|---|---|---|
+| nvb (bisection) | `N^-0.55` | suboptimal |
+| centroid | `N^-0.31` | badly suboptimal — this is the stall |
+| edge-split | **`N^-0.67`** | **optimal** |
+| edge-split + flip | **`N^-0.69`** | **optimal** |
+
+At matched DOF (~7 000 cells) edge-split gives 0.193 against NVB's ~0.35 —
+**1.8× better**, and it is the only engine achieving the optimal P1 rate.
+
+**But reconnection buys almost nothing in 3-D.** On the good engine, at
+`h_near = 0.07`:
+
+| | edge-split | + flip |
+|---|---|---|
+| cells | 26 632 | 26 557 |
+| in-band FE error | 0.0862 | 0.0851 (−1.3 %) |
+| cells with q<0.1 | 0.96 % | 0.94 % |
+| runtime | 3 s | **116 s (39×)** |
+
+And on the centroid engine, flips move `q<0.1` 41.2 % → 27.8 % but leave the
+error unchanged (0.6154 → 0.6192) and the max dihedral identical at 178.7°.
+
+**Why the 2-D result does not carry over.** 2-D Lawson flips reach the *unique*
+Delaunay triangulation — a global optimum for the given points. The 3-D 2↔3 /
+3↔2 flip set is a weak local search that cannot escape slivers, and a Delaunay
+tetrahedralisation contains them anyway. The kernel test shows this directly: a
+Delaunay tet mesh of a random cloud has `q_min = 1.9e-3` with 10 % of cells
+below `q = 0.1`, and 125 quality-gated flips left `q_min` **exactly unchanged**.
+
+This is the outcome flagged as the real risk before the port, and it is
+confirmed. The literature agrees: clearing slivers needs flips *plus* smoothing
+*plus* insertion/deletion (Klingner & Shewchuk), not flips alone.
+
+## Finding 4 — the price of preserving the decomposition
+
+Freezing the seam (the synthetic partition at `x = 0.5` deliberately **crosses**
+the refinement band — the worst case):
+
+- 13.2 % of base cells frozen;
+- on `edge-split + flip` the cell-count benefit survives (3395 vs 3376) but
+  accuracy costs ~10 % (0.0673 vs 0.0610) — freezing eats roughly the whole
+  *accuracy* benefit of flipping while keeping the *cell-count* benefit;
+- on the centroid engine the freeze is far more damaging (in-band FE 1.115 vs
+  0.802), because that engine depends on flips for basic shape repair.
+
+**Design rule that falls out: reconnection must be a polish, never load-bearing.**
+An engine that needs flips to be correct will suffer at a partition seam; an
+engine that uses flips to be *better* degrades gracefully. This is a stronger
+argument for `edge-split + flip` than its error numbers.
+
+## What survives reconnection downstream
+
+| consumer | pure flips (vertex set fixed) | point insertion |
+|---|---|---|
+| `child._adapt_prolongation` (exact ½,½, `nvb.py:249`) | survives — matched by *vertex coordinate identity*, which flips do not touch; must be **re-captured** after the DM rebuild, not re-indexed | invalid for new vertices → geometric builder |
+| `child._adapt_parent_cells` (any-degree, #425) | invalid — a flipped cell can straddle two coarse cells | invalid |
+| `barycentric` / `rbf` custom-P | fine (coordinate-based) | fine |
+| `_location_capability` | stays `exact` | stays `exact` |
+| boundary / region labels | preserved iff labelled facets are locked | same |
+| co-partitioning invariant | preserved iff the seam layer is frozen | same |
+
+Secondary payoff worth measuring later: `custom_mg.py:60-89` records
+Delaunay-vs-mesh cell agreement at 58.8 % (3-D uniform) and 17.1 % (3-D adapt
+child). A Delaunay mesh would push that toward 100 % on a convex domain, making
+the geometric P1 builder near-exact and attacking the root cause of the #424
+zero-column failure rather than the symptom.
+
+## Non-negotiables for any implementation
+
+- **Exact predicates.** Orientation and in-circle/in-sphere must be exact in
+  sign. Naive float determinants give inconsistent flip decisions and a
+  non-conforming mesh. The prototype uses a float filter with a `Fraction`
+  fallback; production wants Shewchuk's adaptive expansions.
+- **Locked facets.** Any facet carrying a boundary label, a region interface or
+  a registered `Surface` must never be flipped and no cavity may swallow one.
+  This is the constrained-Delaunay part and it is what protects faults and
+  material interfaces.
+- **Orientation guard.** Reject any modification producing non-positive
+  area/volume (precedent: the snap guard at `discretisation_mesh.py:7217`).
+  `to_dm` also requires CCW winding (`nvb.py:687`).
+- **Mark on the diameter, not `sqrt(2A)`** — see Finding 2.
+- **Never mutate a live mesh's topology in place.** Go `arrays → to_dm → new
+  Mesh`, as `adapt()` does; the in-place route hits the known `_nav_coords` /
+  face-control-point staleness traps (issues #286, #135).
+
+## Finding 6 — end-to-end: TI weak-plane Stokes on an edge-split child
+
+The engine carries a real solve. Same shear box, fault, and constitutive model as
+the validated reference (`~/+Simulations/shear_box_fault_study/shear_box_fault_ti.py`);
+only the refinement engine differs. Irregular base, 1056 cells, `max_levels=3`.
+
+| | cells | q_med | q<0.1 | in-band slip (TI − uniform) |
+|---|---|---|---|---|
+| nvb child | 2081 | 0.944 | 0.00 % | 0.193 |
+| edge-split child | 2868 | 0.959 | 0.00 % | 0.215 |
+
+Both converge; the weak plane localises slip as it should
+(`eta_1` verified to dip to exactly 1e-3 at the fault and recover by `|d| = 0.05`,
+director = (0.866, 0.5) = the exact fault normal).
+
+**Multigrid via the geometric route works, with one wiring step.** Measured
+velocity-block preconditioner:
+
+| child | velocity-block PC |
+|---|---|
+| nvb (from `base.adapt`) | `mg` — automatic, 8-mesh custom-P tail |
+| edge-split, as built | `gamg` — falls back |
+| edge-split + `set_custom_fmg(s, base._coarse_level_meshes(), field_id=0)` | **`mg`** |
+
+The gap is only that `_custom_mg_coarse_meshes` is attached by `_adapt_nested`,
+not by `Mesh` construction, so a child built from arrays has no tail until one is
+attached. One line when this is wired in as a real engine — the transfers
+themselves need no work, since every inserted vertex is an exact edge midpoint.
+
+**What is NOT shown here.** Iteration counts. `getLinearSolveIterations()` returns
+1–2 for every configuration, which cannot be right for a saddle-point solve and
+means the counter is not capturing the nested KSP work. No MG-vs-GAMG performance
+claim should be read off this run; the run establishes that the path *works*, not
+that it is fast.
+
+**Measurement errors made and fixed along the way** (both would have produced a
+confident wrong answer):
+- Slip was first sampled at ±3·`w_mech`, *outside* the weak zone, where the two
+  sample points differ in `y` and the imposed simple shear dominates. The fix is
+  to sample at `w_mech` and subtract a uniform-viscosity solve on the same mesh,
+  so what is reported is the fault's contribution alone.
+- The first run used `regular=True`, whose right-isoceles cells are a single
+  similarity class that *both* engines preserve — every mesh scored q = 0.866 and
+  the comparison could not discriminate. An irregular base is required.
+
+## Finding 7 — `relax()` is the cheapest win, and it composes with flips
+
+Everything above was measured **unrelaxed**. `mesh.relax()` (MMPDE in the ideal
+reference frame) moves nodes without changing topology or the size distribution,
+and its own docstring names the cause this study reached independently:
+*"refinement chooses where new nodes go from combinatorics … never from geometry,
+so a refined mesh carries needles and slivers that reflect the base mesh's
+arbitrary choices"*. Flips answer that from the connectivity side; relax answers
+it from the position side.
+
+Relax-at-end, same base and size field, 2-D:
+
+| engine / state | cells | q_med | q<0.1 | ang p99 | diam band | in-band interp |
+|---|---|---|---|---|---|---|
+| nvb | 1732 | 0.862 | 0.00 % | 118.8 | 0.0168 | 0.0651 |
+| + relax | 1732 | 0.908 | 0.00 % | 108.1 | 0.0163 | **0.0535** |
+| centroid | 1564 | 0.658 | 8.06 % | 175.5 | 0.0331 | 0.1549 |
+| + relax | 1564 | 0.696 | 2.37 % | 170.6 | 0.0332 | **0.1791 (worse)** |
+| centroid + flip | 1546 | 0.874 | 0.00 % | 132.4 | 0.0137 | 0.1171 |
+| + relax | 1546 | 0.929 | 0.00 % | 113.7 | 0.0145 | **0.0869** |
+| edge-split | 2580 | 0.835 | 0.00 % | 142.0 | 0.0101 | 0.0670 |
+| + relax | 2580 | 0.881 | 0.00 % | 115.8 | 0.0104 | **0.0533** |
+| edge-split + flip | 2238 | 0.894 | 0.00 % | 114.8 | 0.0109 | 0.0626 |
+| + relax | 2238 | **0.941** | 0.00 % | **100.9** | 0.0108 | **0.0521** |
+
+Three things follow.
+
+**It is free and it is the largest single accuracy gain measured here.** Cell
+counts are identical and band resolution is preserved to ~1 %, yet in-band
+interpolation error drops **17–20 %** on every healthy configuration — more than
+the flip pass buys (7–14 %).
+
+**Flips and relax compose rather than overlap.** On the centroid child, flips take
+0.155 → 0.117 and relax then takes it to 0.087; each gains where the other could
+not. `edge-split + flip + relax` is the best mesh measured anywhere in this study
+(q_med 0.941, ang p99 100.9°, interp 0.0521) and beats relaxed NVB (0.0535).
+
+**Relax makes centroid refinement WORSE** — the only regression in the table
+(0.1549 → 0.1791). Shape improves (q<0.1 8.06 % → 2.37 %) while accuracy
+degrades: relax equalises shape and in doing so pulls nodes off where the feature
+needs them, because the centroid point *set* was wrong to begin with. That is the
+same conclusion as Findings 2 and 5, reached from a third independent direction —
+**bad placement cannot be rescued, by connectivity or by position**.
+
+## Recommended next steps
+
+The investigation set out to add **reconnection**. What it actually found is a
+better **placement** rule, twice over — and that reconnection matters in 2-D and
+essentially not at all in 3-D. The recommendation follows that, not the original
+premise.
+
+1. **Do not pursue centroid placement.** Finding 2 closes it: the limitation is
+   structural, and reconnection recovers less than half of it.
+2. **`edge-split` is the candidate engine, and the flip pass is optional.** Mark
+   on the diameter, split the longest edge in both incident cells. It is
+   closure-free (the property that motivated centroid refinement), dimension-
+   general with no pattern tables, and the only engine measured at the optimal P1
+   rate in 3-D. Ship the flip pass as an **opt-in polish**: worth it in 2-D
+   (−14 % interpolation error at equal cells), not worth it in 3-D (−1.3 % for
+   39× the runtime).
+3. **The 3-D sliver question is open and is not answered by flips.** If element
+   quality in 3-D needs to improve further, the lever is smoothing between
+   sweeps (`mesh.relax` exists) or insertion/deletion — not a better flip set.
+   Worth knowing that `edge-split` already reaches 0.96 % of cells below q=0.1
+   against NVB's 1.92 %, so this may not need solving at all.
+4. **Then** wire `engine="delaunay"` (better named `engine="edge-split"`) into
+   `_adapt_nested` alongside `"nvb"`/`"sbr"`. The MG hierarchy needs no new work:
+   every inserted vertex is an exact edge midpoint, so the recorded ½,½
+   prolongation applies unchanged, and the geometric route already handles
+   everything else.
+
+Deferred, explicitly not blocking: anisotropic (metric) predicate; edge collapse
+for coarsening.
+
+## Finding 8 — the repair pass, and three corrections to the findings above
+
+Landed 2026-07-30 as `mesh.adapt(engine="edge_split", repair=True)`
+(`utilities/reconnect.py`). Full record in
+`~/.claude/plans/parallel-mesh-reconnection-flips.md`; raw numbers in
+`~/+Simulations/mesh_reconnection_study/results_production_repair.txt`.
+
+**Delaunay is the wrong acceptance criterion — in 2-D as well as 3-D.** Finding 3
+and the recommendation above treat "flip to Delaunay" as settled in 2-D because
+Lawson flips reach the unique Delaunay triangulation. The *operator* question is
+settled; the *criterion* question was not. Delaunay maximises the **minimum**
+angle and says nothing about the maximum, while the P1 interpolation bound depends
+on the **maximum** angle (Babuška–Aziz). Measured: flipping a gmsh-refined mesh
+towards Delaunay **raised** the 99th-percentile maximum angle from 126.8° to
+129.3°, because gmsh optimises element shape rather than the empty-circle property
+and its triangulation is locally non-Delaunay exactly where it chose a
+better-shaped configuration. Since every UW3 mesh starts from gmsh, the production
+pass gates on the angle directly, which makes it monotone — it can decline, but it
+cannot degrade a mesh.
+
+**The "−14 % interpolation error at equal cells" in step 2 above was a placement
+effect, not a connectivity effect.** In the prototype the flip pass ran *inside*
+the refinement loop, so the repaired arm had a different point set (a flip changes
+which edge is longest, hence where the next vertex lands), and the cell-count
+matching bisected the size field separately per arm. Isolated properly — repair
+after refinement is cell-count neutral, since two cells become two cells and no
+vertex is inserted — connectivity alone is worth **≤3 %** of core error. Run
+between passes, the ~20 % is real and belongs to **placement**. That is Finding 2's
+conclusion restated in the opposite direction, and it applies to reconnection's own
+benefit as much as to centroid refinement's failure.
+
+**A flip preserves the point chart, which collapses the parallel design.** Finding
+1 stands — a flip is not a `DMPlexTransform`, so the DM must be rebuilt — but the
+rebuild keeps the **identical point numbering**, because a 2-D flip adds and
+removes no points: the quad keeps its four vertices, five edges and two cells, and
+only the diagonal edge's cone and the two cell cones change. The point star-forest
+therefore transfers verbatim, labels transfer by point id and coordinates transfer
+unchanged. The "reconstruct the star-forest by matching untouched seam
+coordinates" stage in *Non-negotiables* is unnecessary. Two things not to
+re-derive: surgery on the source DM is impossible (`DMPlexSymmetrize` refuses to
+run on a plex that already has supports, and nothing outside `DMDestroy` frees
+them); and a triangle's cone convention is that closure vertex order is
+anticlockwise, cone entry `i` is the edge joining closure vertices `i` and `i+1`
+mod 3, and its orientation is `0` when the edge's own cone runs that way and `-1`
+when reversed — getting it wrong does not raise, it silently yields wrong geometry.
+
+What the pass is actually for is **shape on a poor base**: 99th-percentile maximum
+angle 156.0° → 115.1° on an aspect-ratio-4 grid and 175.5° → 118.0° on a
+non-Delaunay one, with slivers below q=0.1 going 3.84 % → 0.00 %; on a gmsh base,
+124.7° → 120.5° and little else. The aspect-ratio-4 case is the argument for
+building it at all: that base has a maximum angle of **90°**, ideal for P1, and
+edge-split refinement *degrades* it to 156°, because bisecting the longest edge of
+a stretched right triangle repeatedly manufactures obtuse cells. Refinement creates
+the problem; only reconnection removes it.
+
+Two further corrections. **Tier 0 — Rivara terminal-edge selection — was measured
+and rejected**: strict terminal-only selection stalls (a marked cell's
+longest-edge-propagation path walks towards *longer* edges, where the size field
+asks for less, so the terminal edge it reaches is nominated by nobody), and
+completing it with a LEPP walk gives core error identical to the existing veto rule
+while reintroducing propagation. Its apparent 33 % win was an artefact of the wedge
+size field, whose error window is far wider than the region it refines — use a
+flat-core field and a core-only window. And the **seam cost is small and shrinks**:
+frozen repair sites are 3.5 % at np=8 and 56k cells, halving with every halving of
+the target size, because repair sites scale with the refined band while seam
+crossings stay O(1). The 99th-percentile maximum angle recovers fully under a
+frozen seam; the absolute maximum does not.
+
+`repair=True` is opt-in because it gives up the one property `edge_split` has and
+it does not: the refined mesh is no longer **partition-independent**, since which
+cavities may be flipped depends on where the partitioner drew the seam. Conformity,
+orientation, volume, labels and the star-forest stay exact at every rank count.
+
+## Finding 9 — what the mesh is actually for: stress leaked across an interface
+
+The reconnection work above optimises element *shape*. For a fault problem the
+quantity that matters is narrower, and it turns out to rank the options
+differently, so it is recorded here rather than left in a results file.
+
+**The metric.** Stress is `τ = 2ηε̇`, and a P1 element forms it from the
+interpolated viscosity times the interpolated strain rate, independently. So the
+cell carries `mean(η)·mean(ε̇)` while the honest cell average is `mean(η ε̇)`. The
+difference is
+
+```
+leak = 2[mean(η)mean(ε̇) − mean(η ε̇)] = −2 Cov(η, ε̇)
+```
+
+per cell: **zero** for any element lying wholly inside or wholly outside the weak
+zone, positive only where an element straddles the transition with high strain
+rate at one end and high viscosity at the other. It converges (falls monotonically
+with resolution), which is the check that it measures the transition and not
+something else. Note it lives strictly *inside* elements — plotting nodal `2ηε̇`
+cannot show it, because at a node the two fields are sampled at the same point.
+
+**A material-based marking rule loses to the plain distance size field.** Marking
+cells by their internal η variation is the intuitive response and is measurably
+worse per degree of freedom: N^-0.37 for the absolute jump, a complete stall for
+the log ratio, against **N^-1.04** for the size field. The leak is spread across
+the whole transition rather than concentrated in a few identifiable cells, so
+there is nothing for a targeting rule to target, and uniform refinement of a
+correctly sized band is the efficient answer. The log ratio additionally refines
+the wrong end — it is largest where η is *smallest*, i.e. in the fault core, while
+the leak lives on the outer flank where η runs 0.5 → 1.
+
+**The optimal band width depends on which quantity you minimise**, and the
+objectives disagree. Total leak: narrower is better. Leak *into the matrix*: an
+optimum at a core half-width equal to the **influence width**, 2.6× better than a
+narrow band. Straddling-cell count: wider is monotonically better. State the
+objective before choosing the band.
+
+**A step-edged margin confines the artefact.** `influence_function(profile="step")`
+plus marking on the distance level set puts ~0 % of the leak beyond d = 0.03
+against 11.4 % for a smooth blend, and converges slightly faster (N^-1.32 — the
+1-D refinement buys more h per cell than the naive h-scaling argument suggests).
+The price is concentration: total leak 2.5× higher and the worst single cell 20×
+worse, welded into a one-cell collar on the interface. Good for a viscous solve,
+awkward for a yielding model.
+
+**Two exact fixes.** An element-wise constant (P0) viscosity makes `Cov(η, ε̇) ≡ 0`
+on any mesh at any resolution — not reduced, zero. Aligning the interface with
+element boundaries does the same. Both relocate the error from *inside* elements
+to *where the element boundaries fall*, which makes node placement, not shape
+repair, the lever — and hence `relax(pin_bands=...)` (Finding 10).
+
+## Finding 10 — relaxation and interface tracking fight; pin the band
+
+`relax()` on a mesh refined onto an interface makes it worse: manufactured stress
++77 %, and it stops being confined to the fault. The MMPDE mover optimises element
+shape against an equilateral reference and knows nothing about where the material
+changes, so it slides the small cells refinement placed on the interface off it.
+It even *reduces* the straddling-cell count (1343 → 965) while making things
+worse, because the survivors are larger — leak per straddling cell up 2.5×.
+
+`mesh.relax(pin_bands=[surface])` (or `[(surface, offset)]` for a weak zone of
+half-width `offset`) labels the cells the interface cuts and holds them fixed:
+leak unchanged to five decimal places, confinement preserved, straddling count
+identical, and the mover still reshapes the rest of the domain. `pin_halo`
+defaults to 1 because pinning only the cut cells lets the mover pull on them from
+outside.
+
+Two implementation notes that are easy to get wrong and fail silently:
+`pin_bands` must **merge** with `pinned_labels` rather than replace it, since the
+default is "pin every named boundary"; and the band test uses the **signed**
+distance at offset zero and the **unsigned** distance at a non-zero offset — the
+unsigned distance is never negative, so a straddle test against it at offset zero
+labels nothing, and the resulting empty `DMLabel` hard-crashes `getStratumIS`
+rather than raising.
+
+## Open questions / caveats
+
+- **Depth.** The 2-D figures sit at ~3–3.7 levels (log2 of base/finest diameter)
+  and the sweeps reach ~4.7. Nothing here tests 6–8 levels, where a real fault
+  model would sit. `edge-split` has no similarity-class bound — the guarantee
+  newest-vertex bisection gives up front — so its quality at depth is unmeasured.
+- **Halo.** `edge-split` shows a much larger "refined finer than asked" fraction
+  than NVB (90 % vs 42 % in 3-D). Part of that is the diameter-vs-volume marking
+  mismatch rather than genuine waste, and the metric was not re-tuned for the
+  diameter criterion. Worth separating before quoting it as leakage.
+- The flip pass is O(cells) per round in pure Python and is the runtime cost in
+  3-D. A production version would be incremental.
+
+## Related
+
+- `NVB_GRADED_ADAPT.md` — the current engine and why SBR cannot grade.
+- `nested-vs-geometric-mg-transfers.md` — the coordinate-vs-topological transfer
+  trade and issue #424.
+- `mesh-shape-relaxation.md:179` — the leakage convention used here (per-cell
+  `log2(h/h_asked)`, explicitly not a single scalar).
+- memory `project_centroid_vs_bisection_refinement` — the 3-D centroid ruling this
+  study was testing.
diff --git a/docs/developer/index.md b/docs/developer/index.md
index cc663cafc..29c6cb28c 100644
--- a/docs/developer/index.md
+++ b/docs/developer/index.md
@@ -184,6 +184,7 @@ CHANGELOG
 
 subsystems/meshing
 subsystems/mesh-shape-relaxation
+subsystems/conforming-surfaces-and-fault-zones
 subsystems/discretisation
 subsystems/solvers
 subsystems/boundary-stress-and-projection-postprocessing
diff --git a/docs/developer/subsystems/conforming-surfaces-and-fault-zones.md b/docs/developer/subsystems/conforming-surfaces-and-fault-zones.md
new file mode 100644
index 000000000..ecd77d9be
--- /dev/null
+++ b/docs/developer/subsystems/conforming-surfaces-and-fault-zones.md
@@ -0,0 +1,230 @@
+# Conforming surfaces and fault zones
+
+An internal surface — a fault, a material interface, the base of a sticky-air
+layer — can be added to a mesh *after* the mesh exists, by splitting every edge
+the surface crosses at the crossing point. The surface becomes a chain of element
+edges, so no element straddles it and every element lies cleanly on one side.
+
+```python
+fault = uw.meshing.Surface("Fault", mesh, trace_points)
+cut = mesh.add_conforming_surface(fault)
+
+zone = cut.cells_supporting("Fault")            # the fault zone, per cell
+eta = uw.discretisation.MeshVariable("eta", cut, 1, degree=0)
+eta.array[:, 0, 0] = np.where(zone, 1.0e-3, 1.0)
+```
+
+## Why straddling elements are not a resolution problem
+
+Stress is $\tau = 2\eta\dot\varepsilon$. Inside a linear element the discrete
+stress is the *interpolated* viscosity times the *interpolated* strain rate, whose
+cell average differs from the honest one by
+
+$$-2\,\mathrm{Cov}(\eta, \dot\varepsilon)$$
+
+per cell. That covariance is zero for any element lying wholly inside or wholly
+outside the weak zone, and non-zero only for elements that **straddle** it. So
+refining shrinks the straddling band but never empties it: the artefact is a
+*representation* problem, not a resolution one. The cure is to stop straddling.
+
+Measured on a 1/16 box with a viscosity step of $1 \to 10^4$ across a slanted
+line:
+
+| mesh | straddling cells | leak, continuous P1 $\eta$ | leak, cell-wise $\eta$ |
+|---|---|---|---|
+| uncut | 37 | 239.7 | 285.4 |
+| cut | 0 | 298.7 | **0.0 exactly** |
+
+Two things follow, and both matter:
+
+* **the cut alone is not enough.** A continuous P1 viscosity leaks *more* on the
+  cut mesh, because the nodes ON the interface are shared by both sides and a
+  continuous field has to take one value there;
+* **a cell-wise viscosity alone is not enough either.** On the uncut mesh it
+  leaks 285. The cut is what makes a per-cell assignment *correct*.
+
+The pairing is "cut **and** assign per cell".
+
+:::{note}
+Assign the contrast to a `degree=0` (P0) variable. `cells_supporting` returns
+plex cell order, which is exactly the DOF order of a P0 variable, so it can be
+assigned straight across. When rendering such a field, draw it as **cell** data —
+interpolating between centroid DOFs fakes a smear across the sharp interface you
+just went to the trouble of resolving.
+:::
+
+## The fault zone is the facet support
+
+`cells_supporting(name)` returns the cells in the **support of the labelled
+facets** — one element each side of the surface. It is not a geometrically
+bounded region, and that is deliberate.
+
+For a fault one element wide, the end cap (2-D) or edge band (3-D) that would
+close a bounded region has extent equal to the **thickness**, so resolving it
+would need $h \ll h$. You cannot have one-element thickness *and* an
+independently specified geometric boundary. Deriving the zone from the facets
+sidesteps the whole question: no cap, no band, no rim, no creases, and the
+definition says nothing about dimension.
+
+Measured properties:
+
+* the zone is **exactly $2\times$ the facet count**. A cell carrying two labelled
+  edges would have been cut in two, so no cell is double-counted and every facet
+  contributes both its neighbours;
+* it terminates automatically where the chain of facets ends — a fault tip needs
+  no special treatment;
+* the zone of a **network** is the union of its branches' zones, with no geometry
+  to reconcile where they meet.
+
+### The price, and why it is not a price
+
+Thickness is no longer a physical parameter — it tracks $h$. Measured as the mean
+distance from a zone cell's centroid to the trace, over the local cell size:
+
+| mesh | thickness / $h$ |
+|---|---|
+| uniform 1/8, 1/16, 1/32 | 0.189, 0.183, 0.184 |
+| adapted, `h_near` = 0.03, 0.02, 0.015 | 0.195, 0.202, 0.198 |
+
+Constant across a 4× refinement and across the adapt metric. Under adapt-on-top
+that is the *point*: put the surface at the finest adapted level and the fault
+width becomes a **refinement parameter**, set locally by the metric and at
+bounded cost.
+
+```python
+fault = uw.meshing.Surface("Fault", base, trace)
+fault.discretize()
+child = base.adapt(fault.refinement_metric_function(h_near=0.015, h_far=0.09,
+                                                    width=0.06), max_levels=3)
+cut = child.add_conforming_surface(uw.meshing.Surface("Fault", child, trace))
+```
+
+Adapt **then** cut. The child keeps its multigrid tail.
+
+If the fault width matters physically *and* can be made much larger than $h$, that
+is a different regime — bound it geometrically with two offset surfaces and an
+explicit cap, which works today by chaining `add_conforming_surface`.
+
+## Nothing below the child is cut
+
+The surface exists on the **finest level only**. The mesh it is added to, and
+every coarse multigrid level beneath it, are untouched and are reused as the
+child's coarse tail.
+
+That is the point of the stack-on formulation: fault geometry is a design
+variable in an outer optimisation, so the surface has to be able to move and be
+re-added against a base and a hierarchy that never change.
+
+A coarse cut would buy nothing anyway. The custom-P hierarchy sets
+`pc_mg_galerkin=both`, so every coarse operator is $P^\mathsf{T} A P$ formed from
+the **fine** operator and inherits the material contrast whatever the coarse mesh
+looks like. Measured on SolCx at contrasts of $10^2$ and $10^6$, cutting the
+coarse levels changed the error in the fifth significant figure and the solve time
+not at all.
+
+## Snap or cut
+
+A crossing landing close to an existing vertex would leave a sliver — worst case
+measured, a cell of area $10^{-24}$ with a zero interior angle. So a crossing
+within `snap_frac` of an edge's end, **measured along that edge**, moves the
+vertex onto the surface instead of splitting beside it.
+
+The along-edge measure is the one that matters: it is exactly the short side of
+the sliver that would otherwise be created, and it carries no length scale, so the
+same tolerance works on any mesh. The surface stays exactly where it was specified
+either way — a snapped vertex moves *onto* it, never the other way about — so
+what a larger tolerance costs is displacement of the surrounding mesh, not
+accuracy of the interface.
+
+What the slivers cost, measured with GAMG on a Poisson solve (CG iterations to
+`rtol=1e-10`, 5,432 cells), alongside the worst angle of the cut:
+
+| `snap_frac` | worst angle | CG iterations |
+|---|---|---|
+| uncut | 43.7° | 20 |
+| 0.00 | 1.6° | 32 |
+| 0.05 | 3.9° | 28 |
+| 0.10 (default) | 6.6° | 23 |
+| 0.20 | 13.9° | 21 |
+
+Cutting without snapping costs 60 % more iterations; snapping buys it back. A
+Lawson flip pass helps less (32 → 29 at `snap_frac=0`), so snapping is the lever
+and repair is a second-order touch-up.
+
+:::{warning}
+Snapping is a **discrete** switch. As a surface sweeps across the mesh the
+topology changes in jumps, which anything optimising over the surface's position
+has to live with.
+:::
+
+## Tips and junctions
+
+Both are the same problem: a distinguished point of the geometry that has to
+coincide with a mesh vertex. Once it does, every branch arriving there hits the
+already-legal case of "one crossed edge, one on-surface corner", and the cut
+terminates cleanly.
+
+```python
+from underworld3.utilities.line_cut import pull_vertex_onto, cut_along_lines
+
+dm = pull_vertex_onto(mesh.dm, junction)        # collective
+for k, branch in enumerate(branches):
+    dm, info = cut_along_lines(dm, [branch], label=f"F{k}", label_value=20 + k)
+```
+
+Prefer **pulling a vertex onto the tip** to snapping the tip to the nearest
+vertex: measured on a 1/12 box, tip error 0.0000 against 0.0306, and a better
+worst angle (8.79° against 5.29°). It costs mesh displacement rather than
+geometric accuracy — the same trade as `snap_frac` — and the tip is where the
+stress concentrates.
+
+Y (branching), T (abutting) and X (crossing) networks all work, in serial and at
+np=2/3/4. The union-of-cells zone **bulges** where branches meet, because the fan
+of cells around the shared vertex is picked up by each branch. That is accepted:
+intersecting faults are transient — if they slip they change the geometry — so
+junction volume need not be resolved exactly, and a widened damage zone at a
+junction is not physically unreasonable.
+
+:::{warning}
+Do **not** test a tip by asking whether cells straddle the infinite line. A fault
+ending at a vertex deliberately does not separate the material there — you can
+walk around the tip through the fan of cells — so those cells legitimately span
+the line while the fault crosses none of their interiors. Assert instead that
+consecutive on-fault vertices are joined by a **labelled** mesh edge, and that
+nothing beyond the tip is labelled.
+:::
+
+## What is refused
+
+Each of these is a case the cut cannot handle correctly, and each would otherwise
+give a mesh that looks plausible and still leaks stress:
+
+* an edge crossed more than once — it can only be split at one point;
+* a triangle entered but not left, which means a surface ends inside the mesh
+  without a vertex at the tip;
+* a triangle crossed three times;
+* nothing to cut at all;
+* snapping that inverts a cell, or that will not settle.
+
+Every one of these is raised **collectively**. A rank-local refusal aborts one
+rank while its peers walk on into the next collective and block there, turning a
+clear error into a hang.
+
+## Limitations
+
+* **Two dimensions.** The 3-D mechanism is validated on single tets and small
+  boxes but is not wired up.
+* **An essential boundary condition on the surface is not sound** under the
+  geometric multigrid hierarchy. The coarse levels do not carry the surface, so
+  the condition constrains the fine level and *zero* coarse degrees of freedom,
+  and the coarse operator is singular where custom-P needs it not to be. A
+  **material contrast** across the surface — the case this is built for — needs no
+  condition on the facets at all and is unaffected.
+* **Surface integrals do not work on an embedded surface**, however it was
+  created, so flux and traction recovery on one is not yet available.
+
+## See also
+
+* {doc}`meshing` — mesh construction and `Surface`
+* {doc}`mesh-metric-redistribution` — the adapt metric that sets the local `h`
+* `underworld3.utilities.line_cut` — the cutting mechanism
diff --git a/src/underworld3/cython/petsc_discretisation.pyx b/src/underworld3/cython/petsc_discretisation.pyx
index cd5a248f0..a15613057 100644
--- a/src/underworld3/cython/petsc_discretisation.pyx
+++ b/src/underworld3/cython/petsc_discretisation.pyx
@@ -309,3 +309,20 @@ def petsc_vec_concatenate( inputVecs  ):
 def petsc_get_swarm_coord_name( sdm ):
 
     return
+
+
+def petsc_dm_insert_boundary_values(dm_, lvec_, time=0.0):
+    """Insert essential boundary values into a LOCAL vector of ``dm_``.
+
+    Constrained DOFs are absent from the global system, so a global-to-local
+    scatter alone leaves them at zero wherever the essential datum g != 0 —
+    the same gap the consistent-boundary-flux paths close internally (issues
+    #407/#411). A solve that bypasses SNES's own copy-back (the rotated
+    strong-BC path) calls this to complete its output fields. Wraps
+    ``DMPlexInsertBoundaryValues``, which petsc4py does not expose.
+    """
+    cdef DM dm = dm_
+    cdef Vec lv = lvec_
+    cdef PetscReal t = time
+    CHKERRQ(DMPlexInsertBoundaryValues(dm.dm, PETSC_TRUE, lv.vec, t,
+                                       NULL, NULL, NULL))
diff --git a/src/underworld3/cython/petsc_generic_snes_solvers.pyx b/src/underworld3/cython/petsc_generic_snes_solvers.pyx
index 5d590b2fd..dc8b2f4a7 100644
--- a/src/underworld3/cython/petsc_generic_snes_solvers.pyx
+++ b/src/underworld3/cython/petsc_generic_snes_solvers.pyx
@@ -69,9 +69,38 @@ def _jacobian_unwrap(expr):
     This is a no-op for constant-viscosity problems (eta has no grad-v
     dependence), so those Jacobians stay bit-identical.
 
+    The unwrapped result is additionally made DIFFERENTIATION-SAFE: any
+    ``sqrt(g)`` whose argument carries non-constant symbols becomes
+    ``sqrt(g + 1e-36)``. Differentiating a bare invariant
+    :math:`\dot\varepsilon_{II} = \sqrt{g}` produces
+    :math:`\partial\sqrt{g}/\partial L = \dot\varepsilon/(2\dot\varepsilon_{II})`
+    — the DIRECTION of the strain rate, which is 0/0 at a state of rest —
+    so every consistent-tangent assembly at a cold (v = 0) start filled
+    the operator with NaN (measured: J(0) norm = nan for a ViscoPlastic
+    model at ANY yield stress, surfacing as GAMG's "Computed maximum
+    singular value as zero", error 77; the alpha-blended continuation
+    kernel inherits it even at alpha = 0 because IEEE 0*NaN = NaN). The
+    guard makes the derivative exactly zero at the singular point and
+    perturbs it by under one part in 1e24 at any resolvable strain rate.
+    The RESIDUAL is never routed through here, and the default (Picard)
+    tangent never calls this function, so both remain bit-identical.
+
     See ``docs/developer/design/jacobian-unwrap-constants-bug.md``.
     """
-    f = lambda e: _unwrap_expression(e, mode="symbolic_keep_constants")
+    eps2 = sympy.Float(1.0e-36)
+
+    def _guard_sqrts(e):
+        # every HALF-INTEGER power: +1/2 (the invariant itself), -1/2
+        # (its reciprocal in eta_pl = tau_y/(2 edot_II)), -3/2 (their
+        # derivatives), ... — all singular in value or derivative at a
+        # zero-argument state
+        return e.replace(
+            lambda n: (n.is_Pow and n.exp.is_Rational
+                       and n.exp.q == 2 and n.args[0].free_symbols),
+            lambda n: sympy.Pow(n.args[0] + eps2, n.exp))
+
+    f = lambda e: _guard_sqrts(
+        _unwrap_expression(e, mode="symbolic_keep_constants"))
     if isinstance(expr, sympy.MatrixBase):
         return expr.applyfunc(f)
     if isinstance(expr, sympy.NDimArray):
@@ -1357,9 +1386,11 @@ class SolverBaseClass(uw_object):
         unguard : remove the deadline.
         estimate_difficulty : bound the *work* (an iteration count) instead.
         """
-        if getattr(self, "_rotated_freeslip_bcs", None):
+        if getattr(self, "_rotated_freeslip_bcs", None) \
+                or getattr(self, "_fault_contact_faults", None):
             raise NotImplementedError(
-                "guard() is not available with rotated free-slip BCs: that path runs "
+                "guard() is not available with rotated free-slip / fault-contact "
+                "BCs: that path runs "
                 "its own Krylov loop outside self.snes (utilities/rotated_bc.py), so "
                 "the deadline cannot reach it and the guard would be silently inert."
             )
@@ -1415,9 +1446,11 @@ class SolverBaseClass(uw_object):
         ``consistent_jacobian="continuation"`` the cap applies to EACH stage (Picard
         then Newton), so one probe may run up to twice ``max_nl_its``.
         """
-        if getattr(self, "_rotated_freeslip_bcs", None):
+        if getattr(self, "_rotated_freeslip_bcs", None) \
+                or getattr(self, "_fault_contact_faults", None):
             raise NotImplementedError(
-                "estimate_difficulty() is not available with rotated free-slip BCs: "
+                "estimate_difficulty() is not available with rotated free-slip / "
+                "fault-contact BCs: "
                 "that path solves outside self.snes (utilities/rotated_bc.py), so the "
                 "iteration cap and resume anchor cannot be applied to it."
             )
@@ -5753,6 +5786,12 @@ class SNES_Stokes_SaddlePt(SolverBaseClass):
         self._rotated_freeslip_bcs = []
         self._rotated_freeslip_datum = {}
         self._rotated_freeslip_info = None
+        # Split-fault interface conditions (add_fault_bc): fault names whose
+        # coincident DOF pairs carry a contact (the laws themselves live in
+        # _fault_interface_laws, set lazily by utilities/fault_contact.py).
+        # Non-empty => solve() takes the rotated path, where fault_contact
+        # supplies the pair blocks and the interface operator.
+        self._fault_contact_faults = []
         # Give the Lagrange-multiplier (lambda) block its own viscosity-scaled
         # Schur preconditioner. The constraint Schur complement S_lambda = C A^-1 C^T
         # scales as 1/mu (since A ~ mu K), exactly like the pressure Schur S_p ~ mu^-1 M_p
@@ -5995,6 +6034,63 @@ class SNES_Stokes_SaddlePt(SolverBaseClass):
         self.is_setup = False
         return
 
+    def add_fault_bc(self, conds=0, boundary=None, normal=None):
+        r"""Interface condition on a split-node fault (value-first).
+
+        ``boundary`` names a fault split by ``Mesh.add_fault`` (or
+        ``fault_split.split_fault``); the mesh carries its coincident DOF
+        pairing. The no-opening constraint :math:`[\mathbf v]\cdot\hat n = 0`
+        is always imposed strongly; ``conds`` sets the tangential law:
+
+        * ``conds = 0`` — frictionless (perfectly slippery): zero shear
+          traction, the slip emerges (the stress-driven crack).
+        * ``conds`` > 0 — viscous interface :math:`\tau = \eta_f V` with
+          ``conds`` = :math:`\eta_f` (viscosity per unit length; the
+          zero-thickness limit of a band is :math:`\eta_f = \eta_{band}/w`,
+          where :math:`\eta_{band}` is the band's OWN weak-zone viscosity —
+          not the background's — and :math:`w` its width). ``conds`` large
+          removes the fault (only the JUMP is penalised — nothing becomes
+          rigid).
+
+        ``normal`` optionally supplies the fault's smooth unit normal —
+        a sympy ``1×dim`` Matrix in ``mesh.X`` (same conventions as
+        :meth:`add_rotated_freeslip_bc`), the string ``"trace"`` (2-D: the
+        smoothed normal is built from the fault's own stored polyline —
+        the right choice for digitized traces with no analytic formula),
+        or a constant ``(dim,)`` array. Use it whenever the fault trace is
+        a SAMPLED SMOOTH CURVE: the default per-node normal averages the
+        adjacent facet normals, which zig-zags at the sampling kinks, and
+        the no-opening constraint then forbids smooth slip past each kink —
+        slip notches and normal-traction sawteeth that GROW under mesh
+        refinement. The smooth normal restores the smooth curve's
+        mechanics on the same polyline mesh. On a straight fault the
+        default is already exact, and a deliberately KINKED fault should
+        NOT be smoothed — there the kink response is the physics.
+
+        The solve then takes the rotated strong-constraint path
+        (``utilities/rotated_bc.py`` with the pair blocks of
+        ``utilities/fault_contact.py``); ``guard()`` /
+        ``estimate_difficulty()`` are unavailable, as for rotated free-slip.
+        Slip and leak per coincident pair afterwards:
+        ``fault_contact.fault_slip(solver, boundary,
+        solver._rotated_freeslip_info)``.
+        """
+        from underworld3.utilities import fault_contact
+
+        if not isinstance(boundary, str):
+            raise TypeError(
+                f"add_fault_bc() requires the fault's boundary name string; "
+                f"got {type(boundary).__name__}")
+        eta_f = float(conds)
+        if eta_f == 0.0:
+            fault_contact.add_frictionless_fault_bc(self, boundary,
+                                                    normal=normal)
+        else:
+            fault_contact.add_viscous_fault_bc(self, eta_f, boundary,
+                                               normal=normal)
+        self.is_setup = False
+        return
+
     def _residual_is_nonlinear(self, tol=1e-8):
         r"""True if the Stokes residual is nonlinear in the unknowns :math:`(v, p)`
         — i.e. the assembled Jacobian depends on the solution, so Newton / Picard
@@ -9004,7 +9100,7 @@ class SNES_Stokes_SaddlePt(SolverBaseClass):
         # Rotated strong free-slip: delegate to the rotated_bc module (per-node DOF
         # rotation + strong v_n=0 + reaction=sigma_nn). Handles the whole assemble/
         # solve/rotate-back/gauge-removal; stashes info for boundary_normal_traction.
-        if self._rotated_freeslip_bcs:
+        if self._rotated_freeslip_bcs or self._fault_contact_faults:
             # Run the same pre-solve preamble as the standard path so the pointwise
             # functions see the DM time, the auxiliary vector, and updated constants
             # (needed for problems whose coefficients live in auxiliary fields). This
@@ -9101,13 +9197,21 @@ class SNES_Stokes_SaddlePt(SolverBaseClass):
         # (frozen) tangent path is left bit-identical, and an explicit Picard count
         # is honoured as given.
         #
-        # This is a DESIGN REQUIREMENT, not an optimisation: under the consistent
-        # tangent a viscoplastic Jacobian is NaN at zero strain rate (the residual
-        # survives, its derivative does not), so the machinery has to make that
-        # state unreachable. Both routes to it are covered — an explicit cold start,
-        # and a nominally warm one whose solution has never been written. The
-        # "continuation" tangent needs no help: it opens on a Picard stage
-        # (alpha = 0) by construction. See
+        # This warm-up is a CONVERGENCE aid (move a cold guess toward the Newton
+        # basin), NOT the correctness mechanism for the zero-strain-rate state.
+        # Two measured facts (issue #507) retired the old "make the NaN state
+        # unreachable" framing: (1) one nrichardson sweep only propagates
+        # boundary data a single element layer, so on a BOUNDARY-DRIVEN problem
+        # the deep interior stays exactly zero after the warm-up (body-force
+        # problems fill F(0) everywhere, which is why the yield campaigns never
+        # saw it); (2) a rigidly-translating stuck region has edot = 0 at the
+        # CONVERGED solution — the state is physics, not a start-up artifact.
+        # Finiteness of the consistent tangent at edot = 0 is owned by the
+        # half-integer-power guard in _jacobian_unwrap (the derivative's
+        # removable-singularity limit, implemented). NOTE the "continuation"
+        # tangent is NOT protected by its alpha = 0 phase (the blended kernel
+        # still evaluates the Newton branch pointwise, and IEEE 0*NaN = NaN);
+        # with the guard in place both tangents are finite everywhere. See
         # docs/developer/design/nonlinear-solver-homotopy-warmstart.md (Layer 1).
         if (picard == 0 and self.consistent_jacobian is True
                 and (zero_init_guess or self._solution_is_trivially_zero())):
diff --git a/src/underworld3/discretisation/discretisation_mesh.py b/src/underworld3/discretisation/discretisation_mesh.py
index a032ca6ba..cf34c05fd 100644
--- a/src/underworld3/discretisation/discretisation_mesh.py
+++ b/src/underworld3/discretisation/discretisation_mesh.py
@@ -275,6 +275,50 @@ def _mesh_coords_update_callback(array, change_context):
     return
 
 
+
+def _compose_prolongations(fine, coarse):
+    """The transfer ``fine @ coarse``, as COO triplets, in numpy alone.
+
+    Composing two prolongations is a sparse matrix product, but not one that
+    needs a sparse-matrix library: every row of a bisection prolongation holds
+    one or two entries (an inherited vertex, or the average of two), so expanding
+    each entry of ``fine`` through the matching rows of ``coarse`` and summing
+    duplicates stays small and is the whole operation.
+
+    ``fine`` maps the middle level to the fine one and ``coarse`` maps the coarse
+    level to the middle, so the result maps coarse to fine.
+    """
+    f_rows, f_cols, f_vals = fine
+    c_rows, c_cols, c_vals = coarse
+
+    order = numpy.argsort(c_rows, kind="stable")
+    cr, cc, cv = c_rows[order], c_cols[order], c_vals[order]
+
+    start = numpy.searchsorted(cr, f_cols, side="left")
+    stop = numpy.searchsorted(cr, f_cols, side="right")
+    counts = stop - start
+    if counts.sum() == 0:
+        return (numpy.empty(0, dtype=numpy.int64),
+                numpy.empty(0, dtype=numpy.int64), numpy.empty(0))
+
+    # Gather every (fine entry, matching coarse entry) pair without a Python loop.
+    total = int(counts.sum())
+    offsets = numpy.repeat(numpy.cumsum(counts) - counts, counts)
+    picks = numpy.repeat(start, counts) + (numpy.arange(total) - offsets)
+
+    rows = numpy.repeat(f_rows, counts)
+    cols = cc[picks]
+    vals = numpy.repeat(f_vals, counts) * cv[picks]
+
+    # A fine vertex can reach the same coarse vertex by more than one route, so
+    # duplicates are summed rather than dropped — dropping them silently loses
+    # part of the weight and the transfer stops being a partition of unity.
+    key = rows * (int(cols.max()) + 1) + cols
+    uniq, inverse = numpy.unique(key, return_inverse=True)
+    summed = numpy.bincount(inverse, weights=vals, minlength=uniq.size)
+    width = int(cols.max()) + 1
+    return (uniq // width, uniq % width, summed)
+
 class Mesh(Stateful, uw_object):
     r"""
     Unstructured mesh with PETSc DMPlex backend.
@@ -2527,13 +2571,24 @@ def _refine_restrict(self, child_var, parent_var, mode="replace"):
                 uw.function.global_evaluate(cv.sym, numpy.asarray(pv.coords))
             ).reshape(pv.data.shape)
         else:
-            from scipy.spatial import cKDTree
+            from underworld3.utilities import custom_mg
             cc = numpy.asarray(self.parent._get_coords_for_basis(pv.degree, pv.continuous))
             fc = numpy.asarray(self._get_coords_for_basis(cv.degree, cv.continuous))
-            # nested SBR: every coarse DOF coincides with a fine DOF (P1) or sits
-            # on a fine element edge (P2) -> nearest fine node is exact / near-exact.
-            _, idx = cKDTree(fc).query(cc)
-            out = numpy.asarray(cv.data)[idx].reshape(pv.data.shape)
+            if getattr(self, "_refine_dofs_coincide", True):
+                from scipy.spatial import cKDTree
+                # nested SBR: every coarse DOF coincides with a fine DOF (P1) or
+                # sits on a fine element edge (P2) -> nearest fine node is exact.
+                _, idx = cKDTree(fc).query(cc)
+                out = numpy.asarray(cv.data)[idx].reshape(pv.data.shape)
+            else:
+                # A child that MOVED parent nodes — adding a conforming surface
+                # snaps vertices onto it — has no coincident DOF to inject from.
+                # Nearest-node still returns that vertex, so the query succeeds
+                # and silently reports the field at the DISPLACED position, an
+                # O(snap_frac x h) error that nothing downstream can see.
+                # Interpolate instead, which is what the parallel path above does.
+                P = custom_mg.barycentric_prolongation(fc, cc)
+                out = (P @ numpy.asarray(cv.data)).reshape(pv.data.shape)
 
         new = numpy.array(pv.data)
         if mode == "replace":
@@ -6709,7 +6764,96 @@ def redistribute_nodes(self, metric, *, verbose=False, **kwargs):
         smooth_mesh_interior(self, metric=metric, method="mmpde",
                              verbose=verbose, **kwargs)
 
-    def relax(self, metric=None, *, verbose=False, **kwargs):
+    def label_interface_band(self, surface, offset=0.0, halo=1, name=None):
+        """Label the vertices of every cell an interface passes through.
+
+        The interface is the level set ``distance(surface) == offset`` — the
+        surface itself when ``offset`` is zero, or the margin of a weak zone of
+        half-width ``offset``. Cells the level set cuts are the ones that cannot
+        represent the material change across them, and their vertices are what
+        :meth:`relax` must hold still if the refinement that placed small cells
+        there is not to be undone.
+
+        Parameters
+        ----------
+        surface : Surface
+            Provides the exact distance field.
+        offset : float, default 0.0
+            Distance at which the interface sits.
+        halo : int, default 1
+            Extra rings of vertices to include. Pinning only the cut cells leaves
+            the mover free to pull on their immediate neighbours, which drags the
+            pinned ring out of shape from outside, so at least one ring is
+            usually wanted.
+        name : str, optional
+            Label name. Defaults to ``"PinnedBand_<surface name>"``.
+
+        Returns
+        -------
+        str
+            The label name, ready to pass to :meth:`relax` or
+            :meth:`redistribute_nodes` as part of ``pinned_labels``.
+
+        Notes
+        -----
+        The test is purely geometric, so every rank labels its own copy of a
+        shared vertex identically and the result does not depend on the partition.
+        """
+        import numpy
+
+        dm = self.dm
+        vS, vE = dm.getDepthStratum(0)
+        cS, cE = dm.getHeightStratum(0)
+        coords = numpy.asarray(dm.getCoordinatesLocal().array).reshape(
+            -1, self.dim)
+        # SIGNED distance for the surface itself, UNSIGNED for a margin. The
+        # straddle test is "the level set passes between these vertices", and
+        # against the unsigned distance that can never be true at offset zero
+        # because the unsigned distance is never negative — the surface would
+        # label nothing at all. At a non-zero offset the unsigned distance is the
+        # right choice precisely because a weak zone has TWO margins, at +offset
+        # and -offset, and it catches both.
+        distance = (surface.signed_distance(coords) if offset == 0.0
+                    else surface.unsigned_distance(coords))
+
+        cell_vertices = [
+            numpy.array([int(p) for p in dm.getTransitiveClosure(c)[0]
+                         if vS <= p < vE])
+            for c in range(cS, cE)]
+
+        pinned = set()
+        for verts in cell_vertices:
+            d = distance[verts - vS]
+            if d.min() < offset < d.max():
+                pinned.update(int(v) for v in verts)
+        for _ring in range(halo):
+            grown = set()
+            for verts in cell_vertices:
+                vv = [int(v) for v in verts]
+                if any(v in pinned for v in vv):
+                    grown.update(vv)
+            pinned |= grown
+
+        if not pinned:
+            # An empty DMLabel is not merely useless: querying its strata is a
+            # hard crash, not an exception, so refuse rather than hand one back.
+            raise ValueError(
+                f"no cell is cut by distance == {offset} on surface "
+                f"{getattr(surface, 'name', surface)!r}, so there is no band to "
+                f"pin. Check the offset lies inside the mesh and matches the "
+                f"interface you meant (for a weak zone it is the HALF-WIDTH, not "
+                f"zero).")
+
+        name = name or f"PinnedBand_{getattr(surface, 'name', 'surface')}"
+        if not dm.hasLabel(name):
+            dm.createLabel(name)
+        label = dm.getLabel(name)
+        for v in pinned:
+            label.setValue(v, 1)
+        return name
+
+    def relax(self, metric=None, *, pin_bands=None, pin_halo=1, verbose=False,
+              **kwargs):
         r"""Improve this mesh's element **shapes** without changing its
         size distribution or its topology.
 
@@ -6797,6 +6941,24 @@ def relax(self, metric=None, *, verbose=False, **kwargs):
             no metric but 117.9 -> **127.4** with one. Pass a metric when
             you want the sizes corrected too, and accept that shape is no
             longer the objective.
+        pin_bands : sequence, optional
+            Interfaces whose cells must not move: each entry is a ``Surface``, or
+            a ``(surface, offset)`` pair when the interface is a level set of the
+            distance rather than the surface itself (a weak zone of half-width
+            ``offset``). Their bands are labelled via
+            :meth:`label_interface_band` and held fixed.
+
+            This is the difference between relaxation helping and hurting when a
+            mesh has been refined onto an interface. The mover optimises element
+            shape against an equilateral reference and knows nothing about where
+            the material changes, so it slides the small cells that refinement
+            placed on the interface *off* it: measured on a step-edged fault, the
+            manufactured stress across the interface rose 77 % and stopped being
+            confined to the fault. Pinning the band leaves that quantity unchanged
+            to five decimal places while the mover still reshapes everywhere else.
+        pin_halo : int, default 1
+            Rings of neighbouring vertices pinned alongside each band. Pinning the
+            cut cells alone lets the mover pull on them from outside.
         verbose : bool, default False
             Print mover progress.
         **kwargs
@@ -6804,6 +6966,11 @@ def relax(self, metric=None, *, verbose=False, **kwargs):
             ``pinned_labels``, ``slip_surfaces``, ``method_kwargs``
             (mover tunables such as ``n_outer``).
 
+            Note that passing ``pinned_labels`` explicitly REPLACES the default,
+            which is to pin every named boundary. ``pin_bands`` is merged with
+            that default rather than replacing it, so it cannot silently release
+            the domain boundary.
+
         See Also
         --------
         adapt : Add resolution (topology change, returns a child mesh).
@@ -6812,6 +6979,21 @@ def relax(self, metric=None, *, verbose=False, **kwargs):
         """
         import sympy
 
+        if pin_bands:
+            from underworld3.meshing.smoothing.graph import _auto_pinned_labels
+
+            names = []
+            for entry in pin_bands:
+                surface, offset = entry if isinstance(entry, tuple) else (entry, 0.0)
+                names.append(self.label_interface_band(
+                    surface, offset=offset, halo=pin_halo))
+            # MERGE with the caller's list, or with the auto default when there is
+            # none. Replacing the default would quietly unpin the domain boundary.
+            existing = kwargs.pop("pinned_labels", None)
+            if existing is None:
+                existing = list(_auto_pinned_labels(self))
+            kwargs["pinned_labels"] = list(existing) + names
+
         method_kwargs = dict(kwargs.pop("method_kwargs", None) or {})
         # No metric  -> keep each cell's own size, repair shape only.
         # With one   -> the metric sets size (a uniform reference volume),
@@ -6828,9 +7010,451 @@ def relax(self, metric=None, *, verbose=False, **kwargs):
             sympy.sympify(1) if metric is None else metric,
             verbose=verbose, method_kwargs=method_kwargs, **kwargs)
 
+    def _boundaries_with(self, name):
+        """This mesh's boundary enum, extended with one more named boundary.
+
+        An ``Enum`` carrying members cannot be subclassed, so the extended enum is
+        built fresh from the existing members. The new value is the first free one
+        past the largest ordinary boundary.
+
+        Excluding the sentinels ``Null_Boundary`` (666) and ``All_Boundaries``
+        (1001) from that maximum is NOT enough to keep off them: a mesh whose
+        largest ordinary value is 665 lands the surface exactly on 666. So the
+        candidate is stepped past anything already taken. ``Enum`` would not
+        complain — it would alias the two names to one value, and every facet of
+        the surface would answer to ``Null_Boundary``.
+        """
+        from enum import Enum
+
+        members = {b.name: b.value for b in self.boundaries}
+        if name in members:
+            raise ValueError(
+                f"this mesh already has a boundary called {name!r}; a conforming "
+                "surface needs its own name so a solver can tell them apart.")
+        taken = set(members.values())
+        ordinary = [v for v in taken if v < 666]
+        value = (max(ordinary) + 1) if ordinary else 1
+        while value in taken:
+            value += 1
+        members[name] = value
+        return Enum("boundaries", members)
+
+    def cells_supporting(self, name):
+        """The cells in the SUPPORT of the facets labelled ``name``.
+
+        This is the **fault zone** of a conforming surface: not a geometrically
+        bounded region but the set of cells the labelled facets belong to — one
+        element each side of the surface, by construction.
+
+        The definition is worth stating plainly because the obvious alternative
+        does not work. A fault one element wide has an end cap (2-D) or an edge
+        band (3-D) whose extent equals the THICKNESS, so resolving it would need
+        `h` much smaller than `h`. Deriving the zone from the facets instead
+        needs no cap, no band and no rim: it terminates automatically where the
+        chain of facets ends, it says nothing about dimension, and the zone of a
+        network is simply the union of its branches' zones, with no geometry to
+        reconcile where they meet.
+
+        The price is that thickness is no longer a physical parameter — it tracks
+        `h` (measured: 0.13 `h` half-thickness, constant across a 4x refinement).
+        Under adapt-on-top that is the point rather than a defect: the surface
+        lives at the finest level, so the zone width is whatever the adapt metric
+        asks for locally, which makes fault width a *refinement* parameter.
+
+        Parameters
+        ----------
+        name : str
+            A boundary of this mesh, normally one added by
+            :meth:`add_conforming_surface`.
+
+        Returns
+        -------
+        numpy.ndarray
+            Boolean, one entry per cell, in **plex cell order** — which is also
+            the DOF order of a ``degree=0`` :class:`MeshVariable`, so it can be
+            assigned straight across.
+
+        Examples
+        --------
+        >>> zone = mesh.cells_supporting("Fault")
+        >>> eta = uw.discretisation.MeshVariable("eta", mesh, 1, degree=0)
+        >>> eta.array[:, 0, 0] = numpy.where(zone, 1.0e-3, 1.0)
+
+        See Also
+        --------
+        add_conforming_surface : add the surface whose facets these are.
+        """
+        from underworld3.utilities.edge_split import _cells_on_edge
+
+        if name not in [b.name for b in self.boundaries]:
+            raise ValueError(
+                f"{name!r} is not a boundary of this mesh; the surface must be "
+                f"added before its zone can be read. Have: "
+                f"{[b.name for b in self.boundaries]}")
+
+        dm = self.dm
+        cS, cE = dm.getHeightStratum(0)
+        zone = numpy.zeros(cE - cS, dtype=bool)
+
+        value = self.boundaries[name].value
+        label = dm.getLabel(name)
+        # An empty stratum hands back a null IS that segfaults in getIndices().
+        # A rank owning no part of the surface is the normal case at np>2.
+        if label is None or label.getStratumSize(value) == 0:
+            return zone
+
+        for f in label.getStratumIS(value).getIndices():
+            # `_cells_on_edge` rather than `getSupport` directly: in 2-D an edge
+            # IS a facet and its support is already the cells, but in 3-D the
+            # support holds faces and the cells are one level further up.
+            # Applying the 2-D walk in 3-D returns nothing at all, silently.
+            for c in _cells_on_edge(dm, int(f)):
+                zone[c - cS] = True
+        return zone
+
+    @staticmethod
+    def _repair_cut(cut_dm, lines, info, reach, verbose):
+        """Flip, then delete, the cells a conforming cut left thin.
+
+        The order is measured, not assumed, and it does not commute — see
+        :meth:`add_conforming_surface`. Deletion is offered only the vertices
+        near the surface, because it removes degrees of freedom and the cut is
+        what justifies removing these particular ones; flipping is offered the
+        whole mesh, because it conserves the point set.
+
+        ``info`` is restated rather than left as the cut wrote it: its
+        ``min_angle`` describes the mesh before repair, and a caller reading it
+        off a repaired mesh would be reading the wrong number.
+        """
+        from underworld3.utilities import reconnect
+        from underworld3.utilities.line_cut import (_coords, _distance_to_lines,
+                                                    _edge_vertices, _vertex_h,
+                                                    min_angles)
+
+        cut_dm, n_flips = reconnect.flip_to_reduce_max_angle(cut_dm)
+
+        vS, vE = cut_dm.getDepthStratum(0)
+        X = _coords(cut_dm)[: vE - vS]
+        near = _distance_to_lines(X, lines) < reach * _vertex_h(
+            X, _edge_vertices(cut_dm))
+        cut_dm, n_removed = reconnect.remove_vertices(
+            cut_dm, numpy.flatnonzero(near) + vS)
+
+        angles = min_angles(cut_dm)
+        info = dict(info, n_repair_flips=n_flips, n_repair_removals=n_removed,
+                    min_angle=float(angles.min()) if len(angles) else 0.0)
+        if verbose:
+            uw.pprint(f"[surface repair] {n_flips} flips, {n_removed} vertices "
+                      f"removed, min angle now {info['min_angle']:.2f} deg")
+        return cut_dm, info
+
+    def add_conforming_surface(self, surface, snap_frac=0.10, verbose=False,
+                               snap_quality=0.15, snap_dist=0.0,
+                               mg_coarsening_ratio=2.0, repair=False,
+                               repair_reach=0.6):
+        r"""Add an internal surface that the mesh conforms to.
+
+        The surface is added *on top of* an existing mesh rather than built into
+        the mesh generator, so its position does not have to be known when the
+        mesh is made. Every edge the surface crosses is split **at the crossing
+        point**, so the surface becomes a chain of element edges: no element
+        straddles it, each element lies cleanly on one side, and the edges along
+        it carry a boundary label of the surface's name.
+
+        Two things follow from conforming, and both need the surface to be a real
+        mesh entity rather than a smooth field:
+
+        * a material property can be assigned per **cell** and be exactly right.
+          A property interpolated across a straddling element manufactures stress
+          :math:`-2\,\mathrm{Cov}(\eta, \dot\varepsilon)` per cell, which
+          refinement shrinks but never removes;
+        * the surface is a **named, labelled** set of facets, so downstream passes
+          can find it again: ``relax(pin_bands=[name])`` holds it, the reconnection
+          pass refuses to flip across it, and the cells either side of it can be
+          marked.
+
+        .. warning::
+
+           An **essential boundary condition** on the surface is not yet sound
+           under the geometric multigrid hierarchy. The coarse levels do not carry
+           the surface at all — by design, see above — so the condition constrains
+           the fine level and **zero** coarse degrees of freedom, and the coarse
+           operator is singular where custom-P needs it not to be. Surface
+           integrals on an embedded surface do not work either, however the
+           surface was created.
+
+           A **material contrast** across the surface — a fault zone, or sticky
+           air — is unaffected: it needs the surface labelled and the cells either
+           side marked, and no condition applied on the facets at all. That is the
+           use this method is for.
+
+        **Nothing below the child is cut.** The surface exists on the finest level
+        only; this mesh and every coarse multigrid level under it are untouched
+        and are reused as the child's coarse tail. That is the whole point of the
+        stack-on formulation — the surface's position is a design variable in an
+        outer optimisation, so it has to be able to move and be re-added against a
+        base and a hierarchy that never change.
+
+        Nor does a coarse cut buy anything. The custom-P hierarchy sets
+        ``pc_mg_galerkin=both``, so every coarse operator is
+        :math:`P^\mathsf{T} A P` formed from the **fine** operator and inherits
+        the material contrast whatever the coarse mesh looks like. Measured on
+        SolCx at contrasts of :math:`10^2` and :math:`10^6`, cutting the coarse
+        levels changed the error in the fifth significant figure and the solve
+        time not at all.
+
+        Parameters
+        ----------
+        surface : uw.meshing.Surface
+            The surface to conform to. Its control points give the polyline and
+            its ``name`` becomes a boundary of the returned mesh, so
+            ``relax(pin_bands=[surface.name])`` holds it.
+
+            A :class:`~underworld3.meshing.Surface` rather than a
+            ``(points, name)`` pair because that is what the rest of the fault
+            machinery already takes — ``fault_metric``, ``fault_metric_tensor``
+            and ``refinement_metric_function`` all do — so the same object drives
+            the refinement metric and the cut, instead of being unpacked and its
+            name re-stated. It also carries ``signed_distance`` and ``director``,
+            which is what a weak-plane constitutive model needs afterwards.
+
+            The polyline must cross the mesh from boundary to boundary and must
+            not cross itself.
+        snap_frac : float
+            A crossing landing within this fraction of an edge's length from
+            either end moves that end onto the surface instead of splitting the
+            edge. This is what keeps slivers out: without it an algebraic solver
+            pays about 60 % more iterations on the slivers a cut leaves behind.
+            The surface stays exactly where it was specified either way — a
+            snapped vertex moves *onto* it, not the other way about.
+
+            On a GRADED mesh the 0.10 default is not the best value: measured on
+            a four-level adapted mesh, 0.30 took the worst angle from 4.96 to
+            10.81 degrees and cells below 15 degrees from 231 to 31. The default
+            is left alone because it was chosen on a uniform mesh, where the
+            trade is different again — raise it deliberately, and measure.
+        verbose : bool
+            Report how many edges were split and the worst cell of the result.
+        snap_quality : float
+            Triangle-quality floor protecting the snap; see
+            :func:`~underworld3.utilities.line_cut.cut_along_lines`. It does not
+            bind at the recommended tolerances — it is what stops a large
+            ``snap_frac`` from flattening cells onto the surface and silently
+            breaking the chain.
+        snap_dist : float
+            Also snap any vertex within this multiple of its local h of the
+            surface, whatever the crossings on its edges look like; see
+            :func:`~underworld3.utilities.line_cut.cut_along_lines`.
+        mg_coarsening_ratio : float
+            How much finer the cut must be than the mesh it is cut from before
+            that mesh is kept as a multigrid level in its own right rather than
+            replaced by the child. Same meaning, and the same routine, as in
+            :meth:`adapt`: a level is a coarsening ratio, not a record that an
+            operation happened. A cut usually does not clear it, and should not.
+        repair : bool, default False
+            Repair the element shapes the cut leaves behind, by flipping and then
+            deleting. Off by default for the same reason
+            :meth:`adapt`'s ``repair`` is: the cut alone gives the same mesh at
+            any rank count, and repair gives that up, because which cells may be
+            touched depends on where the partitioner drew the seam.
+
+            The cut can only **snap** a vertex onto the surface or **split** an
+            edge it crosses, so a crossing landing near a vertex must either drag
+            the vertex to it or carve a thin cell beside it — tightening
+            ``snap_frac`` only trades one for the other. Repair adds the two
+            operations the cut does not have. Measured on a box fault, counting
+            cells whose smallest angle is under 15 degrees: 60 after the cut, 18
+            after flipping, and **4** after deleting as well — while removing 242
+            cells. A second round of either finds nothing.
+
+            The order is fixed and is not symmetric: deleting first leaves the
+            count at 60, because a cavity, once retriangulated, no longer
+            presents the quad the flip pass was looking for.
+
+            The surface itself is untouched — its vertex and facet counts are
+            bit-identical through both passes, at every rank count, because both
+            refuse to act on a labelled edge.
+        repair_reach : float, default 0.6
+            How far from the surface a vertex may be and still be offered for
+            deletion, as a multiple of its own local h. This is the *policy*
+            half of the repair and the cut is what justifies it: the vertices
+            worth removing are the ones the cut had to work around. Deleting
+            removes a degree of freedom, so a pass turned loose on the whole mesh
+            would coarsen it wherever the shape happened to be poor. Flipping is
+            not restricted this way — it conserves the point set.
+
+        Returns
+        -------
+        Mesh
+            A child mesh conforming to the surface, with ``surface.name`` among
+            its ``boundaries``. Call again on the result to add a second,
+            non-intersecting surface — that is also how a fault NETWORK is built,
+            one branch at a time, since each branch wants its own label.
+
+        Examples
+        --------
+        A weak fault zone one element wide, assigned per cell so the contrast
+        falls exactly on the surface:
+
+        >>> fault = uw.meshing.Surface("Fault", mesh,
+        ...                            np.array([[0.5, -0.1], [0.5, 1.1]]))
+        >>> mesh2 = mesh.add_conforming_surface(fault)
+        >>> zone = mesh2.cells_supporting("Fault")          # boolean, per cell
+        >>> eta = uw.discretisation.MeshVariable("eta", mesh2, 1, degree=0)
+        >>> eta.array[:, 0, 0] = np.where(zone, 1.0e-3, 1.0)
+
+        The same object drives the refinement, so the zone is one element wide at
+        whatever resolution the metric asks for locally:
+
+        >>> child = base.adapt(fault.refinement_metric_function(
+        ...     h_near=0.01, h_far=0.08, width=0.05), max_levels=3)
+        >>> cut = child.add_conforming_surface(fault)
+
+        Notes
+        -----
+        Two dimensions only. A surface **ending inside** the mesh (a fault tip) is
+        refused rather than silently mis-meshed, as is a triangle the surface
+        crosses three times.
+
+        See Also
+        --------
+        cells_supporting : the fault zone — the cells these facets belong to.
+        adapt : local refinement, which reduces the straddling error without
+            removing it.
+        """
+        from underworld3.meshing.surfaces import Surface, _fault_collect_polylines
+        from underworld3.utilities.line_cut import cut_along_lines as _cut
+
+        if not isinstance(surface, Surface):
+            raise TypeError(
+                "add_conforming_surface takes a uw.meshing.Surface, not "
+                f"{type(surface).__name__}. Build one with "
+                "uw.meshing.Surface(name, mesh, control_points) — it is what the "
+                "refinement metric takes too, so the same object can drive both.")
+
+        name = surface.name
+        boundaries = self._boundaries_with(name)
+        value = boundaries[name].value
+        # Reuse the machinery's own "normalise a fault argument" routine, which
+        # reads control points in MODEL space — the space the DM's coordinates
+        # are in. `surface.control_points` is the dimensionalised gateway and
+        # would be the wrong space under an active units system.
+        lines = [numpy.array([segs[0][0]] + [b for _a, b in segs])
+                 for segs in _fault_collect_polylines(surface)]
+
+        cut_dm, info = _cut(self.dm, lines, snap_frac=snap_frac,
+                            label=name, label_value=value,
+                            snap_quality=snap_quality, snap_dist=snap_dist)
+        if repair:
+            cut_dm, info = self._repair_cut(cut_dm, lines, info, repair_reach,
+                                            verbose)
+        if verbose:
+            uw.pprint(f"[surface {name!r}] split {info['n_split']} edges, "
+                      f"{info['n_on_surface']} vertices on the surface; "
+                      f"{info['n_cut_edges']} surface facets, "
+                      f"min angle {info['min_angle']:.2f} deg")
+
+        child = Mesh(
+            cut_dm,
+            simplex=self.dm.isSimplex(),
+            coordinate_system_type=self.CoordinateSystem.coordinate_type,
+            qdegree=self.qdegree,
+            boundaries=boundaries,
+            verbose=False,
+        )
+        child.parent = self
+        child._relationship_kind = "refinement"
+        # ... but NOT a nested one. Snapping moves parent vertices onto the
+        # surface, so a coarse DOF need not have a coincident fine DOF, and the
+        # injection that a bisection child's restriction relies on would quietly
+        # read the field at the displaced position instead.
+        child._refine_dofs_coincide = False
+        child.regions = self.regions
+        child._parent_mesh_version = self._mesh_version
+        child._surface_info = info
+
+        # Mesh-owned custom-P geometric-MG tail. Adding a surface refines this
+        # mesh, so this mesh plus everything below it is a valid coarse tail and
+        # the solver appends the child as the finest level. The transfers are
+        # coordinate-based and do not need the levels to nest — just as well,
+        # since a cut vertex is not an edge midpoint and the exact 1/2,1/2
+        # prolongation does not apply to it.
+        #
+        # A mesh that is ITSELF a child (a second surface, or an adapt child) has
+        # to EXTEND its own tail rather than read `dm_hierarchy`, which for a child
+        # holds only its own DM: reading it there would silently discard every
+        # level below and leave a two-level hierarchy calling itself multigrid.
+        #
+        # Tested with `is not None`, not for truthiness. A child whose own tail
+        # is EMPTY is still a child, and reading `dm_hierarchy` there returns
+        # just its own DM — the two-level collapse this comment warns about,
+        # reached by the one input the truth test cannot distinguish from a
+        # parent.
+        own_tail = getattr(self, "_custom_mg_coarse_meshes", None)
+        tail = (list(own_tail) + [self]) if own_tail is not None \
+            else self._coarse_level_meshes()
+
+        # A cut is not necessarily a refinement. It re-represents the same grid
+        # with the surface conformed, so `self` earns its place as a separate
+        # level only if the child is genuinely finer — the same question `adapt`
+        # asks of an engine pass, so ask it with the same routine rather than a
+        # second rule that could drift from it.
+        #
+        # Measured on a box fault before this: nine levels, of which the two
+        # added by the two cuts coarsened h by 1.11x and 1.17x on the 5th
+        # percentile against a threshold of 1.8 — each costing a full Galerkin
+        # RAP and smoother sweep for no correction. Worse, transfer 7->8, BETWEEN
+        # those two, is where the barycentric builder ran out of coarse DOFs with
+        # a fine image and fell back to the dense RBF one (#424).
+        #
+        # `_subsample_mg_levels` already does "replace the level below rather
+        # than append to it" for its own finest generation; handing it the pair
+        # (self, child) against the level beneath them puts that decision here
+        # too. One level back means it kept only the child.
+        if len(tail) >= 2:
+            kept, _Ps, _pc = self._subsample_mg_levels(
+                tail[-2].dm, [tail[-1].dm, cut_dm], [None, None], [],
+                ratio=mg_coarsening_ratio, verbose=verbose)
+            if len(kept) == 1:
+                tail = tail[:-1]
+        child._custom_mg_coarse_meshes = tail
+        child._custom_mg_builder = self._custom_mg_builder
+
+        self._registered_children.add(child)
+        return child
+
+    def add_fault(self, faults, verbose=False):
+        """Cut AND split one or more faults; return the split mesh.
+
+        The split-node fault pipeline in one call: each fault becomes a
+        genuine velocity discontinuity — a conforming facet chain whose
+        nodes are duplicated, with boundaries ``<name>Plus`` /
+        ``<name>Minus`` and the coincident DOF pairing recorded. Interface
+        conditions then go through ``solver.add_fault_bc(conds, name)``
+        (``conds = 0`` frictionless, ``conds`` > 0 a viscous interface) and
+        an ordinary ``solve()``.
+
+        ``faults`` is a ``Surface``, a ``(name, points)`` pair, or a
+        sequence of either (a network — cut all, then split all). Each
+        fault is one open polyline with both tips strictly inside the
+        domain; segments must not share vertices, so branches and
+        crossings are represented as OFFSET segments (a one-to-two-cell
+        ligament). The result is standalone — no geometric-MG tail, since
+        the coarse levels do not carry the fault (see
+        :meth:`add_conforming_surface`); solvers take their
+        algebraic-multigrid defaults.
+
+        Implementation and design: ``underworld3.utilities.fault_split``
+        and ``docs/developer/design/FAULT_CONTACT_DEPLOYMENT_2026-08.md``.
+        """
+        from underworld3.utilities.fault_split import add_fault
+        return add_fault(self, faults, verbose=verbose)
+
+
     def adapt(self, metric_field, max_levels=None, node_budget=None,
               builder=None, adapter=None, engine=None, verbose=False,
-              relax=False, relax_kwargs=None):
+              relax=False, relax_kwargs=None, repair=False,
+              mg_coarsening_ratio=2.0):
         r"""
         Nested **adapt-on-top**: return a refined **child** mesh.
 
@@ -6915,12 +7539,53 @@ def adapt(self, metric_field, max_levels=None, node_budget=None,
             ``"sbr"`` (default) is the nested adapt-on-top path (the refinement
             engine is then chosen by ``engine``). ``"mmg"`` is a **deprecated shim**
             that forwards to :meth:`remesh` (in-place, returns ``self``).
-        engine : {"nvb", "sbr"}, optional
+        engine : {"nvb", "sbr", "edge_split"}, optional
             Advanced selector for the nested refinement engine (ignored when
             ``adapter="mmg"``). Default ``"nvb"`` — graded newest-vertex
             bisection; ``"sbr"`` is longest-edge bisection (uniform patch,
             still the right choice when a uniform-finest MG patch is wanted).
             See above.
+
+            ``"edge_split"`` splits the **longest edge** of every cell coarser
+            than the metric asks for, and needs no conforming closure at all
+            because splitting an edge divides every cell incident on it at the
+            same new vertex. Refinement therefore stays inside the marked region
+            instead of a bounded halo around it, at the cost of giving up the
+            similarity-class bound that makes bisection shape-safe at arbitrary
+            depth. It marks on the cell **diameter** rather than
+            ``(dim!·vol)^(1/dim)``; see
+            :mod:`underworld3.utilities.edge_split`.
+        mg_coarsening_ratio : float
+            Target coarsening in cell size `h` between consecutive multigrid
+            levels. A refinement engine takes as many passes as it needs to reach
+            the size the metric asks for, so a pass is not a level: recording one
+            level per pass gives a hierarchy of half-steps with a tail that
+            coarsens nothing, which was measured 2.3-7.3x slower than one level
+            per doubling at the same iteration count. ``2.0`` (halve `h` each
+            level) is the standard choice and the measured default; raise it for
+            fewer, cheaper levels or lower it if a problem needs a gentler
+            sequence.
+        repair : bool, default False
+            Run a reconnection (Lawson flip) pass after each ``edge_split``
+            generation, repairing the element shapes the split leaves behind. 2-D
+            and ``engine="edge_split"`` only. Off by default for one specific
+            reason: ``edge_split`` alone produces a **partition-independent** mesh,
+            identical at any communicator size, and repair gives that up, because
+            the flips it may perform depend on where the partitioner drew the seam
+            (a cavity spanning two ranks cannot be flipped). Conformity,
+            orientation, volume, labels and the star-forest stay exact at every
+            rank count.
+
+            Worth turning on when the base is poor — anisotropic, graded, relaxed
+            or read from a file. Measured there: 41 degrees off the 99th-percentile
+            maximum angle, slivers below q=0.1 from 3.84 % to 0.00 %, and 20-30 %
+            lower interpolation error per degree of freedom. On a well-shaped gmsh
+            base it costs a little time and changes little else. It also
+            invalidates the cell-parent map used by the any-degree nested MG
+            transfer (a flipped cell can straddle two coarse cells), so a degree-2
+            or higher space falls back to the geometric prolongation builder; the
+            exact vertex prolongation is unaffected because flips move no vertex.
+            See :mod:`underworld3.utilities.reconnect`.
         verbose : bool
 
         Returns
@@ -6990,18 +7655,37 @@ def adapt(self, metric_field, max_levels=None, node_budget=None,
             return self
         if adapter != "sbr":
             raise ValueError(f"adapter must be 'sbr' or 'mmg', got {adapter!r}")
-        if engine not in ("sbr", "nvb"):
-            raise ValueError(f"engine must be 'sbr' or 'nvb', got {engine!r}")
+        if engine not in ("sbr", "nvb", "edge_split"):
+            raise ValueError(
+                f"engine must be 'sbr', 'nvb' or 'edge_split', got {engine!r}")
+        if repair:
+            # Refuse rather than silently ignore: a caller asking for repair has a
+            # badly shaped mesh, and quietly returning an unrepaired one sends them
+            # looking for the problem somewhere else.
+            if engine != "edge_split":
+                raise ValueError(
+                    f"repair=True needs engine='edge_split', got {engine!r}. The "
+                    f"bisection engines carry a similarity-class bound that keeps "
+                    f"child quality tied to the base, so there is nothing for a "
+                    f"flip pass to repair.")
+            if self.dim != 2:
+                raise NotImplementedError(
+                    "repair=True is 2-D only. In 3-D no single flip is enough — "
+                    "the operator set has to become quality-gated edge removal. "
+                    "See docs/developer/design/"
+                    "mesh-reconnection-and-delaunay-adapt.md")
 
         return self._adapt_nested(
             metric_field, max_levels=max_levels, node_budget=node_budget,
             builder=builder, engine=engine, verbose=verbose,
-            relax=relax, relax_kwargs=relax_kwargs,
+            relax=relax, relax_kwargs=relax_kwargs, repair=repair,
+            mg_coarsening_ratio=mg_coarsening_ratio,
         )
 
     def _adapt_nested(self, metric_field, max_levels=2, node_budget=None,
                       builder="barycentric", engine="nvb", verbose=False,
-                      relax=False, relax_kwargs=None):
+                      relax=False, relax_kwargs=None, repair=False,
+                      mg_coarsening_ratio=2.0):
         """Core nested adapt-on-top (SBR or NVB engine). See :meth:`adapt`."""
         import math
         from underworld3.utilities import custom_mg
@@ -7406,6 +8090,99 @@ def _relax_generation(engine_obj, carry, rcarry):
                                  f"-> {fe - fs} cells (rank-local)")
             if not level_dms:
                 current_dm = base_finest.clone()
+        elif engine == "edge_split":
+            # Longest-edge refinement with NO conforming closure: splitting an
+            # edge divides every cell incident on it at the same new vertex, so
+            # there is no hanging node to repair and refinement cannot escape the
+            # marked region. Marking is on the cell DIAMETER, not (dim!·vol)^(1/dim)
+            # — for bisection the two shrink together, but this engine shortens
+            # the longest edge directly and the volume proxy would report the
+            # target met while the mesh is still coarse across the feature.
+            from underworld3.utilities import edge_split
+            # Independence caps a pass (no cell may carry two split edges), so a
+            # generation satisfies only some marked cells and the loop re-marks.
+            # 3D needs more passes than 2D: an edge is shared by more cells there,
+            # so fewer edges are independent per pass.
+            n_pass = 8 * dim * max_levels
+            current_dm = base_finest
+            for level in range(n_pass):
+                centroids, _proxy_h, cs = cell_geometry(current_dm)
+                if centroids.shape[0]:
+                    M = numpy.clip(eval_metric(centroids), 1e-30, None)
+                    h_target = 1.0 / numpy.sqrt(M)
+                    diameter = edge_split.cell_diameters(current_dm)
+                    sel = numpy.where(diameter > h_target)[0]
+                    if node_budget is not None and sel.size > node_budget:
+                        order = numpy.argsort(M[sel])[::-1]
+                        sel = sel[order[:node_budget]]
+                else:
+                    sel = numpy.empty(0, dtype=int)   # rank owns no cells
+
+                marked = [int(cs + j) for j in sel]
+                _coarse_for_P = current_dm
+                current_dm, n_split = edge_split.bisect_longest_edges(
+                    current_dm, marked)
+                # n_split is global, so this stop is collective without a further
+                # reduction — a rank with nothing marked still enters the split.
+                if n_split == 0:
+                    if verbose:
+                        uw.pprint(0, f"[adapt] edge_split pass {level}: "
+                                     f"nothing to refine")
+                    break
+                markers_per_level.append(marked)
+                # Every inserted vertex is the exact float midpoint of a parent
+                # edge, so the exact parent/child prolongation applies unchanged.
+                # Capture it BEFORE the snap and any relaxation move it out of
+                # reach of coordinate matching (#425).
+                from underworld3.utilities.nvb import (
+                    nested_prolongation_from_dms as _nested_from_dms,
+                    nested_cell_parents as _nested_parents)
+                _vP = _nested_from_dms(_coarse_for_P, current_dm)
+                _nested_Ps.append(_vP)
+                if repair:
+                    # Reconnection repairs the cells the split left thin. It
+                    # rebuilds the DM on the SAME point chart, so the vertex
+                    # prolongation just captured stays valid (a P1 section numbers
+                    # DOFs from the point numbering, which is preserved) — but the
+                    # cell-parent map does not: a flipped cell can straddle two
+                    # coarse cells, so the any-degree transfer has to fall back to
+                    # the geometric builder.
+                    from underworld3.utilities import reconnect
+                    current_dm, n_flips = reconnect.flip_to_reduce_max_angle(
+                        current_dm)
+                    _nested_parent_cells.append(None)
+                    if verbose:
+                        uw.pprint(0, f"[adapt] edge_split pass {level}: repaired "
+                                     f"with {n_flips} flip(s)")
+                else:
+                    _nested_parent_cells.append(
+                        None if _vP is None
+                        else _nested_parents(_coarse_for_P, current_dm, _vP))
+                snap_level_boundaries(current_dm)
+                if _relax_mode == "per-generation":
+                    _mg = Mesh(current_dm.clone(),
+                               simplex=self.dm.isSimplex(),
+                               coordinate_system_type=(
+                                   self.CoordinateSystem.coordinate_type),
+                               qdegree=self.qdegree,
+                               boundaries=self.boundaries, verbose=False)
+                    _mg.relax(_relax_metric, **(relax_kwargs or {}))
+                    current_dm.setCoordinatesLocal(
+                        _mg.dm.getCoordinatesLocal())
+                level_dms.append(current_dm)
+                if verbose:
+                    fs, fe = current_dm.getHeightStratum(0)
+                    uw.pprint(0, f"[adapt] edge_split pass {level}: split "
+                                 f"{n_split} edge(s) -> {fe - fs} cells "
+                                 f"(rank-local)")
+            else:
+                # Ran out of passes with cells still coarser than the metric.
+                # Silence here would look like a satisfied size field.
+                uw.pprint(0, f"[adapt] edge_split: stopped at the {n_pass}-pass "
+                             f"cap with the metric not yet satisfied; raise "
+                             f"max_levels if the feature needs to be finer.")
+            if not level_dms:
+                current_dm = base_finest.clone()
         elif engine == "nvb":
             # Serial cell-list engines: the slot-based NVBMesh in 2D (until
             # the native transform adopts the tagged rule — capstone stage
@@ -7544,14 +8321,21 @@ def _relax_generation(engine_obj, carry, rcarry):
         # checkpoint-by-marker payload (design only; storage is a follow-up).
         child._adapt_markers = markers_per_level
         child._adapt_engine = engine
+        # One multigrid level per DOUBLING OF RESOLUTION, not one per engine
+        # pass. This has to happen BEFORE the prolongations are recorded on the
+        # child: custom_mg indexes that list BY LEVEL, so a per-pass list against
+        # a subsampled hierarchy lines the transfers up against the wrong levels.
+        if level_dms:
+            level_dms, _nested_Ps, _nested_parent_cells = self._subsample_mg_levels(
+                base_finest, level_dms, _nested_Ps, _nested_parent_cells,
+                ratio=mg_coarsening_ratio, verbose=verbose)
+
         # Exact per-generation prolongations when the engine could supply them
         # (cell-list path). Empty for the native transform path, which falls
         # back to the geometric builder. See #425.
         child._adapt_prolongation = _nested_Ps
         child._adapt_parent_cells = _nested_parent_cells
-        # Mesh-owned custom-P geometric-MG tail. EVERY refinement level is its own
-        # MG level (one custom-P transfer per refinement step), not a single
-        # base-finest -> child jump: the tail is
+        # Mesh-owned custom-P geometric-MG tail: the tail is
         #   [base L0 … base finest]  +  [refine level 1 … refine level n-1]
         # and the solver appends its own mesh (the finest level = child). Each
         # intermediate level is wrapped here (transient, lives on the child); the
@@ -7561,7 +8345,14 @@ def _relax_generation(engine_obj, carry, rcarry):
         intermediate = [
             self._wrap_coarse_level(d) for d in level_dms[:-1]
         ]
-        coarse_tail = self._coarse_level_meshes()
+        # A mesh that is ITSELF a child — an adapt child, or one carrying a
+        # conforming surface — owns its tail; `dm_hierarchy` for such a mesh holds
+        # only its own DM, so reading it here discards every level below and
+        # leaves a two-level hierarchy calling itself multigrid. Tested with
+        # `is not None`: an empty own-tail is still an own-tail.
+        own_tail = getattr(self, "_custom_mg_coarse_meshes", None)
+        coarse_tail = (list(own_tail) + [self]) if own_tail is not None \
+            else self._coarse_level_meshes()
         if _moved:
             # the finest base level of the MG tail must carry the SAME moved
             # geometry the child was refined from; coarser levels keep their
@@ -7573,6 +8364,110 @@ def _relax_generation(engine_obj, carry, rcarry):
         self._registered_children.add(child)
         return child
 
+    _MG_RATIO_SLACK = 0.9      # a step of 1.92 counts as a doubling
+
+    def _subsample_mg_levels(self, base_finest, level_dms, nested_Ps,
+                             nested_parent_cells, ratio=2.0, verbose=False):
+        """Keep one multigrid level per DOUBLING OF RESOLUTION, not one per pass.
+
+        A refinement engine takes as many passes as it needs to reach the size
+        the metric asks for — independence caps how many edges one pass may
+        split, and a conforming closure cascades — so a pass is an implementation
+        detail of *reaching* a size, while a multigrid level is a *coarsening
+        ratio*. Recording one level per pass conflates them, and the tail of the
+        iteration becomes levels that coarsen nothing: measured, ``edge_split``
+        produced ten levels whose last three grew the mesh by 4 %, 1 % and 0.7 %,
+        each costing a full Galerkin RAP and smoother sweep for no correction,
+        and that hierarchy stopped SolCx converging at all.
+
+        **The measure is resolution, not element count.** Under adapt-on-top the
+        mesh only grows where the feature is, so a genuine halving of `h` shows up
+        as a global cell-count ratio near 1: measured on a thin band, NVB grew the
+        mesh by 1.06-1.11x per generation while the in-band `h` went 0.125 ->
+        0.0626 -> 0.0313 -> 0.0157. A count-based rule keeps nothing and collapses
+        the hierarchy; the whole-mesh median `h` is likewise flat and useless. So
+        the resolution of the refined region is what decides a level.
+
+        The exact per-generation prolongations are COMPOSED across the generations
+        a level skips, so the recorded transfer stays exact rather than falling
+        back to the geometric builder.
+
+        A level's parent-cell map survives only if that level is ONE generation.
+        A composed span crosses several, so a cell no longer has a single parent
+        and the any-degree transfer has to fall back to the geometric builder —
+        but that is a property of the individual level, not of the call. Dropping
+        every map whenever any subsampling happened discards maps that are still
+        valid, and it tautologised the test that told ``repair=True`` from
+        ``repair=False``.
+        """
+        from underworld3.utilities import edge_split
+
+        def resolution(dm):
+            """The size of the cells this level actually resolves with.
+
+            A low percentile rather than the strict minimum, so one thin cell
+            cannot declare a level; reduced with MIN so the finest region counts
+            wherever it happens to live.
+            """
+            d = edge_split.cell_diameters(dm)
+            local = float(numpy.percentile(d, 5)) if d.size else float("inf")
+            return uw.mpi.comm.allreduce(local, op=min)
+
+        # An engine lands near the target, not on it (1.92, 1.97, 2.19 measured),
+        # so the test is against a slightly slack ratio; without it a 1.99 step is
+        # rejected and two real levels fuse into one.
+        threshold = ratio * self._MG_RATIO_SLACK
+        h_ref = resolution(base_finest)
+        keep = []
+        for i, dm in enumerate(level_dms):
+            h = resolution(dm)
+            if h <= h_ref / threshold:
+                keep.append(i)
+                h_ref = h
+        # The finest generation IS the child, so it is always a level. If the
+        # level below it is within `ratio`, that level is a near-duplicate of the
+        # child rather than a coarsening of it, and REPLACING it is right —
+        # appending would reintroduce exactly the pair this routine exists to
+        # remove (measured: a last ratio of 1.04).
+        last = len(level_dms) - 1
+        if not keep:
+            keep = [last]
+        elif keep[-1] != last:
+            if resolution(level_dms[keep[-1]]) <= resolution(level_dms[last]) * threshold:
+                keep[-1] = last
+            else:
+                keep.append(last)
+
+        composed, parent_cells = [], []
+        start = 0
+        for i in keep:
+            span = [P for P in nested_Ps[start:i + 1]]
+            # One generation -> the level IS that pass, so its parent-cell map
+            # still describes it. More -> no single parent per cell. Not every
+            # engine records the maps at all (the native transform and SBR paths
+            # do not), so a short list means "none for this level".
+            parent_cells.append(nested_parent_cells[i]
+                                if i == start and i < len(nested_parent_cells)
+                                else None)
+            if any(P is None for P in span) or not span:
+                composed.append(None)
+            elif len(span) == 1:
+                composed.append(span[0])
+            else:
+                # x_fine = P_i ... P_start x_coarse, so the product runs
+                # fine-most first.
+                M = span[0]
+                for P in span[1:]:
+                    M = _compose_prolongations(P, M)
+                composed.append(M)
+            start = i + 1
+
+        if verbose:
+            uw.pprint(f"[adapt] {len(level_dms)} engine pass(es) -> "
+                      f"{len(keep)} multigrid level(s) "
+                      f"(kept {keep}, one per {ratio:.2g}x in h)")
+        return [level_dms[i] for i in keep], composed, parent_cells
+
     def remesh(self, metric_field, verbose=False):
         r"""
         Re-mesh (regenerate) the discretization in place from a metric field.
diff --git a/src/underworld3/meshing/__init__.py b/src/underworld3/meshing/__init__.py
index 0d60bb08b..73f0214d5 100644
--- a/src/underworld3/meshing/__init__.py
+++ b/src/underworld3/meshing/__init__.py
@@ -10,6 +10,7 @@
     UnstructuredSimplexBox,
     StructuredQuadBox,
     BoxInternalBoundary,
+    BoxInternalPatch,
 )
 
 from .spherical import (
@@ -45,6 +46,8 @@
     SurfaceVariable,
     SurfaceCollection,
     fault_metric_tensor,
+    prepare_fault_network,
+    damage_zone_yield,
     fault_comb_metric,
     fault_metric,
     compose_metrics,
@@ -78,6 +81,7 @@
     "UnstructuredSimplexBox",
     "StructuredQuadBox",
     "BoxInternalBoundary",
+    "BoxInternalPatch",
     # Spherical meshes
     "SphericalShell",
     "SphericalShellInternalBoundary",
@@ -103,6 +107,8 @@
     "SurfaceVariable",
     "SurfaceCollection",
     "fault_metric_tensor",
+    "prepare_fault_network",
+    "damage_zone_yield",
     "fault_comb_metric",
     "fault_metric",
     "compose_metrics",
diff --git a/src/underworld3/meshing/cartesian.py b/src/underworld3/meshing/cartesian.py
index 4f9659764..9d4749d5c 100644
--- a/src/underworld3/meshing/cartesian.py
+++ b/src/underworld3/meshing/cartesian.py
@@ -969,6 +969,235 @@ def box_return_coords_to_bounds(coords):
     return new_mesh
 
 
+@timing.routine_timer_decorator
+def BoxInternalPatch(
+    cellSize: float = 0.1,
+    minCoords: Optional[Tuple[float, float, float]] = (0, 0, 0),
+    maxCoords: Optional[Tuple[float, float, float]] = (1, 1, 1),
+    patch_points=None,
+    patch_name: str = "Fault",
+    patch_cellSize: Optional[float] = None,
+    grading_distance: Optional[float] = None,
+    degree: int = 1,
+    qdegree: int = 2,
+    filename=None,
+    refinement=None,
+    gmsh_verbosity=0,
+    units=None,
+    verbose=False,
+):
+    r"""
+    Create a 3-D simplex box with an interior conforming surface patch.
+
+    The patch is a planar polygon embedded in the tetrahedral mesh so that
+    a set of mesh FACES coincides with it exactly, labelled ``patch_name``.
+    Its rim stays strictly inside the box — this is the geometry a
+    split-node fault needs (:func:`underworld3.utilities.fault_split.
+    split_fault` duplicates everything inside the rim, and the rim is where
+    slip must taper to zero). Unlike :func:`BoxInternalBoundary`, the patch
+    does not span the domain and does not partition it into regions.
+
+    Parameters
+    ----------
+    cellSize : float
+        Target element size.
+    minCoords, maxCoords : tuple of float
+        Box corners.
+    patch_points : array_like, shape (N, 3)
+        Corners of the planar patch polygon, in order around its rim,
+        N >= 3. All points must be coplanar and strictly inside the box.
+        A disc (penny) patch is a many-sided polygon: sides of length
+        ``cellSize`` resolve the rim as well as the mesh can.
+    patch_name : str
+        Physical name for the patch — the fault name ``split_fault`` and
+        ``add_fault_bc`` will use.
+    patch_cellSize : float, optional
+        Target element size AT the patch. When set, the mesh grades from
+        ``patch_cellSize`` on the fault to ``cellSize`` in the far field
+        (gmsh Distance/Threshold size field from the patch surface) —
+        resolution belongs at the fault, exactly as the 2-D practice
+        refines on the cuts. Without it the box is uniform at
+        ``cellSize``.
+    grading_distance : float, optional
+        Distance from the patch at which the size reaches ``cellSize``
+        (default ``8 * patch_cellSize``). Only used with
+        ``patch_cellSize``.
+
+    Example
+    -------
+    >>> patch = np.array([[0.5, 0.3, 0.3], [0.5, 0.7, 0.3],
+    ...                   [0.5, 0.7, 0.7], [0.5, 0.3, 0.7]])
+    >>> mesh = uw.meshing.BoxInternalPatch(cellSize=0.1,
+    ...                                    patch_points=patch,
+    ...                                    patch_name="FltA")
+    >>> child = uw.utilities.fault_split.split_fault(mesh, "FltA")
+    """
+
+    class boundaries_3D(Enum):
+        Bottom = 11
+        Top = 12
+        Right = 13
+        Left = 14
+        Front = 15
+        Back = 16
+
+    class boundary_normals_3D(Enum):
+        Bottom = sympy.Matrix([0, 0, 1])
+        Top = sympy.Matrix([0, 0, 1])
+        Right = sympy.Matrix([1, 0, 0])
+        Left = sympy.Matrix([1, 0, 0])
+        Front = sympy.Matrix([0, 1, 0])
+        Back = sympy.Matrix([0, 1, 0])
+
+    minCoords = tuple(uw.scaling.non_dimensionalise(c) for c in minCoords)
+    maxCoords = tuple(uw.scaling.non_dimensionalise(c) for c in maxCoords)
+    cellSize = uw.scaling.non_dimensionalise(cellSize)
+
+    if len(minCoords) != 3:
+        raise ValueError("BoxInternalPatch is 3-D; in 2-D a fault is a "
+                         "polyline — use Mesh.add_fault on any box mesh.")
+    # a FaultSurface is the preferred input: it names itself, its rim
+    # polygon becomes the conforming patch, and it is stored on the mesh
+    # so add_fault_bc(..., normal="surface") can read the constraint
+    # frame from the surface's own face normals
+    fault_surface = None
+    if hasattr(patch_points, "rim_polygon") and \
+            hasattr(patch_points, "name"):
+        fault_surface = patch_points
+        if patch_name == "Fault":              # the default → its name
+            patch_name = fault_surface.name
+        patch_points = fault_surface.rim_polygon()
+    patch = np.asarray(patch_points, dtype=float)
+    if patch.ndim != 2 or patch.shape[0] < 3 or patch.shape[1] != 3:
+        raise ValueError("patch_points must be an (N, 3) polygon, N >= 3.")
+    lo, hi = np.asarray(minCoords), np.asarray(maxCoords)
+    if not ((patch > lo).all() and (patch < hi).all()):
+        raise ValueError("the patch must sit strictly inside the box — a "
+                         "fault that daylights is not yet supported.")
+
+    members = {b.name: b.value for b in boundaries_3D}
+    patch_tag = max(members.values()) + 4
+    members[patch_name] = patch_tag
+    boundaries = Enum("boundaries", members)
+
+    if patch_cellSize is not None:
+        patch_cellSize = uw.scaling.non_dimensionalise(patch_cellSize)
+        if not 0 < patch_cellSize <= cellSize:
+            raise ValueError("patch_cellSize must be in (0, cellSize].")
+    if grading_distance is None and patch_cellSize is not None:
+        grading_distance = 8.0 * patch_cellSize
+
+    if filename is None:
+        if uw.mpi.rank == 0:
+            os.makedirs(".meshes", exist_ok=True)
+        grade = ("" if patch_cellSize is None
+                 else f"_pcs{patch_cellSize}_gd{grading_distance}")
+        uw_filename = (f".meshes/uw_boxpatch_minC{minCoords}_"
+                       f"maxC{maxCoords}_csize{cellSize}{grade}_"
+                       f"{patch_name}{len(patch)}.msh")
+    else:
+        uw_filename = filename
+
+    if uw.mpi.rank == 0:
+        import gmsh
+
+        gmsh.initialize()
+        gmsh.option.setNumber("General.Verbosity", gmsh_verbosity)
+        gmsh.model.add("BoxInternalPatch")
+
+        box = gmsh.model.occ.addBox(
+            minCoords[0], minCoords[1], minCoords[2],
+            maxCoords[0] - minCoords[0], maxCoords[1] - minCoords[1],
+            maxCoords[2] - minCoords[2])
+
+        corner_tags = [gmsh.model.occ.addPoint(
+            *p, patch_cellSize if patch_cellSize is not None else cellSize)
+            for p in patch]
+        line_tags = [gmsh.model.occ.addLine(corner_tags[i],
+                                            corner_tags[(i + 1) % len(patch)])
+                     for i in range(len(patch))]
+        loop = gmsh.model.occ.addCurveLoop(line_tags)
+        patch_surface = gmsh.model.occ.addPlaneSurface([loop])
+        gmsh.model.occ.synchronize()
+
+        # The embed makes the volume mesh conform to the patch: its faces
+        # become tet faces, shared by one cell on each side.
+        gmsh.model.mesh.embed(2, [patch_surface], 3, box)
+
+        # OCC numbers the box walls itself; identify them by centre of mass.
+        centre = {
+            "Bottom": (None, None, minCoords[2]),
+            "Top": (None, None, maxCoords[2]),
+            "Left": (minCoords[0], None, None),
+            "Right": (maxCoords[0], None, None),
+            "Front": (None, minCoords[1], None),
+            "Back": (None, maxCoords[1], None),
+        }
+        for dim2, tag in gmsh.model.getEntities(2):
+            if tag == patch_surface:
+                continue
+            com = gmsh.model.occ.getCenterOfMass(dim2, tag)
+            for wall, probe in centre.items():
+                if all(p is None or abs(c - p) < 1e-9
+                       for c, p in zip(com, probe)):
+                    value = boundaries[wall].value
+                    gmsh.model.addPhysicalGroup(2, [tag], value)
+                    gmsh.model.setPhysicalName(2, value, wall)
+                    break
+
+        gmsh.model.addPhysicalGroup(2, [patch_surface], patch_tag)
+        gmsh.model.setPhysicalName(2, patch_tag, patch_name)
+        gmsh.model.addPhysicalGroup(3, [box], 99999)
+        gmsh.model.setPhysicalName(3, 99999, "Elements")
+
+        gmsh.option.setNumber("Mesh.CharacteristicLengthMax", cellSize)
+        if patch_cellSize is not None:
+            # grade from the fault outward: Distance field measured from
+            # the patch surface, thresholded to [patch_cellSize, cellSize]
+            df = gmsh.model.mesh.field.add("Distance")
+            gmsh.model.mesh.field.setNumbers(df, "SurfacesList",
+                                             [patch_surface])
+            gmsh.model.mesh.field.setNumber(df, "Sampling", 100)
+            tf = gmsh.model.mesh.field.add("Threshold")
+            gmsh.model.mesh.field.setNumber(tf, "InField", df)
+            gmsh.model.mesh.field.setNumber(tf, "SizeMin", patch_cellSize)
+            gmsh.model.mesh.field.setNumber(tf, "SizeMax", cellSize)
+            gmsh.model.mesh.field.setNumber(tf, "DistMin", patch_cellSize)
+            gmsh.model.mesh.field.setNumber(tf, "DistMax",
+                                            grading_distance)
+            gmsh.model.mesh.field.setAsBackgroundMesh(tf)
+            gmsh.option.setNumber("Mesh.MeshSizeExtendFromBoundary", 0)
+            gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 0)
+            gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0)
+        gmsh.model.mesh.generate(3)
+        gmsh.write(uw_filename)
+        gmsh.finalize()
+
+    new_mesh = Mesh(
+        uw_filename,
+        degree=degree,
+        qdegree=qdegree,
+        boundaries=boundaries,
+        boundary_normals=boundary_normals_3D,
+        coordinate_system_type=CoordinateSystemType.CARTESIAN,
+        useMultipleTags=True,
+        useRegions=True,
+        markVertices=True,
+        refinement=refinement,
+        refinement_callback=None,
+        units=units,
+        verbose=verbose,
+    )
+
+    from underworld3.meshing.bounding_surface import register_box_face_surfaces
+    register_box_face_surfaces(new_mesh, minCoords, maxCoords)
+
+    if fault_surface is not None:
+        new_mesh._fault_surfaces = {patch_name: fault_surface}
+
+    return new_mesh
+
+
 @timing.routine_timer_decorator
 def StructuredQuadBox(
     elementRes: Optional[Tuple[int, int, int]] = (16, 16),
diff --git a/src/underworld3/meshing/faults.py b/src/underworld3/meshing/faults.py
index 9a95874e1..6f636bc17 100644
--- a/src/underworld3/meshing/faults.py
+++ b/src/underworld3/meshing/faults.py
@@ -268,6 +268,82 @@ def triangulate(self, offset: float = 0.01) -> None:
         self._triangles = faces.reshape(-1, 4)[:, 1:4]
         self._normals = np.array(self._pv_mesh.cell_data["Normals"])
 
+    def rim_polygon(self, planar_tol: float = 1e-6) -> np.ndarray:
+        """The ordered rim polygon of a PLANAR triangulated surface.
+
+        This is the bridge into the split-node fault pipeline:
+        ``uw.meshing.BoxInternalPatch(patch_points=fault_surface, ...)``
+        embeds the rim polygon as the conforming patch, and
+        ``split_fault`` then duplicates everything inside it. The rim is
+        the chain of boundary edges (edges used by exactly one
+        triangle), returned as an ``(N, 3)`` loop of point coordinates
+        in walking order.
+
+        Planarity is required for now — the conforming embed handles
+        plane polygons only; a genuinely curved sheet waits on the
+        discrete-entity embed. ``planar_tol`` is relative to the
+        surface's extent.
+
+        Raises
+        ------
+        NotImplementedError
+            If the surface deviates from its best-fit plane by more
+            than ``planar_tol`` times its extent.
+        RuntimeError
+            If the boundary edges do not form a single closed loop
+            (a surface with holes, or a degenerate triangulation).
+        """
+        if not self.is_triangulated:
+            self.triangulate()
+        pts = np.asarray(self._points, dtype=float)
+        tris = np.asarray(self._triangles, dtype=int)
+
+        centre = pts.mean(axis=0)
+        _u, _s, vt = np.linalg.svd(pts - centre, full_matrices=False)
+        extent = float(np.linalg.norm(pts.max(axis=0) - pts.min(axis=0)))
+        dev = float(np.abs((pts - centre) @ vt[2]).max())
+        if dev > planar_tol * extent:
+            raise NotImplementedError(
+                f"fault surface {self.name!r} deviates from planar by "
+                f"{dev:.3g} (tolerance {planar_tol * extent:.3g}); the "
+                "conforming patch embed is plane-polygon only for now.")
+
+        edge_count = {}
+        for tri in tris:
+            for a, b in ((tri[0], tri[1]), (tri[1], tri[2]),
+                         (tri[2], tri[0])):
+                edge_count[(min(a, b), max(a, b))] = \
+                    edge_count.get((min(a, b), max(a, b)), 0) + 1
+        boundary = [e for e, n in edge_count.items() if n == 1]
+        if not boundary:
+            raise RuntimeError(
+                f"fault surface {self.name!r} has no boundary edges — a "
+                "closed surface cannot be a fault patch.")
+        neighbours = {}
+        for a, b in boundary:
+            neighbours.setdefault(a, []).append(b)
+            neighbours.setdefault(b, []).append(a)
+        if any(len(v) != 2 for v in neighbours.values()):
+            raise RuntimeError(
+                f"fault surface {self.name!r}: rim is not a simple loop "
+                "(a vertex joins more than two boundary edges).")
+        start = boundary[0][0]
+        loop, prev, here = [start], None, start
+        while True:
+            a, b = neighbours[here]
+            nxt = b if a == prev else a
+            if nxt == start:
+                break
+            loop.append(nxt)
+            prev, here = here, nxt
+        if len(loop) != len(neighbours):
+            raise RuntimeError(
+                f"fault surface {self.name!r}: rim has "
+                f"{len(neighbours)} boundary vertices but the walked "
+                f"loop closes after {len(loop)} — more than one loop "
+                "(holes are not supported).")
+        return pts[np.asarray(loop, dtype=int)]
+
     def compute_normals(self, consistent_normals: bool = True) -> None:
         """Recompute face normals for triangulated surface.
 
diff --git a/src/underworld3/meshing/surfaces.py b/src/underworld3/meshing/surfaces.py
index e9bc3a7e9..b897431b9 100644
--- a/src/underworld3/meshing/surfaces.py
+++ b/src/underworld3/meshing/surfaces.py
@@ -2718,6 +2718,310 @@ def _fault_collect_segments(faults):
     return [seg for poly in _fault_collect_polylines(faults) for seg in poly]
 
 
+def _polyline_arclengths(pts):
+    return np.concatenate(
+        [[0.0], np.cumsum(np.linalg.norm(np.diff(pts, axis=0), axis=1))])
+
+
+def _point_at_arc(pts, s_arc):
+    s_ctrl = _polyline_arclengths(pts)
+    s_arc = float(np.clip(s_arc, 0.0, s_ctrl[-1]))
+    k = int(np.searchsorted(s_ctrl, s_arc, side="right") - 1)
+    k = min(k, len(pts) - 2)
+    f = (s_arc - s_ctrl[k]) / max(s_ctrl[k + 1] - s_ctrl[k], 1e-30)
+    return pts[k] + f * (pts[k + 1] - pts[k])
+
+
+def _sub_polyline(pts, s0, s1):
+    """The part of the polyline between arc lengths s0 < s1, with exact
+    endpoints (interior control points kept)."""
+    s_ctrl = _polyline_arclengths(pts)
+    keep = (s_ctrl > s0 + 1e-12) & (s_ctrl < s1 - 1e-12)
+    return np.vstack([_point_at_arc(pts, s0), pts[keep],
+                      _point_at_arc(pts, s1)])
+
+
+def damage_zone_yield(mesh, junctions, tau_damage, radius,
+                      tau_far=1.0e3):
+    """A composite yield-stress expression: damage plugs at junctions.
+
+    The gap-and-let-it-link policy: declared master faults keep
+    geometric continuity, every other junction is left as an offset gap
+    (:func:`prepare_fault_network`), and the gaps carry DAMAGE-ZONE
+    material — a yield cap ``tau_damage`` inside a disc of ``radius``
+    about each junction point, ``tau_far`` (effectively unyielding)
+    elsewhere — so the stress lobes of the abutting tips decide how the
+    faults link up. Assign the result to a ViscoPlastic model::
+
+        prepared, report, junctions = prepare_fault_network(
+            faults, spacing=h, through=["Main"], return_junctions=True)
+        child = mesh.add_fault(prepared)
+        stokes.constitutive_model = ViscoPlasticFlowModel
+        stokes.constitutive_model.Parameters.yield_stress = \\
+            uw.meshing.damage_zone_yield(child, junctions,
+                                         tau_damage=0.5, radius=3 * h)
+
+    Regions are SHARP (Piecewise), deliberately: blending a huge far
+    yield through any smooth mask tail contaminates the plug
+    (measured — the plug shrinks to a fraction of a cell).
+
+    Parameters
+    ----------
+    mesh : Mesh
+        Supplies the coordinate symbols.
+    junctions : sequence
+        Junction records from ``prepare_fault_network`` (anything with
+        a ``point`` key or a 2-vector as its second element), or bare
+        2-vectors.
+    tau_damage : float or sequence of float
+        The damage yield stress (one value, or one per junction).
+    radius : float or sequence of float
+        Plug radius (one value, or one per junction) — a couple of
+        ligaments is the measured sweet spot.
+    tau_far : float, optional
+        The unyielding far-field cap. Keep it finite and sane (1e3):
+        it only needs to exceed any stress the model can produce.
+    """
+    x, y = mesh.X[0], mesh.X[1]
+    pts = []
+    for j in junctions:
+        if isinstance(j, dict):
+            pts.append(np.asarray(j["point"], dtype=float))
+        else:
+            pts.append(np.asarray(j, dtype=float))
+    n = len(pts)
+    taus = (list(tau_damage) if np.ndim(tau_damage) else [tau_damage] * n)
+    radii = (list(radius) if np.ndim(radius) else [radius] * n)
+    expr = sympy.sympify(tau_far)
+    for P, tau, R in zip(pts, taus, radii):
+        r2 = (x - float(P[0])) ** 2 + (y - float(P[1])) ** 2
+        expr = sympy.Min(expr, sympy.Piecewise(
+            (float(tau), r2 < float(R) ** 2), (tau_far, True)))
+    return expr
+
+
+def prepare_fault_network(faults, spacing, ligament=1.5, through=None,
+                          verbose=True, return_junctions=False):
+    """Make an imported set of 2-D fault traces splittable.
+
+    The split-node pipeline refuses faults that cross or share vertices
+    — a junction vertex needs a non-binary DOF pairing, which is a
+    design of its own. The SUPPORTED representation of a junction is
+    the offset form: the traces stop short of the intersection, leaving
+    a ligament of intact material about a cell across. Stress transfers
+    across the ligament (the measured mechanism of the interaction
+    examples); slip does not transfer through the junction point.
+
+    This function detects the junctions in an imported set and applies
+    that conversion, loudly:
+
+    - X crossing (interiors intersect): BOTH traces are cut at the
+      intersection, every cut end pulled back ``ligament * spacing``
+      along its own trace; a trace cut into k pieces is renamed
+      ``<name>_1 .. <name>_k``. If exactly one of the two is listed in
+      ``through``, it stays CONTINUOUS and only the other is cut (the
+      through-going fault offsets the crossing one); two ``through``
+      faults crossing is a hard error.
+    - T abutment (an endpoint of one trace on or near another's
+      interior): the abutting END is pulled back; the through-going
+      trace is untouched.
+    - Y contact (endpoints of two traces closer than the ligament):
+      both endpoints pulled back.
+
+    Pieces left shorter than ``2 * ligament * spacing`` are dropped and
+    reported. Returns ``(prepared, report)`` where ``prepared`` is a
+    list of ``(name, points)`` ready for :meth:`Mesh.add_fault` and
+    ``report`` is the list of actions taken (printed when ``verbose``).
+
+    Parameters
+    ----------
+    faults : sequence of (name, points) and/or Surface
+        The imported traces (each an open polyline).
+    spacing : float
+        The local mesh size the network will be meshed at — sets the
+        ligament in mesh units.
+    ligament : float, optional
+        Ligament size in multiples of ``spacing`` (default 1.5; the
+        add_fault contract wants segments at least a cell or two apart).
+    through : iterable of str, optional
+        Names of MASTER faults: never cut at X crossings (the other
+        trace yields on both sides). T abutments never cut the
+        through-going trace regardless.
+    """
+    lig = float(ligament) * float(spacing)
+    through = set(through or ())
+    junctions = []
+    traces = []
+    for entry in faults:
+        if isinstance(entry, tuple) and len(entry) == 2 \
+                and isinstance(entry[0], str):
+            name, pts = entry
+            pts = np.asarray(pts, dtype=float)[:, :2]
+        else:
+            name = entry.name
+            cp = np.asarray(entry._control_points, dtype=float)[:, :2]
+            pts = cp
+        traces.append([name, pts, []])          # [name, points, cut arcs]
+
+    report = []
+
+    def seg_intersect(p0, p1, q0, q1):
+        d1, d2 = p1 - p0, q1 - q0
+        den = d1[0] * d2[1] - d1[1] * d2[0]
+        if abs(den) < 1e-30:
+            return None
+        w = q0 - p0
+        t = (w[0] * d2[1] - w[1] * d2[0]) / den
+        u = (w[0] * d1[1] - w[1] * d1[0]) / den
+        if -1e-12 <= t <= 1 + 1e-12 and -1e-12 <= u <= 1 + 1e-12:
+            return t, u
+        return None
+
+    # pass 1: X crossings and T abutments -> cut/trim events per trace.
+    # The pull-back must give EUCLIDEAN clearance >= the ligament, and
+    # it is measured along each trace, so an oblique junction (crossing
+    # angle theta) needs pullback = lig / sin(theta) — a perpendicular
+    # crossing pulls back by exactly lig, a grazing one by more (capped,
+    # and reported, at 5 lig).
+    for i in range(len(traces)):
+        for j in range(i + 1, len(traces)):
+            ni, pi, ci = traces[i]
+            nj, pj, cj = traces[j]
+            si, sj = _polyline_arclengths(pi), _polyline_arclengths(pj)
+            for a in range(len(pi) - 1):
+                for b in range(len(pj) - 1):
+                    hit = seg_intersect(pi[a], pi[a + 1], pj[b], pj[b + 1])
+                    if hit is None:
+                        continue
+                    t, u = hit
+                    d1 = pi[a + 1] - pi[a]
+                    d2 = pj[b + 1] - pj[b]
+                    sin_th = abs(d1[0] * d2[1] - d1[1] * d2[0]) / (
+                        np.linalg.norm(d1) * np.linalg.norm(d2) + 1e-30)
+                    pull = lig / max(sin_th, 0.2)
+                    if sin_th < 0.2:
+                        report.append(
+                            f"grazing junction between {ni!r} and "
+                            f"{nj!r} (angle {np.degrees(np.arcsin(max(sin_th, 0.0))):.1f} deg): "
+                            f"pull-back capped at {pull:.4g}.")
+                    arc_i = si[a] + t * (si[a + 1] - si[a])
+                    arc_j = sj[b] + u * (sj[b + 1] - sj[b])
+                    end_i = min(arc_i, si[-1] - arc_i) < pull
+                    end_j = min(arc_j, sj[-1] - arc_j) < pull
+                    P = pi[a] + t * (pi[a + 1] - pi[a])
+                    # who yields: an abutting END always yields; a
+                    # through-going trace is only CUT at a genuine X
+                    # crossing, and never if it is a declared master
+                    if end_i and end_j:
+                        kind = "Y contact"
+                        cut_i = cut_j = True
+                    elif end_i:
+                        kind = f"T abutment ({ni!r} onto {nj!r})"
+                        cut_i, cut_j = True, False
+                    elif end_j:
+                        kind = f"T abutment ({nj!r} onto {ni!r})"
+                        cut_i, cut_j = False, True
+                    else:
+                        kind = "X crossing"
+                        if ni in through and nj in through:
+                            raise ValueError(
+                                f"two through-going faults ({ni!r}, "
+                                f"{nj!r}) cross at ({P[0]:.4g}, "
+                                f"{P[1]:.4g}) — one of them must be "
+                                "allowed to yield.")
+                        cut_i = ni not in through
+                        cut_j = nj not in through
+                    if cut_i:
+                        ci.append((arc_i, pull))
+                    if cut_j:
+                        cj.append((arc_j, pull))
+                    kept_name = ni if not cut_i else (
+                        nj if not cut_j else None)
+                    kept = ("" if kept_name is None
+                            else f" {kept_name!r} kept continuous;")
+                    junctions.append(dict(kind=kind, point=P.copy(),
+                                          pull=pull, faults=(ni, nj)))
+                    report.append(
+                        f"{kind} between {ni!r} and {nj!r} at "
+                        f"({P[0]:.4g}, {P[1]:.4g}):{kept} offset "
+                        f"junction (ligament {lig:.4g}, pull-back "
+                        f"{pull:.4g}).")
+
+    # pass 1b: NEAR-MISS abutments — an endpoint stopping just short of
+    # another trace never intersects, so pass 1 cannot see it, but the
+    # meshed ligament would be thinner than requested. Pull such an
+    # endpoint back until its Euclidean clearance reaches the ligament.
+    def dist_to(P, Q):
+        best = np.inf
+        for a, b in zip(Q[:-1], Q[1:]):
+            ab = b - a
+            t = float(np.clip(((P - a) @ ab) / max(ab @ ab, 1e-30),
+                              0.0, 1.0))
+            best = min(best, float(np.linalg.norm(P - (a + t * ab))))
+        return best
+
+    for i, (ni, pi, ci) in enumerate(traces):
+        s_i = _polyline_arclengths(pi)
+        for arc_end, P in ((0.0, pi[0]), (float(s_i[-1]), pi[-1])):
+            for j, (nj, pj, _cj) in enumerate(traces):
+                if j == i:
+                    continue
+                if dist_to(P, pj) >= lig:
+                    continue
+                if any(abs(arc - arc_end) < 4.0 * lig for arc, _ in ci):
+                    continue                    # already handled above
+                pull = lig
+                for _ in range(5):
+                    s_q = arc_end + pull if arc_end < 1e-12 \
+                        else arc_end - pull
+                    if dist_to(_point_at_arc(pi, s_q), pj) >= lig:
+                        break
+                    pull *= 1.6
+                ci.append((arc_end, pull))
+                junctions.append(dict(kind="near-miss", point=P.copy(),
+                                      pull=pull, faults=(ni, nj)))
+                report.append(
+                    f"near-miss abutment: the end of {ni!r} sits within "
+                    f"the ligament of {nj!r} — pulled back {pull:.4g}.")
+
+    # pass 2: apply the events trace by trace
+    prepared = []
+    for name, pts, cuts in traces:
+        total = _polyline_arclengths(pts)[-1]
+        if not cuts:
+            prepared.append((name, pts))
+            continue
+        pull_at = {}
+        for arc, pull in cuts:
+            pull_at[float(arc)] = max(pull_at.get(float(arc), 0.0), pull)
+        edges = sorted(set([0.0] + list(pull_at) + [total]))
+        pieces = []
+        for s0, s1 in zip(edges[:-1], edges[1:]):
+            a = s0 + pull_at.get(s0, 0.0)
+            b = s1 - pull_at.get(s1, 0.0)
+            if b - a < 2.0 * lig:
+                report.append(
+                    f"piece of {name!r} between arc {s0:.4g} and "
+                    f"{s1:.4g} is shorter than two ligaments — dropped.")
+                continue
+            pieces.append(_sub_polyline(pts, a, b))
+        if len(pieces) == 1:
+            prepared.append((name, pieces[0]))
+        else:
+            for k, piece in enumerate(pieces):
+                prepared.append((f"{name}_{k + 1}", piece))
+        if len(pieces) != 1:
+            report.append(
+                f"{name!r} became {len(pieces)} sub-fault(s).")
+
+    if verbose:
+        for line in report:
+            print(f"[prepare_fault_network] {line}")
+    if return_junctions:
+        return prepared, report, junctions
+    return prepared, report
+
+
 def fault_metric_tensor(mesh, faults, refinement=3.0, width="auto", base=1.0):
     r"""Build the analytic, Eulerian **normal-aligned anisotropic metric
     tensor** ``M(x)`` for refining a thin band of cells **across** one or more
diff --git a/src/underworld3/utilities/__init__.py b/src/underworld3/utilities/__init__.py
index 0d7c627ec..75891f486 100644
--- a/src/underworld3/utilities/__init__.py
+++ b/src/underworld3/utilities/__init__.py
@@ -94,3 +94,8 @@ def _append_petsc_path():
 from . import boundary_flux
 from . import custom_mg
 from .custom_mg import set_custom_fmg
+from . import edge_split
+from . import fault_contact
+from . import fault_split
+from . import line_cut
+from . import reconnect
diff --git a/src/underworld3/utilities/edge_split.py b/src/underworld3/utilities/edge_split.py
new file mode 100644
index 000000000..877ddb91d
--- /dev/null
+++ b/src/underworld3/utilities/edge_split.py
@@ -0,0 +1,290 @@
+"""Longest-edge refinement without a conforming closure.
+
+An alternative refinement engine for :meth:`Mesh.adapt`. Where newest-vertex
+bisection chooses which edge to split from a combinatorial tagging rule and then
+pays a *conforming closure* to repair the hanging nodes that choice creates, this
+engine splits the edge the geometry asks for — the longest edge of every cell
+that is still coarser than the metric wants — and needs no closure at all,
+because splitting an edge divides **every** cell incident on it at the same new
+vertex. There is therefore no hanging node to repair, and no
+longest-edge-propagation chain: we never require a neighbour to split its *own*
+preferred edge.
+
+Two consequences that matter for adaptation:
+
+* refinement does not spread beyond the cells the metric marked, so the refined
+  region hugs the feature rather than a bounded halo around it;
+* the marking criterion is the cell **diameter**, not :math:`(d!\\,V)^{1/d}`.
+  For bisection the two shrink together and either will do. For any engine that
+  reduces volume without shortening the longest edge they diverge badly — a
+  measured factor of 3.2 on a centroid-refined mesh, where the volume proxy
+  reports the target as met while the mesh is nowhere near resolved.
+
+The topology, coordinates, labels and parallel star-forest are all handled by the
+``uwnvb_bisect`` :c:type:`DMPlexTransform` (see
+``docs/developer/design/NVB_GRADED_ADAPT.md``), which is the same primitive the
+newest-vertex engine uses for each of its sub-passes. That transform bisects a
+set of edges named in a per-edge label and requires them to be **pairwise
+independent** — no cell may carry two marked edges in one pass — so a pass here
+splits an independent subset and the caller iterates.
+
+Notes
+-----
+One pass does not necessarily satisfy every marked cell: independence caps how
+many edges can be split at once. Drive it in a loop that re-marks from the
+current mesh, as :meth:`Mesh.adapt` does.
+
+Status
+------
+Wired into :meth:`Mesh.adapt` as ``engine="edge_split"``. Validated serial and
+parallel in 2-D and 3-D: conforming, refinement confined to the marked region,
+and the refined mesh identical at np=1/2/3/4. Tests in
+``tests/test_0843_edge_split_adapt.py`` and
+``tests/parallel/ptest_0843_edge_split_parallel.py``.
+
+Not yet done: the reconnection (flip) pass that repairs element shape. It is not
+expressible as a ``DMPlexTransform`` — a flip's output cells span two parents'
+closures, while a transform's children may only reference their own parent's —
+so it needs a separate parallel design and is tracked outside this module.
+"""
+
+import numpy as np
+from mpi4py import MPI
+from petsc4py import PETSc
+
+import underworld3 as uw
+
+_BISECT_LABEL = "uwnvb_bisect_edges"
+
+
+def _register_transform():
+    """Import the compiled extension that registers ``uwnvb_bisect`` in PETSc."""
+    from underworld3.utilities import _nvb_transform  # noqa: F401  (registers on import)
+
+
+def _edge_lengths(dm):
+    """Length of every edge, indexed by ``edge_point - edge_start``."""
+    cdim = dm.getCoordinateDim()
+    vS, _vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, cdim)
+    ends = np.array([dm.getCone(e) for e in range(eS, eE)], dtype=np.int64) - vS
+    d = X[ends[:, 0]] - X[ends[:, 1]]
+    return np.sqrt(np.einsum("ij,ij->i", d, d))
+
+
+def _cell_edges(dm):
+    """Edge points of each cell, as a list indexed by ``cell - cell_start``.
+
+    In 2-D a cell's cone is already its edges; in 3-D the cone holds faces, so
+    the edges come from the transitive closure filtered to the edge stratum.
+    """
+    eS, eE = dm.getDepthStratum(1)
+    cS, cE = dm.getHeightStratum(0)
+    if dm.getDimension() == 2:
+        return [np.asarray(dm.getCone(c), dtype=np.int64) for c in range(cS, cE)]
+    out = []
+    for c in range(cS, cE):
+        closure = dm.getTransitiveClosure(c)[0]
+        out.append(np.array([p for p in closure if eS <= p < eE], dtype=np.int64))
+    return out
+
+
+def cell_diameters(dm):
+    """Longest edge length of every cell, in plex cell order.
+
+    This is the quantity the interpolation error of a linear element depends on,
+    and the one this engine marks against.
+    """
+    L = _edge_lengths(dm)
+    eS, _eE = dm.getDepthStratum(1)
+    return np.array([L[edges - eS].max() for edges in _cell_edges(dm)])
+
+
+def _sf_logical_or(dm, flag):
+    """Logical-OR a point-indexed flag array over the point star-forest, in place.
+
+    Every rank holding a copy of a shared point ends up with the same value, so a
+    shared edge chosen for bisection anywhere is split everywhere — the condition
+    ``uwnvb_bisect`` needs to keep the child point star-forest conforming.
+
+    For a plex point star-forest the leaf and root spaces are BOTH the local point
+    chart, so the SAME array is passed as leaf data and root data. This mirrors
+    ``uwnvb_sf_lor`` in ``nvb_transform.c``, which is the proven form. Gathering
+    the leaves into a separately-indexed buffer first — the obvious reading of the
+    PetscSF signature — mis-sizes the reduce and corrupts the heap.
+    """
+    # COLLECTIVE, so every rank must reach it: a rank owning no shared point
+    # still has to participate or its peers block forever. Only a genuinely
+    # serial run may skip, and that is a communicator-size test — never a test
+    # of what this rank happens to own.
+    if uw.mpi.size == 1:
+        return flag
+    sf = dm.getPointSF()
+    try:
+        nroots, _ilocal, _iremote = sf.getGraph()
+    except (ValueError, TypeError):
+        # An unpopulated star-forest reports a negative root count that petsc4py
+        # cannot shape an array from; nothing is shared, so nothing to reconcile.
+        return flag
+    if nroots < 0:
+        return flag
+
+    sf.reduceBegin(MPI.INT32_T, flag, flag, MPI.LOR)
+    sf.reduceEnd(MPI.INT32_T, flag, flag, MPI.LOR)
+    sf.bcastBegin(MPI.INT32_T, flag, flag, MPI.REPLACE)
+    sf.bcastEnd(MPI.INT32_T, flag, flag, MPI.REPLACE)
+    return flag
+
+
+def _owned_count(dm, points):
+    """How many of ``points`` this rank owns, i.e. holds as a root not a leaf."""
+    if uw.mpi.size == 1:
+        return len(points)
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        # Unpopulated star-forest: nothing is shared, so every point is owned.
+        return len(points)
+    if ilocal is None or len(ilocal) == 0:
+        return len(points)
+    leaves = set(int(p) for p in ilocal)
+    return sum(1 for p in points if int(p) not in leaves)
+
+
+def _edge_strength(dm):
+    """Per-edge sort key making "the strongest candidate in a cell" well defined.
+
+    Length decides; the midpoint coordinate breaks ties. Both are computed from
+    the coordinates alone, so the key is identical on every rank holding the edge
+    and the selection below is independent of the partition — the property that
+    makes the refined mesh the same at any communicator size.
+    """
+    cdim = dm.getCoordinateDim()
+    vS, _vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, cdim)
+    ends = np.array([dm.getCone(e) for e in range(eS, eE)], dtype=np.int64) - vS
+    d = X[ends[:, 0]] - X[ends[:, 1]]
+    length = np.sqrt(np.einsum("ij,ij->i", d, d))
+    mid = 0.5 * (X[ends[:, 0]] + X[ends[:, 1]])
+    return length, mid
+
+
+def _independent_edges(dm, candidates):
+    """The candidates that beat every competing candidate sharing a cell.
+
+    This replaces a greedy sweep, which would depend on iteration order and
+    therefore on the partition (measured: 414 cells at np=1/2 but 463 at np=3 and
+    925 at np=4). A candidate is *vetoed* when a stronger candidate shares one of
+    its cells; vetoes are OR-ed across ranks so a shared edge is judged against
+    the cells on both sides. What survives is independent by construction — two
+    edges in the same cell cannot both beat the other — and is a function of the
+    geometry only.
+    """
+    eS, eE = dm.getDepthStratum(1)
+    cS, cE = dm.getHeightStratum(0)
+    pStart, pEnd = dm.getChart()
+
+    is_candidate = np.zeros(pEnd - pStart, dtype=np.int32)
+    if len(candidates):
+        is_candidate[np.asarray(candidates, dtype=np.int64) - pStart] = 1
+    _sf_logical_or(dm, is_candidate)
+
+    length, mid = _edge_strength(dm)
+    veto = np.zeros(pEnd - pStart, dtype=np.int32)
+    edges_of = _cell_edges(dm)
+    for c in range(cS, cE):
+        edges = edges_of[c - cS]
+        rival = edges[is_candidate[edges - pStart] == 1]
+        if len(rival) < 2:
+            continue
+        keys = [(length[e - eS], *mid[e - eS]) for e in rival]
+        winner = rival[int(np.lexsort(np.array(keys).T[::-1])[-1])]
+        veto[rival[rival != winner] - pStart] = 1
+    _sf_logical_or(dm, veto)
+
+    chosen = np.flatnonzero((is_candidate == 1) & (veto == 0)) + pStart
+    return chosen[(chosen >= eS) & (chosen < eE)]
+
+
+def _cells_on_edge(dm, edge):
+    """Cells incident on an edge — the star of the vertex a split would insert.
+
+    The walk up from an edge is dimension-dependent and getting it wrong fails
+    silently rather than loudly. In 2-D an edge *is* a face, so its support is
+    already the cells; in 3-D the support holds faces and the cells are one level
+    further up. Applying the 3-D walk in 2-D asks for the support of a cell, which
+    is empty, so the function returns no cells at all and every caller reads "this
+    edge touches nothing".
+    """
+    cS, cE = dm.getHeightStratum(0)
+    if dm.getDimension() == 2:
+        return sorted(int(c) for c in dm.getSupport(edge) if cS <= c < cE)
+    seen = set()
+    for f in dm.getSupport(edge):
+        for c in dm.getSupport(f):
+            if cS <= c < cE:
+                seen.add(int(c))
+    return sorted(seen)
+
+
+def bisect_longest_edges(dm, cells):
+    """Split the longest edge of as many of ``cells`` as one pass allows.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        Simplex mesh to refine. Not modified.
+    cells : array of int
+        Plex cell points to refine.
+
+    Returns
+    -------
+    refined : PETSc.DMPlex
+        A fresh DM, co-partitioned with ``dm`` and carrying its labels forward.
+    n_split : int
+        Number of edges bisected globally. Zero means the pass was empty and the
+        caller should stop.
+
+    Notes
+    -----
+    Independence caps one pass, so a cell marked here may still exceed the metric
+    afterwards. Re-mark from the returned mesh and call again.
+    """
+    _register_transform()
+
+    cS, _cE = dm.getHeightStratum(0)
+    eS, _eE = dm.getDepthStratum(1)
+    L = _edge_lengths(dm)
+    edges_of = _cell_edges(dm)
+
+    wanted = {int(edges_of[int(c) - cS][np.argmax(L[edges_of[int(c) - cS] - eS])])
+              for c in cells}
+    chosen = _independent_edges(dm, np.array(sorted(wanted), dtype=np.int64))
+
+    # Count OWNED edges only: a shared edge is held by every rank on the seam, so
+    # summing local counts would report it once per sharer and overstate the pass.
+    n_split = uw.mpi.comm.allreduce(int(_owned_count(dm, chosen)), op=MPI.SUM)
+    if n_split == 0:
+        return dm, 0
+
+    work = dm.clone()
+    work.createLabel(_BISECT_LABEL)
+    label = work.getLabel(_BISECT_LABEL)
+    label.setDefaultValue(0)
+    for e in chosen:
+        label.setValue(int(e), 1)
+
+    transform = PETSc.DMPlexTransform().create(comm=work.comm)
+    transform.setType("uwnvb_bisect")
+    transform.setDM(work)
+    transform.setUp()
+    refined = transform.apply(work)
+    transform.destroy()
+
+    # The transform copies its driving label onto the output, where it would be
+    # read as a stale request by the next pass.
+    if refined.hasLabel(_BISECT_LABEL):
+        refined.removeLabel(_BISECT_LABEL)
+    return refined, n_split
diff --git a/src/underworld3/utilities/fault_contact.py b/src/underworld3/utilities/fault_contact.py
new file mode 100644
index 000000000..4b0c13f38
--- /dev/null
+++ b/src/underworld3/utilities/fault_contact.py
@@ -0,0 +1,1116 @@
+r"""Interface conditions on a split-node fault: the frictionless contact.
+
+A split fault (:mod:`underworld3.utilities.fault_split`) carries two
+geometrically coincident boundaries, ``<name>Plus`` / ``<name>Minus``, whose
+degrees of freedom pair exactly through the split's clone map. This module
+imposes the **frictionless (perfectly slippery) contact** on those pairs:
+
+.. math::
+
+    [\mathbf v]\cdot\hat n = 0 \quad\text{(no opening, strong)}, \qquad
+    \hat t\cdot\sigma\cdot\hat n = 0 \quad\text{(zero shear traction)},
+
+with the tangential slip :math:`V = [\mathbf v]\cdot\hat t` left to EMERGE —
+the stress-driven crack, as opposed to the kinematic (prescribed-slip)
+fault, which dictates both sides.
+
+The mechanism is the rotated strong-constraint machinery of
+:mod:`underworld3.utilities.rotated_bc`, extended from per-node blocks to
+per-PAIR blocks: for each coincident pair the composite rotation ``Q`` gets an
+orthogonal :math:`2\,\mathrm{dim}\times 2\,\mathrm{dim}` block that transforms
+``(v^+, v^-)`` to mean/jump components in the fault frame
+:math:`(\hat n,\hat t)`. The jump-normal row is strongly constrained to zero;
+every other row — the two mean rows and the slip row — is left free, and a
+free slip row IS the zero-shear-traction condition (its conjugate reaction is
+the shear traction, and an unconstrained row carries none). Friction, later,
+is a nonlinear relation placed on that same slip row; prescribed jump-only
+slip is a datum on it.
+
+Both points of a pair are rank-local (a seam-touching fault is
+redistributed onto one rank before the split; a direct low-level split of
+one is refused), so every pair block sits inside one rank's diagonal
+portion of ``Q``, exactly like the single-node wall blocks.
+
+Until the interface lands in the solver API proper, the entry points are
+module functions::
+
+    child = split_fault(cut_mesh, "Fault")
+    stokes = uw.systems.Stokes(child, ...)
+    ... wall BCs ...
+    add_frictionless_fault_bc(stokes, "Fault")
+    info = solve_with_fault(stokes)
+    s, V, leak = fault_slip(stokes, "Fault", info)
+"""
+
+import numpy as np
+import sympy
+from petsc4py import PETSc
+
+from underworld3 import mpi
+
+# PETSc section field id of the velocity unknown (solver field registration
+# order: velocity first) — the same convention as rotated_bc.
+_VELOCITY_FIELD = 0
+
+
+def _collective_raise(problem):
+    """One synchronisation point for rank-local failures in collective paths.
+
+    ``problem`` is ``None`` or an error message string. The verdicts are
+    allgathered and, if any rank failed, the SAME error is raised on EVERY
+    rank — the same contract as fault_split's refusals. Without this, a
+    rank-local raise inside the rotation build or the interface assembler
+    leaves the other ranks blocked in the next collective (Q assembly, the
+    trace-mass exchange, the Newton loop) instead of aborting: a deadlock
+    where an error was meant. COLLECTIVE — every rank must reach it.
+    """
+    if mpi.size > 1:
+        gathered = mpi.comm.allgather(problem)
+        problems = [p for p in gathered if p is not None]
+        problem = problems[0] if problems else None
+    if problem is not None:
+        raise RuntimeError(problem)
+
+
+def add_frictionless_fault_bc(solver, boundary, normal=None):
+    """Register the frictionless contact on the split fault ``boundary``.
+
+    ``boundary`` is the fault's original surface name; the mesh must be one
+    returned by :func:`fault_split.split_fault`, which records the
+    Plus/Minus DOF pairing. The condition itself is imposed inside the
+    rotated solve — run it with :func:`solve_with_fault`.
+
+    ``normal`` optionally supplies the fault's ANALYTIC unit normal — a
+    sympy ``1×dim`` Matrix in ``mesh.X`` or a constant ``(dim,)`` array,
+    the same conventions as ``add_rotated_freeslip_bc``. Without it the
+    per-node normal is the average of the adjacent facet normals, which is
+    exact on a straight fault but on a SAMPLED CURVE zig-zags at node
+    scale: slip past each sampling kink is then geometrically incompatible
+    with the no-opening constraint, producing slip notches and normal-
+    traction spikes that INTENSIFY under mesh refinement. The analytic
+    normal restores the smooth curve's mechanics on the same kinked mesh
+    (measured: an order of magnitude off the sawtooth, h-convergent).
+    """
+    pairs = getattr(solver.mesh, "_fault_point_pairs", {})
+    if boundary not in pairs:
+        raise ValueError(
+            f"mesh carries no split-fault pairing for {boundary!r} — the "
+            "solver's mesh must come from fault_split.split_fault, which is "
+            "what records the coincident DOF pairs. "
+            f"Available: {sorted(pairs) or 'none'}")
+    registered = getattr(solver, "_fault_contact_faults", [])
+    if boundary not in registered:
+        solver._fault_contact_faults = registered + [boundary]
+    if normal is not None:
+        _compile_normal_spec(normal, solver.mesh, boundary)   # fail fast
+        overrides = dict(getattr(solver, "_fault_normal_overrides", {}))
+        overrides[boundary] = normal
+        solver._fault_normal_overrides = overrides
+
+
+def _trace_normal_fn(poly):
+    """The smoothed normal field of a sampled 2-D trace, from the trace.
+
+    Tangent ANGLE at each control point by central difference (one-sided
+    at the tips), interpolated linearly along each segment — the smooth
+    reconstruction of the curve the polyline sampled, with error
+    O(kink angle squared) and no dependence on an analytic formula. Fault
+    nodes lie ON the polyline (every control point is pulled onto a mesh
+    vertex before the cut), so the nearest-segment projection is exact.
+    """
+    pts = np.asarray(poly, dtype=float)
+    d = np.diff(pts, axis=0)
+    seg2 = np.einsum("ij,ij->i", d, d)
+    seg_ang = np.unwrap(np.arctan2(d[:, 1], d[:, 0]))
+    ang = np.empty(len(pts))
+    ang[0], ang[-1] = seg_ang[0], seg_ang[-1]
+    ang[1:-1] = 0.5 * (seg_ang[:-1] + seg_ang[1:])
+
+    def fn(X):
+        t = np.clip(np.einsum("ij,ij->i", X[None, :2] - pts[:-1], d)
+                    / seg2, 0.0, 1.0)
+        proj = pts[:-1] + t[:, None] * d
+        i = int(np.argmin(np.einsum("ij,ij->i", X[None, :2] - proj,
+                                    X[None, :2] - proj)))
+        th = (1.0 - t[i]) * ang[i] + t[i] * ang[i + 1]
+        return np.array([-np.sin(th), np.cos(th)])
+
+    return fn
+
+
+def _compile_normal_spec(spec, mesh, boundary):
+    """Compile an analytic-normal spec into ``callable(X) -> n``.
+
+    Mirrors the rotated-free-slip normal conventions
+    (:func:`rotated_bc._boundary_velocity_nodes`): a sympy ``1×dim`` Matrix
+    in ``mesh.X`` is unwrapped and lambdified ONCE into a numpy callable
+    (per-node ``.subs()`` is orders of magnitude slower); the string
+    ``"trace"`` builds the smoothed normal from the fault's own stored
+    polyline (:func:`_trace_normal_fn` — for digitized traces with no
+    analytic form); anything else is a constant ``(dim,)`` vector. The
+    result need not be unit length — the caller normalises — but must be
+    nonzero at every fault node.
+    """
+    dim = mesh.dim
+    if isinstance(spec, str):
+        if spec == "trace":
+            if dim != 2:
+                raise NotImplementedError(
+                    "normal=\"trace\" is 2-D; in 3-D pass the "
+                    "FaultSurface (or normal=\"surface\").")
+            poly = getattr(mesh, "_fault_traces", {}).get(boundary)
+            if poly is None:
+                raise ValueError(
+                    f"mesh carries no stored trace for {boundary!r} — "
+                    "normal=\"trace\" needs a mesh built by "
+                    "Mesh.add_fault.")
+            return _trace_normal_fn(poly)
+        if spec == "surface":
+            fs = getattr(mesh, "_fault_surfaces", {}).get(boundary)
+            if fs is None:
+                raise ValueError(
+                    f"mesh carries no stored surface object for "
+                    f"{boundary!r} — normal=\"surface\" needs a mesh "
+                    "built from one (Mesh.add_fault(Surface) in 2-D, "
+                    "BoxInternalPatch(patch_points=fault_surface) in "
+                    "3-D).")
+            if dim == 2:
+                # a 2-D Surface's on-fault normal IS the smoothed
+                # normal of its control polyline (its signed-distance
+                # gradient is discontinuous exactly ON the trace, so
+                # the director is the wrong object here)
+                return _trace_normal_fn(
+                    np.asarray(fs.control_points, dtype=float)[:, :2])
+            return _compile_normal_spec(fs, mesh, boundary)
+        raise ValueError(
+            f"unknown normal spec {spec!r} for fault {boundary!r}: pass "
+            "\"trace\" (2-D), \"surface\"/a FaultSurface (3-D), a sympy "
+            "1×dim Matrix in mesh.X, or a constant vector.")
+    if hasattr(spec, "triangles") and hasattr(spec, "normals"):
+        # a FaultSurface: the frame comes from the surface's OWN
+        # geometry — nearest-face normal (exact for a planar patch,
+        # unchanged for future curved sheets)
+        if dim != 3:
+            raise NotImplementedError(
+                "a FaultSurface normal source is 3-D; in 2-D use "
+                "normal=\"trace\".")
+        if spec.normals is None:
+            spec.compute_normals()
+        centres = np.asarray(spec.face_centers, dtype=float)
+        face_normals = np.asarray(spec.normals, dtype=float)
+        from scipy.spatial import cKDTree
+        tree = cKDTree(centres)
+        return lambda X: face_normals[int(tree.query(X)[1])]
+    if isinstance(spec, sympy.MatrixBase):
+        if len(spec) != dim:
+            raise ValueError(
+                f"analytic normal for fault {boundary!r} has {len(spec)} "
+                f"components; the mesh is {dim}-D.")
+        from underworld3.function.expressions import unwrap
+        comps = [sympy.sympify(unwrap(spec[k], keep_constants=False,
+                                      return_self=False))
+                 for k in range(dim)]
+        # unwrap canonicalises coordinate BaseScalars onto the FIRST
+        # mesh's frame (multi-mesh symbol identity, see issue #501), so
+        # on any later mesh the unwrapped x is not ``mesh.X[0]`` by
+        # identity even though it prints the same. Re-tag by NAME onto
+        # this mesh's coordinates before the stray check and the
+        # lambdify.
+        by_name = {str(xk): xk for xk in mesh.X}
+        retag = {s: by_name[str(s)] for c in comps for s in c.free_symbols
+                 if str(s) in by_name and s is not by_name[str(s)]}
+        if retag:
+            comps = [c.subs(retag) for c in comps]
+        stray = set().union(*[c.free_symbols for c in comps]) \
+            - set(mesh.X)
+        if stray:
+            raise ValueError(
+                f"analytic normal for fault {boundary!r} contains symbols "
+                f"{sorted(map(str, stray))} that are not mesh coordinates "
+                "— express it in mesh.X.")
+        fn = sympy.lambdify(list(mesh.X), comps, "numpy")
+        return lambda X: np.asarray(fn(*X), dtype=float).ravel()
+    const = np.asarray(spec, dtype=float).ravel()
+    if const.shape != (dim,):
+        raise ValueError(
+            f"constant normal for fault {boundary!r} must have shape "
+            f"({dim},); got {const.shape}.")
+    return lambda X: const
+
+
+def _compiled_normal_override(solver, boundary):
+    """The fault's registered analytic-normal override, compiled — or None."""
+    spec = getattr(solver, "_fault_normal_overrides", {}).get(boundary)
+    if spec is None:
+        return None
+    return _compile_normal_spec(spec, solver.mesh, boundary)
+
+
+def add_viscous_fault_bc(solver, conds, boundary, normal=None):
+    r"""Register a viscous (linear dashpot) law on the split fault ``boundary``:
+
+    .. math::  \hat t\cdot\sigma\cdot\hat n = \eta_f\, V,
+               \qquad V = [\mathbf v]\cdot\hat t,
+
+    with ``conds`` = :math:`\eta_f`, the interface viscosity (viscosity per
+    unit length: the zero-thickness limit of a shear band is
+    :math:`\eta_f = \eta_{band}/w` with :math:`\eta_{band}` the band's OWN
+    — weak-zone — viscosity and :math:`w` its width. Not the background
+    viscosity: matching a layer means :math:`V = \tau w/\eta_{band}`, and
+    with the background value the layer would not be weak). The
+    no-opening constraint rides along as always. Limits: ``conds = 0`` is the
+    frictionless contact; ``conds`` large welds the fault. The natural scale
+    is :math:`\eta/a` (bulk viscosity over fault half-length), at which the
+    fault slips at roughly half its free rate.
+
+    This is the linear member of the interface-law family: the term enters
+    the rotated system as :math:`2\eta_f M` on the slip rows (:math:`M` the
+    1-D trace mass), which is exactly the tangent structure a friction law
+    occupies with :math:`2\,(\partial\tau/\partial V)\,M` — so everything
+    downstream of this hook is what friction will reuse.
+    """
+    add_frictionless_fault_bc(solver, boundary, normal=normal)
+    eta_f = float(conds)
+    if eta_f < 0.0:
+        raise ValueError(f"interface viscosity must be >= 0 (got {eta_f}).")
+    if eta_f > 0.0:
+        _register_law(solver, boundary, ViscousFaultLaw(eta_f))
+
+
+#: The canonical slip-rate symbol an interface law is written in: a fault
+#: law is ``tau(slip_rate)`` as a SYMPY expression, and its consistent
+#: Newton tangent is derived by ``sympy.diff`` — never hand-coded. This is
+#: the same division of labour as the bulk constitutive models: the law is
+#: symbolic; only the innermost trace quadrature evaluates compiled
+#: (lambdified) callables.
+slip_rate = sympy.Symbol(r"V_{slip}", real=True)
+
+#: The effective normal stress symbol, SIGNED: positive in compression,
+#: negative in tension. The assembler feeds it per node from the no-opening
+#: constraint's REACTION, Picard-lagged once per Newton iteration — the one
+#: deliberately lagged quantity (its derivative is nonlocal and non-stiff;
+#: the stiff direction dtau/dV stays full Newton). A law must clamp its OWN
+#: strength at zero — e.g. ``Max(0, C + mu*normal_stress)`` — because the
+#: physics of losing strength lives in the law: a cohesive fault keeps
+#: shear strength into MILD tension (down to sigma = -C/mu), a cohesionless
+#: one loses it the moment the normal stress turns tensile. Where the
+#: strength is zero AND the normal stress is tensile the fault would OPEN:
+#: the bilateral no-opening constraint then holds it shut with a tensile
+#: reaction (glue), and the computed solution is no longer physical —
+#: detect this by the sign of ``fault_normal_traction``.
+normal_stress = sympy.Symbol(r"\sigma_{n,eff}", real=True)
+
+#: The interface state variable (rate-state theta), per node like the
+#: normal stress: a law may use it; the values are held per fault on the
+#: solver (``solver._fault_state``) and advanced between solves by
+#: :func:`update_fault_state` — the ageing-law ODE integrated exactly for
+#: piecewise-constant V. (When manifold MeshVariables land, theta moves
+#: there; the law layer is unchanged either way.)
+state_variable = sympy.Symbol(r"\theta_{state}", real=True, positive=True)
+
+
+class SymbolicFaultLaw:
+    r"""An interface law :math:`\tau(V)` given as a sympy expression in
+    :data:`slip_rate`.
+
+    The consistent tangent :math:`d\tau/dV` is derived symbolically and
+    both are lambdified ONCE at registration into fast numpy callables —
+    the interface analogue of the JIT step for bulk kernels. A physical law
+    should be monotone (:math:`d\tau/dV > 0`), which keeps the Newton
+    block positive; nothing enforces it, exactly as nothing stops a
+    negative bulk viscosity.
+    """
+
+    def __init__(self, tau_expr):
+        expr = sympy.sympify(tau_expr)
+        stray = expr.free_symbols - {slip_rate, normal_stress,
+                                     state_variable}
+        if stray:
+            raise ValueError(
+                f"a fault law must be an expression in fault_contact."
+                f"slip_rate (and optionally normal_stress and "
+                f"state_variable) alone (found {sorted(map(str, stray))}); "
+                "substitute other parameters before registering.")
+        self.expr = expr
+        args = (slip_rate, normal_stress, state_variable)
+        self._tau = sympy.lambdify(args, expr, "numpy")
+        self._dtau = sympy.lambdify(args, sympy.diff(expr, slip_rate),
+                                    "numpy")
+
+    def tau(self, V, S, T):
+        V = np.asarray(V, dtype=float)
+        return np.broadcast_to(np.asarray(self._tau(V, S, T), dtype=float),
+                               V.shape).copy()
+
+    def dtau_dV(self, V, S, T):
+        V = np.asarray(V, dtype=float)
+        return np.broadcast_to(np.asarray(self._dtau(V, S, T), dtype=float),
+                               V.shape).copy()
+
+
+def ViscousFaultLaw(eta_f):
+    r"""The linear member, :math:`\tau = \eta_f V`, as a symbolic law."""
+    return SymbolicFaultLaw(float(eta_f) * slip_rate)
+
+
+def CoulombFaultLaw(mu, sigma_n, V0):
+    r"""Regularised Coulomb friction,
+    :math:`\tau = \mu\sigma_n\,\tfrac{2}{\pi}\arctan(V/V_0)`.
+
+    Smooth, bounded by the strength :math:`\mu\sigma_n`, monotone. Below
+    the regularisation velocity :math:`V_0` the fault sticks (residual
+    creep :math:`\sim V_0`); above it the shear traction saturates and the
+    fault slides at constant stress drop. ``sigma_n`` is PRESCRIBED here;
+    feeding it from the no-opening constraint's reaction (Picard-lagged) is
+    the follow-up increment. The tangent comes from ``sympy.diff``, not a
+    hand-coded derivative.
+    """
+    if sigma_n == "reaction":
+        # the strength clamp is the law's own: bare friction loses all
+        # strength the moment the normal stress turns tensile
+        strength = float(mu) * sympy.Max(normal_stress, 0)
+    else:
+        strength = float(mu) * float(sigma_n)
+    return SymbolicFaultLaw(
+        strength * (2 / sympy.pi) * sympy.atan(slip_rate / float(V0)))
+
+
+def add_coulomb_fault_bc(solver, conds, boundary, sigma_n=None, V0=1.0e-5,
+                         normal=None):
+    """Regularised Coulomb friction on the split fault ``boundary``
+    (value-first: ``conds`` is the friction coefficient mu).
+
+    ``sigma_n`` is the effective normal stress, prescribed and required in
+    this version (reaction-fed sigma_n is the next increment). ``V0`` is the
+    regularisation velocity — choose it well below the slip rates the flow
+    produces; below it the fault sticks (creep ~ V0), above it the shear
+    traction saturates at mu*sigma_n and the fault slides at constant
+    stress drop.
+    """
+    if sigma_n is None:
+        raise ValueError(
+            "add_coulomb_fault_bc requires sigma_n: a prescribed effective "
+            "normal stress, or \"reaction\" to feed it from the no-opening "
+            "constraint's reaction (Picard-lagged).")
+    mu = float(conds)
+    if mu <= 0.0 or float(V0) <= 0.0 or (
+            sigma_n != "reaction" and float(sigma_n) <= 0.0):
+        raise ValueError("mu, sigma_n and V0 must all be positive.")
+    add_frictionless_fault_bc(solver, boundary, normal=normal)
+    _register_law(solver, boundary, CoulombFaultLaw(mu, sigma_n, V0))
+
+
+def RateStateFaultLaw(a, b, V0, f0, Dc, sigma_n="reaction"):
+    r"""Regularised rate-and-state friction (arcsinh form — never the raw
+    logarithmic law, which is singular at V = 0):
+
+    .. math:: \tau = a\,\sigma_n\,\mathrm{asinh}\!\left[
+        \frac{V}{2V_0}\exp\!\left(\frac{f_0 + b\ln(V_0\theta/D_c)}
+        {a}\right)\right],
+
+    smooth and odd in V (sign-correct for either slip direction), with the
+    state :math:`\theta` entering per node through
+    :data:`state_variable` and evolving by the ageing law between solves
+    (:func:`update_fault_state`). At steady state
+    (:math:`\theta = D_c/V`) it reduces to
+    :math:`\tau = \sigma_n(f_0 + (a-b)\ln V/V_0)`: velocity
+    strengthening for a > b, weakening for a < b. The consistent tangent
+    in V comes from ``sympy.diff``, exactly as for every other law.
+    """
+    a, b, V0, f0, Dc = (float(q) for q in (a, b, V0, f0, Dc))
+    sn = (sympy.Max(normal_stress, 0) if sigma_n == "reaction"
+          else float(sigma_n))
+    return SymbolicFaultLaw(
+        a * sn * sympy.asinh(
+            (slip_rate / (2 * V0)) * sympy.exp(
+                (f0 + b * sympy.log(V0 * state_variable / Dc)) / a)))
+
+
+def add_rate_state_fault_bc(solver, conds, boundary, *, a, b, V0, Dc,
+                            sigma_n="reaction", theta0=None, normal=None):
+    """Rate-and-state friction on the split fault ``boundary``
+    (value-first: ``conds`` is the reference friction coefficient f0).
+
+    ``a``/``b`` are the direct-effect and evolution coefficients, ``V0``
+    the reference slip rate, ``Dc`` the state-evolution distance;
+    ``sigma_n`` as for Coulomb. The state starts at ``theta0`` (default
+    ``Dc/V0``, steady at the reference rate) and is advanced after each
+    solve with :func:`update_fault_state`.
+    """
+    add_frictionless_fault_bc(solver, boundary, normal=normal)
+    _register_law(solver, boundary,
+                  RateStateFaultLaw(a, b, V0, conds, Dc, sigma_n=sigma_n))
+    states = dict(getattr(solver, "_fault_state", {}))
+    states.setdefault(boundary, {"theta0": float(
+        theta0 if theta0 is not None else float(Dc) / float(V0)),
+        "Dc": float(Dc), "by_point": {}})
+    solver._fault_state = states
+
+
+def update_fault_state(solver, boundary, dt, solve_result):
+    """Advance the fault's state variable by the ageing law over ``dt``:
+
+    d(theta)/dt = 1 - V*theta/Dc, integrated EXACTLY for the solve's
+    (piecewise-constant) slip rates:
+    theta' = theta*exp(-x) + (Dc/|V|)*(1 - exp(-x)), x = |V| dt / Dc —
+    written with expm1 so the V -> 0 limit degrades smoothly to pure
+    ageing, theta' = theta + dt. Returns the median of theta*|V|/Dc over
+    the slipping nodes (1.0 at steady state — the convergence monitor).
+    """
+    state = solver._fault_state[boundary]
+    Dc = state["Dc"]
+    assembler = _InterfaceAssembler(solver, include=(boundary,))
+    V = np.linalg.norm(assembler._nodal_slip(solver, solve_result["U"])[:-1],
+                       axis=1)
+    pts = sorted(assembler._points, key=assembler._points.get)
+    theta = np.array([state["by_point"].get(q, state["theta0"])
+                      for q in pts])
+    x = V * float(dt) / Dc
+    decay = np.exp(-x)
+    growth = np.where(x > 1e-8,
+                      (Dc / np.maximum(V, 1e-300)) * (-np.expm1(-x)),
+                      float(dt) * (1.0 - 0.5 * x))
+    theta = theta * decay + growth
+    state["by_point"] = {q: float(t) for q, t in zip(pts, theta)}
+    slipping = V > 0.2 * V.max() if V.size and V.max() > 0 else \
+        np.zeros(0, dtype=bool)
+    if not slipping.any():
+        return float("nan")
+    return float(np.median(theta[slipping] * V[slipping] / Dc))
+
+
+def _register_law(solver, boundary, law):
+    registered = dict(getattr(solver, "_fault_interface_laws", {}))
+    registered[boundary] = law
+    solver._fault_interface_laws = registered
+
+
+def solve_with_fault(solver, verbose=False, zero_init_guess=True, picard=0):
+    """Solve with the registered fault contact(s) imposed; returns the
+    rotated-solve result dict (see ``rotated_bc.solve_rotated_freeslip``).
+
+    Drives the SAME manual Newton loop as ``add_rotated_freeslip_bc`` — the
+    fault pair blocks ride in the rotation the loop already builds — so
+    rotated wall free-slip and the fault contact compose. The result is also
+    stashed on ``solver._rotated_freeslip_info`` so the reaction-based
+    recoveries can find it.
+    """
+    from underworld3.utilities.rotated_bc import solve_rotated_freeslip
+
+    if not getattr(solver, "_fault_contact_faults", []):
+        raise RuntimeError(
+            "no fault contact registered on this solver; call "
+            "add_frictionless_fault_bc first.")
+    info = solve_rotated_freeslip(
+        solver, list(getattr(solver, "_rotated_freeslip_bcs", [])),
+        verbose=verbose, zero_init_guess=zero_init_guess, picard=picard)
+    solver._rotated_freeslip_info = info
+    return info
+
+
+def _fault_pair_nodes(solver, boundary):
+    """The velocity-carrying coincident pairs of a split fault, with normals.
+
+    Returns ``[(q_plus, q_minus, n_hat), ...]`` over this rank's pairs, where
+    the points are DMPlex points of the solver's DM (vertices and fault
+    facets — P2 midpoint DOFs live on the facets) and ``n_hat`` is the fault
+    unit normal at the pair, oriented from the Plus side toward the Minus
+    side. Orientation is derived per facet from its single support cell —
+    after the split a fault facet is one-sided, which is what makes the
+    orientation well-defined — and accumulated to the facet closure points.
+    The sign only flips the constrained row's sign, so either orientation
+    imposes the same no-opening condition.
+
+    An analytic-normal override registered for this fault (the ``normal``
+    argument of the ``add_*_fault_bc`` family) replaces the accumulated
+    facet-average DIRECTION per node, sign-aligned to the Plus→Minus
+    orientation. This is the single authority for the pair normal: the
+    rotated pair blocks, the interface-law rows, and every diagnostic
+    (slip, leak, normal traction) all read the frame from here, so the
+    override is consistent everywhere by construction.
+    """
+    mesh = solver.mesh
+    dm = solver.dm
+    dim = mesh.dim
+    lsec = dm.getLocalSection()
+    fS, fE = dm.getHeightStratum(1)
+
+    pairs = mesh._fault_point_pairs[boundary]
+
+    plus_name = f"{boundary}Plus"
+    value = mesh.boundaries[plus_name].value
+    # Empty-stratum guard: a rank owning no part of the fault is the normal
+    # case in parallel, and a null IS segfaults in getIndices().
+    if not (dm.hasLabel(plus_name)
+            and dm.getLabel(plus_name).getStratumSize(value) > 0):
+        return []
+    facets = [int(p) for p in
+              dm.getLabel(plus_name).getStratumIS(value).getIndices()
+              if fS <= int(p) < fE]
+
+    nacc = {}
+    for f in facets:
+        _, cent, nrm = dm.computeCellGeometryFVM(f)
+        ne = np.asarray(nrm, dtype=float)
+        ne = ne / (np.linalg.norm(ne) + 1e-30)
+        support = dm.getSupport(f)
+        _, ccent, _ = dm.computeCellGeometryFVM(int(support[0]))
+        if np.dot(ne, np.asarray(cent) - np.asarray(ccent)) < 0:
+            ne = -ne
+        for q in (int(c) for c in dm.getTransitiveClosure(f)[0]):
+            if lsec.getFieldDof(q, _VELOCITY_FIELD) > 0:
+                nacc[q] = nacc.get(q, np.zeros(dim)) + ne
+
+    override = _compiled_normal_override(solver, boundary)
+    if override is not None:
+        from underworld3.utilities.rotated_bc import _point_coord
+        csec = dm.getCoordinateSection()
+        cvec = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dim)
+        v0, v1 = dm.getDepthStratum(0)
+
+    out = []
+    for q_minus, q_plus in pairs.items():
+        if lsec.getFieldDof(int(q_plus), _VELOCITY_FIELD) <= 0:
+            continue
+        acc = nacc.get(int(q_plus))
+        if acc is None:
+            # A paired point off the Plus closure would mean the pairing and
+            # the labels disagree — a split bug, not a configuration error.
+            raise RuntimeError(
+                f"fault_contact: paired point {q_plus} carries velocity DOFs "
+                f"but is not in the {plus_name!r} facet closure.")
+        nrm = acc / (np.linalg.norm(acc) + 1e-30)
+        if override is not None:
+            X = np.asarray(_point_coord(dm, dim, cvec, csec, v0, v1,
+                                        int(q_plus)), dtype=float)
+            ne = np.asarray(override(X), dtype=float).ravel()
+            norm = np.linalg.norm(ne)
+            if not norm > 0:
+                raise ValueError(
+                    f"analytic normal for fault {boundary!r} vanishes at "
+                    f"node {int(q_plus)} (coordinate {X}).")
+            ne = ne / norm
+            # keep the Plus→Minus orientation of the facet-derived normal
+            if np.dot(ne, nrm) < 0:
+                ne = -ne
+            nrm = ne
+        out.append((int(q_plus), int(q_minus), nrm))
+    return out
+
+
+def _tangent_frame(nrm):
+    """The in-fault tangent(s) completing a pair block's rotation frame.
+
+    One tangent in 2-D (the quarter-turn of the normal), two in 3-D (t̂1
+    from the coordinate axis least aligned with the normal — deterministic
+    per node — and t̂2 completing the right-handed triad). The SINGLE
+    authority for the frame: the pair blocks in ``rotated_bc`` and the
+    interface assembler's slip components must agree row for row.
+    """
+    nrm = np.asarray(nrm, dtype=float)
+    if len(nrm) == 2:
+        return [np.array([-nrm[1], nrm[0]])]
+    axis = np.zeros(3)
+    axis[int(np.argmin(np.abs(nrm)))] = 1.0
+    t1 = np.cross(nrm, axis)
+    t1 = t1 / np.linalg.norm(t1)
+    return [t1, np.cross(nrm, t1)]
+
+
+# 3-point Gauss-Legendre on [0,1] (exact through quartics — the tangent's
+# N_i N_j weighting of a P2 trace is quartic) and the quadratic line shape
+# functions at those points, node order (end, midpoint, end).
+_XI = 0.5 + (np.sqrt(15.0) / 10.0) * np.array([-1.0, 0.0, 1.0])
+_WQ = np.array([5.0, 8.0, 5.0]) / 18.0
+_NQ = np.column_stack([2.0 * (_XI - 0.5) * (_XI - 1.0),
+                       4.0 * _XI * (1.0 - _XI),
+                       2.0 * _XI * (_XI - 0.5)])
+
+# The 3-D trace element is the P2 TRIANGLE: 6-point degree-4 Dunavant rule
+# (N_i N_j of P2 is quartic, as on the line) with weights summing to 1 on
+# the unit-area reference, and the quadratic shapes in barycentric
+# coordinates, node order (v0, v1, v2, e01, e12, e20).
+_L1, _W1 = 0.445948490915965, 0.223381589678011
+_L2, _W2 = 0.091576213509771, 0.109951743655322
+_LAMBDA3 = np.array([[1 - 2 * _L1, _L1, _L1], [_L1, 1 - 2 * _L1, _L1],
+                     [_L1, _L1, 1 - 2 * _L1],
+                     [1 - 2 * _L2, _L2, _L2], [_L2, 1 - 2 * _L2, _L2],
+                     [_L2, _L2, 1 - 2 * _L2]])
+_WQ3 = np.array([_W1, _W1, _W1, _W2, _W2, _W2])
+_NQ3 = np.column_stack(
+    [_LAMBDA3[:, i] * (2.0 * _LAMBDA3[:, i] - 1.0) for i in range(3)]
+    + [4.0 * _LAMBDA3[:, i] * _LAMBDA3[:, j]
+       for i, j in ((0, 1), (1, 2), (2, 0))])
+
+
+class _InterfaceAssembler:
+    r"""Residual and consistent tangent of the interface laws, per iterate.
+
+    The interface term is :math:`\int_\Gamma \tau(V)\,\delta V\,d\Gamma`
+    on the fault trace. In the rotated frame the slip row carries
+    :math:`V/\sqrt2`, so the residual lands on the slip rows as
+    :math:`\sqrt2\,L\sum_q w_q\,\tau(V_q)N_i` per facet and the tangent
+    as :math:`2\,L\sum_q w_q\,(d\tau/dV)(V_q)\,N_iN_j` — for a linear
+    law exactly :math:`2\eta_f M`, the measured dashpot. Geometry (facet
+    tables, pair offsets, tangent vectors) is cached at construction; each
+    call evaluates the lambdified law at the CURRENT iterate's slip rates,
+    which is what makes the tangent consistent Newton rather than Picard.
+
+    Tip nodes have no slip DOF (the jump space vanishes there): they enter
+    the quadrature with V = 0 and receive no row or column. All entry
+    points are COLLECTIVE — ranks holding no fault still participate in
+    the assemblies.
+    """
+
+    def __init__(self, solver, include=()):
+        dm = solver.dm
+        dim = solver.mesh.dim
+        ncomp = dim - 1                       # slip components per node
+        lsec = dm.getLocalSection()
+        l2g = dm.getLGMap()
+        csec = dm.getCoordinateSection()
+        cvec = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dim)
+        fS, fE = dm.getHeightStratum(1)
+
+        rows, lo_p, lo_m, tans, nrms, laws_of, facets = \
+            [], [], [], [], [], [], []
+        index_of = {}
+        fault_of = []
+        current = [None]                      # the fault being walked
+
+        registered = dict(getattr(solver, "_fault_interface_laws", {}))
+        for name in include:
+            registered.setdefault(name, None)   # geometry only (diagnostics)
+        if include:
+            # A PER-FAULT view: the diagnostics (fault_normal_traction,
+            # update_fault_state) ask for one fault, and their rows, slip
+            # vectors and theta stores must not be interleaved with the
+            # other registered faults' nodes (measured: a two-fault network
+            # returned A-union-B rows for fault A). The SOLVE path passes no
+            # ``include`` and keeps every law-carrying fault, as it must.
+            registered = {name: registered[name] for name in include}
+        problem = None
+        for name, law in registered.items():
+            current[0] = name
+            pairs = solver.mesh._fault_point_pairs[name]
+            minus_of = {qp: qm for qm, qp in pairs.items()}
+            # A rank-local geometry failure (pairing/closure mismatch, a
+            # vanishing analytic normal) must not leave the peers blocked
+            # in the collective trace-mass exchange below — collect the
+            # verdict, raise collectively after the walk.
+            try:
+                pair_nodes = _fault_pair_nodes(solver, name)
+            except (RuntimeError, ValueError) as err:
+                problem = str(err)
+                break
+            normals = {q_plus: nrm for q_plus, _q_minus, nrm in pair_nodes}
+
+            def node_index(q):
+                q = int(q)
+                qm = minus_of.get(q)
+                if qm is None:
+                    return -1              # a tip/rim node: V = 0, no DOF
+                if q in index_of:
+                    return index_of[q]
+                lo = lsec.getFieldOffset(qm, _VELOCITY_FIELD)
+                nrm = normals[q]
+                index_of[q] = len(rows)
+                fault_of.append(current[0])
+                # one global row per slip component, on the Minus point's
+                # rotated rows — the jump-tangent rows of the pair block
+                rows.append([int(l2g.apply([lo + 1 + a])[0])
+                             for a in range(ncomp)])
+                lo_p.append(lsec.getFieldOffset(q, _VELOCITY_FIELD))
+                lo_m.append(lo)
+                tans.append(_tangent_frame(nrm))
+                nrms.append(nrm)
+                return index_of[q]
+
+            plus_name = f"{name}Plus"
+            value = solver.mesh.boundaries[plus_name].value
+            if not (dm.hasLabel(plus_name) and
+                    dm.getLabel(plus_name).getStratumSize(value) > 0):
+                continue
+            law_id = len(laws_of) if law is not None else -1
+            if law is not None:
+                laws_of.append(law)
+            for f in (int(q) for q in dm.getLabel(plus_name)
+                      .getStratumIS(value).getIndices()):
+                if not (fS <= f < fE):
+                    continue
+                if dim == 2:
+                    va, vb = (int(q) for q in dm.getCone(f))
+                    L = float(np.linalg.norm(
+                        cvec[csec.getOffset(va) // dim]
+                        - cvec[csec.getOffset(vb) // dim]))
+                    facets.append(((node_index(va), node_index(f),
+                                    node_index(vb)), L, law_id))
+                else:
+                    # P2 triangle: vertex nodes carry barycentric shapes
+                    # in list order, edge nodes pair them (v0v1, v1v2,
+                    # v2v0) — the _NQ3 node convention.
+                    edges = [int(q) for q in dm.getCone(f)]
+                    epair = {e: tuple(int(q) for q in dm.getCone(e))
+                             for e in edges}
+                    verts = sorted({v for pr in epair.values() for v in pr})
+                    Xv = [cvec[csec.getOffset(v) // dim] for v in verts]
+                    area = 0.5 * float(np.linalg.norm(
+                        np.cross(Xv[1] - Xv[0], Xv[2] - Xv[0])))
+                    edge_of_pair = {frozenset(pr): e
+                                    for e, pr in epair.items()}
+                    idx = tuple(node_index(v) for v in verts) + tuple(
+                        node_index(edge_of_pair[frozenset(
+                            (verts[i], verts[j]))])
+                        for i, j in ((0, 1), (1, 2), (2, 0)))
+                    facets.append((idx, area, law_id))
+        _collective_raise(problem)
+
+        # petsc4py refuses to narrow index arrays — Vec/Mat setValues need
+        # PETSc's own integer type.
+        self._ncomp = ncomp
+        self._rows = np.asarray(rows, dtype=PETSc.IntType).reshape(-1, ncomp)
+        self._lo_p = np.asarray(lo_p, dtype=np.int64)
+        self._lo_m = np.asarray(lo_m, dtype=np.int64)
+        self._tan = np.asarray(tans, dtype=float).reshape(-1, ncomp, dim)
+        self._nrm = np.asarray(nrms, dtype=float).reshape(-1, dim)
+        self._NQ = _NQ if dim == 2 else _NQ3
+        self._WQ = _WQ if dim == 2 else _WQ3
+        self._laws = laws_of
+        self._facets = facets
+        self._dim = dim
+        self._points = {q: k for q, k in index_of.items()}
+
+        # Positive trace mass per pair node, for de-smearing the constraint
+        # reaction into a pointwise normal traction. On the P2 LINE the
+        # lumped (row-sum) mass is positive (L/6, 2L/3, L/6) and is used
+        # directly. On the P2 TRIANGLE the lumped VERTEX rows vanish (the
+        # known trap: row sums are 0, 0, 0, A/3, A/3, A/3), so the triangle
+        # uses the P1 SUB-LUMPING instead — each straight P2 triangle is
+        # four P1 sub-triangles of area A/4, whose lumped masses give every
+        # node a positive weight (A/12 per vertex, A/4 per midpoint).
+        # The star-forest completion below is defensive: after the
+        # redistribution that precedes every parallel split the fault is
+        # rank-interior and the exchange is a no-op on the fault rows.
+        mass = np.zeros(len(rows))
+        for idx, measure, _law_id in facets:
+            if dim == 2:
+                weights = (measure / 6.0, 2.0 * measure / 3.0,
+                           measure / 6.0)
+            else:
+                weights = (measure / 12.0,) * 3 + (measure / 4.0,) * 3
+            for k, w in zip(idx, weights):
+                if k >= 0:
+                    mass[k] += w
+        if mpi.size > 1:
+            pStart, pEnd = dm.getChart()
+            chart_mass = np.zeros(pEnd - pStart, dtype=np.float64)
+            for q, k in index_of.items():
+                chart_mass[q - pStart] = mass[k]
+            sf = dm.getPointSF()
+            try:
+                nroots, _il, _ir = sf.getGraph()
+            except (ValueError, TypeError):
+                nroots = -1
+            if nroots >= 0:
+                from mpi4py import MPI
+                sf.reduceBegin(MPI.DOUBLE, chart_mass, chart_mass, MPI.SUM)
+                sf.reduceEnd(MPI.DOUBLE, chart_mass, chart_mass, MPI.SUM)
+                sf.bcastBegin(MPI.DOUBLE, chart_mass, chart_mass,
+                              MPI.REPLACE)
+                sf.bcastEnd(MPI.DOUBLE, chart_mass, chart_mass, MPI.REPLACE)
+            for q, k in index_of.items():
+                mass[k] = float(chart_mass[q - pStart])
+        self._mass = mass
+        # Effective normal stress per pair node (positive in compression),
+        # fed by update_normal_stress; zero until the first reaction exists,
+        # which makes a reaction-fed law START frictionless — a natural
+        # homotopy from the crack toward the frictional state.
+        self._sigma = np.zeros(len(rows) + 1)
+        # Interface state (rate-state theta) per pair node, loaded from the
+        # solver's per-fault store; 1.0 for faults without state (the value
+        # is inert unless the law references state_variable).
+        self._theta = np.ones(len(rows) + 1)
+        fault_states = getattr(solver, "_fault_state", {})
+        points_in_order = sorted(index_of, key=index_of.get)
+        for k, fname in enumerate(fault_of):
+            st = fault_states.get(fname)
+            if st is not None:
+                self._theta[k] = st["by_point"].get(points_in_order[k],
+                                                    st["theta0"])
+
+    def _nodal_slip(self, solver, uvec):
+        """The slip components at every law-carrying pair node, from the
+        CURRENT iterate — shape ``(n + 1, dim - 1)``, one column per
+        in-fault tangent — read through the local vector so ghosted
+        (cross-seam) values resolve, and padded with the tips'/rim's
+        identically-zero slip in the final row."""
+        dm = solver.dm
+        dim = self._nrm.shape[1]
+        lvec = dm.getLocalVec()
+        dm.globalToLocal(uvec, lvec)
+        a = np.asarray(lvec.getArray())
+        V = np.zeros((len(self._rows) + 1, self._ncomp))
+        for k in range(len(self._rows)):
+            du = (a[self._lo_p[k]:self._lo_p[k] + dim]
+                  - a[self._lo_m[k]:self._lo_m[k] + dim])
+            V[k] = self._tan[k] @ du
+        dm.restoreLocalVec(lvec)
+        return V                          # V[-1] == 0: the tip/rim pad
+
+    def residual_add(self, solver, uvec, Fh):
+        """Add the interface force to the ROTATED residual, in place.
+        COLLECTIVE (the Vec assembly): every rank calls, fault or not.
+
+        The slip is a scalar in 2-D (the law reads it SIGNED — every law
+        is odd in V) and an in-plane vector in 3-D, where the traction is
+        collinear with the slip: tau_vec = tau(|V|) V-hat.
+        """
+        NQ, WQ = self._NQ, self._WQ
+        V = self._nodal_slip(solver, uvec)
+        S = self._sigma
+        vals = np.zeros((len(self._rows), self._ncomp))
+        s2 = np.sqrt(2.0)
+        for idx, measure, law_id in self._facets:
+            if law_id < 0:
+                continue                       # geometry-only (diagnostics)
+            Vq = NQ @ V[list(idx)]
+            Sq = NQ @ S[list(idx)]
+            # theta varies by orders of magnitude along a fault and only ever
+            # enters a law through ln(theta): interpolate the LOG, which
+            # is also what keeps a positive-only state positive under
+            # quadratic shape functions (their undershoot sent theta
+            # negative at a quadrature point the plain way).
+            Tq = np.exp(NQ @ np.log(self._theta[list(idx)]))
+            if self._ncomp == 1:
+                tvec = self._laws[law_id].tau(Vq[:, 0], Sq, Tq)[:, None]
+            else:
+                mag = np.linalg.norm(Vq, axis=1)
+                tq = self._laws[law_id].tau(mag, Sq, Tq)
+                # collinear traction; where |V| vanishes so does tau(|V|)
+                scale = np.where(mag > 1e-300, tq / np.maximum(mag, 1e-300),
+                                 0.0)
+                tvec = scale[:, None] * Vq
+            contrib = s2 * measure * (NQ.T @ (WQ[:, None] * tvec))
+            for j, k in enumerate(idx):
+                if k >= 0:
+                    vals[k] += contrib[j]
+        if len(self._rows):
+            Fh.setValues(self._rows.ravel(), vals.ravel(), addv=True)
+        Fh.assemblyBegin()
+        Fh.assemblyEnd()
+
+    def nodal_normal_traction(self, solver, reaction):
+        """Signed normal traction sigma_nn per pair node from the Cartesian
+        reaction (negative in compression): the jump-normal constraint's
+        nodal load l_i = (n.r+ - n.r-)/2, de-smeared by the lumped trace
+        mass. The reaction must be the PURE bulk residual — the loop
+        stashes it before the interface force is added."""
+        dm = solver.dm
+        dim = self._nrm.shape[1]
+        lvec = dm.getLocalVec()
+        dm.globalToLocal(reaction, lvec)
+        a = np.asarray(lvec.getArray())
+        sig = np.zeros(len(self._rows))
+        for k in range(len(self._rows)):
+            rp = a[self._lo_p[k]:self._lo_p[k] + dim]
+            rm = a[self._lo_m[k]:self._lo_m[k] + dim]
+            load = 0.5 * float(self._nrm[k] @ (rp - rm))
+            sig[k] = load / max(self._mass[k], 1e-300)
+        dm.restoreLocalVec(lvec)
+        return sig
+
+    def update_normal_stress(self, solver, reaction):
+        """Picard-lag the SIGNED effective normal stress into the laws:
+        positive in compression, negative in tension. Each law clamps its
+        own strength at zero (Max in the sympy expression) — the clamp
+        cannot live here, because where strength vanishes is constitutive:
+        at sigma = 0 for bare friction, at sigma = -C/mu with cohesion."""
+        sig = self.nodal_normal_traction(solver, reaction)
+        self._sigma[:len(sig)] = -sig
+
+    def tangent(self, solver, uvec):
+        """The consistent interface tangent at the current iterate, as a
+        fresh Mat on the composite layout (caller destroys). COLLECTIVE.
+
+        In 3-D the per-quadrature block on the two slip components is the
+        collinear-traction tangent
+
+        .. math:: (d\\tau/dV)\\,\\hat V\\hat V^T
+                  + (\\tau/|V|)\\,(I - \\hat V\\hat V^T),
+
+        regularised at :math:`|V| \\to 0` by the laws' own smoothness —
+        arctan/asinh forms give :math:`\\tau/|V| \\to d\\tau/dV(0)`, so the
+        zero-slip block is the isotropic :math:`d\\tau/dV(0)\\,I`.
+        """
+        dm = solver.dm
+        NQ, WQ = self._NQ, self._WQ
+        A = solver.snes.getJacobian()[0]
+        rstart, rend = A.getOwnershipRange()
+        K = PETSc.Mat().create(comm=dm.comm)
+        K.setSizes(((rend - rstart, A.getSize()[0]),
+                    (rend - rstart, A.getSize()[0])))
+        K.setType("aij")
+        K.setPreallocationNNZ((3 if self._ncomp == 1 else 40, 0))
+        K.setOption(PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR, False)
+
+        V = self._nodal_slip(solver, uvec)
+        S = self._sigma
+        for idx, measure, law_id in self._facets:
+            if law_id < 0:
+                continue                       # geometry-only (diagnostics)
+            Vq = NQ @ V[list(idx)]
+            Sq = NQ @ S[list(idx)]
+            # theta varies by orders of magnitude along a fault and only ever
+            # enters a law through ln(theta): interpolate the LOG, which
+            # is also what keeps a positive-only state positive under
+            # quadratic shape functions (their undershoot sent theta
+            # negative at a quadrature point the plain way).
+            Tq = np.exp(NQ @ np.log(self._theta[list(idx)]))
+            if self._ncomp == 1:
+                dq = self._laws[law_id].dtau_dV(Vq[:, 0], Sq, Tq)
+                Ke = 2.0 * measure * (NQ.T @ (NQ * (WQ * dq)[:, None]))
+                for i, ki in enumerate(idx):
+                    if ki < 0:
+                        continue
+                    for j, kj in enumerate(idx):
+                        if kj >= 0:
+                            K.setValue(int(self._rows[ki, 0]),
+                                       int(self._rows[kj, 0]),
+                                       float(Ke[i, j]), addv=True)
+                continue
+            mag = np.linalg.norm(Vq, axis=1)
+            tq = self._laws[law_id].tau(mag, Sq, Tq)
+            dq = self._laws[law_id].dtau_dV(mag, Sq, Tq)
+            for q in range(len(WQ)):
+                if mag[q] > 1e-12:
+                    vhat = Vq[q] / mag[q]
+                    P = np.outer(vhat, vhat)
+                    B = dq[q] * P + (tq[q] / mag[q]) * (np.eye(2) - P)
+                else:
+                    B = dq[q] * np.eye(2)
+                w = 2.0 * measure * WQ[q]
+                for i, ki in enumerate(idx):
+                    if ki < 0:
+                        continue
+                    for j, kj in enumerate(idx):
+                        if kj < 0:
+                            continue
+                        NiNj = w * NQ[q, i] * NQ[q, j]
+                        for aa in range(2):
+                            for bb in range(2):
+                                K.setValue(int(self._rows[ki, aa]),
+                                           int(self._rows[kj, bb]),
+                                           float(NiNj * B[aa, bb]),
+                                           addv=True)
+        K.assemble()
+        return K
+
+
+def fault_normal_traction(solver, boundary, solve_result):
+    """Signed normal traction sigma_nn along the split fault ``boundary``
+    (negative in compression), per coincident pair on this rank —
+    recovered from the solve's stashed reaction, exactly as the interface
+    laws read their effective normal stress. In 2-D returns
+    ``(s, sigma_nn)`` ordered by the along-fault coordinate; a 3-D patch
+    has no such ordering, so there the first element is the pair
+    COORDINATES instead: ``(coords, sigma_nn)``.
+    """
+    from underworld3.utilities.rotated_bc import _point_coord
+
+    assembler = _InterfaceAssembler(solver, include=(boundary,))
+    sig = assembler.nodal_normal_traction(solver, solve_result["reaction"])
+
+    dm = solver.dm
+    dim = solver.mesh.dim
+    csec = dm.getCoordinateSection()
+    cvec = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dim)
+    v0, v1 = dm.getDepthStratum(0)
+    pts = sorted(assembler._points, key=assembler._points.get)
+    coords = np.array([_point_coord(dm, dim, cvec, csec, v0, v1, q)
+                       for q in pts]) if pts else np.zeros((0, dim))
+    if not len(coords):
+        return np.zeros(0), np.zeros(0)
+    if dim == 3:
+        return coords, sig
+    tbar = assembler._tan[:, 0, :].mean(axis=0)
+    tbar /= np.linalg.norm(tbar) + 1e-30
+    s_coord = coords @ tbar
+    s_coord -= s_coord.min()
+    order = np.argsort(s_coord)
+    return s_coord[order], sig[order]
+
+
+def fault_pair_jumps(solver, boundary, solve_result):
+    """The velocity jump at every coincident pair, from the solve.
+
+    Returns ``(coords, jumps, normals)`` on this rank — the pair position,
+    the full jump vector :math:`v^+ - v^-`, and the fault unit normal —
+    in any dimension. Reads the composite solution ``solve_result["U"]``
+    through the pairing, which is the only correct route: the pair
+    coordinates are identical, so field queries by position see one side
+    only. The tangential part of the jump is the slip (a scalar against
+    the in-fault tangent in 2-D, an in-plane vector in 3-D); the normal
+    part is the leak, held at machine zero by the strong constraint.
+    """
+    dm = solver.dm
+    dim = solver.mesh.dim
+    lsec = dm.getLocalSection()
+    l2g = dm.getLGMap()
+    U = solve_result["U"]
+    rs, re = U.getOwnershipRange()
+    ua = np.asarray(U.getArray())
+
+    csec = dm.getCoordinateSection()
+    cvec = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dim)
+    v0, v1 = dm.getDepthStratum(0)
+
+    from underworld3.utilities.rotated_bc import _point_coord
+
+    nodes = _fault_pair_nodes(solver, boundary)
+    coords, jumps, normals = [], [], []
+    for q_plus, q_minus, nrm in nodes:
+        vals = {}
+        for tag, q in (("plus", q_plus), ("minus", q_minus)):
+            lo = lsec.getFieldOffset(q, _VELOCITY_FIELD)
+            grows = [int(l2g.apply([lo + c])[0]) for c in range(dim)]
+            if not all(rs <= g < re for g in grows):
+                break
+            vals[tag] = ua[[g - rs for g in grows]]
+        if len(vals) < 2:
+            continue
+        coords.append(_point_coord(dm, dim, cvec, csec, v0, v1, q_plus))
+        jumps.append(vals["plus"] - vals["minus"])
+        normals.append(nrm)
+    if not coords:
+        return (np.zeros((0, dim)),) * 3
+    return np.array(coords), np.array(jumps), np.array(normals)
+
+
+def fault_slip(solver, boundary, solve_result):
+    """Slip and leak along a 2-D fault, per coincident pair, from the solve.
+
+    Returns ``(s, V, leak)`` on this rank: the along-fault coordinate of each
+    pair (arc-length-like, measured along the fault's mean tangent from the
+    first tip), the tangential velocity jump :math:`V = \\hat t\\cdot(v^+ -
+    v^-)`, and the normal jump :math:`\\hat n\\cdot(v^+ - v^-)` — the leak,
+    which the strong constraint holds at machine zero. The 2-D profile view
+    of :func:`fault_pair_jumps`; a 3-D patch has no along-fault ordering, so
+    read the jumps directly there.
+    """
+    coords, jumps, normals = fault_pair_jumps(solver, boundary, solve_result)
+    if not len(coords):
+        return (np.zeros(0),) * 3
+    if solver.mesh.dim != 2:
+        raise NotImplementedError(
+            "fault_slip's arc-length profile is 2-D; use fault_pair_jumps "
+            "for a 3-D patch.")
+    tangents = np.column_stack([-normals[:, 1], normals[:, 0]])
+    # Along-fault coordinate from the mean tangent, origin at the trailing end.
+    tbar = tangents.mean(axis=0)
+    tbar /= np.linalg.norm(tbar) + 1e-30
+    s = coords @ tbar
+    s -= s.min()
+    order = np.argsort(s)
+    V = np.einsum("ij,ij->i", jumps, tangents)
+    leak = np.einsum("ij,ij->i", jumps, normals)
+    return s[order], V[order], leak[order]
diff --git a/src/underworld3/utilities/fault_split.py b/src/underworld3/utilities/fault_split.py
new file mode 100644
index 000000000..ea0ad7b49
--- /dev/null
+++ b/src/underworld3/utilities/fault_split.py
@@ -0,0 +1,1449 @@
+r"""Split-node faults: a labelled facet chain becomes a genuine discontinuity.
+
+A conforming surface (:meth:`Mesh.add_conforming_surface`) leaves the fault as
+a chain of interior facets that the two flanking cells *share*, so every
+continuous finite-element space is continuous across it. Splitting the nodes
+removes that: each interior vertex of the chain is duplicated, the cells on one
+side are rewired to the replicas, and the fault facets themselves are doubled —
+two geometrically coincident copies with no degrees of freedom in common. A
+velocity (or any) field can then jump across the fault, which is what a fault
+*is*: slip, not strain. The tips are never duplicated, so the field stays
+continuous there and a slip datum must taper to zero at the tips.
+
+The two sides become named boundaries — ``<name>Plus`` and ``<name>Minus`` —
+so an ordinary essential condition prescribes slip::
+
+    child = split_fault(mesh, "Fault")
+    stokes.add_dirichlet_bc(v_bg + s/2 * taper * tangent, "FaultPlus")
+    stokes.add_dirichlet_bc(v_bg - s/2 * taper * tangent, "FaultMinus")
+
+``Plus`` is the LEFT side walking the chain from its first tip to its second,
+where the first tip is the one lower in coordinate order: with tangent
+:math:`\hat t` along the walk, the normal :math:`\hat n = (-t_y, t_x)` points
+into the Plus side. The original label survives on BOTH copies, so it remains
+the whole-fault handle for visualisation and for the repair passes'
+interface protection.
+
+The split is a pure function of the source DM — nothing is cached, the source
+is not modified — because a fault MOVES: re-splitting after migration is
+re-cutting the (static) base mesh at the new position and calling this again,
+the same non-cumulative pattern as :meth:`Mesh.adapt`.
+
+Built on the rebuild machinery of :mod:`underworld3.utilities.reconnect`:
+the same fresh-plex construction (`DMPlexSymmetrize` refuses surgery in
+place), the same derived-edge rule (an old facet is reused wherever its vertex
+pair is still wanted, which is what carries its labels), and the same
+one-broadcast star-forest renumbering. Where the deletion pass compacts the
+point chart, the split grows it.
+
+Restrictions in this version, all refused loudly rather than mishandled: a
+single open chain in 2-D (no junctions, no loops, no single-facet chains) or
+a single orientable manifold patch in 3-D (:func:`split_along_label_3d`; the
+patch rim is the tip rule one dimension up); the fault must not touch the
+domain boundary; and in parallel the fault's cell fans must not touch the
+partition seam — the replicas are then rank-local and the star-forest carries
+over by renumbering alone, exactly as the deletion pass argues for its own
+seam freeze. A fault that DOES touch the seam is not the user's problem:
+:func:`split_fault` (and :func:`add_fault`) REDISTRIBUTE first — the fault's
+cell star plus one growth layer moves to the rank that already owns most of
+it (:func:`_redistribute_fault_interior`), the chain or patch becomes
+rank-interior, and the split runs with serial topology. Only a direct call
+to the low-level splitters on a seam-touching fault is refused.
+
+An essential condition on the fault is NOT sound under the custom-P geometric
+multigrid hierarchy (the coarse levels do not carry the fault — see the
+warning on :meth:`Mesh.add_conforming_surface`), so the split mesh is built
+standalone, with no coarse tail: the Stokes velocity block then takes its
+algebraic-multigrid default.
+"""
+
+import numpy as np
+from mpi4py import MPI
+from petsc4py import PETSc
+
+import underworld3 as uw
+from underworld3.utilities.reconnect import (
+    _TOPOLOGY_LABELS, _cell_vertices_and_seam, _coords, _copy_labels,
+    _rebuild_point_sf, _shared_points, _write_coordinates)
+
+
+def _fault_chain(dm, fault_edges, X, vS, shared, pStart, orientation=None):
+    """The fault as an ordered vertex path, tip to tip.
+
+    Returns ``(problem, chain)`` where ``problem`` is ``None`` or an
+    ``(ExceptionClass, message)`` pair and ``chain`` lists the fault vertices
+    in walk order, starting from the tip lower in coordinate order so the walk
+    — and with it the Plus/Minus sides — is a function of the geometry, not of
+    label-stratum order.
+
+    ``shared`` (chart-indexed rank-sharing flags) refines the two boundary
+    rules: a support-1 facet in a fault vertex's star is the DOMAIN boundary
+    only if it is unshared — on a partition seam every facet is locally
+    one-sided, and a fault may run arbitrarily close to a seam. What it may
+    not have is a CHAIN VERTEX on the seam: an unshared vertex owns its
+    whole cell fan (any cell touching it would make it shared), so every
+    replica and every re-homed spoke stays rank-local; a shared chain
+    vertex means the fault touches or crosses the seam, which the split
+    cannot represent. :func:`split_fault` REDISTRIBUTES the fault's cell
+    star onto one rank before splitting exactly so this never happens; a
+    direct low-level call on a seam-touching fault is refused. The check
+    comes FIRST — before the fragment/tip topology checks — because a
+    rank holding only a fragment of a seam-straddling fault would
+    otherwise report a misleading chain-shape symptom where the true
+    verdict is the seam.
+    """
+    eS, eE = dm.getDepthStratum(1)
+
+    nbr = {}
+    for e in fault_edges:
+        a, b = (int(p) for p in dm.getCone(e))
+        nbr.setdefault(a, []).append(b)
+        nbr.setdefault(b, []).append(a)
+
+    if any(shared[v - pStart] for v in nbr):
+        return (RuntimeError,
+                "fault_split: a fault vertex sits on the partition seam — "
+                "the split needs the whole chain rank-interior. split_fault "
+                "redistributes the fault's cell star onto one rank before "
+                "splitting; a direct split_along_label call must present a "
+                "rank-interior fault."), None
+    if len(fault_edges) < 2:
+        return (ValueError,
+                "fault_split: the chain has a single facet, so no interior "
+                "vertex exists to split. A one-facet fault cannot slip."), None
+    if any(len(ns) > 2 for ns in nbr.values()):
+        return (ValueError,
+                "fault_split: the label meets itself at a junction. Junctions "
+                "need a side assignment this version does not define; split "
+                "each branch under its own label instead."), None
+    tips = [v for v, ns in nbr.items() if len(ns) == 1]
+    if len(tips) != 2:
+        return (ValueError,
+                "fault_split: the labelled facets form a closed loop or "
+                "several fragments, not a single open chain."), None
+
+    # The fault must be strictly interior. An edge with a single support cell
+    # is a domain-boundary facet — unless it is SHARED, in which case it is a
+    # partition-seam facet that merely looks one-sided locally. One in the
+    # star of any fault vertex means the slit would reach the boundary, where
+    # the tip-clamping argument fails.
+    for v in nbr:
+        star = dm.getTransitiveClosure(v, useCone=False)[0]
+        for p in star:
+            p = int(p)
+            if eS <= p < eE and len(dm.getSupport(p)) != 2 \
+                    and not shared[p - pStart]:
+                # distinguish the domain boundary from the slit of an
+                # ALREADY-SPLIT fault: a chain terminating on one is a
+                # touching junction, which the split cannot represent —
+                # and would not want to: a single shared vertex forces
+                # every arm's slip to zero there, STIFFER than the true
+                # sector junction. The offset form brackets the truth
+                # (see the true-branch teaching example).
+                on_slit = any(
+                    dm.getLabelValue(lname, p) >= 0
+                    for lname in (dm.getLabelName(i) for i in
+                                  range(dm.getNumLabels()))
+                    if lname.endswith("Plus") or lname.endswith("Minus"))
+                if on_slit:
+                    return (ValueError,
+                            "fault_split: the fault terminates on an "
+                            "already-split fault's slit (a touching "
+                            "junction). A shared point would clamp every "
+                            "arm's slip to zero there — stiffer than a "
+                            "true junction. Use the offset form "
+                            "(uw.meshing.prepare_fault_network), which "
+                            "brackets the true branch."), None
+                return (ValueError,
+                        "fault_split: the fault touches the domain boundary. "
+                        "Only strictly interior faults, with both tips inside "
+                        "the mesh, are supported in this version."), None
+
+    start = min(tips, key=lambda t: (float(X[t - vS][0]),
+                                     float(X[t - vS][1]), t))
+    chain, prev, cur = [start], None, start
+    while True:
+        onward = [w for w in nbr[cur] if w != prev]
+        if not onward:
+            break
+        prev, cur = cur, onward[0]
+        chain.append(cur)
+        if len(chain) > len(nbr):
+            return (ValueError,
+                    "fault_split: the chain walk did not terminate; the "
+                    "labelled facets are not a simple path."), None
+    if len(chain) != len(nbr):
+        return (ValueError,
+                "fault_split: the labelled facets are not one connected "
+                "chain. Cut and split one polyline at a time."), None
+
+    # Optional caller-supplied chain direction (add_fault passes the
+    # polyline's own direction): the walk is aligned against it so the Plus
+    # side is the LEFT of the directed line the USER drew, not of the
+    # coordinate-order tip rule.
+    if orientation is not None and len(chain) >= 2:
+        d = np.asarray(orientation, dtype=float).ravel()[:2]
+        if float((X[chain[-1] - vS] - X[chain[0] - vS]) @ d) < 0.0:
+            chain.reverse()
+    return None, chain
+
+
+def _take_sides(dm, chain, verts, cS, cE):
+    """Classify every fault-fan cell as Plus (+1) or Minus (-1).
+
+    At each interior chain vertex the incident cells are walked as a fan,
+    using the directed link edge each anticlockwise cell triple contributes —
+    :func:`reconnect._link_ring` opened at the two fault facets. Walking from
+    the outgoing fault neighbour to the incoming one sweeps the cells on the
+    LEFT of the directed chain, which is the Plus side. Any structural anomaly
+    in the fan (a duplicated directed link edge, a walk that escapes or fails
+    to close) means the cell orientations are not consistent there, and is a
+    refusal rather than a guess: unlike a declined flip, a mis-sided cell
+    would silently weld the fault shut at one node.
+
+    Returns ``(problem, side_of_cell, substitutions)`` where ``substitutions``
+    maps a Minus cell to the set of chain vertices it must replace with
+    replicas.
+    """
+    side_of_cell, substitutions = {}, {}
+
+    def _assign(cells, side, v):
+        for c in cells:
+            if side_of_cell.setdefault(c, side) != side:
+                return (ValueError,
+                        "fault_split: a cell meets the fault from both "
+                        "sides (the chain kinks through it). Refine the "
+                        "mesh near the kink and re-cut.")
+            if side < 0:
+                substitutions.setdefault(c, set()).add(v)
+        return None
+
+    for i in range(1, len(chain) - 1):
+        v, before, after = chain[i], chain[i - 1], chain[i + 1]
+        fan = [int(p) for p in dm.getTransitiveClosure(v, useCone=False)[0]
+               if cS <= int(p) < cE]
+        step = {}
+        for c in fan:
+            tri = [int(t) for t in verts[c - cS]]
+            j = tri.index(v)
+            p, q = tri[(j + 1) % 3], tri[(j + 2) % 3]
+            if p in step:
+                return (ValueError,
+                        "fault_split: two cells at a fault vertex claim the "
+                        "same directed link edge — the fan is not a "
+                        "consistently oriented manifold disc."), None, None
+            step[p] = (q, c)
+
+        plus_arc, cur, guard = [], after, 0
+        while cur != before:
+            if cur not in step or guard > len(step):
+                return (ValueError,
+                        "fault_split: the fan walk at a fault vertex did not "
+                        "reach the incoming fault facet — the fan is not a "
+                        "manifold disc."), None, None
+            cur, c = step[cur]
+            plus_arc.append(c)
+            guard += 1
+        minus_arc = [c for c in fan if c not in set(plus_arc)]
+        if not plus_arc or not minus_arc:
+            return (ValueError,
+                    "fault_split: a fault vertex has all its cells on one "
+                    "side, which cannot happen on a manifold interior "
+                    "chain."), None, None
+
+        # A cell can meet the fault at two chain vertices and be walked
+        # onto opposite sides only when the chain kinks through it (a chord
+        # cell); _assign refuses rather than resolves.
+        problem = _assign(plus_arc, 1, v) or _assign(minus_arc, -1, v)
+        if problem is not None:
+            return problem, None, None
+    return None, side_of_cell, substitutions
+
+
+def _clone_labels(new, dm, clone_map):
+    """Give each replica point its original's label values.
+
+    :func:`reconnect._copy_labels` maps one source point to at most one new
+    point; a split maps the duplicated ones to TWO. The replica's values are
+    applied as a second pass over the same strata, filtered by nothing:
+    ``Null_Boundary`` and ``UW_Boundaries`` are rebuilt from scratch when a
+    ``Mesh`` is constructed on the result, so cloning them costs nothing, and
+    every other label on a duplicated point (the fault's own name above all)
+    is exactly what the replica must carry.
+    """
+    if not clone_map:
+        return
+    twins = {}
+    for new_pt, old_pt in clone_map.items():
+        twins.setdefault(old_pt, []).append(new_pt)
+    for i in range(dm.getNumLabels()):
+        name = dm.getLabelName(i)
+        if name in _TOPOLOGY_LABELS:
+            continue
+        source, target = dm.getLabel(name), new.getLabel(name)
+        values = source.getValueIS()
+        if values is None:
+            continue
+        for val in values.getIndices():
+            points = source.getStratumIS(int(val))
+            if points is None:
+                continue
+            for p in points.getIndices():
+                for q in twins.get(int(p), ()):
+                    target.setValue(q, int(val))
+
+
+def split_along_label(dm, name, value, plus_name, plus_value,
+                      minus_name, minus_value, orientation=None,
+                      verbose=False):
+    """Duplicate the interior vertices of a labelled facet chain.
+
+    Builds a fresh plex in which the cells on the Minus side of the chain are
+    rewired to replica vertices, so the two sides of the fault share no points
+    — and therefore no degrees of freedom in any FE space — except the two
+    tips. The fault facets are doubled: the originals keep every label they
+    carried and gain ``plus_name``; the replicas clone the originals' labels
+    and gain ``minus_name``.
+
+    COLLECTIVE. Every rank must call this, including ranks holding no part of
+    the fault (they rebuild their local chart unchanged); a refusal raises the
+    same error on every rank.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        Source mesh, 2-D simplex. Not modified.
+    name : str
+        Label holding the fault facets.
+    value : int
+        The label value marking them.
+    plus_name, plus_value : str, int
+        Label minted on the original (Plus-side) fault facets.
+    minus_name, minus_value : str, int
+        Label minted on the replica (Minus-side) fault facets.
+
+    Returns
+    -------
+    new : PETSc.DMPlex
+        The split mesh. Cells keep their source order, so per-cell data
+        remains aligned.
+    point_map : numpy.ndarray
+        Chart-indexed source point -> new point. ``-1`` marks the Minus-side
+        facets that were re-homed onto replicas (their replacements appear in
+        ``clone_map`` instead).
+    clone_map : dict
+        ``{new point: source point}`` for every replica vertex and every
+        re-homed facet — the provenance a field transfer needs.
+    """
+    if dm.getDimension() != 2:
+        raise NotImplementedError(
+            "split_along_label handles 2-D facet chains; use "
+            "split_along_label_3d for a labelled facet patch in 3-D.")
+
+    pStart, pEnd = dm.getChart()
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    X = _coords(dm)
+
+    fault_edges = []
+    # hasLabel, not getLabel-against-None: petsc4py hands back a wrapper
+    # around a NULL label for a missing name, and the first stratum query on
+    # it aborts the process rather than raising. Likewise an empty stratum
+    # hands back a null IS that segfaults in getIndices() — a rank owning no
+    # part of the fault is the normal case in parallel.
+    if dm.hasLabel(name) and dm.getLabel(name).getStratumSize(int(value)) > 0:
+        stratum = dm.getLabel(name).getStratumIS(int(value))
+        fault_edges = [int(p) for p in stratum.getIndices()
+                       if eS <= int(p) < eE]
+
+    # COLLECTIVE, and reached on every rank whatever the local verdict:
+    # the sharing flags feed the chain validation (seam facets are not the
+    # domain boundary; a shared chain vertex is refused — split_fault
+    # redistributes so the check never fires on the managed path) and the
+    # cell triples feed the rebuild.
+    shared = _shared_points(dm)
+    verts, _frozen = _cell_vertices_and_seam(dm, X, shared)
+
+    problem, chain = (None, None)
+    if fault_edges:
+        problem, chain = _fault_chain(dm, fault_edges, X, vS, shared, pStart,
+                                      orientation=orientation)
+
+    side_of_cell, substitutions = {}, {}
+    if problem is None and fault_edges:
+        problem, side_of_cell, substitutions = _take_sides(
+            dm, chain, verts, cS, cE)
+
+    fault_pair_edge = {}
+    for e in fault_edges:
+        a, b = (int(p) for p in dm.getCone(e))
+        fault_pair_edge[(a, b) if a < b else (b, a)] = e
+
+    if problem is None and fault_edges:
+        # Every fault facet must have been classified onto opposite sides by
+        # the fans of its endpoints; anything else is a mis-wiring that would
+        # otherwise only surface as a wrong stress field.
+        for e in fault_pair_edge.values():
+            sides = sorted(side_of_cell.get(int(c), 0)
+                           for c in dm.getSupport(e))
+            if sides != [-1, 1]:
+                problem = (ValueError,
+                           "fault_split: the two cells of a fault facet were "
+                           "not classified onto opposite sides — the side "
+                           "assignment is inconsistent along the chain.")
+                break
+
+    # One synchronisation point for every refusal, so no rank raises while its
+    # peers continue into the collective rebuild below and block.
+    if uw.mpi.size > 1:
+        gathered = uw.mpi.comm.allgather((problem, len(fault_edges)))
+        problems = [p for p, _m in gathered if p is not None]
+        # Every rank raises the SAME error, and a seam verdict from any rank
+        # wins over the chain-fragment symptoms the other ranks report.
+        seam = [p for p in problems if p[0] is RuntimeError]
+        problem = seam[0] if seam else (problems[0] if problems else None)
+        if problem is None and sum(m for _p, m in gathered) == 0:
+            problem = (ValueError,
+                       f"fault_split: no facets carry label {name!r} value "
+                       f"{value} on any rank.")
+    elif problem is None and not fault_edges:
+        problem = (ValueError,
+                   f"fault_split: no facets carry label {name!r} value "
+                   f"{value}.")
+    if problem is not None:
+        exc, message = problem
+        raise exc(message)
+
+    # ----------------------------------------------------------- the rebuild
+    # From here the shape follows reconnect.rebuild_without_vertices, with the
+    # chart grown instead of compacted: replicas are appended to the vertex
+    # stratum, and the edges are re-derived from the substituted cell list so
+    # that a facet is reused — labels intact — exactly where its vertex pair
+    # survived, and re-homed onto replicas where it did not.
+    interior = chain[1:-1] if chain else []
+    replicas_of = {v: pEnd + i for i, v in enumerate(sorted(interior))}
+    original_of = {t: v for v, t in replicas_of.items()}
+
+    cells = []
+    for c in range(cS, cE):
+        tri = [int(t) for t in verts[c - cS]]
+        if c in substitutions:
+            tri = [replicas_of[t] if t in substitutions[c] else t for t in tri]
+        cells.append(tuple(tri))
+
+    wanted = set()
+    for a, b, c in cells:
+        wanted.update(((a, b) if a < b else (b, a),
+                       (b, c) if b < c else (c, b),
+                       (c, a) if c < a else (a, c)))
+    surv_e, pair_of, old_edge_of_pair = [], {}, {}
+    for e in range(eS, eE):
+        a, b = (int(p) for p in dm.getCone(e))
+        pair = (a, b) if a < b else (b, a)
+        old_edge_of_pair[pair] = e
+        if pair in wanted:
+            surv_e.append(e)
+            pair_of[e] = pair
+    fresh = sorted(wanted - set(pair_of.values()))
+    edges = [pair_of[e] for e in surv_e] + fresh
+
+    sizes = {"c": cE - cS, "v": (vE - vS) + len(interior), "e": len(edges)}
+    offset, at = {}, pStart
+    for _start, key in sorted(((cS, "c"), (vS, "v"), (eS, "e"))):
+        offset[key] = at
+        at += sizes[key]
+
+    point_map = np.full(pEnd - pStart, -1, dtype=np.int64)
+    point_map[np.arange(cS, cE) - pStart] = offset["c"] + np.arange(cE - cS)
+    point_map[np.arange(vS, vE) - pStart] = offset["v"] + np.arange(vE - vS)
+    if surv_e:
+        point_map[np.asarray(surv_e, dtype=np.int64) - pStart] = (
+            offset["e"] + np.arange(len(surv_e)))
+
+    replica_new = {t: offset["v"] + (vE - vS) + i
+                   for i, t in enumerate(sorted(original_of))}
+
+    def v_new(x):
+        return replica_new[x] if x >= pEnd else int(point_map[x - pStart])
+
+    new = PETSc.DMPlex().create(comm=dm.comm)
+    new.setDimension(2)
+    new.setChart(pStart, at)
+    for i in range(sizes["c"]):
+        new.setConeSize(offset["c"] + i, 3)
+    for i in range(len(edges)):
+        new.setConeSize(offset["e"] + i, 2)
+    new.setUp()
+
+    edge_of, first_of = {}, {}
+    for i, (a, b) in enumerate(edges):
+        e = offset["e"] + i
+        new.setCone(e, [v_new(a), v_new(b)])
+        edge_of[(a, b)] = e
+        first_of[e] = a
+
+    for i, (v0, v1, v2) in enumerate(cells):
+        cone, orientation = [], []
+        for x, y in ((v0, v1), (v1, v2), (v2, v0)):
+            e = edge_of[(x, y) if x < y else (y, x)]
+            cone.append(e)
+            orientation.append(0 if first_of[e] == x else -1)
+        new.setCone(offset["c"] + i, cone)
+        new.setConeOrientation(offset["c"] + i, orientation)
+
+    new.symmetrize()
+    new.stratify()
+
+    source_rows = np.concatenate([
+        np.arange(vE - vS, dtype=np.int64),
+        np.asarray(sorted(interior), dtype=np.int64) - vS]) \
+        if interior else np.arange(vE - vS, dtype=np.int64)
+    _write_coordinates(new, dm, (offset["v"], offset["v"] + sizes["v"]),
+                       source_rows)
+
+    clone_map = {replica_new[t]: original_of[t] for t in original_of}
+    minus_copies = []
+    for i, pair in enumerate(fresh):
+        e_new = offset["e"] + len(surv_e) + i
+        a, b = (original_of.get(p, p) for p in pair)
+        collapsed = (a, b) if a < b else (b, a)
+        e_old = old_edge_of_pair.get(collapsed)
+        if e_old is None:
+            # The split invents no connectivity: every fresh facet is an old
+            # one re-homed onto replicas. A missing source is a wiring bug.
+            raise RuntimeError(
+                "fault_split internal: a fresh facet has no source facet.")
+        clone_map[e_new] = e_old
+        if collapsed in fault_pair_edge:
+            minus_copies.append(e_new)
+
+    _copy_labels(new, dm, point_map)
+    _clone_labels(new, dm, clone_map)
+
+    new.createLabel(plus_name)
+    plus = new.getLabel(plus_name)
+    for e in fault_pair_edge.values():
+        plus.setValue(int(point_map[e - pStart]), int(plus_value))
+    new.createLabel(minus_name)
+    minus = new.getLabel(minus_name)
+    for e in minus_copies:
+        minus.setValue(int(e), int(minus_value))
+
+    if uw.mpi.size > 1:
+        # No shared point is ever duplicated or dropped (a shared chain
+        # vertex is refused above; split_fault redistributes so the whole
+        # chain is rank-interior), so the leaf set carries over by
+        # renumbering alone — the same argument as the 3-D splitter.
+        _rebuild_point_sf(new, dm, point_map, at - pStart)
+
+    if verbose and fault_edges:
+        uw.pprint(f"[fault_split {name!r}] duplicated {len(interior)} "
+                  f"vertices along {len(fault_edges)} facets; sides are "
+                  f"{plus_name!r} / {minus_name!r}")
+    return new, point_map, clone_map
+
+
+def _patch_faces_and_edges(dm, fault_faces):
+    """Classify the labelled patch: rim vs interior edges and vertices.
+
+    Returns ``(face_verts, edge_faces, rim_edges, interior_edges, rim_verts,
+    interior_verts, problem)`` where ``face_verts[f]`` is the face's vertex
+    triple and ``edge_faces`` maps each patch edge to the fault faces using
+    it. A patch edge used by one fault face is the RIM (the tip rule one
+    dimension up — those points stay unsplit); by two, patch interior; by
+    more, a non-manifold junction, refused.
+    """
+    vS, vE = dm.getDepthStratum(0)
+    face_verts, edge_faces = {}, {}
+    for f in fault_faces:
+        closure, _ = dm.getTransitiveClosure(f)
+        face_verts[f] = [int(p) for p in closure if vS <= int(p) < vE]
+        for e in dm.getCone(f):
+            edge_faces.setdefault(int(e), []).append(f)
+
+    problem = None
+    if any(len(fs) > 2 for fs in edge_faces.values()):
+        problem = (ValueError,
+                   "fault_split: three or more fault faces meet along an "
+                   "edge — the patch is non-manifold (a branching sheet). "
+                   "Label each sheet separately.")
+    rim_edges = [e for e, fs in edge_faces.items() if len(fs) == 1]
+    interior_edges = [e for e, fs in edge_faces.items() if len(fs) == 2]
+    rim_verts = set()
+    for e in rim_edges:
+        rim_verts.update(int(q) for q in dm.getCone(e))
+    all_verts = set()
+    for vv in face_verts.values():
+        all_verts.update(vv)
+    interior_verts = all_verts - rim_verts
+    return (face_verts, edge_faces, rim_edges, interior_edges,
+            rim_verts, interior_verts, problem)
+
+
+def _orient_patch(face_verts, edge_faces, X, vS, orientation=None):
+    """Give every fault face a consistently oriented vertex triple.
+
+    Adjacent faces must traverse their shared edge in opposite directions —
+    the standard orientability propagation over the patch's face-adjacency
+    graph. The propagation also proves the patch is one connected, orientable
+    sheet; either failure is refused. The global sign — which side is Plus —
+    is the side the oriented normal points into: the ``orientation`` vector
+    when given, otherwise the sign making the largest component of the
+    area-weighted mean normal positive (deterministic, documented, and no
+    more meaningful than 2-D's coordinate-order tip rule).
+
+    Returns ``(oriented, problem)`` with ``oriented[f]`` an ordered triple.
+    """
+    faces = list(face_verts)
+    oriented, problem = {}, None
+
+    def _directed(tri):
+        a, b, c = tri
+        return {(a, b), (b, c), (c, a)}
+
+    stack = [faces[0]]
+    oriented[faces[0]] = list(face_verts[faces[0]])
+    while stack:
+        f = stack.pop()
+        dirs = _directed(oriented[f])
+        for e, fs in edge_faces.items():
+            if f not in fs or len(fs) != 2:
+                continue
+            g = fs[0] if fs[1] == f else fs[1]
+            shared = [v for v in face_verts[g] if v in face_verts[f]]
+            u, w = shared[0], shared[1]
+            forward = (u, w) if (u, w) in dirs else (w, u)
+            if g not in oriented:
+                tri = list(face_verts[g])
+                if forward in _directed(tri):
+                    tri = [tri[0], tri[2], tri[1]]
+                oriented[g] = tri
+                stack.append(g)
+            elif forward in _directed(oriented[g]):
+                return oriented, (ValueError,
+                                  "fault_split: the patch is not orientable "
+                                  "— no consistent two-sided normal exists.")
+    if len(oriented) != len(faces):
+        return oriented, (ValueError,
+                          "fault_split: the labelled faces form more than "
+                          "one connected patch. Split one fault at a time — "
+                          "label each patch under its own name.")
+
+    normal_sum = np.zeros(3)
+    for tri in oriented.values():
+        a, b, c = (X[t - vS] for t in tri)
+        normal_sum += np.cross(b - a, c - a)
+    reference = (np.asarray(orientation, dtype=float)
+                 if orientation is not None
+                 else np.eye(3)[int(np.argmax(np.abs(normal_sum)))])
+    if float(normal_sum @ reference) < 0.0:
+        for f in oriented:
+            t0, t1, t2 = oriented[f]
+            oriented[f] = [t0, t2, t1]
+    return oriented, problem
+
+
+def _take_sides_3d(dm, oriented, face_verts, cell_verts, interior_verts,
+                   fault_face_set, X, vS, cS):
+    """Assign every patch-adjacent cell to the Plus or Minus half-ball.
+
+    The two support cells of each fault face are classified geometrically:
+    with the face's oriented triple :math:`(a, b, c)` and the cell's fourth
+    vertex :math:`d`, the sign of :math:`\\det[b-a,\\; c-a,\\; d-a]` says
+    which side of the oriented plane the cell lies on (positive = Plus, the
+    side the normal points into). Around each interior patch vertex the rest
+    of the star is then flooded: cells connect through shared non-fault faces
+    containing the vertex, the patch cuts that star into exactly two
+    components, and each component inherits the side of the fault-face
+    supports it contains. Anything else — one component (a pinched sheet),
+    an unseeded component, conflicting seeds — is a mis-labelling, refused.
+
+    Returns ``(side_of_cell, substitutions, problem)``; ``substitutions[c]``
+    is the set of vertices cell ``c`` must swap for replicas.
+    """
+    side_of_cell, substitutions = {}, {}
+    for f in fault_face_set:
+        a, b, c = (X[t - vS] for t in oriented[f])
+        for cell in (int(q) for q in dm.getSupport(f)):
+            tet = cell_verts[cell - cS]
+            d = next(t for t in tet if t not in face_verts[f])
+            volume = float(np.linalg.det(
+                np.array([b - a, c - a, X[d - vS] - a])))
+            if volume == 0.0:
+                return {}, {}, (ValueError,
+                                "fault_split: a fault-flanking cell is "
+                                "degenerate — zero volume against the fault "
+                                "plane.")
+            side = 1 if volume > 0.0 else -1
+            if side_of_cell.setdefault(cell, side) != side:
+                return {}, {}, (ValueError,
+                                "fault_split: a cell flanks fault faces "
+                                "from opposite sides — the patch folds "
+                                "back through its own star.")
+
+    star = {v: [] for v in interior_verts}
+    for i, tet in enumerate(cell_verts):
+        for t in tet:
+            if int(t) in star:
+                star[int(t)].append(cS + i)
+
+    vS_dm, vE_dm = dm.getDepthStratum(0)
+    verts_of_face = dict(face_verts)
+
+    def _face_verts(f):
+        if f not in verts_of_face:
+            closure, _ = dm.getTransitiveClosure(f)
+            verts_of_face[f] = [int(p) for p in closure
+                                if vS_dm <= int(p) < vE_dm]
+        return verts_of_face[f]
+
+    for v, cells in star.items():
+        in_star = set(cells)
+        neighbours = {c: [] for c in cells}
+        for c in cells:
+            for f in (int(q) for q in dm.getCone(c)):
+                if f in fault_face_set or v not in _face_verts(f):
+                    continue
+                for other in (int(q) for q in dm.getSupport(f)):
+                    if other != c and other in in_star:
+                        neighbours[c].append(other)
+        components, seen = [], set()
+        for c in cells:
+            if c in seen:
+                continue
+            component, queue = [], [c]
+            seen.add(c)
+            while queue:
+                q = queue.pop()
+                component.append(q)
+                for r in neighbours[q]:
+                    if r not in seen:
+                        seen.add(r)
+                        queue.append(r)
+            components.append(component)
+        if len(components) != 2:
+            return {}, {}, (ValueError,
+                            "fault_split: the patch does not cut a vertex "
+                            "star into two half-balls — the sheet is "
+                            "pinched or the label leaks off the patch.")
+        for component in components:
+            seeds = {side_of_cell[c] for c in component if c in side_of_cell}
+            if len(seeds) != 1:
+                return {}, {}, (ValueError,
+                                "fault_split: a star component seeds from "
+                                "both sides (or neither) — the side "
+                                "assignment is inconsistent at a vertex.")
+            side = seeds.pop()
+            for c in component:
+                if side_of_cell.setdefault(c, side) != side:
+                    return {}, {}, (ValueError,
+                                    "fault_split: a cell is assigned to "
+                                    "opposite sides by two vertex stars.")
+                if side < 0:
+                    substitutions.setdefault(c, set()).add(v)
+    return side_of_cell, substitutions, None
+
+
+def split_along_label_3d(dm, name, value, plus_name, plus_value,
+                         minus_name, minus_value, orientation=None,
+                         verbose=False):
+    """Duplicate the interior of a labelled facet patch in a 3-D mesh.
+
+    The 3-D counterpart of :func:`split_along_label`: the fault is a
+    triangulated PATCH of interior faces, its RIM (the boundary edges and
+    vertices of the patch) is the tip rule one dimension up and stays
+    unsplit, and everything strictly inside the rim — vertices, edges, and
+    the faces themselves — is doubled. Slip data must vanish on the rim.
+
+    Where the 2-D rebuild hand-wires edge cones, this one builds the
+    substituted cells UNINTERPOLATED (vertex 4-tuples carry no orientation)
+    and lets ``DMPlexInterpolate`` derive faces and edges — cell and vertex
+    numbering are preserved, and every old face or edge is recovered in the
+    new chart by joining its (mapped) vertex tuple. A tuple that no longer
+    joins was re-homed onto replicas; its replacement is found by collapsing
+    replicas back to originals, exactly the 2-D fresh-facet rule.
+
+    COLLECTIVE. Refusals beyond the 2-D list: a non-manifold or pinched or
+    non-orientable patch; a patch so coarse that a fault face has no
+    interior vertex (its two copies would be the same vertex triple — the
+    3-D analogue of the single-facet chain); and ANY contact between the
+    patch's cell star and the partition seam — :func:`split_fault`
+    redistributes the star onto one rank so the managed path never sees
+    the refusal, exactly as in 2-D.
+
+    Parameters and returns match :func:`split_along_label`, with
+    ``orientation`` a reference NORMAL vector (Plus is the side it points
+    into) rather than a chain direction.
+    """
+    if dm.getDimension() != 3:
+        raise NotImplementedError(
+            "split_along_label_3d handles 3-D meshes; use split_along_label "
+            "for a 2-D facet chain.")
+
+    pStart, pEnd = dm.getChart()
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    fS, fE = dm.getHeightStratum(1)
+    eS, eE = dm.getDepthStratum(1)
+    X = _coords(dm)
+    nc, nv = cE - cS, vE - vS
+
+    fault_faces = []
+    # hasLabel + stratum-size guards for the petsc4py NULL-wrapper aborts,
+    # exactly as in the 2-D path.
+    if dm.hasLabel(name) and dm.getLabel(name).getStratumSize(int(value)) > 0:
+        stratum = dm.getLabel(name).getStratumIS(int(value))
+        fault_faces = [int(p) for p in stratum.getIndices()
+                       if fS <= int(p) < fE]
+    fault_face_set = set(fault_faces)
+
+    shared = _shared_points(dm)
+
+    cell_verts = np.empty((nc, 4), dtype=np.int64)
+    for c in range(cS, cE):
+        closure, _ = dm.getTransitiveClosure(c)
+        cell_verts[c - cS] = [int(p) for p in closure if vS <= int(p) < vE]
+
+    problem = None
+    interior_verts, interior_edges, rim_verts = set(), [], set()
+    face_verts, oriented, substitutions = {}, {}, {}
+    if fault_faces:
+        (face_verts, edge_faces, _rim_edges, interior_edges, rim_verts,
+         interior_verts, problem) = _patch_faces_and_edges(dm, fault_faces)
+
+        # v1 seam rule, deliberately the most conservative one: the whole
+        # cell star of the patch must be rank-interior. split_fault's
+        # redistribution satisfies it on the managed path; a direct call
+        # on a seam-touching patch is refused.
+        #
+        # Diagnosed FIRST, before any check that interprets this rank's
+        # patch topology: a rank holding only a ghost FRAGMENT of the
+        # patch sees the fragment's edge as "rim", its faces as
+        # support-1, its interior as empty — every later check would
+        # mis-fire with a misleading message where the true verdict is
+        # the seam. (The union rim | interior used here is
+        # fragment-correct even though the classification is not.)
+        if problem is None and bool(shared.any()):
+            patch_verts = rim_verts | interior_verts
+            for i, tet in enumerate(cell_verts):
+                if not (set(int(t) for t in tet) & patch_verts):
+                    continue
+                closure, _ = dm.getTransitiveClosure(cS + i)
+                if shared[np.asarray(closure, dtype=np.int64)
+                          - pStart].any():
+                    problem = (RuntimeError,
+                               "fault_split: the fault patch's cell star "
+                               "touches the partition seam. 3-D faults must "
+                               "be rank-interior in this version — "
+                               "partition around the fault.")
+                    break
+
+        if problem is None and any(
+                dm.getSupportSize(f) != 2 for f in fault_faces):
+            problem = (ValueError,
+                       "fault_split: a fault face lies on the domain "
+                       "boundary — the patch rim must be strictly interior.")
+
+        if problem is None:
+            patch_verts = rim_verts | interior_verts
+            boundary_verts = set()
+            for f in range(fS, fE):
+                if dm.getSupportSize(f) == 1 and not shared[f - pStart]:
+                    boundary_verts.update(
+                        int(p) for p in dm.getTransitiveClosure(f)[0]
+                        if vS <= int(p) < vE)
+            if patch_verts & boundary_verts:
+                problem = (ValueError,
+                           "fault_split: the patch touches the domain "
+                           "boundary. A fault that daylights is not yet "
+                           "supported — keep the rim strictly interior.")
+
+        if problem is None and any(
+                not (set(face_verts[f]) & interior_verts)
+                for f in fault_faces):
+            problem = (ValueError,
+                       "fault_split: a fault face has no interior vertex, "
+                       "so its two copies would carry the same vertex "
+                       "triple. The patch is too coarse to split — refine "
+                       "it until every face reaches inside the rim.")
+
+        if problem is None:
+            oriented, problem = _orient_patch(face_verts, edge_faces, X, vS,
+                                              orientation=orientation)
+
+        side_of_cell = {}
+        if problem is None:
+            side_of_cell, substitutions, problem = _take_sides_3d(
+                dm, oriented, face_verts, cell_verts, interior_verts,
+                fault_face_set, X, vS, cS)
+
+        if problem is None:
+            for f in fault_faces:
+                sides = sorted(side_of_cell.get(int(q), 0)
+                               for q in dm.getSupport(f))
+                if sides != [-1, 1]:
+                    problem = (ValueError,
+                               "fault_split: the two cells of a fault face "
+                               "were not classified onto opposite sides — "
+                               "the side assignment is inconsistent across "
+                               "the patch.")
+                    break
+
+    # One synchronisation point for every refusal — the 2-D contract.
+    if uw.mpi.size > 1:
+        gathered = uw.mpi.comm.allgather((problem, len(fault_faces)))
+        problems = [p for p, _m in gathered if p is not None]
+        seam = [p for p in problems if p[0] is RuntimeError]
+        problem = seam[0] if seam else (problems[0] if problems else None)
+        if problem is None and sum(m for _p, m in gathered) == 0:
+            problem = (ValueError,
+                       f"fault_split: no faces carry label {name!r} value "
+                       f"{value} on any rank.")
+    elif problem is None and not fault_faces:
+        problem = (ValueError,
+                   f"fault_split: no faces carry label {name!r} value "
+                   f"{value}.")
+    if problem is not None:
+        exc, message = problem
+        raise exc(message)
+
+    # ----------------------------------------------------------- the rebuild
+    interior_sorted = sorted(interior_verts)
+    replica_index = {v: i for i, v in enumerate(interior_sorted)}
+    k = len(interior_sorted)
+
+    def v_uninterp(t, subs):
+        if t in subs:
+            return nc + nv + replica_index[t]
+        return nc + (t - vS)
+
+    new = PETSc.DMPlex().create(comm=dm.comm)
+    new.setDimension(3)
+    new.setChart(0, nc + nv + k)
+    for i in range(nc):
+        new.setConeSize(i, 4)
+    new.setUp()
+    empty = frozenset()
+    for c in range(cS, cE):
+        subs = substitutions.get(c, empty)
+        new.setCone(c - cS, [v_uninterp(int(t), subs)
+                             for t in cell_verts[c - cS]])
+    new.symmetrize()
+    new.stratify()
+    new.interpolate()
+
+    vS2, vE2 = new.getDepthStratum(0)
+    if (new.getHeightStratum(0) != (0, nc)
+            or (vS2, vE2) != (nc, nc + nv + k)):
+        raise RuntimeError(
+            "fault_split internal: DMPlexInterpolate moved the cell or "
+            "vertex numbering — the point-map arithmetic below relies on "
+            "both being preserved.")
+
+    source_rows = np.concatenate([
+        np.arange(nv, dtype=np.int64),
+        np.asarray(interior_sorted, dtype=np.int64) - vS]) \
+        if k else np.arange(nv, dtype=np.int64)
+    _write_coordinates(new, dm, (vS2, vE2), source_rows)
+
+    point_map = np.full(pEnd - pStart, -1, dtype=np.int64)
+    point_map[np.arange(cS, cE) - pStart] = np.arange(nc)
+    point_map[np.arange(vS, vE) - pStart] = vS2 + np.arange(nv)
+
+    def v_new(t):
+        return int(vS2 + (t - vS))
+
+    def replica_new(t):
+        return int(vS2 + nv + replica_index[t])
+
+    clone_map = {replica_new(v): v for v in interior_sorted}
+
+    # Every old face and edge is recovered by joining its vertex tuple in the
+    # new chart: found directly, it survived (Plus side keeps the original
+    # vertices); found only after replica substitution, it was re-homed onto
+    # the Minus side. The doubled points — fault faces and interior patch
+    # edges — are found BOTH ways: the original maps, the substituted copy
+    # clones. The split invents no connectivity, so a tuple found neither
+    # way is a wiring bug, raised.
+    interior_edge_set = set(interior_edges)
+    minus_faces = []
+    for p, tuple_size in ((slice(fS, fE), 3), (slice(eS, eE), 2)):
+        for q in range(p.start, p.stop):
+            closure, _ = dm.getTransitiveClosure(q)
+            verts = [int(t) for t in closure if vS <= int(t) < vE]
+            direct = new.getFullJoin([v_new(t) for t in verts])
+            doubled = (q in fault_face_set) or (q in interior_edge_set)
+            if len(direct) == 1:
+                point_map[q - pStart] = int(direct[0])
+            subs_tuple = [replica_new(t) if t in replica_index else v_new(t)
+                          for t in verts]
+            if doubled or len(direct) != 1:
+                rehomed = new.getFullJoin(subs_tuple)
+                if len(rehomed) != 1:
+                    raise RuntimeError(
+                        "fault_split internal: an old point joins to "
+                        f"{len(direct)} direct and {len(rehomed)} "
+                        "substituted points in the new chart.")
+                clone_map[int(rehomed[0])] = q
+                if q in fault_face_set:
+                    minus_faces.append(int(rehomed[0]))
+
+    _copy_labels(new, dm, point_map)
+    _clone_labels(new, dm, clone_map)
+
+    new.createLabel(plus_name)
+    plus = new.getLabel(plus_name)
+    for f in fault_faces:
+        plus.setValue(int(point_map[f - pStart]), int(plus_value))
+    new.createLabel(minus_name)
+    minus = new.getLabel(minus_name)
+    for f in minus_faces:
+        minus.setValue(int(f), int(minus_value))
+
+    if uw.mpi.size > 1:
+        # The seam rule above guarantees every shared point is far from
+        # the patch, so the leaf set carries over by renumbering alone —
+        # the same argument as the 2-D splitter.
+        _rebuild_point_sf(new, dm, point_map, new.getChart()[1])
+
+    if verbose and fault_faces:
+        uw.pprint(f"[fault_split {name!r}] duplicated {k} vertices, "
+                  f"{len(interior_edges)} edges and {len(fault_faces)} "
+                  f"faces of the patch; sides are {plus_name!r} / "
+                  f"{minus_name!r}")
+    return new, point_map, clone_map
+
+
+def add_fault(mesh, faults, verbose=False):
+    """Cut AND split one or more faults into a mesh; return the split Mesh.
+
+    The one-call form of the split-node pipeline: for each fault, the tips
+    are placed onto mesh vertices, the mesh is cut so the fault becomes a
+    conforming facet chain, and the chain is split into a genuine
+    discontinuity with boundaries ``<name>Plus`` / ``<name>Minus`` and the
+    coincident DOF pairing recorded. Slip conditions then go through
+    ``solver.add_fault_bc(conds, name)`` and an ordinary ``solve()``.
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh to fault — typically an adapted child already refined
+        toward the fault. Not modified; the fault position stays a design
+        variable (re-call on the base when it moves).
+    faults : Surface, (name, points), or a sequence of either
+        Each fault is a single open polyline with both tips strictly inside
+        the domain. A sequence is a NETWORK: every fault is cut first, then
+        every fault is split, so disjoint (offset-junction) networks work in
+        one call. Segments must not share vertices — represent a branch or
+        crossing as offset segments (a ligament of one or two local cell
+        sizes), the J0 pattern of the deployment design.
+    verbose : bool, optional
+        Report each cut and split.
+
+    Returns
+    -------
+    Mesh
+        The split mesh, carrying every fault's side boundaries and pairing.
+    """
+    from enum import Enum
+
+    from underworld3.discretisation import Mesh
+    from underworld3.meshing.surfaces import (Surface,
+                                              _fault_collect_polylines)
+    from underworld3.utilities.line_cut import (cut_along_lines,
+                                                pull_vertex_onto)
+
+    if isinstance(faults, (Surface, tuple)) or (
+            hasattr(faults, "name") and hasattr(faults, "control_points")):
+        faults = [faults]
+
+    segments = []
+    for entry in faults:
+        if isinstance(entry, tuple) and len(entry) == 2 \
+                and isinstance(entry[0], str):
+            name, points = entry
+            polylines = [np.asarray(points, dtype=float)]
+        else:
+            name = entry.name
+            polylines = [np.array([segs[0][0]] + [b for _a, b in segs])
+                         for segs in _fault_collect_polylines(entry)]
+        if len(polylines) != 1:
+            raise ValueError(
+                f"fault {name!r} holds {len(polylines)} polylines; a fault "
+                "segment is ONE open polyline — pass a sequence of "
+                "single-segment faults for a network.")
+        segments.append((name, polylines[0]))
+
+    # One boundary value per fault, minted with _boundaries_with's rule
+    # (first free ordinary value, stepped past anything taken).
+    members = {b.name: b.value for b in mesh.boundaries}
+    values = {}
+    for name, _poly in segments:
+        if name in members:
+            raise ValueError(
+                f"this mesh already has a boundary called {name!r}.")
+        taken = set(members.values())
+        ordinary = [v for v in taken if v < 666]
+        candidate = (max(ordinary) + 1) if ordinary else 1
+        while candidate in taken:
+            candidate += 1
+        members[name] = values[name] = candidate
+
+    dm = mesh.dm
+    for name, poly in segments:
+        # EVERY control point gets a vertex, not just the tips: an interior
+        # kink is the same problem as a tip — a distinguished point of the
+        # geometry that must coincide with a mesh vertex, or the cut leaves
+        # the chain fragmented at the turn.
+        dm = pull_vertex_onto(dm, np.asarray(poly, dtype=float))
+        dm, info = cut_along_lines(dm, [poly], label=name,
+                                   label_value=values[name])
+        if verbose:
+            uw.pprint(f"[add_fault {name!r}] {info['n_cut_edges']} facets, "
+                      f"min angle {info['min_angle']:.2f} deg")
+
+    # In parallel the balanced partition's cuts are attracted to the refined
+    # fault band, so a cut chain generally touches the seam. Redistribute
+    # ONCE, keyed on EVERY fault's facets together, BEFORE any split: each
+    # fault's cell star (plus one growth layer) moves to the rank that
+    # already owns most of the union, the chains become rank-interior, and
+    # the splits below run with serial topology. Doing it here rather than
+    # per split also keeps a network's prior pairings valid — a pairing
+    # cannot yet migrate through a redistribution, so split_fault refuses
+    # exactly the per-split case this pre-pass avoids.
+    if uw.mpi.size > 1 and dm.getDimension() == 2:
+        labels = [(name, values[name]) for name, _poly in segments]
+        if _fault_labels_touch_seam(dm, labels):
+            dm = _redistribute_fault_interior(dm, labels, verbose=verbose)
+
+    cut = Mesh(dm, simplex=mesh.dm.isSimplex(),
+               coordinate_system_type=mesh.CoordinateSystem.coordinate_type,
+               qdegree=mesh.qdegree,
+               boundaries=Enum("boundaries", members), verbose=False)
+    cut.parent = mesh
+    cut._relationship_kind = "refinement"
+    cut._refine_dofs_coincide = False
+    cut.regions = mesh.regions
+    cut._parent_mesh_version = mesh._mesh_version
+    mesh._registered_children.add(cut)
+
+    out = cut
+    for name, poly in segments:
+        out = split_fault(out, name, orientation=poly[-1] - poly[0],
+                          verbose=verbose)
+    # the traces themselves, for trace-smoothed fault normals
+    # (add_fault_bc(..., normal="trace")) and for rendering overlays;
+    # Surface OBJECTS ride along too, so normal="surface" spells the
+    # same thing in 2-D as it does for a 3-D FaultSurface
+    out._fault_traces = {name: np.array(poly, dtype=float)
+                         for name, poly in segments}
+    surfaces = {entry.name: entry for entry in faults
+                if hasattr(entry, "control_points")
+                and hasattr(entry, "name")}
+    if surfaces:
+        out._fault_surfaces = surfaces
+    return out
+
+
+def _boundaries_with_sides(mesh, name):
+    """The mesh's boundary enum extended with ``<name>Plus`` / ``<name>Minus``.
+
+    The value-minting rule is :meth:`Mesh._boundaries_with`'s — first free
+    value past the largest ordinary boundary, stepped past anything taken so
+    the sentinels 666/1001 can never be landed on — applied twice, since that
+    method can only add one member per constructed mesh.
+    """
+    from enum import Enum
+
+    members = {b.name: b.value for b in mesh.boundaries}
+    if name not in members:
+        raise ValueError(
+            f"this mesh has no boundary called {name!r}; add the surface with "
+            "add_conforming_surface first, then split it.")
+    for side in (f"{name}Plus", f"{name}Minus"):
+        if side in members:
+            raise ValueError(
+                f"this mesh already has a boundary called {side!r}; the fault "
+                "appears to have been split already.")
+        taken = set(members.values())
+        ordinary = [v for v in taken if v < 666]
+        candidate = (max(ordinary) + 1) if ordinary else 1
+        while candidate in taken:
+            candidate += 1
+        members[side] = candidate
+    return Enum("boundaries", members)
+
+
+def _fault_labels_touch_seam(dm, labels):
+    """Does any labelled fault facet reach the partition seam? COLLECTIVE.
+
+    ``labels`` is a sequence of ``(name, value)`` pairs. The test matches
+    the 2-D split's refusal exactly: a fault facet that is itself shared,
+    or has a shared cone vertex, would put a chain vertex on the seam —
+    the configuration :func:`_redistribute_fault_interior` exists to
+    dissolve. Every rank returns the same verdict (allreduce), so the
+    caller's redistribute-or-not decision is collective by construction.
+    """
+    if uw.mpi.size == 1:
+        return False
+    shared = _shared_points(dm)
+    pStart, _pEnd = dm.getChart()
+    fS, fE = dm.getHeightStratum(1)
+    touch = False
+    for name, value in labels:
+        if touch:
+            break
+        if not (dm.hasLabel(name)
+                and dm.getLabel(name).getStratumSize(int(value)) > 0):
+            continue
+        for f in dm.getLabel(name).getStratumIS(int(value)).getIndices():
+            f = int(f)
+            if not (fS <= f < fE):
+                continue
+            if shared[f - pStart] or any(
+                    shared[int(q) - pStart] for q in dm.getCone(f)):
+                touch = True
+                break
+    return bool(uw.mpi.comm.allreduce(touch, op=MPI.LOR))
+
+
+def _redistribute_fault_interior(dm, labels, verbose=False):
+    """Redistribute a cut mesh so each fault's cell star is rank-interior.
+
+    The default partition's balance cuts are ATTRACTED to the locally
+    refined fault region, so at any np >= 2 a graded fault mesh
+    essentially always violates the split's rank-interior requirement
+    (in 2-D the chain, in 3-D the patch). This reassigns ONLY the
+    fault-star cells (cells incident to any fault vertex — a layer
+    about two cells thick) to the single rank that already owns most
+    of them; every other cell stays where the load-balanced partition
+    put it, and the move is applied with a shell partitioner. The star
+    is thin, so the imbalance cost is bounded by its size — NOT by the
+    refined band — and the split's seam rule then holds by
+    construction. The coincident pair blocks of the contact solve are
+    rank-local for the same reason. ``labels`` is a sequence of
+    ``(name, value)`` pairs — a NETWORK is redistributed in one move,
+    keyed on the union of its faults, which is what lets every split
+    that follows run without migrating any prior pairing. Returns a
+    NEW dm; the input is untouched.
+    """
+    comm = dm.getComm().tompi4py()
+    if comm.size == 1:
+        return dm
+
+    work = dm.clone()
+    cS, cE = work.getHeightStratum(0)
+    fS, fE = work.getHeightStratum(1)
+    vS, vE = work.getDepthStratum(0)
+    _pS, pEnd = work.getChart()
+    sf = work.getPointSF()
+
+    def propagate(mark):
+        # global OR of a chart-length mark across the point SF: remote
+        # copies fold into the owner, the owner's verdict returns to
+        # every copy — after this, every rank agrees on every point it
+        # can see. (A cell can touch a patch vertex without holding any
+        # labelled face in its own closure, so purely local label
+        # reading under-marks near the current seam.)
+        tmp = mark.copy()
+        sf.reduceBegin(MPI.INT32_T, tmp, mark, MPI.MAX)
+        sf.reduceEnd(MPI.INT32_T, tmp, mark, MPI.MAX)
+        out = mark.copy()
+        sf.bcastBegin(MPI.INT32_T, mark, out, MPI.REPLACE)
+        sf.bcastEnd(MPI.INT32_T, mark, out, MPI.REPLACE)
+        return np.maximum(mark, out)
+
+    def star_of_marked(mark):
+        cells = set()
+        for v in range(vS, vE):
+            if mark[v]:
+                for q in work.getTransitiveClosure(v, useCone=False)[0]:
+                    if cS <= int(q) < cE:
+                        cells.add(int(q))
+        return cells
+
+    # fault vertices (of every fault in the batch), marked globally
+    mark = np.zeros(pEnd, dtype=np.int32)
+    for name, value in labels:
+        if work.hasLabel(name) and \
+                work.getLabel(name).getStratumSize(int(value)) > 0:
+            for f in work.getLabel(name).getStratumIS(
+                    int(value)).getIndices():
+                if fS <= int(f) < fE:
+                    for q in work.getTransitiveClosure(int(f))[0]:
+                        if vS <= int(q) < vE:
+                            mark[int(q)] = 1
+    mark = propagate(mark)
+    star = star_of_marked(mark)
+
+    # one growth layer: the split's seam rule needs every point in the
+    # CLOSURE of a patch-vertex-star cell unshared, and a point is
+    # unshared exactly when all its incident cells are co-resident —
+    # so gather every cell touching any vertex of the star cells'
+    # closures. One layer is exactly sufficient (each such point's
+    # incident cells all touch a marked-closure vertex).
+    mark2 = np.zeros(pEnd, dtype=np.int32)
+    for c in star:
+        for q in work.getTransitiveClosure(c)[0]:
+            if vS <= int(q) < vE:
+                mark2[int(q)] = 1
+    mark2 = propagate(mark2)
+    star |= star_of_marked(mark2)
+
+    counts = np.asarray(comm.allgather(len(star)))
+    if counts.sum() == 0:
+        names = sorted(name for name, _value in labels)
+        raise RuntimeError(
+            f"fault_split: no facets labelled {names} found on any rank.")
+    target = int(np.argmax(counts))
+
+    n_local = cE - cS
+    assign = np.full(n_local, comm.rank, dtype=np.int32)
+    for c in star:
+        assign[c - cS] = target
+    order = np.argsort(assign, kind="stable").astype(np.int32)
+    sizes = np.bincount(assign, minlength=comm.size).astype(np.int32)
+
+    part = work.getPartitioner()
+    part.setType(PETSc.Partitioner.Type.SHELL)
+    part.setShellPartition(comm.size, sizes=sizes, points=order)
+    work.distribute()
+    if verbose:
+        names = sorted(name for name, _value in labels)
+        uw.pprint(f"[fault_split] {names}: star of "
+                  f"{int(counts.sum())} cells gathered onto rank "
+                  f"{target}; local cells now "
+                  f"{work.getHeightStratum(0)[1]}")
+    return work
+
+
+def split_fault(mesh, name, orientation=None, verbose=False):
+    """Split the nodes along the conforming surface ``name``; return the mesh.
+
+    The result is a new, standalone :class:`Mesh` on which every continuous FE
+    space is discontinuous across the fault: the surface's facets are doubled
+    into boundaries ``<name>Plus`` and ``<name>Minus`` (coincident, no shared
+    DOFs except the tips — the two chain endpoints in 2-D, the patch rim in
+    3-D), and slip is prescribed with ordinary essential conditions on those
+    two names. A slip datum must taper to zero at the tips/rim, which stay
+    single points shared by both sides.
+
+    The source mesh is untouched, and the operation is re-applicable: when the
+    fault moves, re-cut the base mesh at the new position and split again —
+    the same non-cumulative pattern as :meth:`Mesh.adapt`.
+
+    The split mesh carries NO geometric-multigrid tail. The coarse levels do
+    not carry the fault, so an essential condition on it would constrain zero
+    coarse DOFs and leave the custom-P coarse operator singular (see the
+    warning on :meth:`Mesh.add_conforming_surface`); solvers on this mesh get
+    their algebraic-multigrid defaults instead.
+
+    Parameters
+    ----------
+    mesh : Mesh
+        A mesh carrying the surface as a labelled facet chain — normally the
+        child returned by :meth:`Mesh.add_conforming_surface`.
+    name : str
+        The surface's boundary name.
+    verbose : bool, optional
+        Report what was duplicated.
+
+    Returns
+    -------
+    Mesh
+        The split mesh, with ``mesh`` recorded as its parent.
+    """
+    from underworld3.discretisation import Mesh
+
+    boundaries = _boundaries_with_sides(mesh, name)
+    plus_name, minus_name = f"{name}Plus", f"{name}Minus"
+    source_dm = mesh.dm
+    if uw.mpi.size > 1:
+        labels = [(name, int(mesh.boundaries[name].value))]
+        # The split requires the fault's cell star rank-interior, and
+        # balance cuts are attracted to the refined fault region — gather
+        # the (thin) star onto one rank first. 3-D always redistributes
+        # (the patch star essentially always straddles the seam on a
+        # graded mesh); 2-D redistributes only when the chain actually
+        # touches the seam, which is what lets add_fault's one-shot
+        # union redistribution make every subsequent per-fault split a
+        # no-move here. Both branches of the decision are collective.
+        if source_dm.getDimension() == 3 \
+                or _fault_labels_touch_seam(source_dm, labels):
+            if getattr(mesh, "_fault_point_pairs", {}):
+                # a prior fault's pairing holds point ids of the CURRENT
+                # distribution; redistribution renumbers every point, so
+                # carrying it through needs pairing migration along the
+                # migration SF — not built yet. Refuse loudly (and
+                # identically on every rank: the pairing dict and the
+                # seam verdict agree across ranks by construction).
+                raise NotImplementedError(
+                    "fault_split: multi-fault networks in parallel need "
+                    "pairing migration through the redistribution — pass "
+                    "the whole network to ONE add_fault call (2-D), or "
+                    "split the network in serial.")
+            source_dm = _redistribute_fault_interior(
+                source_dm, labels, verbose=verbose)
+    pStart, _pEnd = source_dm.getChart()
+    splitter = (split_along_label if source_dm.getDimension() == 2
+                else split_along_label_3d)
+    new_dm, point_map, clone_map = splitter(
+        source_dm, name, int(mesh.boundaries[name].value),
+        plus_name, int(boundaries[plus_name].value),
+        minus_name, int(boundaries[minus_name].value),
+        orientation=orientation, verbose=verbose)
+
+    child = Mesh(
+        new_dm,
+        simplex=mesh.dm.isSimplex(),
+        coordinate_system_type=mesh.CoordinateSystem.coordinate_type,
+        qdegree=mesh.qdegree,
+        boundaries=boundaries,
+        verbose=False,
+    )
+    child.parent = mesh
+    child._relationship_kind = "refinement"
+    # Replica vertices are coincident with their originals, so a coincidence-
+    # based injection would read one side of the jump for both — the transfer
+    # must stay geometric.
+    child._refine_dofs_coincide = False
+    # geometry objects ride along so add_fault_bc can source the
+    # constraint frame from them (normal="trace" / normal="surface")
+    if getattr(mesh, "_fault_traces", None):
+        child._fault_traces = dict(mesh._fault_traces)
+    if getattr(mesh, "_fault_surfaces", None):
+        child._fault_surfaces = dict(mesh._fault_surfaces)
+    child.regions = mesh.regions
+    child._parent_mesh_version = mesh._mesh_version
+    # The Minus->Plus point pairing in the SPLIT mesh's numbering, for every
+    # replica whose original SURVIVED — the duplicated vertices and the
+    # doubled fault facets (the P2 midpoint DOFs live on the latter). Fresh
+    # minus-side SPOKE facets are excluded: their originals were dropped
+    # (point_map -1), because a re-homed spoke is the same geometric edge
+    # renumbered, not a coincident copy. This dict is the ONLY source of the
+    # pairing — the sides are geometrically coincident, so no coordinate
+    # query can ever recover it — and it is what a fault interface condition
+    # (slip constraint, friction) pairs degrees of freedom with.
+    #
+    # Splitting renumbers the whole chart, so PRIOR faults' pairings are
+    # carried through point_map rather than copied verbatim — copied ids
+    # would silently index the wrong points on the new mesh. A prior fault's
+    # points always survive this split (only this fault's minus spokes are
+    # re-homed), asserted rather than assumed.
+    child._fault_point_pairs = {}
+    for prior, pairs in getattr(mesh, "_fault_point_pairs", {}).items():
+        remapped = {int(point_map[qm - pStart]): int(point_map[qp - pStart])
+                    for qm, qp in pairs.items()}
+        if any(q < 0 for kv in remapped.items() for q in kv):
+            raise RuntimeError(
+                f"fault_split internal: splitting {name!r} dropped a point "
+                f"of the prior fault {prior!r}'s pairing — the faults are "
+                "not disjoint.")
+        child._fault_point_pairs[prior] = remapped
+    child._fault_point_pairs[name] = {
+        int(q_minus): int(point_map[old_pt - pStart])
+        for q_minus, old_pt in clone_map.items()
+        if point_map[old_pt - pStart] >= 0}
+    mesh._registered_children.add(child)
+    return child
diff --git a/src/underworld3/utilities/line_cut.py b/src/underworld3/utilities/line_cut.py
new file mode 100644
index 000000000..ece69a6e5
--- /dev/null
+++ b/src/underworld3/utilities/line_cut.py
@@ -0,0 +1,893 @@
+"""Make a line a chain of mesh edges, on a mesh that already exists.
+
+A weak zone whose boundary runs *through* elements cannot be represented by a
+linear element: inside such an element the discrete stress is the interpolated
+viscosity times the interpolated strain rate, whose cell average differs from the
+honest one by
+
+.. math::  -2\\,\\mathrm{Cov}(\\eta, \\dot\\varepsilon)
+
+per cell. That covariance is zero for any element lying wholly inside or wholly
+outside the zone and positive only for elements that **straddle** it, so the
+artefact is not a resolution problem — refining shrinks the straddling band but
+never empties it. The cure is to stop straddling: split each edge the line crosses
+**at the crossing point**, so the line becomes a chain of element edges and every
+element lies cleanly on one side.
+
+The point of doing this *on top of* an existing mesh, rather than building the
+line into the mesh generator, is that the line's position may be a design variable
+in an outer optimisation: the base mesh — and the multigrid hierarchy resting on
+it — has to stay fixed while the line moves. Nothing here modifies the mesh it is
+given; the cut is a new mesh.
+
+Mechanism
+---------
+No new topology code is needed. The ``uwnvb_bisect`` transform inserts a vertex on
+every marked edge, and for a triangle carrying **two** marks it emits the segment
+joining the two inserted vertices — which is exactly the cut. A triangle carrying
+one mark emits the segment from the inserted vertex to the **opposite** vertex,
+which is the cut for a triangle the line enters through an edge and leaves through
+a corner. Marking every crossed edge and applying the transform once therefore
+produces the whole chain. The transform places each new vertex at the edge
+midpoint; moving it to the true crossing is a coordinate write, and the topology
+does not care.
+
+Snap or cut
+-----------
+A crossing landing close to an existing vertex leaves a sliver — in the worst case
+measured here, a cell of area 1e-24 and a zero interior angle. So a crossing
+within ``snap_frac`` of an edge's end, *measured along that edge*, moves the
+vertex onto the line instead of splitting beside it (in the cut mesh; the mesh
+passed in is untouched).
+
+The along-edge measure is the one that matters: it is exactly the short side of
+the sliver that would otherwise be created, and unlike an absolute distance it
+carries no length scale, so the same tolerance works on any mesh. Note this is a
+*discrete* switch — as a line sweeps across the mesh the topology changes in
+jumps, which anything optimising over the line's position has to live with.
+:func:`sliver_report` measures what a given tolerance buys.
+
+Cutting without snapping costs about 60 % more iterations of an algebraic solver
+on the slivers it leaves behind, and snapping buys that back — which is where the
+0.10 default comes from. A Lawson flip pass
+(:func:`~underworld3.utilities.reconnect.flip_to_reduce_max_angle`, which locks
+the cut automatically because :data:`CUT_LABEL` is an edge label) helps less, so
+raising the snap fraction is the better lever and repair is a second-order
+touch-up rather than a requirement. The measurements behind all of that are in
+``docs/developer/subsystems/conforming-surfaces-and-fault-zones.md``.
+
+Scope
+-----
+Two dimensions, and lines that cross the mesh from boundary to boundary. A line
+*ending* inside the mesh (a fault tip) leaves a triangle the line enters but does
+not leave, which bisects without cutting; that is refused rather than silently
+mis-meshed, as are triangles crossed three times.
+
+Parallel
+--------
+Two rules hold everywhere in this module, and both are load-bearing rather than
+defensive.
+
+**Every refusal is global.** A rank-local ``raise`` aborts one rank while its
+peers walk on into the next collective and block there, so what should be a clear
+error message becomes a hang. Every condition tested here is a property of one
+rank's cells, so each is reduced *before* it is tested: either every rank raises
+or none does. The happy path is not evidence — a parallel test that never takes an
+error path cannot see this class of defect at all, and nine of them have been
+found this way so far. np=1 and np=2 both pass every one; np=3 is what exposes
+them.
+
+**Every tolerance is built from a GLOBAL length.** The cut is partition
+independent because each quantity is a pure function of the coordinates and the
+line, so every rank holding a shared edge computes the same crossing — which is
+what ``uwnvb_bisect`` needs to keep the child point star-forest conforming. A
+rank-local coordinate extent is not that: it varies with the partition (measured
+0.58-0.67 against 1.0 in serial), and it raises outright on a rank owning no
+vertices. :func:`_global_extent` is the one source of that number.
+"""
+
+import numpy as np
+from mpi4py import MPI
+from petsc4py import PETSc
+
+import underworld3 as uw
+from underworld3.utilities.edge_split import (_independent_edges, _owned_count,
+                                              _sf_logical_or)
+
+_BISECT_LABEL = "uwnvb_bisect_edges"
+
+#: Default name for the label marking the mesh edges along a cut. Callers adding a
+#: NAMED surface pass their own name instead, so the label doubles as the boundary
+#: label a solver applies conditions on. Downstream passes read whatever it is
+#: called: ``relax(pin_bands=...)`` holds it, and the reconnection pass refuses to
+#: flip across it (it locks every non-topology EDGE label).
+CUT_LABEL = "uw_cut_edges"
+
+
+def _edge_vertices(dm):
+    """(n_edges, 2) local vertex indices of every edge, in cone order."""
+    vS, _vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    return np.array([dm.getCone(e) for e in range(eS, eE)], dtype=np.int64) - vS
+
+
+def _coords(dm):
+    return np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dm.getCoordinateDim())
+
+
+def _global_extent(dm):
+    """Longest side of the mesh's bounding box, reduced over every rank.
+
+    COLLECTIVE. Every tolerance in this module is a fraction of this length, and
+    the module's central invariant is that the crossings are a pure function of
+    the coordinates and the line — so the length has to be the same number on
+    every rank. A local ``np.ptp`` is not: it measures this rank's piece of the
+    mesh, which spread 0.58-0.67 against 1.0 in serial on a three-way partition,
+    and it raises on a rank owning no vertices, which is where the small coarse
+    levels of a cut hierarchy end up.
+
+    Reduced as a bounding BOX rather than as each rank's own longest side: the
+    maximum of local extents is not the extent of the union.
+    """
+    cdim = dm.getCoordinateDim()
+    X = _coords(dm)
+    # Pack as [lo, -hi] so one MIN reduction serves both ends. An empty rank
+    # contributes the identity, +inf, and must still take part in the reduce.
+    box = (np.concatenate([X.min(axis=0), -X.max(axis=0)]) if len(X)
+           else np.full(2 * cdim, np.inf))
+    uw.mpi.comm.Allreduce(MPI.IN_PLACE, box, op=MPI.MIN)
+    return float((-box[cdim:] - box[:cdim]).max())
+
+
+def _segments(lines):
+    """Every (A, B) segment of every polyline."""
+    for pts in lines:
+        pts = np.asarray(pts, dtype=float)[:, :2]
+        for A, B in zip(pts[:-1], pts[1:]):
+            if np.any(B != A):
+                yield A, B
+
+
+def _distance_to_lines(X, lines):
+    """Distance from each point to the nearest point of the polylines.
+
+    Measured to the *segments*, not to their infinite extensions, so a line stops
+    attracting vertices beyond its own end.
+    """
+    best = np.full(len(X), np.inf)
+    for A, B in _segments(lines):
+        d = B - A
+        u = np.clip(((X - A) @ d) / (d @ d), 0.0, 1.0)
+        best = np.minimum(best, np.linalg.norm(X - (A + u[:, None] * d), axis=1))
+    return best
+
+
+def _project_onto_lines(X, lines):
+    """The nearest point of the polylines to each point."""
+    best = np.full(len(X), np.inf)
+    out = X.copy()
+    for A, B in _segments(lines):
+        d = B - A
+        u = np.clip(((X - A) @ d) / (d @ d), 0.0, 1.0)
+        foot = A + u[:, None] * d
+        dist = np.linalg.norm(X - foot, axis=1)
+        closer = dist < best
+        best = np.where(closer, dist, best)
+        out[closer] = foot[closer]
+    return out
+
+
+def _crossing_parameters(X, ends, lines, on_line):
+    """Parameter along each edge where a line crosses it.
+
+    ``NaN`` where the edge is not crossed. An edge with an endpoint already on a
+    line is never counted: the line meets it at that vertex, and splitting it as
+    well would put two cut vertices a hair apart.
+
+    Every quantity here is a function of the coordinates and the line alone, so
+    every rank holding a shared edge computes the same crossing. That is what
+    makes the cut partition-independent, and what ``uwnvb_bisect`` needs to keep
+    the child point star-forest conforming.
+    """
+    P, Q = X[ends[:, 0]], X[ends[:, 1]]
+    touches = on_line[ends[:, 0]] | on_line[ends[:, 1]]
+
+    t = np.full(len(P), np.nan)
+    multiply_crossed = np.zeros(len(P), dtype=bool)
+    for A, B in _segments(lines):
+        d = B - A
+        nrm = np.array([-d[1], d[0]])
+        sP, sQ = (P - A) @ nrm, (Q - A) @ nrm
+        straddles = (sP * sQ < 0.0) & ~touches
+
+        with np.errstate(invalid="ignore", divide="ignore"):
+            tk = np.where(straddles, sP / (sP - sQ), np.nan)
+        # The crossing must lie between A and B, not merely on the infinite line
+        # through them: a polyline is a chain of finite segments.
+        foot = P + tk[:, None] * (Q - P)
+        u = ((foot - A) @ d) / (d @ d)
+        hit = straddles & (u >= 0.0) & (u <= 1.0)
+
+        multiply_crossed |= hit & np.isfinite(t)
+        t = np.where(hit, tk, t)
+    return t, np.flatnonzero(multiply_crossed)
+
+
+def _vertex_h(X, ends):
+    """Mean length of the edges meeting each vertex: the local h AT a vertex."""
+    L = np.linalg.norm(X[ends[:, 0]] - X[ends[:, 1]], axis=1)
+    total = np.zeros(len(X))
+    count = np.zeros(len(X))
+    for k in (0, 1):
+        np.add.at(total, ends[:, k], L)
+        np.add.at(count, ends[:, k], 1.0)
+    return total / np.maximum(count, 1.0)
+
+
+def _resolve_snapping(dm, X, ends, lines, snap_frac, scale, snap_quality=0.5,
+                      snap_dist=0.0):
+    """Which vertices to move onto the line, and where the crossings then land.
+
+    A crossing at parameter ``t`` on an edge sits ``t`` of the way along it, so
+    ``t < snap_frac`` means the split would carve off a sliver whose short side is
+    that fraction of an edge. In that case the edge's endpoint is moved onto the
+    line instead and the edge is left whole.
+
+    Snapping a vertex changes the crossings on every edge that touches it, which
+    can bring a further crossing close to a vertex, so this repeats until the set
+    settles. It settles quickly — each round only ever adds vertices, and the mesh
+    is finite — but the loop is capped rather than trusted.
+
+    The VETO is what lets ``snap_frac`` be large. Without it the tolerance does
+    two jobs at once: it decides which crossings are near enough to snap, and — by
+    having no say in the matter afterwards — how much damage is acceptable. A cell
+    thinner than the tolerance band has every corner pulled onto the line from
+    both sides and is flattened; measured on a graded mesh, every collapsed cell
+    at ``snap_frac=0.4`` had all three corners snapped, and the cut was refused
+    outright. So a proposed move that would drive an incident cell's quality below
+    ``snap_quality`` is rejected, and that crossing falls back to being split —
+    the path that already works. The tolerance then chooses, and the guard vetoes.
+
+    An offending cell vetoes ALL of its moving corners at once rather than
+    searching for the cheapest one to give up. Over-vetoing costs splits, which is
+    the conservative direction, and it makes the outcome independent of the order
+    cells are visited — which a partition would otherwise change.
+
+    The chosen set is reconciled over the point star-forest EVERY round. The
+    decision "this crossing is too close to that end" is read off one edge, and a
+    rank holding only one side of a shared vertex can decide differently from its
+    neighbour. The vertex then moves on one rank and not the other, the two ranks
+    disagree about which edges are crossed, and the caller's split loop never
+    empties its crossing set — measured, at np=3, as a cut that converged at
+    snap_frac=0 and never converged at snap_frac=0.1.
+
+    The veto is reconciled the same way and for a sharper reason: a vertex's
+    incident cells are spread across the ranks that share it, so a rank can hold
+    the ruined cell that another rank cannot see. Vetoes are OR-reduced, so one
+    rank objecting stops the move everywhere.
+    """
+    cell_verts = _cell_vertices(dm)
+    # The floor a cell must not drop below: the absolute one, or its own current
+    # quality if it already sits under that. "Never below the floor, and never
+    # worse if already below it" — which, unlike a floor expressed as a FRACTION
+    # of the current quality, does not compound when this routine is applied
+    # repeatedly. Measured: a relative 0.5 over six refine-and-snap rounds
+    # licenses 0.5**6 of the original, and the worst angle duly fell 15.4 -> 2.3
+    # degrees while every individual round looked well behaved.
+    floor = (None if snap_quality is None else
+             np.minimum(snap_quality, np.abs(_cell_quality(X, cell_verts))))
+    # Vertices ALREADY on the line — a tip or junction placed by
+    # `pull_vertex_onto` — do not move, so they cannot ruin anything and must
+    # never be vetoed. Vetoing one would unplace the very point that makes a
+    # terminating chain legal.
+    fixed = _distance_to_lines(X, lines) < 1e-12 * scale
+    vetoed = np.zeros(len(X), dtype=bool)
+    # Distance from each vertex to the line, in units of the local h. The
+    # along-edge criterion cannot see this: a vertex can sit a fraction of an
+    # element from the line while every edge meeting it is crossed near its
+    # MIDPOINT, so no crossing is ever "close to an end" and nothing proposes it.
+    # The cut then runs past it and leaves a cell with one edge on the surface
+    # and its apex a fraction of h away. Measured: every cell below 15 degrees
+    # had exactly that shape — two corners on the cut, elongated along it, apex
+    # 0.45 W off — and no value of snap_frac touched a single one of them.
+    reach = snap_dist * _vertex_h(X, ends) if snap_dist > 0.0 else None
+    # Seed with the vertices that are ALREADY on the surface, not just the ones
+    # snapping will move. A junction or a tip placed on a vertex lies exactly on
+    # the line, so the edges radiating from it show `s == 0` and register no
+    # strict sign change — nothing proposes them for snapping, and they would be
+    # invisible here. The validation then reads such a cell as "entered but not
+    # left" and refuses a perfectly legal branch: measured on a three-way (Y)
+    # junction, which this makes work.
+    on_line = fixed.copy()
+    vS, _vE = dm.getDepthStratum(0)
+    pStart, pEnd = dm.getChart()
+
+    def reconcile(mask):
+        """OR the mask over every rank sharing each vertex."""
+        flag = np.zeros(pEnd - pStart, dtype=np.int32)
+        flag[np.flatnonzero(mask) + vS - pStart] = 1
+        _sf_logical_or(dm, flag)
+        return flag[np.arange(len(X)) + vS - pStart] == 1
+
+    # Rounds are spent on vetoes as well as on proposals now, and a veto can
+    # re-open a crossing that had settled, so the cap is larger than the ten a
+    # pure proposal loop needed.
+    for _ in range(30):
+        X_snapped = X.copy()
+        if on_line.any():
+            X_snapped[on_line] = _project_onto_lines(X[on_line], lines)
+
+        t, multiply_crossed = _crossing_parameters(X_snapped, ends, lines, on_line)
+        near = np.isfinite(t) & ((t < snap_frac) | (t > 1.0 - snap_frac))
+
+        # The end the crossing is nearest is the one that would form the sliver.
+        rows = np.flatnonzero(near)
+        pick = ends[rows, np.where(t[rows] < 0.5, 0, 1)]
+        proposed = on_line.copy()
+        proposed[pick[~vetoed[pick]]] = True
+        if reach is not None:
+            close = (_distance_to_lines(X, lines) < reach) & ~vetoed
+            proposed |= close
+
+        # COLLECTIVE, so every rank must reach it — including one that proposes
+        # nothing. An early `if not near.any(): return` here deadlocked at np=3:
+        # the rank owning no part of the line walked out while its peers waited
+        # in the reduce.
+        proposed = reconcile(proposed) & ~vetoed
+
+        # Would the proposal ruin a cell? Test it on the fully moved coordinates
+        # rather than one vertex at a time: it is the cell with several corners
+        # coming in from both sides that collapses, and no single move of that set
+        # looks bad on its own.
+        X_try = X.copy()
+        if proposed.any():
+            X_try[proposed] = _project_onto_lines(X[proposed], lines)
+        fresh = np.zeros(len(X), dtype=bool)
+        quality = _cell_quality(X_try, cell_verts)
+        ruined = (np.zeros(len(cell_verts), dtype=bool) if floor is None
+                  else (quality <= 0.0) | (quality < floor))
+        if ruined.any():
+            corners = np.unique(cell_verts[ruined].ravel())
+            fresh[corners[proposed[corners] & ~fixed[corners]]] = True
+        # Reduced whether or not this rank found anything: a rank seeing no
+        # ruined cell still has to reach the exchange, and a vertex whose bad
+        # cell lives on a neighbour must be vetoed here too.
+        fresh = reconcile(fresh)
+        if uw.mpi.comm.allreduce(int(fresh.any()), op=MPI.MAX):
+            vetoed |= fresh
+            continue
+
+        # Settled is a GLOBAL property: one rank still moving means another round
+        # for everyone, or the reconcile above goes unmatched.
+        settled = uw.mpi.comm.allreduce(
+            int(np.array_equal(proposed, on_line)), op=MPI.MIN)
+        if settled:
+            return on_line, X_snapped, t, multiply_crossed
+        on_line = proposed
+
+    raise RuntimeError(
+        "snapping did not settle in 30 rounds; snap_frac is large enough that "
+        "moving one vertex keeps dragging the next crossing into tolerance.")
+
+
+def _cell_vertices(dm):
+    """(n_cells, 3) local vertex indices of every triangle."""
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    return np.array([[int(p) - vS for p in dm.getTransitiveClosure(c)[0]
+                      if vS <= p < vE] for c in range(cS, cE)],
+                    dtype=np.int64).reshape(cE - cS, 3)
+
+
+def _cell_quality(X, cell_verts):
+    """Scale-free triangle quality: 1 equilateral, 0 degenerate, <0 inverted.
+
+    ``4 sqrt(3) A / sum(l^2)``, signed through the area. The sign matters: an
+    inverted cell reports a negative number instead of a small positive one, and
+    a *flattened* cell reports ~0 either way. Testing area > 0 does neither — a
+    cell snapping flat onto the line lands at area 1e-19 of random sign, which
+    passes an inversion test about half the time. Measured: guarding on inversion
+    alone still left a zero interior angle.
+    """
+    P = X[cell_verts]
+    e = np.stack([P[:, 2] - P[:, 1], P[:, 0] - P[:, 2], P[:, 1] - P[:, 0]],
+                 axis=1)
+    twice_area = ((P[:, 1, 0] - P[:, 0, 0]) * (P[:, 2, 1] - P[:, 0, 1])
+                  - (P[:, 1, 1] - P[:, 0, 1]) * (P[:, 2, 0] - P[:, 0, 0]))
+    return 2.0 * np.sqrt(3.0) * twice_area / np.maximum(
+        (e ** 2).sum(axis=(1, 2)), np.finfo(float).tiny)
+
+
+def _cell_edge_counts(dm, crossed_edges, on_line_vertices):
+    """Per cell: how many of its edges are crossed, how many corners are on a line."""
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    pEnd = dm.getChart()[1]
+
+    is_crossed = np.zeros(pEnd, dtype=bool)
+    is_crossed[crossed_edges] = True
+    is_on = np.zeros(pEnd, dtype=bool)
+    is_on[np.flatnonzero(on_line_vertices) + vS] = True
+
+    n_cross = np.zeros(cE - cS, dtype=np.int64)
+    n_corner = np.zeros(cE - cS, dtype=np.int64)
+    for c in range(cS, cE):
+        edges = np.asarray(dm.getCone(c), dtype=np.int64)
+        n_cross[c - cS] = is_crossed[edges].sum()
+        verts = np.array([int(p) for p in dm.getTransitiveClosure(c)[0]
+                          if vS <= p < vE], dtype=np.int64)
+        n_corner[c - cS] = is_on[verts].sum()
+    return n_cross, n_corner
+
+
+def _child_vertex_of(child, positions, scale):
+    """Child vertices nearest the given positions, and how many did not match.
+
+    Parent vertices keep their coordinates through the transform and inserted
+    vertices land on their parent edge's midpoint, so position identifies both.
+    petsc4py does not expose ``DMPlexTransformGetTargetPoint``, so this is the
+    available route, and matching on geometry keeps it independent of the
+    transform's internal point numbering.
+
+    The mismatch COUNT is returned rather than raised on. Raising here would be
+    rank-local, and it would sit inside the caller's rank-local "did this rank
+    split anything?" guard as well — two ways for one rank to leave while its
+    peers wait in the next reduce. The caller reduces the count and raises for
+    everyone. A rank with nothing to look up returns empty and zero, which is a
+    result, not a special case.
+    """
+    if not len(positions):
+        return np.empty(0, dtype=np.int64), 0
+
+    Xc = _coords(child)
+    vS, vE = child.getDepthStratum(0)
+    tree = uw.kdtree.KDTree(np.ascontiguousarray(Xc[: vE - vS]))
+    idx, dist_sqr, found = tree.find_closest_point(np.ascontiguousarray(positions))
+
+    bad = (~np.asarray(found).ravel()
+           | (np.asarray(dist_sqr).ravel() > (1e-9 * scale) ** 2))
+    return np.asarray(idx, dtype=np.int64).ravel(), int(bad.sum())
+
+
+def _set_coordinates(dm, indices, values):
+    """Move a set of vertices. The coordinate vector is written whole."""
+    vec = dm.getCoordinatesLocal()
+    arr = np.asarray(vec.array).reshape(-1, dm.getCoordinateDim()).copy()
+    arr[indices] = values
+    new = vec.duplicate()
+    new.array[:] = arr.reshape(-1)
+    dm.setCoordinatesLocal(new)
+
+
+def _label_cut_edges(dm, lines, tol, name, value):
+    """Mark the edges lying along the cut; return the edge points marked.
+
+    An edge is on the cut when both its endpoints and its midpoint lie on a line.
+    The midpoint test is what distinguishes the cut from a chord: where a polyline
+    turns, two vertices on different segments can be joined by an edge that is not
+    part of the line at all.
+
+    The points are returned rather than counted here because a shared edge is held
+    by every rank on the seam: counting locally and summing would report it once
+    per sharer. The caller counts the OWNED ones.
+    """
+    X = _coords(dm)
+    on = _distance_to_lines(X, lines) < tol
+    eS, _eE = dm.getDepthStratum(1)
+    ends = _edge_vertices(dm)
+    mid_on = _distance_to_lines(0.5 * (X[ends[:, 0]] + X[ends[:, 1]]), lines) < tol
+    keep = on[ends[:, 0]] & on[ends[:, 1]] & mid_on
+
+    if not dm.hasLabel(name):
+        dm.createLabel(name)
+    label = dm.getLabel(name)
+    label.setDefaultValue(0)
+    marked = np.flatnonzero(keep) + eS
+    for e in marked:
+        label.setValue(int(e), int(value))
+    return marked
+
+
+def cell_areas(dm):
+    """Signed area of every triangle. Negative means the cell is inverted.
+
+    A cell's cone holds its edges together with an orientation saying which way
+    the cell traverses each; taking the first vertex of every edge regardless
+    returns a ring that is not the cell, and reports zero area for perfectly good
+    cells — so an inversion check built that way always passes.
+    """
+    X = _coords(dm)
+    vS, _vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    out = np.empty(cE - cS)
+    for c in range(cS, cE):
+        ring = []
+        for e, o in zip(dm.getCone(c), dm.getConeOrientation(c)):
+            a, b = (int(v) - vS for v in dm.getCone(e))
+            ring.append(a if o >= 0 else b)
+        p, q, r = X[ring[0]], X[ring[1]], X[ring[2]]
+        out[c - cS] = 0.5 * ((q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]))
+    return out
+
+
+def min_angles(dm):
+    """Smallest interior angle of every triangle, in degrees.
+
+    Area alone does not identify a sliver — a small cell near a refined feature is
+    not one. A collapsing angle is what costs the solver.
+    """
+    X = _coords(dm)
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    out = np.empty(cE - cS)
+    for c in range(cS, cE):
+        v = np.array([int(p) - vS for p in dm.getTransitiveClosure(c)[0]
+                      if vS <= p < vE])
+        P = X[v]
+        e = np.array([P[2] - P[1], P[0] - P[2], P[1] - P[0]])
+        L = np.linalg.norm(e, axis=1)
+        cosines = [(L[1] ** 2 + L[2] ** 2 - L[0] ** 2) / (2 * L[1] * L[2]),
+                   (L[2] ** 2 + L[0] ** 2 - L[1] ** 2) / (2 * L[2] * L[0]),
+                   (L[0] ** 2 + L[1] ** 2 - L[2] ** 2) / (2 * L[0] * L[1])]
+        out[c - cS] = np.degrees(np.arccos(np.clip(cosines, -1.0, 1.0))).min()
+    return out
+
+
+def cut_along_lines(dm, lines, snap_frac=0.10, label=CUT_LABEL, label_value=1,
+                    snap_quality=0.15, snap_dist=0.0):
+    """Split every edge the given lines cross, at the crossing point.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        A 2-D simplex mesh. **Not modified** — the cut is returned as a new mesh,
+        so a line can be moved and re-cut against the same fixed base.
+    lines : sequence of array_like
+        One or more polylines, each an ``(N, 2)`` array of points. They must not
+        intersect one another or themselves, and each must cross the mesh from
+        boundary to boundary.
+    snap_frac : float
+        A crossing landing within this fraction of an edge's length from either
+        end moves that end onto the line instead of splitting the edge. This is
+        what keeps slivers out; ``0.0`` disables it and will produce degenerate
+        cells wherever a line passes near a vertex. The default is the smallest
+        value measured to bring an algebraic solver back within about 15 % of the
+        uncut mesh's cost (see the table above). The cut stays exactly on the
+        line either way — a snapped vertex is moved *onto* the line, not the line
+        onto the vertex — so what a larger value costs is displacement of the
+        surrounding mesh, not accuracy of the interface. See :func:`sliver_report`.
+    snap_quality : float
+        Floor on triangle quality (``4 sqrt(3) A / sum(l^2)``: 1 equilateral, 0
+        degenerate). A snap is refused if it would drive any cell touching it
+        below this — or below that cell's present quality, if it is already worse
+        — and the crossing is split instead. Roughly, 0.75 is a 30 degree worst
+        angle, 0.43 is 15 degrees and 0.15 is 5 degrees.
+
+        This is what makes a large ``snap_frac`` safe: without it, a cell thinner
+        than the tolerance band has every corner pulled onto the line and is
+        flattened. ``0.0`` leaves only the inversion veto, which is measurably
+        *not* enough: a flattened cell lands at quality ~1e-16 of either sign, so
+        half of them survive an inversion test, the worst interior angle still
+        reaches zero, and — worse than the refusal it replaces — the returned mesh
+        looks fine while the cut chain has silently broken. ``None`` removes the
+        guard altogether, restoring the behaviour from before it existed — where
+        a tolerance this large refuses the cut outright, which is the refusal
+        the guard was written to avoid.
+
+        Keep it LOW. The guard protects the SNAPPED mesh, which is not the mesh
+        that comes back: every snap it vetoes becomes a split, and the splits are
+        what make the cut's slivers. Measured on one graded cut, raising the floor
+        from 0.15 to 0.55 held the snapped mesh's worst angle up (15.6 -> 24.5
+        degrees) while driving the CUT's down (10.9 -> 0.16) and the split count
+        up (139 -> 359). This is a backstop against flattening, not a quality
+        target.
+    snap_dist : float
+        Also snap any vertex lying within this multiple of its own local h of the
+        line, whatever the crossings on its edges look like. ``snap_frac`` is
+        measured ALONG an edge and is blind to a vertex that sits close to the
+        line while every edge meeting it is crossed near its midpoint — which is
+        the configuration that produces the cut's worst cells, and which no value
+        of ``snap_frac`` reaches. The quality guard applies to these proposals
+        too, so a vertex whose move would flatten a cell is split around instead.
+    label, label_value : str, int
+        Name and stratum value of the label put on the cut edges. Naming it after
+        the surface lets a solver apply a boundary condition there directly; the
+        default is a generic name for callers that only want the geometry.
+
+    Returns
+    -------
+    cut : PETSc.DMPlex
+        A new mesh in which every segment of every line between consecutive
+        crossings is an edge. Those edges carry ``label`` with value
+        ``label_value``.
+    info : dict
+        ``n_split`` edges split, ``n_on_surface`` vertices lying on a line,
+        ``n_cut_edges`` edges labelled, ``min_area`` and ``min_angle`` of the
+        result. Every entry is GLOBAL, and counts are over owned points, so the
+        numbers are the same at any communicator size.
+
+        ``n_on_surface`` counts vertices moved onto a line by snapping AND
+        vertices that were already on one — a tip or a junction placed on a
+        vertex, which is how those are represented. Both are cut vertices; the
+        distinction does not survive into the result.
+
+    Raises
+    ------
+    ValueError
+        If a line ends inside the mesh, if a triangle is crossed three times, or
+        if an edge is crossed more than once. Each is a case this routine cannot
+        cut correctly, and each would otherwise give a mesh that looks plausible
+        and still leaks stress.
+    RuntimeError
+        If snapping inverts a cell or fails to settle, which means ``snap_frac``
+        is too large for this mesh.
+
+    Examples
+    --------
+    A single line crossing the mesh cuts ONE chain, so its facets number one
+    fewer than the vertices along it — and every vertex along it is either one
+    this routine inserted or one already on the line:
+
+    >>> cut, info = cut_along_lines(mesh.dm, [np.array([[0.5, -0.1], [0.5, 1.1]])])
+    >>> info["n_cut_edges"] == info["n_split"] + info["n_on_surface"] - 1
+    True
+    """
+    if dm.getDimension() != 2:
+        raise ValueError(
+            f"cut_along_lines is 2-D; this mesh is {dm.getDimension()}-D. Cutting "
+            "tetrahedra along a surface is a different pattern problem.")
+
+    from underworld3.utilities import _nvb_transform  # noqa: F401  (registers the type)
+
+    X = _coords(dm)
+    ends = _edge_vertices(dm)
+    # One global length, computed once and threaded through every tolerance
+    # below. Cutting never moves a vertex outside the bounding box, so the same
+    # number is valid for the child meshes the pass loop produces.
+    scale = _global_extent(dm)
+
+    on_line, X_snapped, t, multiply_crossed = _resolve_snapping(
+        dm, X, ends, lines, snap_frac, scale, snap_quality, snap_dist)
+    eS, _eE = dm.getDepthStratum(1)
+    crossed = np.flatnonzero(np.isfinite(t)) + eS
+
+    n_cross, n_corner = _cell_edge_counts(dm, crossed, on_line)
+    # A triangle the line passes through leaves by an edge (two crossings) or by a
+    # corner (one crossing, one on-line vertex). Anything else it cannot cut.
+    #
+    # Every one of these is REDUCED before it is tested. Each condition is a
+    # property of one rank's cells, so a rank-local raise would abort that rank
+    # while its peers walked on into the next collective and hung — which is
+    # exactly what a three-way partition produced. Reducing first means every rank
+    # raises, or none does.
+    faults = np.array([len(multiply_crossed),
+                       int(((n_cross == 1) & (n_corner == 0)).sum()),
+                       int((n_cross == 3).sum())], dtype=np.int64)
+    n_multi, n_tip, n_triple = uw.mpi.comm.allreduce(faults, op=MPI.SUM)
+
+    if n_multi:
+        raise ValueError(
+            f"{n_multi} edge(s) are crossed more than once; an edge can only be "
+            "split at one point. Refine the mesh near the line, or simplify the "
+            "line.")
+    if n_tip:
+        raise ValueError(
+            f"{n_tip} triangle(s) are entered but not left, which means a line "
+            "ends inside the mesh. A line must cross from boundary to boundary; a "
+            "terminating tip needs a vertex placed at the tip and is not "
+            "supported.")
+    if n_triple:
+        raise ValueError(
+            f"{n_triple} triangle(s) are crossed three times. The transform "
+            "splits these into four rather than cutting them. Refine the mesh "
+            "near the line so no triangle sees more than one line segment.")
+
+    # Both reduced before either is tested: a rank that owns no part of the line
+    # must not take a different branch from one that does. Counted over OWNED
+    # points only — a shared edge or vertex sits on every rank of the seam, and
+    # summing local counts would report it once per sharer.
+    vS, _vE = dm.getDepthStratum(0)
+    totals = np.array([_owned_count(dm, crossed),
+                       _owned_count(dm, np.flatnonzero(on_line) + vS)],
+                      dtype=np.int64)
+    n_crossed_total, n_on_surface = uw.mpi.comm.allreduce(totals, op=MPI.SUM)
+    if n_crossed_total == 0 and n_on_surface == 0:
+        raise ValueError("no mesh edge is crossed by any line: nothing to cut.")
+
+    # Apply the snapping to a WORKING COPY. The caller's mesh is never touched, so
+    # a line can be moved and re-cut against the same fixed base. Unconditional:
+    # an empty index set is a no-op, and a rank-local guard around mesh surgery is
+    # the shape every deadlock in this module has had.
+    work = dm.clone()
+    _set_coordinates(work, np.flatnonzero(on_line), X_snapped[on_line])
+
+    # Split in PASSES of pairwise-INDEPENDENT edges, never two edges of one cell
+    # at once.
+    #
+    # The transform can split two edges of a triangle in one go, and doing so
+    # emits the segment joining the two inserted vertices — the cut, in a single
+    # pass. That works perfectly in serial and is WRONG IN PARALLEL: the
+    # double-split path leaves the child's point star-forest inconsistent, and
+    # wrapping the result as a Mesh dies in PetscSectionCreateGlobalSection
+    # ("Global dof 0 for point N is not the unconstrained 2") at np>=3. Its own
+    # source calls those tables "a safety net", and nothing had exercised them
+    # across a partition.
+    #
+    # Independent single splits are the validated path, and they still build the
+    # cut: splitting the entry edge inserts a vertex, and the SECOND pass splits
+    # the exit edge and joins its new vertex to the OPPOSITE vertex of the cell —
+    # which is the first vertex. The cut segment appears as an edge either way; it
+    # just takes two passes rather than one.
+    n_split, cut = 0, work
+    for _pass in range(12):
+        X_now = _coords(cut)
+        ends_now = _edge_vertices(cut)
+        on_now = _distance_to_lines(X_now, lines) < 1e-12 * scale
+        t_now, _multi = _crossing_parameters(X_now, ends_now, lines, on_now)
+
+        eS_now = cut.getDepthStratum(1)[0]
+        want = np.flatnonzero(np.isfinite(t_now)) + eS_now
+        chosen = _independent_edges(cut, want)
+
+        n_this = uw.mpi.comm.allreduce(int(_owned_count(cut, chosen)), op=MPI.SUM)
+        if n_this == 0:
+            break
+        n_split += n_this
+
+        work_pass = cut.clone()
+        work_pass.createLabel(_BISECT_LABEL)
+        bisect_label = work_pass.getLabel(_BISECT_LABEL)
+        bisect_label.setDefaultValue(0)
+        for e in chosen:
+            bisect_label.setValue(int(e), 1)
+
+        transform = PETSc.DMPlexTransform().create(comm=work_pass.comm)
+        transform.setType("uwnvb_bisect")
+        transform.setDM(work_pass)
+        transform.setUp()
+        child = transform.apply(work_pass)
+        transform.destroy()
+        if child.hasLabel(_BISECT_LABEL):
+            child.removeLabel(_BISECT_LABEL)
+
+        # Move each inserted vertex from the midpoint, where the transform put it,
+        # to the crossing. Everything else is already where it belongs.
+        #
+        # No `if len(chosen):` guard. A pass is entered by GLOBAL agreement, so a
+        # rank that happens to have split nothing still has to reach the reduce
+        # below; guarding the block would walk it straight past.
+        ce = ends_now[chosen - eS_now]
+        tc = t_now[chosen - eS_now][:, None]
+        midpoints = 0.5 * (X_now[ce[:, 0]] + X_now[ce[:, 1]])
+        targets, n_missing = _child_vertex_of(child, midpoints, scale)
+        if uw.mpi.comm.allreduce(n_missing, op=MPI.SUM):
+            raise RuntimeError(
+                "expected vertex position(s) have no child vertex; the transform "
+                "did not place points where this routine assumes it does.")
+        _set_coordinates(child, targets,
+                         (1.0 - tc) * X_now[ce[:, 0]] + tc * X_now[ce[:, 1]])
+        cut = child
+    else:
+        raise RuntimeError(
+            "the cut did not converge in 12 passes; every pass must split at "
+            "least one edge and remove it from the crossing set.")
+
+    # Reduced before it is tested. Whether a rank holds an inverted cell depends
+    # on the partition, so this raise was rank-local at np>1 while its peers went
+    # on into `Mesh(cut_dm, ...)` and waited there. Measured: snap_frac=0.49 on a
+    # 1/12 box inverts a cell.
+    areas = cell_areas(cut)
+    n_inverted = uw.mpi.comm.allreduce(int((areas <= 0.0).sum()), op=MPI.SUM)
+    if n_inverted:
+        raise RuntimeError(
+            f"snapping inverted {n_inverted} cell(s); snap_frac={snap_frac} is "
+            "too large for this mesh.")
+
+    marked = _label_cut_edges(cut, lines, 1e-9 * scale, label, label_value)
+
+    # Every reported number is GLOBAL. They are printed together as one summary,
+    # so a mix of rank-local and reduced values would be read as agreeing when
+    # they do not — and the documented identity between them cannot hold.
+    # `min_angles` is O(cells), so it is computed once and reduced with the rest.
+    # An empty rank contributes the identity of each reduction, never a raise.
+    angles = min_angles(cut)
+    worst = np.array([areas.min() if areas.size else np.inf,
+                      angles.min() if angles.size else np.inf])
+    uw.mpi.comm.Allreduce(MPI.IN_PLACE, worst, op=MPI.MIN)
+    return cut, {
+        "n_split": int(n_split),
+        "n_on_surface": int(n_on_surface),
+        "n_cut_edges": int(uw.mpi.comm.allreduce(_owned_count(cut, marked),
+                                                 op=MPI.SUM)),
+        "min_area": float(worst[0]),
+        "min_angle": float(worst[1]),
+    }
+
+
+def pull_vertex_onto(dm, targets):
+    """Move the nearest mesh vertex onto each target point; return a new mesh.
+
+    COLLECTIVE. This is how a fault TIP or a network JUNCTION is placed, and both
+    are the same problem: a distinguished point of the geometry that has to
+    coincide with a mesh vertex. Once it does, every branch meeting there arrives
+    at the already-legal "one crossed edge, one on-surface corner" case, and
+    :func:`cut_along_lines` terminates the chain cleanly instead of refusing it.
+
+    Prefer this to snapping the tip to the nearest vertex. Moving the MESH keeps
+    the tip exactly where it was asked for — measured on a 1/12 box, tip error
+    0.0000 against 0.0306, and a better worst angle (8.79 deg against 5.29) — and
+    it costs mesh displacement rather than geometric accuracy, the same trade as
+    ``snap_frac``. The tip is where the stress concentrates, so accuracy there is
+    worth more than tidiness.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        **Not modified.** The pull is returned as a new mesh.
+    targets : array_like
+        An ``(N, 2)`` array of points, or one point.
+
+    Returns
+    -------
+    PETSc.DMPlex
+        A copy with one vertex moved onto each target.
+
+    Notes
+    -----
+    Which vertex gets chosen JUMPS as the target moves, so this is a discrete
+    switch in what may be a continuous design variable — the same class of
+    behaviour as ``snap_frac``, and anything optimising over fault geometry has
+    to live with it.
+
+    The choice is made from the coordinates alone and reduced globally, so every
+    rank moves the same vertex: a rank-local nearest-vertex search picks a
+    different one on each rank, which is how the mesh stops being
+    partition-independent. Exact ties in distance are broken by coordinate order;
+    two distinct vertices at bit-identical distance would be arbitrary, and that
+    is measure-zero rather than handled.
+    """
+    X = _coords(dm)
+    arr = X.copy()
+    scale = _global_extent(dm)
+
+    for t in np.atleast_2d(np.asarray(targets, dtype=float))[:, :2]:
+        d = np.linalg.norm(X[:, :2] - t, axis=1)
+        # Reduced as (distance, x, y) so the tie-break is part of the same
+        # reduction: tuples compare lexicographically, so MIN gives the closest
+        # vertex and, among equals, the one lowest in coordinate order.
+        local = ((float(d.min()), *X[int(d.argmin()), :2]) if d.size
+                 else (np.inf, np.inf, np.inf))
+        _dist, tx, ty = uw.mpi.comm.allreduce(local, op=MPI.MIN)
+
+        # Move it by POSITION, not by index: the chosen vertex may be a ghost
+        # here and an owned point there, and both copies have to end up in the
+        # same place without a star-forest exchange.
+        hit = np.flatnonzero(np.linalg.norm(X[:, :2] - np.array([tx, ty]),
+                                            axis=1) < 1e-12 * scale)
+        arr[hit, :2] = t
+
+    out = dm.clone()
+    _set_coordinates(out, np.arange(len(arr)), arr)
+    return out
+
+
+def sliver_report(dm, lines, snap_fracs):
+    """How the cut's worst cell varies with the snap tolerance.
+
+    The tolerance trades slivers against a perturbed mesh, and neither cost is
+    knowable in advance — it depends on how the line happens to fall relative to
+    this mesh's vertices. Measure it rather than guess.
+
+    Returns a list of ``(snap_frac, info)``; entries where the cut failed carry the
+    exception message under ``"error"`` instead.
+    """
+    out = []
+    for frac in snap_fracs:
+        try:
+            _cut, info = cut_along_lines(dm, lines, snap_frac=frac)
+            out.append((frac, info))
+        except (ValueError, RuntimeError) as exc:
+            # A tolerance can legitimately be unusable on a given mesh: too small
+            # leaves a triple crossing, too large inverts a cell. Both are results.
+            out.append((frac, {"error": str(exc)}))
+    return out
diff --git a/src/underworld3/utilities/nvb.py b/src/underworld3/utilities/nvb.py
index 9308eabe5..c891d4534 100644
--- a/src/underworld3/utilities/nvb.py
+++ b/src/underworld3/utilities/nvb.py
@@ -376,6 +376,15 @@ def nested_prolongation_from_dms(coarse_dm, fine_dm):
 
 def nested_prolongation(engine, coarse_map, fine_map, n_coarse, vS_fine,
                         n_fine):
+    # TODO(BUG): in 3-D this is NOT the coarse P1 embedding for vertices a
+    # closure cascade places strictly INSIDE a coarse tet. Measured 2026-08-02:
+    # transfer against a barycentric reference, worst |P.u - P1(x)| = 1.19 on a
+    # cellSize=0.4 unit cube, per GENERATION (no composition involved). 2-D is
+    # exact (1.9e-15). It went unnoticed because the test's reference was
+    # edge-based — a single bisection puts vertices on coarse EDGES, and the
+    # interior ones were skipped by its coverage rule rather than checked. The
+    # 3-D case of test_0753::test_reproduces_an_arbitrary_coarse_field is
+    # xfailed against this.
     """Exact P1 prolongation for ONE bisection generation, in DM numbering.
 
     A bisection generation adds exactly one kind of vertex: the midpoint of a
diff --git a/src/underworld3/utilities/reconnect.py b/src/underworld3/utilities/reconnect.py
new file mode 100644
index 000000000..d6bed5a5d
--- /dev/null
+++ b/src/underworld3/utilities/reconnect.py
@@ -0,0 +1,1198 @@
+"""Reconnection: repair the element shapes a refinement pass leaves behind (2-D).
+
+Refinement engines choose *where* to put a new vertex; they do not get to choose
+how the surrounding cells reconnect. :mod:`underworld3.utilities.edge_split`
+splits an edge in every cell incident on it, so a cell that nominated that edge
+gains two well-shaped children while a cell dragged along — split at an edge it
+did not nominate — gains a thin one. Reconnection is the missing third operation
+of the classical refine / swap / smooth triple: UW3 has refine (:meth:`Mesh.adapt`)
+and smooth (:meth:`Mesh.relax`), and this is swap.
+
+Two passes live here. :func:`flip_to_reduce_max_angle` changes *connectivity* and
+keeps every point; :func:`remove_vertices` deletes a point and retriangulates the
+hole. They fix different damage and they compose — in one order only. See
+`Deleting a vertex`_.
+
+What it is worth, and where the benefit actually comes from
+----------------------------------------------------------
+Measured on the production path — ``edge_split`` refinement of a real DM, flat-core
+size field, error over the refined core, raw numbers in
+``~/+Simulations/mesh_reconnection_study/results_production_repair.txt``.
+
+A flip replaces two cells by two cells and inserts no vertex, so a repair pass run
+**after** refinement is cell-count neutral and changes connectivity alone:
+
+==========================  ===================  =====================
+base mesh                   99th-pct max angle   core error, same DOFs
+==========================  ===================  =====================
+gmsh box (the normal case)  124.7 -> 120.5 deg   -0.4 %
+gmsh box, regular           116.6 -> 116.6 deg   0 %
+grid, aspect ratio 4        156.0 -> 115.1 deg   +0.9 %
+non-Delaunay (scrambled)    175.5 -> 118.0 deg   -3.1 %
+==========================  ===================  =====================
+
+So as a post-pass this fixes **shape and only shape** — decisively on a poor base
+(slivers below q=0.1 go 3.84 % to 0.00 %, and the aspect-ratio-4 row loses 41
+degrees of maximum angle) and hardly at all on a gmsh base. Interpolation error
+barely moves either way.
+
+Run **between** refinement passes it does more, because a flip changes which edge
+of a cell is longest and therefore where the *next* pass inserts a vertex. That
+buys roughly 20-30 % lower core error per degree of freedom on a degraded base
+(and 20-30 % fewer cells for the same size field), and nothing on a gmsh base. The
+gain is therefore a *placement* gain that reconnection unlocks, not a connectivity
+gain — the same conclusion this study reached about centroid refinement, in the
+opposite direction.
+
+The aspect-ratio-4 row is why the pass exists at all. That base has a maximum
+angle of 90 degrees — ideal for P1, since the interpolation bound depends on the
+maximum angle (Babuska-Aziz) and not the minimum — and longest-edge refinement
+*degrades* it to 156, because repeatedly bisecting the longest edge of a
+high-aspect-ratio right triangle manufactures obtuse cells. Refinement creates the
+problem; only reconnection removes it.
+
+Scope
+-----
+The pass considers every edge it is allowed to touch, not only those around
+freshly inserted vertices. That is deliberate — the gains on a degraded base come
+precisely from repairing connectivity the refinement did not create — but it does
+mean a deliberately hand-built triangulation may be re-connected away from the
+refined region, which is one reason the pass is opt-in.
+
+Edges carrying an interface label are never flipped, which is what would protect a
+fault or a material boundary that is *represented in the mesh*. Note that the
+standard adapt-on-top fault workflow does not do that: there a ``Surface`` is a
+distance field driving a refinement metric and a constitutive weak zone, and it
+labels no mesh edge at all. Repair therefore reconnects freely across such a weak
+zone — measured to be harmless, since the weak zone is a smooth function of
+distance rather than a discontinuity across a facet, and a sheared weak-zone Stokes
+solve gives the same vrms to four significant figures with and without repair. A
+fault that must not be crossed has to be a labelled interface, not a distance
+field.
+
+.. _Deleting a vertex:
+
+Deleting a vertex
+-----------------
+A conforming cut (:mod:`underworld3.utilities.line_cut`) has only two primitives:
+**snap** a vertex onto the surface, or **split** an edge the surface crosses.
+Every sliver it leaves follows from that — a crossing falling near a vertex must
+either drag the vertex to it or carve a thin cell beside it, and tightening the
+snap tolerance only trades one for the other. **Delete** is the missing third. It
+dissolves the case rather than trading it, and it is the only one of the three
+that *removes* work instead of adding it.
+
+Measured on a box fault cut into an adapted mesh, counting cells whose smallest
+angle is under 15 degrees:
+
+===========================  =====  ========  ==========
+pass                         cells  < 15 deg  max angle
+===========================  =====  ========  ==========
+the cut                       4548        60      148.45
+flip                          4548        18      133.27
+flip, then delete             4306         4      133.27
+delete, then flip             4076        60      138.81
+===========================  =====  ========  ==========
+
+Two things to read off that. The order is **not** symmetric: flipping first and
+deleting second removes 242 cells *and* takes the sliver count from 60 to 4,
+while deleting first leaves it at 60. Deletion retriangulates a cavity from the
+point set it is given, so running it on connectivity the flip pass has not yet
+cleaned up spends its independent set on cavities that a flip would have fixed
+for free — and the cavity, once ear-clipped, no longer presents the quad the flip
+pass was looking for. Flip is cheap and reversible; delete is neither. Flip
+first. A second round of each then finds nothing, so the pair converges.
+
+The second is that the acceptance test needs both shape measures, unlike the flip
+pass. Gating on the largest angle alone — correct for flipping, since the P1
+interpolation bound depends on it — let the minimum angle fall from 10.80 to
+10.23 degrees and *raised* the sliver count from 60 to 61, because a needle has
+one tiny angle and two close to 90 and never registers as obtuse. Hence
+``gate="both"``.
+
+Where deletion is *wanted* is not decided here: :func:`remove_vertices` takes a
+candidate list, and refuses whatever it cannot improve. Offered every vertex of a
+clean mesh it does nothing, which is the behaviour a pass that removes degrees of
+freedom has to have.
+
+Parallel: the frozen seam
+-------------------------
+A flip cannot be a :c:type:`DMPlexTransform` — a child's cone may only reference
+its own parent's closure, while a flip's output cells use the *other* parent's
+apex — so there is no inherited star-forest propagation and the DM must be
+rebuilt. It is rebuilt **on the same point chart**: a 2-D flip adds and removes no
+points, since the quad keeps its four vertices, five edges and two cells and only
+the diagonal edge's cone and the two cell cones change. Preserving the numbering
+means the point star-forest transfers verbatim, labels transfer by point id and
+coordinates transfer unchanged, with no coordinate matching anywhere.
+
+That holds because **no cavity may contain a cell incident on a shared plex
+point**. A flip across a partition seam would need one rank's cell to reference an
+edge living on another rank, which means enlarging its local chart and rebuilding
+the star-forest — a much larger job. Freezing the seam instead costs a measured
+0.9-3.5 % of repair sites at 56k cells and np=2..8, and that cost *halves* with
+every halving of the target cell size, because repair sites scale with the refined
+band while the sites a seam crosses stay O(1).
+
+.. warning::
+
+   **The repaired mesh is not partition-independent.** ``edge_split`` alone is
+   bit-confluent — identical at any communicator size — and repair gives that up
+   by construction, because which cells are frozen depends on where the
+   partitioner drew the seam. Conformity, orientation, volume, labels and the
+   star-forest remain exact at every rank count; it is the *choice* of flips near
+   a seam that differs. This is the same trade adapt-on-top already makes in
+   preferring local adaptation to global remeshing, but it is a change of contract
+   relative to the engine, so repair is opt-in rather than automatic.
+
+A related cost: the 99th-percentile maximum angle recovers fully under a frozen
+seam, but the absolute maximum does not — a few of the worst cells sit on the seam
+and are exactly the ones that may not be touched.
+
+Deletion freezes the same seam, for a stronger reason: it compacts the point
+chart, so unlike a flip it cannot hand the star-forest across verbatim. Every
+point after a deleted one shifts, and each leaf's *remote* index is a number only
+its owner holds. :func:`rebuild_without_vertices` renumbers locally and
+broadcasts the new numbering root-to-leaf **once** to close that gap. One
+exchange of bookkeeping over the existing partition — no cell changes rank and
+nothing is redistributed, which is the property an external remesher costs us.
+Freezing the seam is then what keeps the *leaf set* itself unchanged, so the
+forest need only be renumbered and never rebuilt. Measured cost at np=2..4 on a
+cut mesh: 113-115 deletions against 121 serial.
+
+Status
+------
+2-D only, both passes. A deleted vertex's cavity is a polygon in 2-D and a
+polyhedron in 3-D, and ear clipping does not generalise to one — though cavity
+insertion is standard practice in 3-D meshing where ad-hoc cutting of tets along
+a surface is not, so this is the operation that generalises *better* than the cut
+it replaces.
+
+In 3-D no single flip suffices either: the operator set has to become
+quality-gated edge removal, and the empty-sphere property is no help either since
+a Delaunay tetrahedralisation still contains slivers — measured directly, a
+Delaunay tet mesh of a random cloud has 10 % of its cells below q=0.1. See
+``docs/developer/design/mesh-reconnection-and-delaunay-adapt.md``.
+"""
+
+import numpy as np
+from mpi4py import MPI
+from petsc4py import PETSc
+
+import underworld3 as uw
+
+# Labels PETSc maintains itself. They are rebuilt by ``stratify`` so they must not
+# be copied onto a fresh plex, and an edge carrying one is not an interface.
+_TOPOLOGY_LABELS = ("depth", "celltype")
+
+#: Labels that partition the CELLS but carry no material meaning, so an edge
+#: between two cells holding different values of one is not an interface.
+#:
+#: ``uwnvb_refedge`` is the newest-vertex transform's per-triangle *slot*: which
+#: of a cell's edges is its refinement edge. It takes values 0/1/2 across any
+#: NVB-adapted mesh, which :func:`_cell_regions` read as three material regions —
+#: 2230/2184/134 cells on one measured fault mesh — and duly locked every edge
+#: between them. That silently disabled repair over most of ANY adapted mesh: of
+#: the edges around a sliver in a cut mesh, 113 were declined as a "region
+#: interface" against 54 genuinely locked on the fault.
+#:
+#: This is the same trap :func:`_interface_edges` documents for ``Elements``, one
+#: level along. ``Elements`` does not trip :func:`_cell_regions` only because it
+#: is uniform; a bookkeeping label that VARIES does.
+_BOOKKEEPING_LABELS = ("uwnvb_refedge",)
+
+# Shewchuk's static filters (Robust Predicates, 1997) with eps = 2^-53. A
+# determinant whose magnitude clears the bound has a certain sign; one that does
+# not is reported as _UNCERTAIN and the caller declines to act.
+#
+# Declining is always safe: a flip is an optimisation, never a requirement. That
+# is what lets a filter stand in for adaptive-precision arithmetic here. Exact
+# arithmetic would resolve more cases and could not resolve any of them wrongly,
+# but it is not needed to keep the mesh valid and it is far too slow to sit inside
+# a refinement loop. What would NOT be safe is trusting a bare float determinant:
+# an inconsistently signed predicate produces a non-conforming mesh.
+_EPS = 1.1102230246251565e-16
+_ORIENT_BOUND = (3.0 + 16.0 * _EPS) * _EPS
+
+_UNCERTAIN = 0
+
+# A flip must improve the pair's largest angle by at least this much, measured in
+# the cosine. Without a margin, two configurations of equal quality could each
+# look like an improvement on the other and the sweeps would cycle.
+_MIN_GAIN = 1.0e-9
+
+
+def _orient2d(pa, pb, pc):
+    """Sign of the area of triangle ``(pa, pb, pc)``, positive for anticlockwise.
+
+    Returns ``_UNCERTAIN`` when the filter cannot resolve the sign.
+    """
+    acx, acy = pa[0] - pc[0], pa[1] - pc[1]
+    bcx, bcy = pb[0] - pc[0], pb[1] - pc[1]
+    left, right = acx * bcy, acy * bcx
+    det = left - right
+    if det == 0.0:
+        # Collinear as far as this arithmetic can tell. Reported as unresolved,
+        # never as a sign: the filter below reduces to `0 >= 0` when both products
+        # vanish — which they do for any axis-aligned collinear triple, an
+        # ordinary configuration on a structured mesh — and would then return a
+        # confident "clockwise" for points that are not clockwise at all.
+        return _UNCERTAIN
+    if abs(det) >= _ORIENT_BOUND * (abs(left) + abs(right)):
+        return 1 if det > 0.0 else -1
+    return _UNCERTAIN
+
+
+def _largest_cosine(triangles):
+    """The largest cosine of any interior angle across ``triangles``.
+
+    The companion of :func:`_smallest_cosine`, and a monotone stand-in for "the
+    smallest angle" by the same argument. The two measure different failures and
+    a pass that watches only one is blind to the other: an obtuse cell has a
+    cosine near ``-1`` and a *needle* — one tiny angle and two near right angles
+    — has one near ``+1`` while its largest angle stays close to 90 degrees, so
+    it slips past a maximum-angle test untouched.
+    """
+    worst = -1.0
+    for P in triangles:
+        for i in range(3):
+            u = P[(i + 1) % 3] - P[i]
+            v = P[(i + 2) % 3] - P[i]
+            denom = np.hypot(u[0], u[1]) * np.hypot(v[0], v[1])
+            if denom == 0.0:
+                return 1.0
+            worst = max(worst, float((u[0] * v[0] + u[1] * v[1]) / denom))
+    return worst
+
+
+def _smallest_cosine(triangles):
+    """The most negative cosine of any interior angle across ``triangles``.
+
+    A monotone stand-in for "the largest angle": angle is largest exactly where
+    its cosine is smallest, and comparing cosines avoids an ``arccos`` per angle
+    and the tiny non-monotonicity its rounding would introduce near 180 degrees.
+    """
+    worst = 1.0
+    for P in triangles:
+        for i in range(3):
+            u = P[(i + 1) % 3] - P[i]
+            v = P[(i + 2) % 3] - P[i]
+            denom = np.hypot(u[0], u[1]) * np.hypot(v[0], v[1])
+            if denom == 0.0:
+                return -1.0
+            worst = min(worst, float((u[0] * v[0] + u[1] * v[1]) / denom))
+    return worst
+
+
+# --------------------------------------------------------------- topology reads
+
+def _coords(dm):
+    return np.asarray(dm.getCoordinatesLocal().array).reshape(
+        -1, dm.getCoordinateDim())
+
+
+def _shared_points(dm):
+    """Chart-indexed 0/1 flags marking points held by more than one rank.
+
+    Marking the local leaves and OR-ing over the star-forest also flags the roots
+    on the owning side, so every rank agrees on the seam. Reuses
+    ``edge_split._sf_logical_or``, whose leaf/root convention — the same array
+    passed as both leaf and root data — is the one proven correct against
+    ``uwnvb_sf_lor`` in the C.
+    """
+    from underworld3.utilities import edge_split
+
+    pStart, pEnd = dm.getChart()
+    flag = np.zeros(pEnd - pStart, dtype=np.int32)
+    if uw.mpi.size == 1:
+        return flag
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        # An unpopulated star-forest reports a root count petsc4py cannot shape an
+        # array from. Nothing is shared, so there is no seam.
+        return flag
+    if ilocal is not None and len(ilocal):
+        flag[np.asarray(ilocal, dtype=np.int64) - pStart] = 1
+    # COLLECTIVE, and reached on every rank: one that shares nothing still has to
+    # participate or its peers block. Gate on communicator size, never on what
+    # this rank happens to own.
+    edge_split._sf_logical_or(dm, flag)
+    return flag
+
+
+def _interface_edges(dm):
+    """Chart-indexed flags for the **edges** of an interface label.
+
+    A labelled interior edge is an interface — a named boundary, or a registered
+    surface — and must never be flipped, nor be dissolved by deleting one of its
+    end points, since that is what protects a fault or a material boundary from
+    being reconnected across.
+
+    Two whole strata are ignored, and both exclusions are load-bearing rather
+    than fastidious.
+
+    A label value carried by a **cell** is a *volume* and not an interface.
+    ``Elements`` labels every cell of a gmsh mesh, and the ``uwnvb_bisect``
+    transform propagates a parent's labels to its children, so after refinement
+    every new *interior edge* carries ``Elements`` as well. Treating any labelled
+    point as an interface therefore locked 81 % of the interior edges of a plain
+    refined box, and repair quietly did almost nothing on every real UW3 mesh —
+    while hand-built fixtures, which have no such label, kept working.
+
+    **Vertices** are ignored because in 2-D an interface is a *curve*, so it is
+    identified by the edges that make it up; a vertex on one always carries
+    interface edges too, and reading the vertices adds nothing but noise. It adds
+    a great deal of noise: ``Null_Boundary`` marks **every vertex of every UW3
+    mesh** with the reserved value 666 — the sentinel a natural boundary
+    condition attaches to when it applies to no boundary — and ``UW_Boundaries``
+    re-packs every per-boundary stratum, sentinel included, into one stacked
+    label. Between them every vertex in the chart is labelled. That costs the
+    flip pass nothing, since it asks only about edges, but a vertex-level test
+    built on it refuses every candidate it is ever offered. Measured: 1114 of
+    1114 on a cut mesh, before a single one reached a shape test.
+
+    Over-locking is safe in the sense that it cannot corrupt a mesh, but not in
+    the sense that matters: it disables the feature silently. Third instance of
+    the same trap, after ``Elements`` here and ``uwnvb_refedge`` in
+    :data:`_BOOKKEEPING_LABELS`. A label's *presence* on a point says nothing
+    about whether it means a material interface.
+
+    A region *join* is handled separately, by :func:`_cell_regions`, which
+    compares the two cells rather than reading the edge.
+    """
+    pStart, pEnd = dm.getChart()
+    cS, cE = dm.getHeightStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    flag = np.zeros(pEnd - pStart, dtype=bool)
+    for i in range(dm.getNumLabels()):
+        if dm.getLabelName(i) in _TOPOLOGY_LABELS:
+            continue
+        label = dm.getLabel(dm.getLabelName(i))
+        values = label.getValueIS()
+        if values is None:
+            continue
+        for val in values.getIndices():
+            points = label.getStratumIS(int(val))
+            if points is None:
+                continue
+            idx = np.asarray(points.getIndices(), dtype=np.int64)
+            if not len(idx):
+                continue
+            if ((idx >= cS) & (idx < cE)).any():
+                continue                 # a volume label, not an interface
+            flag[idx[(idx >= eS) & (idx < eE)] - pStart] = True
+    return flag
+
+
+def _cell_regions(dm):
+    """Per-cell label signature, or ``None`` when every cell carries the same one.
+
+    An edge between two cells with different region values is a material
+    interface even when the edge itself is unlabelled, so the signature is what
+    lets those edges be locked. Built from label strata rather than a per-cell
+    query, which would be one PETSc call per cell per label.
+
+    :data:`_BOOKKEEPING_LABELS` is excluded: a label may partition the cells for
+    reasons that have nothing to do with material, and treating one of those as a
+    region locks most of the mesh against repair without saying so.
+    """
+    cS, cE = dm.getHeightStratum(0)
+    names = [dm.getLabelName(i) for i in range(dm.getNumLabels())
+             if dm.getLabelName(i) not in _TOPOLOGY_LABELS
+             and dm.getLabelName(i) not in _BOOKKEEPING_LABELS]
+    sig = np.zeros((cE - cS, len(names)), dtype=np.int64)
+    for j, name in enumerate(names):
+        label = dm.getLabel(name)
+        values = label.getValueIS()
+        if values is None:
+            continue
+        for val in values.getIndices():
+            points = label.getStratumIS(int(val))
+            if points is None:
+                continue
+            idx = np.asarray(points.getIndices(), dtype=np.int64)
+            cells = idx[(idx >= cS) & (idx < cE)]
+            if len(cells):
+                sig[cells - cS, j] = int(val)
+    if sig.shape[1] == 0 or np.all(sig == sig[0]):
+        return None
+    return sig
+
+
+def _cell_vertices_and_seam(dm, X, shared):
+    """One closure pass: anticlockwise vertices of every cell, and the seam mask.
+
+    Both need the transitive closure of every cell, so they are computed together
+    rather than in two passes.
+    """
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    pStart, _pEnd = dm.getChart()
+    any_shared = bool(shared.any())
+
+    verts = np.empty((cE - cS, 3), dtype=np.int64)
+    frozen = np.zeros(cE - cS, dtype=bool)
+    for c in range(cS, cE):
+        closure = np.asarray(dm.getTransitiveClosure(c)[0], dtype=np.int64)
+        v = [int(p) for p in closure if vS <= p < vE]
+        if _orient2d(X[v[0] - vS], X[v[1] - vS], X[v[2] - vS]) < 0:
+            v = [v[0], v[2], v[1]]
+        verts[c - cS] = v
+        if any_shared:
+            frozen[c - cS] = bool(shared[closure - pStart].any())
+    return verts, frozen
+
+
+# ------------------------------------------------------------------- the rebuild
+
+def _write_coordinates(new, dm, vertex_range, source):
+    """Give ``new`` a local vertex coordinate section holding ``source``'s rows.
+
+    ``vertex_range`` is the new mesh's vertex stratum and ``source`` indexes the
+    source mesh's coordinate rows, one per new vertex — the identity for a
+    rebuild that preserves the numbering, and the survivor list for one that
+    compacts the chart. Written through a section rather than ``setCoordinates``
+    because this is purely local data and the latter wants a global vector.
+    """
+    cdim = dm.getCoordinateDim()
+    vS, vE = vertex_range
+    new.setCoordinateDim(cdim)
+    section = new.getCoordinateSection()
+    section.setNumFields(1)
+    section.setFieldComponents(0, cdim)
+    section.setChart(vS, vE)
+    for v in range(vS, vE):
+        section.setDof(v, cdim)
+        section.setFieldDof(v, 0, cdim)
+    section.setUp()
+    coords = PETSc.Vec().createSeq(section.getStorageSize(),
+                                   comm=PETSc.COMM_SELF)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, cdim)
+    coords.array[:] = X[source].reshape(-1)
+    new.setCoordinatesLocal(coords)
+
+
+def _copy_labels(new, dm, point_map=None):
+    """Copy every non-topology label across, by point id.
+
+    ``point_map`` is chart-indexed and may be ``None`` for an unchanged chart.
+    A point mapped to a negative entry has been deleted and its label value goes
+    with it. No coordinate matching is involved anywhere, which is the whole
+    reason both rebuilds work in terms of a point map.
+    """
+    pStart, _pEnd = dm.getChart()
+    for i in range(dm.getNumLabels()):
+        name = dm.getLabelName(i)
+        if name in _TOPOLOGY_LABELS:
+            continue
+        new.createLabel(name)
+        source, target = dm.getLabel(name), new.getLabel(name)
+        values = source.getValueIS()
+        if values is None:
+            continue
+        for val in values.getIndices():
+            points = source.getStratumIS(int(val))
+            if points is None:
+                continue
+            for p in points.getIndices():
+                q = int(p) if point_map is None else int(point_map[int(p)
+                                                                  - pStart])
+                if q >= 0:
+                    target.setValue(q, int(val))
+
+
+def rebuild_with_cones(dm, new_cells, new_edges):
+    """Build a fresh plex on the **same point chart** with the given cones replaced.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        Source mesh. Not modified.
+    new_cells : dict
+        ``{cell point: (v0, v1, v2)}`` with the vertices anticlockwise.
+    new_edges : dict
+        ``{edge point: (va, vb)}``.
+
+    Returns
+    -------
+    PETSc.DMPlex
+        A new mesh whose chart, coordinates, labels and point star-forest match
+        the source, differing only in the replaced cones.
+
+    Notes
+    -----
+    Surgery on the source is not possible: ``DMPlexSymmetrize`` refuses to run on
+    a plex that already has supports, and nothing outside ``DMDestroy`` frees
+    them. Hence a fresh plex with every untouched cone copied across.
+
+    The cone-orientation convention is derived, not assumed. For a triangle the
+    closure vertex order is anticlockwise, cone entry ``i`` is the edge joining
+    closure vertices ``i`` and ``i+1`` (mod 3), and its orientation is ``0`` when
+    the edge's own cone runs that way and ``-1`` when reversed. A wrong
+    orientation does not raise — it silently yields wrong geometry — so it is
+    computed from the edge cone every time.
+    """
+    pStart, pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+
+    new = PETSc.DMPlex().create(comm=dm.comm)
+    new.setDimension(dm.getDimension())
+    new.setChart(pStart, pEnd)
+    for p in range(pStart, pEnd):
+        new.setConeSize(p, dm.getConeSize(p))
+    new.setUp()
+
+    # Edges first: the cell wiring below reads edge cones back to derive
+    # orientations, so they have to be the new ones already.
+    for p in range(pStart, pEnd):
+        if p in new_cells:
+            continue
+        if p in new_edges:
+            new.setCone(p, [int(v) for v in new_edges[p]])
+            continue
+        new.setCone(p, [int(x) for x in dm.getCone(p)])
+        orientation = [int(o) for o in dm.getConeOrientation(p)]
+        if orientation:
+            new.setConeOrientation(p, orientation)
+
+    edge_of = {}
+    for e in range(eS, eE):
+        a, b = (int(v) for v in new.getCone(e))
+        edge_of[(a, b) if a < b else (b, a)] = e
+
+    for c, (v0, v1, v2) in new_cells.items():
+        cone, orientation = [], []
+        for x, y in ((v0, v1), (v1, v2), (v2, v0)):
+            e = edge_of[(x, y) if x < y else (y, x)]
+            cone.append(e)
+            orientation.append(0 if int(new.getCone(e)[0]) == x else -1)
+        new.setCone(c, cone)
+        new.setConeOrientation(c, orientation)
+
+    new.symmetrize()
+    new.stratify()
+
+    # Coordinates verbatim: the vertex points are unchanged, so this is the same
+    # section over the same chart holding the same values.
+    _write_coordinates(new, dm, (vS, vE), np.arange(vE - vS))
+    _copy_labels(new, dm)
+
+    # The star-forest transfers verbatim: every rank preserves its numbering, so
+    # the remote point numbers it carries are still the right ones.
+    if uw.mpi.size > 1:
+        new.setPointSF(dm.getPointSF())
+    return new
+
+
+def rebuild_without_vertices(dm, victims, drop_cells, new_cells):
+    """Build a fresh plex with vertices deleted and their links retriangulated.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        Source mesh. Not modified.
+    victims : sequence of int
+        Vertex points to delete.
+    drop_cells : sequence of int
+        Cell points to delete — the union of the victims' stars.
+    new_cells : sequence of tuple
+        Replacement cells as anticlockwise vertex triples, in the **source**
+        point numbering.
+
+    Returns
+    -------
+    new : PETSc.DMPlex
+        The rebuilt mesh, on a compacted chart.
+    point_map : numpy.ndarray
+        Chart-indexed source point -> new point, ``-1`` for a deleted point.
+
+    Notes
+    -----
+    This is :func:`rebuild_with_cones` with its one restriction lifted. A flip
+    adds and removes no points, so that function can preserve the numbering and
+    hand the star-forest across verbatim. A deletion cannot: the chart shrinks,
+    and every point after a deleted one shifts. So the numbering is rebuilt, and
+    with it the edges — which are not given, but **derived from the new cells**,
+    since an edge of the retriangulated cavity may be an old edge that survived
+    or a chord the ear-clip invented and there is no way to tell them apart
+    except by looking.
+
+    Ordering is by source point number for everything that survives and by
+    vertex tuple for everything new, so the result is a function of the input
+    topology and not of the order the caller happened to accumulate it in.
+
+    The parallel cost is one exchange. Renumbering the star-forest's *local*
+    indices is local knowledge, but the *remote* index of each leaf is the
+    owner's new number for that point, which only the owner knows — so the new
+    numbering is broadcast root-to-leaf once and read back off the leaves. That
+    is bookkeeping over the existing partition; no cell moves rank, and nothing
+    is redistributed.
+
+    The caller is responsible for never deleting a point that the star-forest
+    touches (see :func:`remove_vertices`), which is what lets the leaf set carry
+    across unchanged rather than having to be recomputed.
+    """
+    pStart, pEnd = dm.getChart()
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+
+    dead_v = np.zeros(vE - vS, dtype=bool)
+    dead_v[np.asarray(victims, dtype=np.int64) - vS] = True
+    dead_c = np.zeros(cE - cS, dtype=bool)
+    dead_c[np.asarray(drop_cells, dtype=np.int64) - cS] = True
+
+    surv_v = np.flatnonzero(~dead_v) + vS
+    surv_c = np.flatnonzero(~dead_c) + cS
+
+    # Cells, in the source numbering, as vertex triples: survivors keep their
+    # relative order, the replacements follow sorted by vertex tuple. Every
+    # triple is turned anticlockwise here, because the cone orientations below
+    # are derived from the traversal and a clockwise cell would be wired to a
+    # negative volume without raising.
+    X = _coords(dm)
+
+    def anticlockwise(tri):
+        a, b, c = (int(v) for v in tri)
+        if _orient2d(X[a - vS], X[b - vS], X[c - vS]) < 0:
+            return (a, c, b)
+        return (a, b, c)
+
+    kept = []
+    for c in surv_c:
+        closure = np.asarray(dm.getTransitiveClosure(int(c))[0], dtype=np.int64)
+        kept.append(anticlockwise([p for p in closure if vS <= p < vE]))
+    made = sorted((anticlockwise(tri) for tri in new_cells),
+                  key=lambda tri: tuple(sorted(tri)))
+    cells = kept + made
+
+    # Edges are whatever the cells ask for. An old edge is reused when its pair
+    # is still wanted, which keeps its labels; the rest are new.
+    wanted = set()
+    for tri in cells:
+        a, b, c = tri
+        wanted.update(((a, b) if a < b else (b, a),
+                       (b, c) if b < c else (c, b),
+                       (c, a) if c < a else (a, c)))
+    surv_e, pair_of = [], {}
+    for e in range(eS, eE):
+        a, b = (int(v) for v in dm.getCone(e))
+        pair = (a, b) if a < b else (b, a)
+        if pair in wanted:
+            surv_e.append(e)
+            pair_of[e] = pair
+    edges = [pair_of[e] for e in surv_e] + sorted(wanted
+                                                  - {pair_of[e]
+                                                     for e in surv_e})
+
+    # Strata keep the source's relative order; only their sizes change.
+    sizes = {"c": len(cells), "v": len(surv_v), "e": len(edges)}
+    offset, at = {}, pStart
+    for _start, key in sorted(((cS, "c"), (vS, "v"), (eS, "e"))):
+        offset[key] = at
+        at += sizes[key]
+
+    point_map = np.full(pEnd - pStart, -1, dtype=np.int64)
+    point_map[surv_c - pStart] = offset["c"] + np.arange(len(surv_c))
+    point_map[surv_v - pStart] = offset["v"] + np.arange(len(surv_v))
+    point_map[np.asarray(surv_e, dtype=np.int64) - pStart] = (
+        offset["e"] + np.arange(len(surv_e)))
+
+    def v_new(v):
+        return int(point_map[v - pStart])
+
+    new = PETSc.DMPlex().create(comm=dm.comm)
+    new.setDimension(dm.getDimension())
+    new.setChart(pStart, at)
+    for i in range(len(cells)):
+        new.setConeSize(offset["c"] + i, 3)
+    for i in range(len(edges)):
+        new.setConeSize(offset["e"] + i, 2)
+    new.setUp()
+
+    edge_of, first_of = {}, {}
+    for i, (a, b) in enumerate(edges):
+        e = offset["e"] + i
+        new.setCone(e, [v_new(a), v_new(b)])
+        edge_of[(a, b)] = e
+        first_of[e] = a
+
+    for i, (v0, v1, v2) in enumerate(cells):
+        cone, orientation = [], []
+        for x, y in ((v0, v1), (v1, v2), (v2, v0)):
+            e = edge_of[(x, y) if x < y else (y, x)]
+            cone.append(e)
+            orientation.append(0 if first_of[e] == x else -1)
+        new.setCone(offset["c"] + i, cone)
+        new.setConeOrientation(offset["c"] + i, orientation)
+
+    new.symmetrize()
+    new.stratify()
+
+    _write_coordinates(new, dm, (offset["v"], offset["v"] + len(surv_v)),
+                       surv_v - vS)
+    _copy_labels(new, dm, point_map)
+
+    if uw.mpi.size > 1:
+        _rebuild_point_sf(new, dm, point_map, at - pStart)
+    return new, point_map
+
+
+def _install_point_sf(new, new_sf):
+    """Install a rebuilt star-forest on the plex AND its coordinate DM.
+
+    The coordinate DM is created when the rebuilt chart's coordinates
+    are written — BEFORE any point SF exists — so it snapshots an empty
+    one. The solve never notices (field sections are created later,
+    from the plex SF), but a parallel HDF5 save then writes every
+    shared vertex as owned on every rank, and the serial reload of such
+    a checkpoint dies in ``coordinatesLoad`` (measured: a split mesh
+    written at np = 4 carried owned+shared = 7121 vertex rows where the
+    true owned count is 6334).
+    """
+    new.setPointSF(new_sf)
+    new.getCoordinateDM().setPointSF(new_sf)
+
+
+def _rebuild_point_sf(new, dm, point_map, nroots):
+    """Carry the point star-forest onto a renumbered chart, in one exchange.
+
+    A leaf's remote entry names the *owner's* local index for the shared point,
+    so renumbering it needs a number this rank does not hold. Broadcasting the
+    new numbering root-to-leaf over the star-forest that is being replaced
+    delivers exactly that, one value per leaf.
+
+    The leaf set itself is unchanged: :func:`remove_vertices` never deletes a
+    shared point, and the split-fault rebuilds never duplicate one (a
+    seam-touching fault is redistributed onto one rank before splitting), so
+    every leaf still exists and only its number has moved.
+    """
+    pStart, pEnd = dm.getChart()
+    sf = dm.getPointSF()
+    try:
+        _nroots, ilocal, iremote = sf.getGraph()
+    except (ValueError, TypeError):
+        return                            # unpopulated: nothing is shared
+
+    root_new = np.ascontiguousarray(point_map, dtype=np.int32)
+    leaf_new = np.full(pEnd - pStart, -1, dtype=np.int32)
+    # COLLECTIVE, and reached on every rank of a parallel run: a rank sharing
+    # nothing still has to participate or its peers block.
+    sf.bcastBegin(MPI.INT32_T, root_new, leaf_new, MPI.REPLACE)
+    sf.bcastEnd(MPI.INT32_T, root_new, leaf_new, MPI.REPLACE)
+
+    # petsc4py will not narrow an index array for us — the graph must arrive as
+    # PETSc's own integer type or `setGraph` raises an unsafe-cast TypeError.
+    new_sf = PETSc.SF().create(comm=dm.comm)
+    if ilocal is None or not len(ilocal):
+        new_sf.setGraph(nroots, np.zeros(0, dtype=PETSc.IntType),
+                        np.zeros(0, dtype=PETSc.IntType))
+        _install_point_sf(new, new_sf)
+        return
+
+    leaves = np.asarray(ilocal, dtype=np.int64)
+    local = point_map[leaves - pStart]
+    remote_index = leaf_new[leaves - pStart]
+    if (local < 0).any() or (remote_index < 0).any():
+        raise RuntimeError(
+            "reconnect: a shared point was deleted. The removal pass must "
+            "freeze the seam; see remove_vertices.")
+
+    remote = np.empty((len(leaves), 2), dtype=PETSc.IntType)
+    remote[:, 0] = np.asarray(iremote).reshape(-1, 2)[:, 0]
+    remote[:, 1] = remote_index
+    new_sf.setGraph(nroots, local.astype(PETSc.IntType), remote.reshape(-1))
+    _install_point_sf(new, new_sf)
+
+
+# ---------------------------------------------------------------- the flip pass
+
+def _flippable(dm, X, verts, frozen, locked, regions):
+    """Edges worth flipping, as ``(edge, cell_t, cell_u, p, a, q, b, gain)``.
+
+    ``(p, a, q, b)`` is the quad anticlockwise with ``(a, b)`` the current
+    diagonal, so the flip replaces cells ``(p, a, b)`` and ``(a, q, b)`` by
+    ``(p, a, q)`` and ``(p, q, b)``. An edge qualifies on two counts:
+
+    * the quad is **strictly convex**, so the flip cannot invert a cell. Declined
+      whenever the filtered orientation predicate cannot resolve a sign;
+    * the flip **strictly reduces the largest of the pair's six angles**.
+
+    The second test is deliberately not the Delaunay (in-circle) criterion, even
+    though this is a Lawson flip. Delaunay maximises the *minimum* angle and says
+    nothing about the maximum, while the P1 interpolation bound depends on the
+    maximum angle and not the minimum (Babuska-Aziz). The two disagree in practice
+    and not marginally: flipping a gmsh-generated mesh towards Delaunay was
+    measured to *raise* the 99th-percentile maximum angle from 126.8 to 129.3
+    degrees, because gmsh optimises element shape rather than the empty-circle
+    property and its triangulation is therefore locally non-Delaunay exactly where
+    it has chosen a better-shaped configuration. Since every UW3 mesh starts from
+    gmsh, a repair pass that can degrade such a mesh is unusable. Gating on the
+    angle instead makes the pass monotone by construction: it can decline, but it
+    cannot make a mesh worse.
+    """
+    eS, eE = dm.getDepthStratum(1)
+    cS, _cE = dm.getHeightStratum(0)
+    vS, _vE = dm.getDepthStratum(0)
+    pStart, _pEnd = dm.getChart()
+
+    out = []
+    for e in range(eS, eE):
+        if locked[e - pStart]:
+            continue
+        support = [int(c) for c in dm.getSupport(e)]
+        if len(support) != 2:
+            continue                     # boundary edge: nothing to flip into
+        t, u = support
+        if frozen[t - cS] or frozen[u - cS]:
+            continue
+        if regions is not None and not np.array_equal(regions[t - cS],
+                                                     regions[u - cS]):
+            continue                     # region interface
+        a, b = (int(v) for v in dm.getCone(e))
+        p = next(v for v in verts[t - cS] if v not in (a, b))
+        q = next(v for v in verts[u - cS] if v not in (a, b))
+
+        # Order the diagonal so the quad p-a-q-b runs anticlockwise.
+        if _orient2d(X[p - vS], X[a - vS], X[q - vS]) < 0:
+            a, b = b, a
+        if _orient2d(X[p - vS], X[a - vS], X[q - vS]) <= 0:
+            continue                     # not strictly convex, or unresolved
+        if _orient2d(X[p - vS], X[q - vS], X[b - vS]) <= 0:
+            continue
+
+        Xp, Xa, Xq, Xb = X[p - vS], X[a - vS], X[q - vS], X[b - vS]
+        old = ((Xp, Xa, Xb), (Xa, Xq, Xb))
+        new = ((Xp, Xa, Xq), (Xp, Xq, Xb))
+        before = _smallest_cosine(old)
+        after = _smallest_cosine(new)
+        if after <= before + _MIN_GAIN:
+            continue                     # no shape gain worth the flip
+        # ... and it may not buy that gain by making a NEEDLE. The objective
+        # stays the maximum angle, for the Babuska-Aziz reason above; this is
+        # only a floor under the other end. Without it the pass is free to
+        # trade an obtuse cell for a thin one, whose largest angle is
+        # unremarkable and so never registers here — measured on a cut graded
+        # mesh, flipping alone took the smallest angle in the mesh DOWN, which
+        # is what a caller composing this with a size field will not expect.
+        if _largest_cosine(new) > _largest_cosine(old) + _MIN_GAIN:
+            continue
+        out.append((e, t, u, int(p), a, int(q), b, after - before))
+
+    # Best gain first, so that when two candidate flips share a cell and only one
+    # can run this sweep, the sweep keeps the better of the two rather than
+    # whichever the edge loop happened to reach first.
+    out.sort(key=lambda row: -row[7])
+    return out
+
+
+def flip_to_reduce_max_angle(dm, max_sweeps=12):
+    """Flip edges to reduce the largest element angles, leaving the seam alone.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        A 2-D simplex mesh. Not modified.
+    max_sweeps : int
+        Cap on sweeps. Reaching it warns rather than failing silently.
+
+    Returns
+    -------
+    repaired : PETSc.DMPlex
+        A new mesh on the same point chart, or ``dm`` itself if nothing flipped.
+    n_flips : int
+        Flips performed across all ranks.
+
+    Notes
+    -----
+    Each sweep applies an **independent** set of flips — no two sharing a cell —
+    and rebuilds once, instead of rebuilding per flip. Two flips sharing a cell
+    would each rewire it from a stale reading of the other's result. Deferring the
+    loser to the next sweep costs a sweep; not deferring it costs correctness.
+
+    Every accepted flip strictly reduces its own pair's largest angle, so the pass
+    cannot degrade a mesh. It is not guaranteed to reach a global optimum: reducing
+    one pair's largest angle can raise a neighbouring pair's, so the sequence is a
+    local improvement and ``max_sweeps`` is the guard against a pathological case
+    cycling between configurations. In practice it converges in a few sweeps.
+    """
+    if dm.getDimension() != 2:
+        raise NotImplementedError(
+            "reconnect.flip_to_reduce_max_angle is 2-D only. In 3-D no single "
+            "flip is enough — the operator set has to change to quality-gated "
+            "edge removal, and a Delaunay tetrahedralisation still contains "
+            "slivers so the empty-sphere test is no help either. See "
+            "docs/developer/design/mesh-reconnection-and-delaunay-adapt.md")
+
+    total = 0
+    for _sweep in range(max_sweeps):
+        X = _coords(dm)
+        verts, frozen = _cell_vertices_and_seam(dm, X, _shared_points(dm))
+        candidates = _flippable(dm, X, verts, frozen, _interface_edges(dm),
+                                _cell_regions(dm))
+
+        claimed = set()
+        new_cells, new_edges = {}, {}
+        for e, t, u, p, a, q, b, _gain in candidates:
+            if t in claimed or u in claimed:
+                continue
+            claimed.update((t, u))
+            new_edges[e] = (p, q)
+            new_cells[t] = (p, a, q)
+            new_cells[u] = (p, q, b)
+
+        # COLLECTIVE, and reached on every rank: one with nothing to flip still
+        # has to vote or its peers block waiting for it.
+        n = uw.mpi.comm.allreduce(len(new_edges), op=MPI.SUM)
+        if n == 0:
+            break
+        dm = rebuild_with_cones(dm, new_cells, new_edges)
+        total += n
+    else:
+        uw.pprint(0, f"[reconnect] reached the {max_sweeps}-sweep cap with flips "
+                     f"still pending. The mesh is valid and conforming but not "
+                     f"fully repaired; raise max_sweeps if this matters.")
+
+    return dm, total
+
+
+# ------------------------------------------------------------- the removal pass
+
+def _link_ring(cells_of_v, v, verts, cS):
+    """The victim's link as a closed anticlockwise ring, or ``None``.
+
+    Each incident cell contributes the directed edge of its link that the cell
+    traverses, so following them from any start walks the ring once. Anything
+    other than a single closed walk visiting every incident cell — a boundary
+    vertex, a non-manifold fan, a vertex reached twice — returns ``None`` and the
+    victim is declined. That is the cheapest available test for "the link is a
+    simple polygon", which is the one thing the ear-clip below assumes.
+    """
+    step = {}
+    for c in cells_of_v:
+        tri = list(verts[c - cS])
+        i = tri.index(v)
+        step[tri[(i + 1) % 3]] = tri[(i + 2) % 3]
+    if len(step) != len(cells_of_v):
+        return None
+    start = min(step)
+    ring, cur = [start], step[start]
+    while cur != start:
+        if cur not in step or len(ring) > len(step):
+            return None
+        ring.append(cur)
+        cur = step[cur]
+    return ring if len(ring) == len(step) else None
+
+
+def _ear_clip(ring, X, vS):
+    """Triangulate a simple polygon, choosing each ear by shape.
+
+    The ear taken is the one whose triangle has the smallest largest angle —
+    the same objective the flip pass optimises, and for the same reason, that
+    the P1 interpolation bound depends on the maximum angle and not the minimum
+    (Babuska-Aziz). Ties break on the ear tip's coordinates.
+
+    Neither the choice nor the order depends on point numbers or on traversal
+    order, only on geometry, so two ranks holding the same polygon would produce
+    the same triangulation. Nothing here relies on that yet — the removal pass
+    freezes the seam — but a pass that did not have the property could never
+    have the restriction lifted.
+
+    Returns ``None`` if no ear can be cut, which is what a polygon that is not
+    simple looks like from the inside.
+    """
+    poly = list(ring)
+    out = []
+    while len(poly) > 3:
+        n = len(poly)
+        best, best_key = None, None
+        for i in range(n):
+            a, b, c = poly[(i - 1) % n], poly[i], poly[(i + 1) % n]
+            Xa, Xb, Xc = X[a - vS], X[b - vS], X[c - vS]
+            if _orient2d(Xa, Xb, Xc) <= 0:
+                continue                      # reflex, or unresolved
+            # An ear may not contain another vertex of the polygon. The test is
+            # inclusive, so a vertex lying ON the candidate ear's long side
+            # blocks it: that is exactly the chord which would run along a
+            # straight run of the link and leave a vertex stranded inside an
+            # edge, and it is how a cut whose flank passes through the link
+            # survives this pass intact.
+            if any(_orient2d(Xa, Xb, X[p - vS]) >= 0
+                   and _orient2d(Xb, Xc, X[p - vS]) >= 0
+                   and _orient2d(Xc, Xa, X[p - vS]) >= 0
+                   for p in poly if p not in (a, b, c)):
+                continue
+            key = (-_smallest_cosine(((Xa, Xb, Xc),)), Xb[0], Xb[1])
+            if best_key is None or key < best_key:
+                best, best_key = (i, a, b, c), key
+        if best is None:
+            return None
+        i, a, b, c = best
+        out.append((a, b, c))
+        poly.pop(i)
+    return out + [tuple(poly)]
+
+
+def _removable(dm, X, verts, frozen, locked, regions, candidates, gate):
+    """Vertices worth deleting, as ``(gain, tie, victim, cells, triangles)``.
+
+    A candidate is declined unless every one of these holds:
+
+    * it is **not shared**, and no cell of its link is — the seam is frozen for
+      the same reason the flip pass freezes it, and one level more strictly,
+      since a deletion changes the chart and not merely a few cones;
+    * no incident edge carries an **interface label**, which is what keeps a cut
+      or a named boundary intact. Testing the *edges* rather than the vertex is
+      what makes this work at all, in both directions:
+      :func:`~underworld3.utilities.line_cut.cut_along_lines` labels the cut's
+      edges and not its vertices, so a vertex test would delete a vertex out of
+      the middle of a fault and leave a gap in it — while every vertex of every
+      UW3 mesh carries a sentinel label, so a vertex test would equally refuse
+      every candidate. See :func:`_interface_edges`;
+    * every incident edge has **two cells**, so the vertex is interior. A
+      boundary vertex would change the domain, and its link is not closed
+      anyway;
+    * its link cells all lie in the **same region**, so a material join is not
+      dissolved;
+    * the retriangulation **improves the shape** of the cells it replaces, in
+      the sense ``gate`` names.
+
+    The last is a refusal, not a policy: it stops the pass making a mesh worse,
+    but it does not decide where deletion is *wanted*. That is the caller's job,
+    and it matters, because unlike a flip a deletion removes a degree of freedom
+    — run over every vertex it would coarsen wherever the mesh happens to be
+    slightly ill-shaped. The intended candidate set is the vertices a conforming
+    cut had to distort, which is where the damage is.
+    """
+    cS, cE = dm.getHeightStratum(0)
+    vS, _vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    pStart, _pEnd = dm.getChart()
+
+    out = []
+    for v in candidates:
+        v = int(v)
+        star = np.asarray(dm.getTransitiveClosure(v, useCone=False)[0],
+                          dtype=np.int64)
+        cells = [int(p) for p in star if cS <= p < cE]
+        edges = [int(p) for p in star if eS <= p < eE]
+        if any(locked[e - pStart] for e in edges):
+            continue
+        if any(len(dm.getSupport(e)) != 2 for e in edges):
+            continue                          # boundary vertex
+        if any(frozen[c - cS] for c in cells):
+            continue                          # seam
+        if regions is not None and not all(
+                np.array_equal(regions[c - cS], regions[cells[0] - cS])
+                for c in cells):
+            continue
+
+        ring = _link_ring(cells, v, verts, cS)
+        if ring is None:
+            continue
+        tris = _ear_clip(ring, X, vS)
+        if tris is None:
+            continue
+
+        old = [X[np.asarray(verts[c - cS]) - vS] for c in cells]
+        new = [X[np.asarray(t) - vS] for t in tris]
+        obtuse = _smallest_cosine(new) - _smallest_cosine(old)
+        needle = _largest_cosine(old) - _largest_cosine(new)
+        if gate in ("obtuse", "both") and obtuse <= -_MIN_GAIN:
+            continue
+        if gate in ("needle", "both") and needle <= -_MIN_GAIN:
+            continue
+        gain = {"obtuse": obtuse, "needle": needle,
+                "both": min(obtuse, needle)}[gate]
+        if gain <= _MIN_GAIN:
+            continue
+        out.append((gain, tuple(X[v - vS]), v, cells, tris))
+
+    # Best gain first, as in the flip pass, so that when two candidates share a
+    # cell the pass keeps the better of the two rather than whichever the loop
+    # reached first. The coordinate tie-break keeps the order geometric.
+    out.sort(key=lambda row: (-row[0], row[1]))
+    return out
+
+
+def remove_vertices(dm, candidates, max_passes=3, gate="both"):
+    """Delete vertices and retriangulate their links, leaving the seam alone.
+
+    The third mesh primitive. A conforming cut has only two — move a vertex onto
+    the surface, or split an edge the surface crosses — and every sliver it
+    leaves follows from that: a crossing that falls near a vertex must either
+    drag the vertex to it or carve a thin cell beside it. Deleting the vertex
+    dissolves the case instead of trading it, and it is the only one of the three
+    that *removes* work rather than adding it.
+
+    Parameters
+    ----------
+    dm : PETSc.DMPlex
+        A 2-D simplex mesh. Not modified.
+    candidates : sequence of int
+        Vertex points offered for deletion. Which vertices to offer is a policy
+        decision and deliberately not made here — see :func:`_removable`.
+    max_passes : int
+        Cap on passes. Each pass deletes an independent set, so a candidate
+        beaten to a shared cell needs another pass to be reconsidered.
+    gate : {"both", "obtuse", "needle"}
+        Which shape measure a deletion must improve, and may never degrade:
+        the cavity's largest angle (``obtuse``), its smallest (``needle``), or
+        both. See the notes.
+
+    Returns
+    -------
+    reduced : PETSc.DMPlex
+        A new mesh, or ``dm`` itself if nothing was deleted.
+    n_removed : int
+        Vertices deleted across all ranks.
+
+    Notes
+    -----
+    Deletions are applied an independent set at a time — no two victims sharing
+    a cell — because two overlapping links would each be retriangulated from a
+    stale reading of the other's result.
+
+    The candidate list is carried between passes through the point map the
+    rebuild returns, so a caller chooses its vertices once against the mesh it
+    was handed rather than having to re-derive them against a renumbered chart.
+    """
+    if dm.getDimension() != 2:
+        raise NotImplementedError(
+            "reconnect.remove_vertices is 2-D only. The cavity of a deleted "
+            "vertex is a polygon in 2-D and a polyhedron in 3-D, and ear "
+            "clipping does not generalise to one.")
+
+    cand = np.unique(np.asarray(candidates, dtype=np.int64))
+    total = 0
+    for _pass in range(max_passes):
+        pStart, _pEnd = dm.getChart()
+        cS, _cE = dm.getHeightStratum(0)
+        X = _coords(dm)
+        verts, frozen = _cell_vertices_and_seam(dm, X, _shared_points(dm))
+        plans = _removable(dm, X, verts, frozen, _interface_edges(dm),
+                           _cell_regions(dm), cand, gate)
+
+        claimed, victims, drop, made = set(), [], [], []
+        for _gain, _tie, v, cells, tris in plans:
+            if any(c in claimed for c in cells):
+                continue
+            claimed.update(cells)
+            victims.append(v)
+            drop.extend(cells)
+            made.extend(tris)
+
+        # COLLECTIVE, and reached on every rank: one with nothing to delete
+        # still has to vote or its peers block waiting for it.
+        n = uw.mpi.comm.allreduce(len(victims), op=MPI.SUM)
+        if n == 0:
+            break
+        dm, point_map = rebuild_without_vertices(dm, victims, drop, made)
+        cand = point_map[cand - pStart]
+        cand = cand[cand >= 0]
+        total += n
+
+    return dm, total
diff --git a/src/underworld3/utilities/rotated_bc.py b/src/underworld3/utilities/rotated_bc.py
index 3d5218450..439ab72b6 100644
--- a/src/underworld3/utilities/rotated_bc.py
+++ b/src/underworld3/utilities/rotated_bc.py
@@ -231,12 +231,18 @@ def build_rotation(solver, boundaries, datum_specs=None):
             if dspec is not None:
                 node_dspec.setdefault(q, dspec)
 
+    # Split-fault contact pairs (fault_contact.add_frictionless_fault_bc):
+    # their 2·dim mean/jump blocks widen the widest row of Q.
+    fault_names = getattr(solver, "_fault_contact_faults", [])
+
     # Distributed Q with the assembled operator's ROW layout. Q is identity except a
     # per-node dim×dim orthonormal block; because a node's dim velocity components
     # live on a SINGLE DMPlex point owned by ONE rank, each block is entirely within
     # that rank's diagonal portion — no off-rank columns. Each rank sets ONLY its
     # owned rows (ghost copies of a shared boundary node are skipped: their global
-    # rows fall outside [rstart, rend)).
+    # rows fall outside [rstart, rend)). A fault PAIR block spans two points, but
+    # both are rank-local (a seam-touching fault is redistributed onto one rank
+    # before the split), so the diagonal-portion argument carries over unchanged.
     A = solver.snes.getJacobian()[0]
     rstart, rend = A.getOwnershipRange()
     nloc = rend - rstart
@@ -244,7 +250,7 @@ def build_rotation(solver, boundaries, datum_specs=None):
     Q = PETSc.Mat().create(comm=dm.comm)
     Q.setSizes(((nloc, N), (nloc, N)))
     Q.setType("aij")
-    Q.setPreallocationNNZ((dim, 0))
+    Q.setPreallocationNNZ((2 * dim if fault_names else dim, 0))
     Q.setOption(PETSc.Mat.Option.NEW_NONZERO_ALLOCATION_ERR, False)
     for i in range(rstart, rend):
         Q.setValue(i, i, 1.0)                    # identity default (owned rows)
@@ -279,6 +285,75 @@ def build_rotation(solver, boundaries, datum_specs=None):
             nn = M.sum(axis=0); nn = nn / (np.linalg.norm(nn) + 1e-30)
             sgn = 1.0 if float(np.dot(Vt[0], nn)) >= 0.0 else -1.0
             datum_nodes.append((grows[0], q, node_dspec[q], sgn))
+
+    # Split-fault contact: one orthogonal 2·dim block per coincident DOF pair,
+    # transforming (v⁺, v⁻) to mean/jump components in the fault (n̂,t̂) frame —
+    # mean rows written on the Plus point's rows, jump rows on the Minus
+    # point's. The jump-NORMAL row joins the constrained set (no opening,
+    # datum 0); the jump-tangent (slip) row stays free, which IS the
+    # frictionless zero-shear-traction condition — its conjugate reaction is
+    # the shear traction and an unconstrained row carries none. (A future
+    # datum on the slip row is jump-only prescribed slip; a nonlinear relation
+    # on it is friction.)
+    if fault_names:
+        from underworld3.utilities import fault_contact
+        s2 = 1.0 / np.sqrt(2.0)
+        # Rank-local failures in this block (a pairing/label mismatch or a
+        # vanishing analytic normal inside _fault_pair_nodes, a fault node
+        # shared with a wall boundary, a pair straddling ranks) must not
+        # leave the peers blocked in the collective Q assembly below —
+        # collect the verdict and raise it identically on every rank.
+        # ``fault_names`` is registration state, identical across ranks, so
+        # every rank reaches the verdict exchange.
+        problem = None
+        try:
+            for fname in fault_names:
+                for q_plus, q_minus, nrm in fault_contact._fault_pair_nodes(
+                        solver, fname):
+                    if q_plus in node_normals or q_minus in node_normals:
+                        raise ValueError(
+                            f"fault {fname!r} shares a node with a rotated "
+                            "free-slip boundary; a point cannot carry both a "
+                            "wall block and a pair block.")
+                    # The tangent frame: one in-fault direction in 2-D, two
+                    # in 3-D. Shared with the interface assembler's slip
+                    # rows — _tangent_frame is the single authority. The
+                    # specific in-plane directions carry no physics: both
+                    # slip rows are free (frictionless) or enter through
+                    # |V| (laws).
+                    frame = [nrm] + fault_contact._tangent_frame(nrm)
+                    gp, gm = [], []
+                    for q, rows in ((q_plus, gp), (q_minus, gm)):
+                        lo = lsec.getFieldOffset(q, _VELOCITY_FIELD)
+                        rows.extend(int(l2g.apply([lo + c])[0])
+                                    for c in range(dim))
+                    if any(g < 0 for g in gp + gm):
+                        continue
+                    owned_p = rstart <= gp[0] < rend
+                    owned_m = rstart <= gm[0] < rend
+                    if owned_p != owned_m:
+                        # Structurally impossible after the fault-aware
+                        # redistribution (the split runs rank-interior),
+                        # but "impossible by the seam rules" is exactly
+                        # where surprises have lived — keep the check,
+                        # and make its verdict collective like the rest.
+                        raise RuntimeError(
+                            "fault_contact: a coincident pair straddles "
+                            "ranks — the split's redistribution should "
+                            "make this impossible.")
+                    if not owned_p:
+                        continue
+                    for i, e in enumerate(frame):
+                        for row, sgn in ((gp[i], +1.0), (gm[i], -1.0)):
+                            for j in range(dim):
+                                Q.setValue(row, gp[j], s2 * float(e[j]))
+                                Q.setValue(row, gm[j],
+                                           sgn * s2 * float(e[j]))
+                    normal_rows.append(gm[0])      # [v]·n̂ = 0, datum 0
+        except (RuntimeError, ValueError) as err:
+            problem = str(err)
+        fault_contact._collective_raise(problem)
+
     Q.assemble()
     Qt = Q.transpose(PETSc.Mat())
 
@@ -596,6 +671,16 @@ def solve_rotated_freeslip(solver, boundaries, remove_rotation_gauge=True,
     # gauge is fixed by the naive pressure pin instead (see _naive_pressure_pin).
     use_lu = bool(getattr(solver, "_rotated_use_lu", False))
     custom_Pl = None if use_lu else _build_rotated_custom_Pl(solver, Q, normal_rows)
+    # Interface constitutive laws (fault_contact.add_viscous_fault_bc /
+    # add_coulomb_fault_bc): the assembler caches the fault-trace geometry
+    # once; each iterate it adds the interface force ∫τ(V)δV to the rotated
+    # residual and the CONSISTENT tangent 2·(dτ/dV)·M to the rotated
+    # operator — full Newton in V, the stiff direction. (Only a future
+    # reaction-fed σ_n argument would be Picard-lagged, by choice.)
+    interface = None
+    if getattr(solver, "_fault_interface_laws", {}):
+        from underworld3.utilities import fault_contact
+        interface = fault_contact._InterfaceAssembler(solver)
     # The null space is built INSIDE the loop, after the first Jacobian assembly:
     # _mode_satisfies_constraints verifies each candidate mode against the
     # ASSEMBLED operator (‖J·m‖ ≈ 0), which an unassembled J cannot support.
@@ -644,6 +729,7 @@ def solve_rotated_freeslip(solver, boundaries, remove_rotation_gauge=True,
     # diagonal scale (frozen at the first tangent — only the magnitude matters),
     # and the KSP/PC context (fieldsplit ISs, FMG hierarchy, GAMG setup survive).
     Ahat = None
+    Atot = None
     Mp = None
     ctx = None
     diag_scale = None
@@ -674,8 +760,23 @@ def rotated_residual(uvec, keep_cartesian=False):
         snes.computeFunction(uvec, Fc)
         if keep_cartesian:
             Fc.copy(reaction)                # stash the Cartesian reaction for σ_nn
+            if interface is not None:
+                # Picard-lag the reaction-fed normal stress into the laws:
+                # the stash IS the pure transmitted traction at this iterate
+                # (the interface force is added below, after it). Updated
+                # only at ITERATION STARTS — line-search trials
+                # (keep_cartesian=False) evaluate against the frozen sigma,
+                # which is what makes the lag a consistent comparison.
+                # Iteration 0 sees a zero state: a reaction-fed law starts
+                # frictionless and tightens as the stress field forms.
+                interface.update_normal_stress(solver, reaction)
         Fh = Fc.duplicate()
         Q.mult(Fc, Fh)
+        if interface is not None:
+            # interface constitutive force on the slip rows, evaluated at
+            # THIS iterate (the pair's equal-and-opposite tractions, already
+            # in the rotated frame)
+            interface.residual_add(solver, uvec, Fh)
         _zero_rows_local(Fh, normal_rows)
         if use_pnull:
             sp = Fh.getSubVector(pres_is)
@@ -737,6 +838,28 @@ def rotated_residual(uvec, keep_cartesian=False):
             Ahat = J.ptap(Qt)
         else:
             J.ptap(Qt, result=Ahat)          # same nonzero pattern → in-place refresh
+        # The interface tangent is REASSEMBLED at every iterate (that is
+        # what makes it consistent Newton, dtau/dV at the current slip
+        # rates) and added to a COPY: the ptap-with-result refresh above
+        # owns Ahat's structure, and injected entries would be
+        # stale-or-doubled on the next refresh.
+        if interface is not None:
+            Khat = interface.tangent(solver, u)
+            if Atot is not None:
+                Atot.destroy()
+            Atot = Ahat.copy()
+            Atot.axpy(1.0, Khat,
+                      structure=PETSc.Mat.Structure.DIFFERENT_NONZERO_PATTERN)
+            Khat.destroy()
+            # A recreated operator loses the null space the first solve
+            # attached; re-attach for iterations after the first (a nonlinear
+            # interface law is what reaches them).
+            if ctx is not None and ctx.get("nsp") is not None:
+                Atot.setNullSpace(ctx["nsp"])
+                Atot.setTransposeNullSpace(ctx["nsp"])
+            Aop = Atot
+        else:
+            Aop = Ahat
         if not use_lu:
             if ctx is None:
                 Mp = _pressure_mass_schur_pmat(solver)
@@ -744,7 +867,7 @@ def rotated_residual(uvec, keep_cartesian=False):
             elif Mp is not None:
                 Jp.createSubMatrix(pres_is, pres_is, submat=Mp)   # viscosity may be u-dependent
         if diag_scale is None:
-            diag_scale = _velocity_diag_scale(Ahat, solver)
+            diag_scale = _velocity_diag_scale(Aop, solver)
         bhat = Fhat.copy()
         bhat.scale(-1.0)
         if lift_datum and iters == 0:
@@ -752,11 +875,11 @@ def rotated_residual(uvec, keep_cartesian=False):
             # b̂[rows] = diag·x̂ and the eliminated columns' A[:,cols]·x̂ are
             # subtracted from the other rows. For a LINEAR model this increment IS
             # the whole solve; the loop converges at the next residual check.
-            Ahat.zeroRowsColumns(normal_rows, diag=diag_scale, x=xhat, b=bhat)
+            Aop.zeroRowsColumns(normal_rows, diag=diag_scale, x=xhat, b=bhat)
             xhat.destroy()
             xhat = None
         else:
-            Ahat.zeroRowsColumns(normal_rows, diag=diag_scale)
+            Aop.zeroRowsColumns(normal_rows, diag=diag_scale)
         if use_lu:
             if ctx is None:
                 ksp_lu = PETSc.KSP().create(comm=dm.comm)
@@ -768,10 +891,10 @@ def rotated_residual(uvec, keep_cartesian=False):
                        "pin": _naive_pressure_pin(dm)}
             pin = ctx["pin"]
             if pin is not None:
-                Ahat.zeroRows([pin], diag=1.0)
+                Aop.zeroRows([pin], diag=1.0)
                 _zero_rows_local(bhat, [pin])
-            ctx["ksp"].setOperators(Ahat)     # values changed in place → refactor
-            dhat = Ahat.createVecRight()
+            ctx["ksp"].setOperators(Aop)      # values changed in place → refactor
+            dhat = Aop.createVecRight()
             dhat.set(0.0)
             ctx["ksp"].solve(bhat, dhat)
             last_reason = ctx["ksp"].getConvergedReason()
@@ -781,7 +904,7 @@ def rotated_residual(uvec, keep_cartesian=False):
             _zero_rows_local(dhat, normal_rows)
         else:
             dhat, last_reason, ctx = _solve_rotated_iterative(
-                solver, Ahat, bhat, Q, Qt, normal_rows,
+                solver, Aop, bhat, Q, Qt, normal_rows,
                 custom_Pl=custom_Pl, nsp=nsp, Mp=Mp, verbose=False, ctx=ctx)
         lin_its.append(ctx["ksp"].getIterationNumber())
         vel_its_last.append(ctx.get("vel_its_last"))
@@ -874,6 +997,8 @@ def rotated_residual(uvec, keep_cartesian=False):
     _destroy_rotated_ksp_ctx(ctx)            # KSP/PC + the owned Schur pmat
     if Ahat is not None:
         Ahat.destroy()                       # the reused rotated operator
+    if Atot is not None:
+        Atot.destroy()                       # rotated operator + interface term
     if xhat is not None:
         xhat.destroy()                       # unused lift vector (loop exited before it)
     removed = _finalize_rotated_solution(solver, u, Q, normal_rows, remove_rotation_gauge)
diff --git a/src/underworld3/visualisation/__init__.py b/src/underworld3/visualisation/__init__.py
index 1b4a6c5f2..755b96cf5 100644
--- a/src/underworld3/visualisation/__init__.py
+++ b/src/underworld3/visualisation/__init__.py
@@ -9,13 +9,18 @@
 # Import main visualization functions from visualisation.py
 from .visualisation import (
     mesh_to_pv_mesh,
+    labelled_facets_to_pv_mesh,
     scalar_fn_to_pv_points,
     vector_fn_to_pv_points,
     plot_mesh,
+    plot_mesh_hierarchy,
+    MG_LEVEL_COLOURS,
+    FAULT_COLOUR,
     plot_scalar,
     plot_vector,
     meshVariable_to_pv_cloud,
     meshVariable_to_pv_mesh_object,
+    meshVariable_to_native_pv_mesh,
     swarm_to_pv_cloud,
 )
 
diff --git a/src/underworld3/visualisation/visualisation.py b/src/underworld3/visualisation/visualisation.py
index 1d73f3fb4..8d89a62e5 100644
--- a/src/underworld3/visualisation/visualisation.py
+++ b/src/underworld3/visualisation/visualisation.py
@@ -187,6 +187,78 @@ def mesh_to_pv_mesh(mesh, jupyter_backend=None):
         return pv_mesh
 
 
+def labelled_facets_to_pv_mesh(mesh, name):
+    """The facets carrying a boundary label, as a PyVista object of their own.
+
+    An embedded surface — a conforming fault, a material interface — is a set of
+    facets *inside* the mesh, so drawing it with the mesh hides it: in 2-D it is
+    a few lines among thousands, and in 3-D the surrounding elements occlude it
+    entirely. Returned separately it can be drawn as a wireframe over a
+    transparent or clipped mesh, and saved to ``.vtp`` for interactive viewing.
+
+    The result is dimension-general because a labelled facet's closure gives its
+    vertices whatever the dimension: two in 2-D (a line segment), three in 3-D
+    (a triangle).
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The mesh carrying the label.
+    name : str
+        A boundary name, normally one added by
+        :meth:`~underworld3.discretisation.Mesh.add_conforming_surface`.
+
+    Returns
+    -------
+    pyvista.PolyData
+        Lines in 2-D, triangles in 3-D. Empty if this rank owns no part of the
+        surface, which is normal in parallel.
+
+    Examples
+    --------
+    >>> fault = vis.labelled_facets_to_pv_mesh(cut, "Fault")
+    >>> pl.add_mesh(vis.mesh_to_pv_mesh(cut), style="wireframe",
+    ...             color="lightgrey", opacity=0.3)
+    >>> pl.add_mesh(fault, color="red", line_width=3)
+    >>> fault.save("fault.vtp")            # open in ParaView or pv.read()
+    """
+    import numpy as np
+    import pyvista as pv
+
+    if name not in [b.name for b in mesh.boundaries]:
+        raise ValueError(
+            f"{name!r} is not a boundary of this mesh; have "
+            f"{[b.name for b in mesh.boundaries]}")
+
+    dm = mesh.dm
+    vS, vE = dm.getDepthStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(
+        -1, dm.getCoordinateDim())
+
+    value = mesh.boundaries[name].value
+    label = dm.getLabel(name)
+    # An empty stratum yields a null IS that segfaults in getIndices(), and a
+    # rank owning no part of the surface is the normal case in parallel.
+    if label is None or label.getStratumSize(value) == 0:
+        return pv.PolyData()
+
+    facets = [
+        [int(p) - vS for p in dm.getTransitiveClosure(int(f))[0] if vS <= p < vE]
+        for f in label.getStratumIS(value).getIndices()
+    ]
+    used = sorted({v for facet in facets for v in facet})
+    remap = {v: i for i, v in enumerate(used)}
+    points = _vector_to_pv_vector(X[used])
+
+    cells = np.hstack([[len(f)] + [remap[v] for v in f] for f in facets])
+    out = pv.PolyData(points)
+    if all(len(f) == 2 for f in facets):
+        out.lines = cells
+    else:
+        out.faces = cells
+    return out
+
+
 def coords_to_pv_coords(coords):
     """Convert coordinate array to PyVista-compatible 3D coordinates.
 
@@ -289,12 +361,86 @@ def meshVariable_to_pv_cloud(meshVar):
     return point_cloud
 
 
+def meshVariable_to_native_pv_mesh(meshVar):
+    """The mesh's OWN cells, renumbered so point ``i`` is the variable's DOF ``i``.
+
+    Returns ``None`` when the variable's degrees of freedom are not the mesh
+    vertices — a higher-order or discontinuous field — in which case there is no
+    native triangulation carrying it and the caller must fall back.
+
+    Why this exists
+    ---------------
+    A **continuous P1** field has exactly one degree of freedom per vertex, so
+    the triangulation that carries it already exists in the DM. Re-deriving it
+    with ``delaunay_2d`` is not merely redundant, it is lossy on a graded mesh:
+    Delaunay is a property of the point set alone, so it neither knows nor
+    respects which triangles the mesh actually has, and the ``alpha`` filter —
+    one length for the whole domain — **deletes** cells whose circumradius
+    exceeds it. On an adapted mesh those are precisely the coarse cells. Measured
+    on a fault mesh graded 8:1, 361 of 11610 cells were dropped, and they render
+    as blank holes in the middle of the field.
+
+    The points are returned in the VARIABLE's DOF order rather than the DM's
+    vertex order, so the documented pattern
+
+    >>> pvm = vis.meshVariable_to_pv_mesh_object(T)
+    >>> pvm.point_data["T"] = np.asarray(T.data[:, 0])
+
+    keeps working unchanged. Getting that backwards would draw the right mesh
+    with the values shuffled, which looks like noise rather than like an error.
+    """
+    import numpy as np
+    import pyvista as pv
+    from scipy.spatial import cKDTree
+
+    mesh = meshVar.mesh
+    dim = mesh.dim
+    pvm = mesh_to_pv_mesh(mesh)
+
+    coords = np.asarray(meshVar.coords, dtype=np.float64)
+    if coords.shape[0] != pvm.n_points:
+        return None                      # not one DOF per vertex
+
+    pts = np.asarray(pvm.points, dtype=np.float64)[:, :dim]
+    dist, dof_of_point = cKDTree(coords[:, :dim]).query(pts)
+    extent = float(np.ptp(pts)) or 1.0
+    if dist.max() > 1.0e-8 * extent:
+        return None                      # coincident in count but not in place
+
+    # Renumber the connectivity into DOF order, and hand back the variable's own
+    # coordinates as the points so the two are aligned by construction.
+    try:
+        conn = np.asarray(pvm.cell_connectivity)
+        offsets = np.asarray(pvm.offset)
+    except AttributeError:               # older pyvista
+        return None
+    sizes = np.diff(offsets)
+    if not len(sizes) or (sizes != sizes[0]).any():
+        return None                      # mixed cell types: not worth the risk
+    cells = np.column_stack(
+        [np.full(len(sizes), sizes[0]),
+         dof_of_point[conn].reshape(len(sizes), sizes[0])]).ravel()
+
+    points = np.zeros((coords.shape[0], 3))
+    points[:, :dim] = coords[:, :dim]
+    native = pv.UnstructuredGrid(cells, np.asarray(pvm.celltypes), points)
+    for attr in ("_units", "_coord_array"):
+        if hasattr(pvm, attr):
+            setattr(native, attr, getattr(pvm, attr))
+    native._coord_array = meshVar.coords
+    return native
+
+
 def meshVariable_to_pv_mesh_object(meshVar, alpha=None):
-    """Convert mesh variable to Delaunay-triangulated PyVista mesh.
+    """Convert a mesh variable to a PyVista mesh carrying its nodal points.
 
-    Creates a mesh by triangulating the mesh variable's nodal points.
-    Useful for higher-order elements where the base mesh doesn't
-    capture all data points.
+    Uses the mesh's **own** triangulation when the variable's degrees of freedom
+    are the mesh vertices (a continuous P1 field) — see
+    :func:`meshVariable_to_native_pv_mesh`, which also explains why the Delaunay
+    route silently drops coarse cells on an adapted mesh.
+
+    Otherwise the points are Delaunay-triangulated, which is what higher-order
+    and discontinuous variables need: the base mesh does not carry their DOFs.
 
     Parameters
     ----------
@@ -302,18 +448,23 @@ def meshVariable_to_pv_mesh_object(meshVar, alpha=None):
         Underworld mesh variable.
     alpha : float, optional
         Alpha parameter for Delaunay triangulation. If None, computed
-        automatically from coordinate range.
+        automatically from coordinate range. Ignored on the native path.
 
     Returns
     -------
     pyvista.UnstructuredGrid
-        Triangulated mesh through the variable's nodal points.
+        Mesh through the variable's nodal points, in the variable's DOF order.
     """
     import numpy as np
 
     mesh = meshVar.mesh
     dim = mesh.dim
 
+    if alpha is None:
+        native = meshVariable_to_native_pv_mesh(meshVar)
+        if native is not None:
+            return native
+
     point_cloud = meshVariable_to_pv_cloud(meshVar)
 
     if alpha is None:
@@ -500,6 +651,246 @@ def clip_mesh(pvmesh, clip_angle):
     return [clip1, clip2]
 
 
+
+#: Wireframe colours for a multigrid tail, coarsest first. Blues and greys, so
+#: that the fault colour has the warm half of the wheel to itself — the whole
+#: point of the figure is that the fault is findable at a glance.
+MG_LEVEL_COLOURS = ("#9aa5ad", "#6fa8c7", "#3d86b4", "#1f5f96", "#123f6b",
+                    "#0a2748")
+
+#: The fault. Deliberately the loudest thing on the page.
+FAULT_COLOUR = "#ff1408"
+
+
+def plot_mesh_hierarchy(mesh, faults=(), clip=None, plotter=None,
+                        window_size=(1400, 1400), background="white",
+                        colours=None, fault_colour=FAULT_COLOUR,
+                        line_width=None, fault_style="facets",
+                        fault_line_width=3.0, opacity=1.0,
+                        nodes=True, node_scale=0.30, legend=True):
+    """Wireframe of a mesh, its multigrid tail, and its faults, in one figure.
+
+    The standard way to look at a stacked-on mesh: one colour per level, coarsest
+    palest, and the fault cells filled in a contrasting red. It answers the three
+    questions that actually come up — did the hierarchy come out with the levels
+    expected, is the refinement where the fault is, and did the fault survive the
+    repair passes — without needing a separate figure for each.
+
+    Written to carry to 3-D. Nothing here reads the dimension except the defaults:
+    in 3-D the wireframes are taken from each level's SURFACE rather than every
+    interior edge, because a full edge extraction of a tetrahedral hierarchy is
+    an unreadable haze, and ``clip`` cuts the model open so the interior levels
+    and the fault can be seen at all.
+
+    Parameters
+    ----------
+    mesh : Mesh
+        The finest mesh. Its ``_custom_mg_coarse_meshes`` tail is drawn beneath
+        it, coarsest first; a mesh without one is simply drawn alone.
+    faults : sequence of str
+        Boundary label names to pick out in ``fault_colour``.
+    fault_style : {"facets", "cells"}
+        What "the fault" means in the picture, and the two are not the same
+        thing.
+
+        ``"facets"`` (the default) draws the LABELLED FACETS themselves, via
+        :func:`labelled_facets_to_pv_mesh` — the segments in 2-D, the triangles
+        in 3-D. This is the fault as the mesh actually represents it, and it is
+        the honest choice: a fault one element wide is one chain of facets, and
+        drawing it as such shows its width to be exactly what it is.
+
+        ``"cells"`` fills the fault ZONE instead, via
+        :meth:`~underworld3.discretisation.Mesh.cells_supporting` — every cell
+        with a labelled facet, which is one element on EACH side. That is the
+        right set for assigning a material property, but as a picture it makes a
+        one-element fault look two or three elements thick, so it is not the
+        default. Ask for it when the question is "which cells carry the weak
+        viscosity", not "where is the fault".
+    fault_line_width : float
+        Width of the facet lines under ``fault_style="facets"``.
+    nodes : bool
+        Mark the vertices, with a different glyph for each kind: **circles** for
+        the base level, **squares** for the levels stacked on top of it, and
+        **triangles** for the fault's own nodes. Shape carries the distinction
+        as well as colour, so the figure survives being printed in grey and does
+        not rely on telling four blues apart.
+
+        In 3-D the same three roles become sphere, cube and cone.
+    legend : bool
+        Build the key, with the RIGHT SHAPE against each entry. PyVista's
+        default legend face is a triangle for everything, so a hand-rolled
+        ``add_legend`` shows triangles beside wireframes and beside square
+        nodes — a key that contradicts the figure it is keying. Since this
+        routine chose the shapes, it is the thing that can label them.
+    node_scale : float
+        Glyph size as a fraction of the finest level's SMALL cells (its 5th
+        percentile) — one size for every level, so shape and colour carry the
+        distinction and size carries none.
+
+        Two ways to get this wrong, both tried. Scaling each level by its own
+        cell size draws a coarse level's marks at the coarse spacing, burying
+        the fine mesh at exactly the zoom the figure exists for. And using the
+        MEAN cell size of a graded mesh sizes the glyphs by the far field —
+        measured, mean h = 0.017 against h = 0.002 at the fault, so every mark
+        came out bigger than the cell it stood on.
+    clip : tuple, optional
+        ``(normal, origin)`` passed to PyVista's ``clip``. Mostly for 3-D, where
+        an unclipped hierarchy shows only its outer skin.
+    plotter : pyvista.Plotter, optional
+        Draw into an existing plotter instead of making one. The plotter is
+        RETURNED either way, unrendered, so the caller sets the camera and
+        decides between ``show`` and ``screenshot``.
+    colours : sequence of str, optional
+        One per level, coarsest first; :data:`MG_LEVEL_COLOURS` by default,
+        cycled if the hierarchy is deeper than the palette.
+    line_width : sequence of float, optional
+        One per level. By default coarse levels are drawn thicker so they read
+        through the fine ones rather than being buried by them.
+
+    Returns
+    -------
+    pyvista.Plotter
+
+    Examples
+    --------
+    >>> pl = vis.plot_mesh_hierarchy(mesh, faults=["FaultA", "FaultB"])
+    >>> pl.camera.parallel_projection = True
+    >>> pl.screenshot("hierarchy.png")
+
+    The cells carrying the weak viscosity, rather than the fault itself:
+
+    >>> pl = vis.plot_mesh_hierarchy(mesh, faults=["FaultA"],
+    ...                              fault_style="cells")
+    """
+    import numpy as np
+    import pyvista as pv
+
+    initialise(None)
+
+    levels = list(getattr(mesh, "_custom_mg_coarse_meshes", None) or []) + [mesh]
+    palette = list(colours) if colours else list(MG_LEVEL_COLOURS)
+    widths = list(line_width) if line_width is not None else None
+
+    if plotter is None:
+        plotter = pv.Plotter(off_screen=pv.OFF_SCREEN, window_size=window_size)
+    plotter.set_background(background)
+
+    def wire(pvm):
+        if clip is not None:
+            pvm = pvm.clip(normal=clip[0], origin=clip[1])
+        if mesh.dim == 3:
+            pvm = pvm.extract_surface()
+        return pvm.extract_all_edges()
+
+    def marks(points, n_sides, size, colour, label):
+        """Glyph a point set. Shape distinguishes the role, size the level."""
+        pts = np.asarray(points, dtype=float)
+        if not len(pts):
+            return
+        cloud = pv.PolyData(pts if pts.shape[1] == 3
+                            else np.column_stack([pts, np.zeros(len(pts))]))
+        if mesh.dim == 3:
+            geom = {24: pv.Sphere(radius=0.5 * size),
+                    4: pv.Cube(x_length=size, y_length=size, z_length=size),
+                    3: pv.Cone(radius=0.5 * size, height=size)}[n_sides]
+        else:
+            geom = pv.Polygon(center=(0.0, 0.0, 0.0), radius=0.5 * size,
+                              normal=(0.0, 0.0, 1.0), n_sides=n_sides)
+        kw = {} if label is None else {"label": label}
+        plotter.add_mesh(cloud.glyph(geom=geom, scale=False, orient=False),
+                         color=colour, lighting=False, **kw)
+
+    def fine_cell_size(level):
+        """A LOW PERCENTILE of the cell size, never the mean.
+
+        On a graded mesh the mean is set by the far field: on the fault meshes
+        here the finest level averages h = 0.017 while h at the fault is 0.002,
+        so glyphs sized on the mean come out several times larger than the cells
+        they are meant to mark and bury the refined region completely. Same trap
+        as judging a multigrid level by its mean h.
+        """
+        from underworld3.utilities.edge_split import cell_diameters
+        d = cell_diameters(level.dm)
+        return float(np.percentile(d, 5)) if len(d) else 0.0
+
+    node_size = node_scale * fine_cell_size(levels[-1])
+
+    # PyVista's named legend faces are only triangle / circle / rectangle /
+    # none, so a WIREFRAME entry has to supply its own geometry — otherwise the
+    # mesh levels and the square nodes would both key as rectangles and the
+    # figure's own distinction would be lost in its key.
+    line_face = pv.Line((-0.5, 0.0, 0.0), (0.5, 0.0, 0.0))
+
+    key = []
+    n = len(levels)
+    for i, level in enumerate(levels):
+        colour = palette[i % len(palette)]
+        # Coarse thick, fine thin: without the taper the finest level's edges
+        # cover every level under it and the hierarchy cannot be read.
+        w = widths[i] if widths else max(0.4, 2.6 - 2.0 * i / max(n - 1, 1))
+        plotter.add_mesh(wire(mesh_to_pv_mesh(level)), color=colour,
+                         line_width=w, lighting=False, opacity=opacity,
+                         label=f"level {i}"
+                               f"{' (finest)' if i == n - 1 else ''}")
+        key.append([f"level {i}{' (finest)' if i == n - 1 else ''}",
+                    colour, line_face])
+        if nodes:
+            # Circles for the base, squares for everything stacked on it.
+            # Unlabelled: the SHAPE is the key (circle = base, square = stacked
+            # on, triangle = fault), and a legend line per level per glyph
+            # doubles its length to say nothing the shapes do not.
+            marks(np.asarray(level.X.coords), 24 if i == 0 else 4,
+                  node_size, colour, None)
+
+    for name in faults:
+        if fault_style == "facets":
+            pvf = labelled_facets_to_pv_mesh(mesh, name)
+            if pvf.n_points == 0:
+                continue                 # this rank owns none of it; normal
+            if clip is not None:
+                pvf = pvf.clip(normal=clip[0], origin=clip[1])
+            plotter.add_mesh(pvf, color=fault_colour, lighting=False,
+                             line_width=fault_line_width, label=name)
+            key.append([name, fault_colour, line_face])
+            if nodes:
+                marks(pvf.points, 3, node_size, fault_colour, None)
+        elif fault_style == "cells":
+            zone = np.asarray(mesh.cells_supporting(name))
+            if not zone.any():
+                continue
+            cells = mesh_to_pv_mesh(mesh).extract_cells(np.flatnonzero(zone))
+            if clip is not None:
+                cells = cells.clip(normal=clip[0], origin=clip[1])
+            plotter.add_mesh(cells, color=fault_colour, lighting=False,
+                             show_edges=True, edge_color=fault_colour,
+                             line_width=1.0, label=name)
+            key.append([f"{name} zone", fault_colour, "rectangle"])
+        else:
+            raise ValueError(
+                f"fault_style must be 'facets' or 'cells', not {fault_style!r}")
+
+    if nodes:
+        # One entry per ROLE, not per level: the shape says which role, the
+        # level colours are already keyed by the wireframe entries above.
+        key.append(["base nodes", palette[0], "circle"])
+        if n > 1:
+            key.append(["stacked-on nodes", palette[min(n - 1,
+                                                        len(palette) - 1)],
+                        "rectangle"])
+        if faults and fault_style == "facets":
+            key.append(["fault nodes", fault_colour, "triangle"])
+
+    # Exposed so the key can be INSPECTED rather than eyeballed: the failure
+    # this guards against is a legend that disagrees with the figure, and that
+    # is invisible in any check that only counts actors.
+    plotter._uw_legend_key = key
+    if legend and key:
+        plotter.add_legend(key, bcolor="white", border=True,
+                           size=(0.24, 0.030 * len(key) + 0.02),
+                           loc="lower right")
+    return plotter
+
+
 def plot_mesh(
     mesh,
     title="",
diff --git a/tests/_mg_ladder.py b/tests/_mg_ladder.py
new file mode 100644
index 000000000..ef2e652f2
--- /dev/null
+++ b/tests/_mg_ladder.py
@@ -0,0 +1,81 @@
+"""Shared check that an adapt child's multigrid levels really do coarsen.
+
+Imported by ``test_0836_nvb_graded_adapt`` and ``test_0840_nvb_3d_serial_adapt``,
+which previously carried a verbatim copy each.
+
+**The estimator here is deliberately NOT the one the implementation uses.**
+``_subsample_mg_levels`` chooses levels by ``percentile(cell_diameters, 5)``.
+Measuring the result with that same statistic asks the implementation whether it
+did what it decided to do, which it always did: on the 2-D band case it reported
+a step of 1.817 against a 1.800 threshold — a 0.9 % margin — while an independent
+measure of the same step gave 1.401. The number being asserted was the
+selector's own opinion, and a 0.9 % margin on a gmsh mesh is a CI flake waiting
+for a version bump.
+
+The estimator below is the MEAN EDGE LENGTH inside the refined region: a mean
+rather than a percentile, edges rather than cell diameters, and the region the
+metric was actually asked about rather than the whole mesh. It agrees with the
+selector about the thing that matters — whether a level is a near-duplicate of
+its neighbour — and disagrees about the exact ratio, which is why it is worth
+having.
+"""
+
+import numpy as np
+
+
+def refined_resolution(dm, inside):
+    """Mean length of the edges whose midpoint lies in the refined region.
+
+    ``inside`` takes an ``(n, dim)`` array of midpoints and returns a boolean
+    mask. Whole-mesh statistics will not do for adapt-on-top: the mesh only grows
+    where the feature is, so a genuine halving of `h` there shows up as a global
+    cell-count ratio near 1 and a flat whole-mesh median.
+    """
+    vS, _vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    cdim = dm.getCoordinateDim()
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, cdim)
+    ends = np.array([dm.getCone(e) for e in range(eS, eE)], dtype=np.int64) - vS
+    A, B = X[ends[:, 0]], X[ends[:, 1]]
+    sel = inside(0.5 * (A + B))
+    assert sel.any(), "no edge lies in the refined region — check `inside`"
+    return float(np.linalg.norm(A - B, axis=1)[sel].mean())
+
+
+def assert_coarsening_ladder(child, inside, ratio=2.0, slack=0.9, floor=1.25):
+    """No level may be a near-duplicate, and the adapted span must match `ratio`.
+
+    Two separate claims, because they fail differently:
+
+    * **no near-duplicate step.** This is the defect ``mg_coarsening_ratio``
+      exists to remove — hierarchies whose top levels differed by under 1 % in
+      `h`, each costing a full Galerkin RAP and smoother sweep for no correction,
+      measured 2.3-7.3x slower for the same iteration count.
+    * **the adapted SPAN matches the request.** Asserted cumulatively rather than
+      per step. An engine lands near a target, not on it, and the individual
+      steps of a graded refinement are legitimately uneven (1.40 then 3.02 for a
+      requested 2.0); what the knob promises is one level per ``ratio`` in `h`
+      across the adapted range, and that is what is checked.
+
+    The base tail is excluded — it is a uniform hierarchy with its own spacing —
+    but its finest level is the rung the first adapted step is measured from.
+    """
+    h = [refined_resolution(m.dm, inside)
+         for m in child._custom_mg_coarse_meshes] + \
+        [refined_resolution(child.dm, inside)]
+
+    n_base = len(child.parent.dm_hierarchy)
+    adapted = h[n_base - 1:]
+    steps = [adapted[i] / adapted[i + 1] for i in range(len(adapted) - 1)]
+    assert steps, "no adapted level was recorded"
+
+    for i, r in enumerate(steps):
+        assert r >= floor, (
+            f"adapted step {i} coarsens by only {r:.2f} (levels "
+            f"{[f'{x:.5f}' for x in adapted]}): a near-duplicate level, which is "
+            f"the defect mg_coarsening_ratio exists to remove")
+
+    span = adapted[0] / adapted[-1]
+    assert span >= (ratio ** len(steps)) * slack, (
+        f"{len(steps)} adapted level(s) span only {span:.2f}x in h, short of the "
+        f"{ratio}x per level requested (levels {[f'{x:.5f}' for x in adapted]})")
diff --git a/tests/parallel/ptest_0843_edge_split_parallel.py b/tests/parallel/ptest_0843_edge_split_parallel.py
new file mode 100644
index 000000000..9f6be15b3
--- /dev/null
+++ b/tests/parallel/ptest_0843_edge_split_parallel.py
@@ -0,0 +1,122 @@
+"""Parallel confluence of ``engine="edge_split"``.
+
+The refined mesh must be the SAME at any communicator size. This is the
+load-bearing test for the engine: three separate defects during development
+showed up here and nowhere else —
+
+- a collective (the star-forest reconcile) reached inside a rank-local branch,
+  which deadlocked as soon as one rank owned no shared point;
+- an edge selection by greedy sweep, whose result depends on iteration order and
+  therefore on the partition (412 cells at np=1/2 but 463 at np=3 and 925 at
+  np=4, all conforming, all plausible-looking in isolation);
+- a mis-sized ``PetscSF`` reduce buffer, which corrupted the heap only after the
+  second pass.
+
+None of them is visible in a serial run, and the first two are invisible in a
+single-pass run. The reference numbers are asserted in the serial file
+(``tests/test_0843_edge_split_adapt.py::test_serial_reference_for_parallel_confluence``)
+so a change to the contract is visible there rather than as a mysterious
+parallel failure here.
+
+Run with:
+    mpirun -n 2 python -m pytest --with-mpi tests/parallel/ptest_0843_edge_split_parallel.py
+    mpirun -n 3 python -m pytest --with-mpi tests/parallel/ptest_0843_edge_split_parallel.py
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities import edge_split
+
+pytestmark = [pytest.mark.mpi(min_size=2), pytest.mark.level_2,
+              pytest.mark.tier_b, pytest.mark.timeout(300)]
+
+# The serial reference: see the serial test file.
+SERIAL_BASE_CELLS = 104
+SERIAL_REFINED_CELLS = 412
+SERIAL_PASSES = 7
+
+CENTRE = np.array([0.35, 0.6])
+
+
+def _owned_cells(dm):
+    cS, cE = dm.getHeightStratum(0)
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    leaves = set() if ilocal is None else {int(p) for p in ilocal}
+    return uw.mpi.comm.allreduce(
+        sum(1 for c in range(cS, cE) if c not in leaves))
+
+
+def _over_shared_facets(dm):
+    fS, fE = dm.getHeightStratum(1)
+    return uw.mpi.comm.allreduce(
+        sum(1 for f in range(fS, fE) if len(dm.getSupport(f)) > 2))
+
+
+def _centroids(dm):
+    cS, cE = dm.getHeightStratum(0)
+    if cE == cS:
+        return np.zeros((0, dm.getCoordinateDim()))
+    return np.array([dm.computeCellGeometryFVM(c)[1] for c in range(cS, cE)])
+
+
+def _h_target(cen):
+    d = np.linalg.norm(cen - CENTRE, axis=1)
+    return np.where(d < 0.2, 0.05, 0.3)
+
+
+def test_refined_mesh_is_independent_of_the_partition():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.35,
+        refinement=1, qdegree=2)
+    dm = base.dm_hierarchy[-1]
+    assert _owned_cells(dm) == SERIAL_BASE_CELLS
+
+    passes = 0
+    while passes < 40:
+        cS, _cE = dm.getHeightStratum(0)
+        cen = _centroids(dm)
+        if cen.shape[0]:
+            sel = np.flatnonzero(
+                edge_split.cell_diameters(dm) > _h_target(cen)) + cS
+        else:
+            sel = np.empty(0, dtype=int)     # this rank owns no cells
+        dm, n_split = edge_split.bisect_longest_edges(dm, sel)
+        if n_split == 0:
+            break
+        assert _over_shared_facets(dm) == 0, f"pass {passes} broke conformity"
+        passes += 1
+
+    assert _owned_cells(dm) == SERIAL_REFINED_CELLS, (
+        f"np={uw.mpi.size} produced {_owned_cells(dm)} cells; serial gives "
+        f"{SERIAL_REFINED_CELLS}. The refined mesh must not depend on the "
+        f"partition.")
+    assert passes == SERIAL_PASSES
+
+
+def test_adapt_child_is_confluent_and_carries_the_tail():
+    """The full ``mesh.adapt`` path, not just the engine."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        regular=False, refinement=2, qdegree=3)
+
+    def metric(cen):
+        d = np.linalg.norm(np.asarray(cen) - np.array([0.4, 0.55]), axis=1)
+        return 1.0 / np.where(d < 0.2, 0.03, 0.12) ** 2
+
+    child = base.adapt(metric, max_levels=2, engine="edge_split")
+
+    assert _over_shared_facets(child.dm) == 0
+    tail = child._custom_mg_coarse_meshes
+    assert tail is not None and len(tail) >= 3
+    recorded = child._adapt_prolongation
+    assert recorded and all(P is not None for P in recorded), (
+        "the exact prolongation must survive at np>1: the inserted vertices are "
+        "exact float edge midpoints on every rank")
+    # Reported so a partition-dependent regression is legible in the log even if
+    # the cell count assertion below is later relaxed.
+    uw.pprint(0, f"[ptest_0843] np={uw.mpi.size}: child "
+                 f"{_owned_cells(child.dm)} cells, tail {len(tail)} levels")
diff --git a/tests/parallel/ptest_0844_line_cut_parallel.py b/tests/parallel/ptest_0844_line_cut_parallel.py
new file mode 100644
index 000000000..53623b910
--- /dev/null
+++ b/tests/parallel/ptest_0844_line_cut_parallel.py
@@ -0,0 +1,499 @@
+"""Parallel confluence of ``mesh.add_conforming_surface``.
+
+The cut is a pure geometric function of the surface and the mesh coordinates:
+every rank holding a shared edge computes the same crossing parameter from the
+same two endpoints, so the result should be partition-independent *by
+construction*. That is an argument, not a measurement, and the surrounding
+machinery is exactly where such arguments have failed before — the ``edge_split``
+engine needed three separate fixes (a collective reached inside a rank-local
+branch, a partition-dependent greedy selection, and a mis-sized ``PetscSF``
+reduce) that were all invisible in serial.
+
+What is asserted:
+
+- **the mesh is the same at any communicator size** — compared by COORDINATES,
+  not counts. Derived counters lie in parallel: a shared vertex is held by every
+  rank on the seam, so summing local counts overstates them, and two different
+  meshes can agree on a total.
+- **conformity** — no facet with more than two cells, which a mis-handled
+  star-forest breaks.
+- **the geometric property survives the partition** — every segment of the
+  surface between consecutive crossings is still a mesh edge, checked on owned
+  points.
+- **the surface label reaches every rank that owns part of it**, since that is
+  what a boundary condition on the surface depends on.
+
+Run with:
+    mpirun -n 2 python -m pytest --with-mpi tests/parallel/ptest_0844_line_cut_parallel.py
+    mpirun -n 3 python -m pytest --with-mpi tests/parallel/ptest_0844_line_cut_parallel.py
+    mpirun -n 4 python -m pytest --with-mpi tests/parallel/ptest_0844_line_cut_parallel.py
+"""
+import hashlib
+
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.line_cut import cell_areas
+
+pytestmark = [pytest.mark.mpi(min_size=2), pytest.mark.level_2,
+              pytest.mark.tier_b, pytest.mark.timeout(300)]
+
+SLANTED = np.array([[-0.2, 0.317], [1.2, 0.683]])
+
+# The serial reference, asserted in the serial file
+# (tests/test_0844_line_cut.py::test_serial_reference_for_parallel_confluence) so
+# a change to the contract is visible there rather than as a mysterious parallel
+# failure here. Building a COMM_SELF mesh inside the parallel run to recompute it
+# is NOT a substitute: every rank then drives gmsh independently, which hangs.
+SERIAL_VERTICES = 224
+SERIAL_CELLS = 396
+SERIAL_SURFACE_FACETS = 26
+SERIAL_COORD_SHA = "c68821fc041cf94c"
+# The fault ZONE: the cells in the support of those 26 facets, so 52 of them,
+# hashed by sorted centroid. A count alone can agree between two different sets.
+SERIAL_ZONE_SHA = "94b098f3d3153eb5"
+
+# Vertices lying exactly ON the surface, per snap fraction: (count, coord hash).
+# This is what the snap test compares against. On the UNCUT base the number is
+# ZERO and the nearest vertex is 5.5e-3 away, so any assertion phrased as "the
+# vertices near the surface are on it" is satisfied by an empty set and holds
+# with the feature removed entirely.
+SERIAL_ON_SURFACE = {
+    0.0:  (29, "38a5cf77322d57bc"),
+    0.05: (29, "38a5cf77322d57bc"),
+    0.2:  (18, "b8dfa8eadd27b59a"),
+}
+
+
+def _surf(name, mesh, points):
+    """A `Surface` for `add_conforming_surface`, which takes one rather than a
+    (points, name) pair: it is what `fault_metric` and
+    `refinement_metric_function` already take, so one object drives both the
+    refinement and the cut."""
+    return uw.meshing.Surface(name, mesh, np.asarray(points, dtype=float))
+
+
+def _coords(dm):
+    return np.asarray(dm.getCoordinatesLocal().array).reshape(-1, dm.getCoordinateDim())
+
+
+def _owned(dm, points):
+    """Those of ``points`` this rank owns — held as a star-forest root, not leaf."""
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    leaves = set() if ilocal is None else {int(p) for p in ilocal}
+    return [int(p) for p in points if int(p) not in leaves]
+
+
+def _owned_label_size(mesh, name):
+    """Globally, how many facets carry ``name`` — counted once per facet.
+
+    A labelled facet on a partition seam is present on every rank of the seam, so
+    summing local stratum sizes overstates it and cannot be compared with a serial
+    number.
+    """
+    value = mesh.boundaries[name].value
+    label = mesh.dm.getLabel(name)
+    # An EMPTY stratum yields a null IS that petsc4py will happily hand back and
+    # then segfault on in `getIndices()`. A rank owning no part of the surface is
+    # the normal case at np>2, so the size has to be checked first.
+    if label.getStratumSize(value) == 0:
+        points = []
+    else:
+        points = label.getStratumIS(value).getIndices()
+    return uw.mpi.comm.allreduce(len(_owned(mesh.dm, points)))
+
+
+def _owned_vertex_coords(dm):
+    """Coordinates of the vertices this rank OWNS, gathered over all ranks.
+
+    Owned-only, because a shared vertex is present on every rank of the seam and
+    would otherwise appear several times in the global set.
+    """
+    vS, vE = dm.getDepthStratum(0)
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    leaves = set() if ilocal is None else {int(p) for p in ilocal}
+    X = _coords(dm)
+    mine = np.array([X[v - vS] for v in range(vS, vE) if v not in leaves])
+    gathered = uw.mpi.comm.allgather(mine)
+    allX = np.vstack([g for g in gathered if len(g)])
+    return allX[np.lexsort((allX[:, 1], allX[:, 0]))]
+
+
+def _over_shared_facets(dm):
+    fS, fE = dm.getHeightStratum(1)
+    return uw.mpi.comm.allreduce(
+        sum(1 for f in range(fS, fE) if len(dm.getSupport(f)) > 2))
+
+
+def _surface_mesh():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3)
+    return base, base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+
+def test_cut_is_independent_of_the_partition():
+    """The whole point: the same surface on the same base gives the same mesh.
+
+    Compared by sorted owned-vertex COORDINATES, not counts. Derived counters lie
+    in parallel — a shared vertex is held by every rank on the seam — and two
+    different meshes can agree on a total anyway.
+    """
+    _base, cut = _surface_mesh()
+    parallel = _owned_vertex_coords(cut.dm)
+
+    assert _over_shared_facets(cut.dm) == 0, "the cut broke conformity"
+
+    assert parallel.shape[0] == SERIAL_VERTICES, (
+        f"np={uw.mpi.size} produced {parallel.shape[0]} owned vertices, serial "
+        f"{SERIAL_VERTICES}. The cut must not depend on the partition.")
+
+    cS, cE = cut.dm.getHeightStratum(0)
+    cells = uw.mpi.comm.allreduce(len(_owned(cut.dm, range(cS, cE))))
+    assert cells == SERIAL_CELLS, (
+        f"np={uw.mpi.size} produced {cells} owned cells, serial {SERIAL_CELLS}")
+
+    got = hashlib.sha256(np.round(parallel, 9).tobytes()).hexdigest()[:16]
+    assert got == SERIAL_COORD_SHA, (
+        f"np={uw.mpi.size} vertex coordinates hash {got}, serial "
+        f"{SERIAL_COORD_SHA}: the cut moved with the partition.")
+
+
+def test_surface_is_a_chain_of_edges_on_every_rank():
+    """The geometric property, checked rank-locally on the cut mesh."""
+    _base, cut = _surface_mesh()
+    dm = cut.dm
+    X = _coords(dm)
+
+    A, B = SLANTED[0], SLANTED[-1]
+    d = B - A
+    nrm = np.array([-d[1], d[0]]) / np.hypot(*d)
+    s = (X - A) @ nrm
+
+    vS = dm.getDepthStratum(0)[0]
+    edges = {frozenset(int(v) - vS for v in dm.getCone(e))
+             for e in range(*dm.getDepthStratum(1))}
+
+    on = np.flatnonzero(np.abs(s) < 1e-11)
+    order = on[np.argsort(((X[on] - A) @ d) / (d @ d))]
+
+    # The chain is asserted GLOBALLY, by counting the facets that carry the
+    # surface label once each. A per-rank gap count cannot be: a pair of
+    # consecutive on-surface vertices straddling a seam legitimately has no local
+    # edge, so the bound has to be scaled by the number of seams — which LOOSENS
+    # as the partition gets harder, permitting 8 broken segments out of 26 at
+    # np=4. The owned facet count is exact and partition-independent.
+    assert _owned_label_size(cut, "Fault") == SERIAL_SURFACE_FACETS, (
+        f"np={uw.mpi.size}: the surface is {_owned_label_size(cut, 'Fault')} "
+        f"facets, serial {SERIAL_SURFACE_FACETS} — the chain is broken.")
+
+    # And locally: consecutive on-surface vertices that are both present here are
+    # joined by an edge here. Reported for diagnosis, bounded by the seams.
+    missing = sum(1 for u, v in zip(order[:-1], order[1:])
+                  if frozenset((int(u), int(v))) not in edges)
+    assert uw.mpi.comm.allreduce(missing) <= 2 * uw.mpi.size
+
+    # No cell may straddle, on any rank — that is the property the whole feature
+    # exists to provide, and it is purely local.
+    vS_, vE_ = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    straddle = 0
+    for c in range(cS, cE):
+        vs = [int(p) - vS_ for p in dm.getTransitiveClosure(c)[0] if vS_ <= p < vE_]
+        sv = s[vs]
+        if (sv > 1e-11).any() and (sv < -1e-11).any():
+            straddle += 1
+    assert uw.mpi.comm.allreduce(straddle) == 0
+
+
+def test_surface_label_survives_distribution():
+    """Finding the surface again needs the WHOLE label, not a facet of it.
+
+    ``allreduce(local) > 0`` is satisfied by one facet on one rank, which is the
+    state a distribution bug produces. The count of owned labelled facets is the
+    assertion that discriminates, and it must equal the serial one exactly.
+    """
+    _base, cut = _surface_mesh()
+    value = cut.boundaries["Fault"].value
+
+    assert cut.dm.hasLabel("Fault")
+    assert _owned_label_size(cut, "Fault") == SERIAL_SURFACE_FACETS, (
+        f"np={uw.mpi.size}: {_owned_label_size(cut, 'Fault')} labelled facets, "
+        f"serial {SERIAL_SURFACE_FACETS}")
+
+    # It must also be stacked into UW_Boundaries, which is what the solver reads.
+    local = cut.dm.getLabel("Fault").getStratumSize(value)
+    stacked = cut.dm.getLabel("UW_Boundaries").getStratumSize(value)
+    assert uw.mpi.comm.allreduce(stacked) == uw.mpi.comm.allreduce(local)
+
+
+VERTICAL = np.array([[0.5, -0.2], [0.5, 1.2]])
+
+# The delivered feature is a surface that carries a boundary condition, so the
+# parallel contract is the SOLVE, not just the mesh. A domain integral is the
+# right comparison: it is independent of the partition and of DOF ordering, which
+# a nodal norm is not.
+#
+# The solve is driven to a TIGHT tolerance so this can be asserted strictly. At
+# the default tolerance serial and np=3 differ by 1.5e-8 — two iterative solves
+# converging to different points within their own rtol, not a parallel defect.
+# Tightened, they agree to 4e-17, which is what makes the assertion meaningful
+# rather than a loosened bound hiding a real difference.
+SERIAL_BC_INTEGRAL = 0.3807400201042878
+
+
+def _bc_mesh():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3, refinement=1)
+    return base.add_conforming_surface(_surf("Fault", base, VERTICAL))
+
+
+def test_a_boundary_condition_on_the_surface_solves_in_parallel():
+    """The feature, end to end: constrain the surface and solve."""
+    mesh = _bc_mesh()
+    u = uw.discretisation.MeshVariable("u_par", mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(mesh, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 1.0
+    for b in ("Left", "Right", "Top", "Bottom"):
+        poisson.add_dirichlet_bc(0.0, b)
+    poisson.add_dirichlet_bc(1.0, "Fault")
+    poisson.petsc_options["ksp_rtol"] = 1.0e-14
+    poisson.petsc_options["snes_rtol"] = 1.0e-14
+    poisson.solve()
+
+    # The constraint must hold on every rank that owns part of the surface.
+    X, vals = np.asarray(u.coords), np.asarray(u.data[:, 0])
+    on = np.abs(X[:, 0] - 0.5) < 1e-11
+    if on.any():
+        assert np.allclose(vals[on], 1.0, atol=1e-9), (
+            f"np={uw.mpi.size}: the surface BC is not honoured on rank "
+            f"{uw.mpi.rank}")
+    assert uw.mpi.comm.allreduce(int(on.sum())) > 0, "no rank owns the surface"
+
+    got = uw.maths.Integral(mesh, u.sym[0]).evaluate()
+    assert abs(got - SERIAL_BC_INTEGRAL) < 1e-12, (
+        f"np={uw.mpi.size}: integral {got!r} differs from serial "
+        f"{SERIAL_BC_INTEGRAL!r}; the parallel solve is not the same problem.")
+
+
+def test_a_second_surface_chains_in_parallel():
+    """Two named surfaces, added one after the other, both usable."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3)
+    one = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+    two = one.add_conforming_surface(
+        _surf("Moho", one, np.array([[-0.2, 0.12], [1.2, 0.12]])))
+
+    names = [b.name for b in two.boundaries]
+    assert "Fault" in names and "Moho" in names
+    for nm in ("Fault", "Moho"):
+        size = two.dm.getLabel(nm).getStratumSize(two.boundaries[nm].value)
+        assert uw.mpi.comm.allreduce(size) > 0, f"{nm} vanished under distribution"
+    assert _over_shared_facets(two.dm) == 0
+
+
+@pytest.mark.parametrize("snap_frac", [0.0, 0.05, 0.2])
+def test_snap_fraction_is_partition_independent(snap_frac):
+    """The snap decision is read off an EDGE, so a rank holding one side of a
+    shared vertex can decide differently from its neighbour. Reconciling that
+    over the star-forest is what makes the cut converge at all — at np=3 the
+    unreconciled version converged at snap_frac=0 and never at 0.1.
+
+    Asserted as the COUNT and the IDENTITY of the on-surface vertices against
+    serial, not as "whatever is near the surface is on it". The failure this
+    names — a vertex snapped on some ranks and not others — leaves that vertex
+    about ``snap_frac * h`` off the line, three or four orders OUTSIDE any
+    tolerance-band selector, and an empty band satisfies a band assertion.
+    """
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED), snap_frac=snap_frac)
+    assert _over_shared_facets(cut.dm) == 0
+
+    A, B = SLANTED[0], SLANTED[-1]
+    d = B - A
+    nrm = np.array([-d[1], d[0]]) / np.hypot(*d)
+
+    vS, vE = cut.dm.getDepthStratum(0)
+    X = _coords(cut.dm)
+    mine = np.array([X[v - vS] for v in _owned(cut.dm, range(vS, vE))])
+    gathered = [g for g in uw.mpi.comm.allgather(mine) if len(g)]
+    allX = np.vstack(gathered)
+    on = allX[np.abs((allX - A) @ nrm) < 1e-11]
+    on = on[np.lexsort((on[:, 1], on[:, 0]))]
+
+    n_expected, sha_expected = SERIAL_ON_SURFACE[snap_frac]
+    assert len(on) == n_expected, (
+        f"np={uw.mpi.size} snap={snap_frac}: {len(on)} vertices on the surface, "
+        f"serial {n_expected}. A snap applied on only some ranks changes this.")
+    got = hashlib.sha256(np.round(on, 9).tobytes()).hexdigest()[:16]
+    assert got == sha_expected, (
+        f"np={uw.mpi.size} snap={snap_frac}: on-surface vertices hash {got}, "
+        f"serial {sha_expected} — the same COUNT of different vertices.")
+
+
+# Inputs found by sweeping in serial (`~/+Simulations/mesh_reconnection_study/`
+# `cut_find_refusal_inputs.py`, `cut_hunt_inversion.py`) and confirmed to reach
+# the refusal each is named for. The first attempt at this test used plausible
+# inputs that quietly returned success for four of five cases.
+_BOX = dict(minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), regular=False, qdegree=2)
+_ZIG = np.array([[-0.1, 0.5], [0.30, 0.62], [0.55, 0.38], [0.80, 0.62], [1.1, 0.5]])
+
+REFUSALS = [
+    ("nothing to cut", 1 / 12, np.array([[5.0, 5.0], [6.0, 6.0]]), 0.10, 0.15,
+     ValueError),
+    ("line ends inside", 1 / 12, np.array([[-0.1, 0.5], [0.5, 0.5]]), 0.0, 0.15,
+     ValueError),
+    ("edge crossed twice", 1 / 3, _ZIG, 0.0, 0.15, ValueError),
+    # The quality guard is turned OFF for this one on purpose. With it on, the
+    # snap that flattens the cell is vetoed and the cut succeeds — which is the
+    # guard working, and is asserted separately in the serial suite. The refusal
+    # path still exists for a cell that inverts during SPLITTING, and it is that
+    # path's collectiveness this case is here to protect.
+    ("snapping inverts a cell", 1 / 8,
+     np.array([[-0.1, 0.503], [1.1, 0.541]]), 0.48, None, RuntimeError),
+]
+
+
+@pytest.mark.parametrize("name,h,line,snap,quality,expected",
+                         REFUSALS, ids=[r[0] for r in REFUSALS])
+def test_every_refusal_is_collective(name, h, line, snap, quality, expected):
+    """A refusal must reach EVERY rank, or it is a hang rather than an error.
+
+    Each condition below is a property of one rank's cells — whether this rank
+    holds the inverted cell, the tip triangle, the twice-crossed edge — so a
+    rank-local ``raise`` aborts that rank while its peers walk on into the next
+    collective and block there. Nine defects of exactly this shape have been
+    found in this module; the parallel suite could not see any of them because it
+    only ever exercised the happy path.
+
+    Negative control, measured: restoring the rank-local form of the
+    cell-inversion test makes this file HANG at np=3 on the last case, while the
+    three before it still pass.
+    """
+    from underworld3.utilities.line_cut import cut_along_lines
+
+    mesh = uw.meshing.UnstructuredSimplexBox(cellSize=h, **_BOX)
+    try:
+        cut_along_lines(mesh.dm, [line], snap_frac=snap, snap_quality=quality)
+        outcome = "no refusal"
+    except (ValueError, RuntimeError) as exc:
+        outcome = type(exc).__name__
+
+    seen = uw.mpi.comm.allgather(outcome)
+    assert set(seen) == {expected.__name__}, (
+        f"np={uw.mpi.size} {name!r}: ranks disagreed — {seen}. Every rank must "
+        f"raise {expected.__name__}, or the ones that do not will hang.")
+
+
+# ---------------------------------------------------------------------------
+# The fault zone, and fault NETWORKS, across a partition.
+# ---------------------------------------------------------------------------
+
+def test_the_fault_zone_is_the_same_set_at_any_partition_size():
+    """The zone is what a cell-wise viscosity is assigned on, so it has to be
+    the same cells however the mesh is split.
+
+    Compared by owned COUNT and by the sorted centroids of the zone cells — the
+    count alone can agree between two different sets.
+    """
+    _base, cut = _surface_mesh()
+    zone = cut.cells_supporting("Fault")
+
+    dm = cut.dm
+    cS, cE = dm.getHeightStratum(0)
+    owned = set(_owned(dm, range(cS, cE)))
+    n = uw.mpi.comm.allreduce(
+        sum(1 for c in np.flatnonzero(zone) if cS + int(c) in owned))
+
+    # One element each side of every facet — the defining property, and it must
+    # survive the partition rather than merely hold on rank 0.
+    assert n == 2 * SERIAL_SURFACE_FACETS, (
+        f"np={uw.mpi.size}: {n} owned zone cells for "
+        f"{SERIAL_SURFACE_FACETS} facets; the zone is the facet support, so it "
+        f"is exactly twice as many")
+
+    vS, vE = dm.getDepthStratum(0)
+    X = _coords(dm)
+    mine = np.array([
+        X[[int(p) - vS for p in dm.getTransitiveClosure(cS + int(c))[0]
+           if vS <= p < vE]].mean(axis=0)
+        for c in np.flatnonzero(zone) if cS + int(c) in owned])
+    gathered = [g for g in uw.mpi.comm.allgather(mine) if len(g)]
+    allc = np.vstack(gathered)
+    allc = allc[np.lexsort((allc[:, 1], allc[:, 0]))]
+    got = hashlib.sha256(np.round(allc, 9).tobytes()).hexdigest()[:16]
+    assert got == SERIAL_ZONE_SHA, (
+        f"np={uw.mpi.size}: zone centroid hash {got}, serial {SERIAL_ZONE_SHA} "
+        f"— the same NUMBER of different cells")
+
+
+JUNCTION = np.array([0.5, 0.5])
+NETWORKS = {
+    # Y: three arms from one junction. Two of them START there.
+    "Y": (np.array([[-0.2, 0.20], [0.5, 0.5]]),
+          np.array([[0.5, 0.5], [1.2, 0.30]]),
+          np.array([[0.5, 0.5], [0.55, 1.2]])),
+    # T: one fault abutting another.
+    "T": (np.array([[-0.2, 0.34], [1.2, 0.66]]),
+          np.array([[0.5, 0.5], [0.62, 1.2]])),
+    # X: two faults crossing.
+    "X": (np.array([[-0.2, 0.22], [1.2, 0.78]]),
+          np.array([[0.30, -0.2], [0.70, 1.2]])),
+}
+
+
+@pytest.mark.parametrize("kind", list(NETWORKS), ids=list(NETWORKS))
+def test_a_fault_network_cuts_at_a_shared_junction_in_parallel(kind):
+    """Branching, abutting and crossing faults, across a partition.
+
+    A junction is the same problem as a tip — a distinguished point that has to
+    coincide with a mesh vertex — and placing it is where a partition bites:
+    ``pull_vertex_onto`` reduces the choice globally, because a rank-local
+    nearest-vertex search moves a DIFFERENT vertex on each rank and the branches
+    then meet at different places on either side of a seam.
+    """
+    from underworld3.utilities.line_cut import cut_along_lines, pull_vertex_onto
+
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 20,
+        regular=False, qdegree=3)
+    dm = pull_vertex_onto(base.dm, JUNCTION)
+
+    branches = NETWORKS[kind]
+    for k, branch in enumerate(branches):
+        dm, _info = cut_along_lines(dm, [branch], label=f"F{k}",
+                                    label_value=20 + k)
+
+    # Conformity first: a mis-handled star-forest breaks this before anything
+    # geometric shows up.
+    fS, fE = dm.getHeightStratum(1)
+    assert uw.mpi.comm.allreduce(
+        sum(1 for f in range(fS, fE) if len(dm.getSupport(f)) > 2)) == 0
+    assert uw.mpi.comm.allreduce(
+        int((cell_areas(dm) <= 0.0).sum())) == 0, "a network cut inverted a cell"
+
+    # Every branch is a labelled chain, and the junction is on all of them.
+    X = _coords(dm)
+    vS = dm.getDepthStratum(0)[0]
+    for k, branch in enumerate(branches):
+        n_owned = uw.mpi.comm.allreduce(
+            len(_owned(dm, dm.getLabel(f"F{k}").getStratumIS(20 + k).getIndices()
+                       if dm.getLabel(f"F{k}").getStratumSize(20 + k) else [])))
+        assert n_owned > 0, f"branch {k} lost its label under distribution"
+
+    on_junction = uw.mpi.comm.allreduce(
+        int((np.linalg.norm(X[:, :2] - JUNCTION, axis=1) < 1e-12).sum()))
+    assert on_junction > 0, "the junction is not a mesh vertex on any rank"
diff --git a/tests/parallel/ptest_0844_reconnect_parallel.py b/tests/parallel/ptest_0844_reconnect_parallel.py
new file mode 100644
index 000000000..d545f6ad8
--- /dev/null
+++ b/tests/parallel/ptest_0844_reconnect_parallel.py
@@ -0,0 +1,279 @@
+"""Reconnection repair under a frozen partition seam.
+
+The parallel contract here is deliberately *not* partition independence. Repair
+gives that up by construction: which cavities may be flipped depends on where the
+partitioner drew the seam, so the flip set — and therefore the mesh — differs with
+rank count. What must hold at every rank count is everything else, and that is
+what this file asserts:
+
+* **no shared point's cone changes.** This is the freeze rule stated as a
+  postcondition, and it is the load-bearing one. It is what allows the rebuilt DM
+  to reuse the point star-forest verbatim instead of reconstructing it by matching
+  seam coordinates — a spatial query standing in for an identity lookup, which is
+  the failure mode ``nvb._exact_vertex_map`` exists to refuse;
+* the **chart, cell count and total area** are invariant, globally;
+* the mesh still carries a solve, which is the only real proof the labels and the
+  star-forest came through usable rather than merely present.
+
+Run with:
+    mpirun -n 2 python -m pytest --with-mpi tests/parallel/ptest_0844_reconnect_parallel.py
+    mpirun -n 3 python -m pytest --with-mpi tests/parallel/ptest_0844_reconnect_parallel.py
+"""
+import numpy as np
+import pytest
+from mpi4py import MPI
+
+import underworld3 as uw
+from underworld3.utilities import edge_split, reconnect
+
+pytestmark = [pytest.mark.mpi(min_size=2), pytest.mark.level_2,
+              pytest.mark.tier_b, pytest.mark.timeout(600)]
+
+CENTRE = np.array([0.4, 0.55])
+
+
+def _refined_dm():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        regular=False, qdegree=2)
+    dm = base.dm
+    for _ in range(20):
+        cS, cE = dm.getHeightStratum(0)
+        if cE > cS:
+            cen = np.array([dm.computeCellGeometryFVM(c)[1]
+                            for c in range(cS, cE)])
+            d = np.linalg.norm(cen - CENTRE, axis=1)
+            target = np.where(d < 0.25, 0.05, 0.4)
+            sel = np.flatnonzero(edge_split.cell_diameters(dm) > target) + cS
+        else:
+            sel = np.empty(0, dtype=np.int64)
+        dm, n = edge_split.bisect_longest_edges(dm, sel)
+        if n == 0:
+            break
+    return dm
+
+
+def _owned(dm, points):
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    leaves = set() if ilocal is None else {int(p) for p in ilocal}
+    return [p for p in points if p not in leaves]
+
+
+def _global(x, op=MPI.SUM):
+    return uw.mpi.comm.allreduce(x, op=op)
+
+
+def _owned_cells_and_area(dm):
+    cS, cE = dm.getHeightStratum(0)
+    owned = _owned(dm, range(cS, cE))
+    area = sum(abs(dm.computeCellGeometryFVM(c)[0]) for c in owned)
+    return len(owned), area
+
+
+def test_shared_points_are_untouched():
+    """The freeze rule as a postcondition — the invariant the design rests on."""
+    dm = _refined_dm()
+    shared = reconnect._shared_points(dm)
+    pStart, _pEnd = dm.getChart()
+    idx = np.flatnonzero(shared) + pStart
+    assert _global(len(idx)) > 0, (
+        "no point is shared, so this run cannot exercise the freeze rule")
+    before = {int(p): tuple(int(x) for x in dm.getCone(p)) for p in idx}
+
+    out, nflips = reconnect.flip_to_reduce_max_angle(dm)
+
+    assert _global(nflips, op=MPI.MAX) > 0, "nothing flipped anywhere"
+    for p, cone in before.items():
+        assert tuple(int(x) for x in out.getCone(p)) == cone, (
+            f"rank {uw.mpi.rank}: shared point {p} was rewired; the point "
+            f"star-forest can no longer be reused verbatim")
+
+
+def test_geometry_and_conformity_survive():
+    dm = _refined_dm()
+    chart = dm.getChart()
+    ncells, area = _owned_cells_and_area(dm)
+
+    out, _ = reconnect.flip_to_reduce_max_angle(dm)
+
+    assert out.getChart() == chart
+    ncells_after, area_after = _owned_cells_and_area(out)
+    assert _global(ncells_after) == _global(ncells)
+    assert _global(area_after) == pytest.approx(_global(area), rel=1e-12)
+
+    fS, fE = out.getHeightStratum(1)
+    assert _global(sum(1 for f in range(fS, fE)
+                       if len(out.getSupport(f)) > 2)) == 0
+
+
+def test_repaired_mesh_still_solves():
+    """Labels and the star-forest present is not the same as usable."""
+    dm = _refined_dm()
+    out, _ = reconnect.flip_to_reduce_max_angle(dm)
+
+    mesh = uw.discretisation.Mesh(out, qdegree=2)
+    u = uw.discretisation.MeshVariable("u_par", mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(mesh, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 1.0
+    poisson.add_dirichlet_bc(0.0, "All_Boundaries")
+    poisson.solve()
+    assert poisson.snes.getConvergedReason() > 0
+
+    # Integrating 1 exercises the assembled section over the rebuilt topology on
+    # every rank at once, which a rank-local area sum does not.
+    one = uw.discretisation.MeshVariable("one_par", mesh, 1, degree=1)
+    one.array[:, 0, 0] = 1.0
+    assert uw.maths.Integral(mesh, one.sym[0]).evaluate() == pytest.approx(
+        1.0, rel=1e-10)
+
+
+def test_adapt_with_repair_runs_in_parallel():
+    """The full ``mesh.adapt(..., repair=True)`` path."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        regular=False, refinement=1, qdegree=3)
+
+    def metric(centroids):
+        d = np.linalg.norm(np.asarray(centroids) - CENTRE, axis=1)
+        return 1.0 / np.where(d < 0.2, 0.04, 0.15) ** 2
+
+    child = base.adapt(metric, max_levels=2, engine="edge_split", repair=True)
+
+    fS, fE = child.dm.getHeightStratum(1)
+    assert _global(sum(1 for f in range(fS, fE)
+                       if len(child.dm.getSupport(f)) > 2)) == 0
+    # Flips move no vertex, so the exact vertex prolongation must survive.
+    assert child._adapt_prolongation and all(
+        P is not None for P in child._adapt_prolongation)
+
+    # The cell-parent map must NOT survive a repair, because a flipped cell can
+    # straddle two coarse cells and using it would transfer from the wrong
+    # parent. Checked at mg_coarsening_ratio=1.0, which is the only setting where
+    # the claim is observable: at the default 2.0 a level spans several
+    # generations, a cell has no single parent whatever the repair did, and the
+    # map is None in BOTH arms — so asserting it there says nothing about repair.
+    arms = {}
+    for repair in (False, True):
+        arm = base.adapt(metric, max_levels=2, engine="edge_split",
+                         repair=repair, mg_coarsening_ratio=1.0)
+        arms[repair] = arm._adapt_parent_cells
+
+    assert any(pc is not None for pc in arms[False]), (
+        "no parent-cell map survived WITHOUT repair, so the assertion below "
+        "cannot distinguish repair from anything else")
+    assert all(pc is None for pc in arms[True]), (
+        "a parent-cell map survived a repair pass; a flipped cell spans two "
+        "coarse cells and the transfer would read the wrong parent")
+
+    uw.pprint(f"[ptest_0844] np={uw.mpi.size}: repaired child "
+              f"{_global(_owned_cells_and_area(child.dm)[0])} cells")
+
+
+# ------------------------------------------------------- the removal primitive
+
+def _sf_coordinate_drift(dm):
+    """Broadcast every vertex's coordinates root-to-leaf; leaves must agree.
+
+    Deletion compacts the point chart, so the star-forest cannot be reused
+    verbatim the way a flip's can: every point after a deleted one shifts, and a
+    leaf's *remote* index is a number only its owner holds.
+    ``rebuild_without_vertices`` renumbers locally and broadcasts the new
+    numbering once to close that gap.
+
+    This is the check a mis-renumbering cannot pass and nothing else catches.
+    Conformity, Euler and area are all rank-local: they stay perfect while the
+    forest points at the wrong points, and only a solve — much later — disagrees.
+    """
+    pStart, pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    sf = dm.getPointSF()
+    worst = 0.0
+    for comp in range(2):
+        root = np.zeros(pEnd - pStart, dtype=np.float64)
+        root[vS - pStart: vE - pStart] = X[: vE - vS, comp]
+        leaf = np.full(pEnd - pStart, np.nan, dtype=np.float64)
+        sf.bcastBegin(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        sf.bcastEnd(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        seen = np.isfinite(leaf[vS - pStart: vE - pStart])
+        if seen.any():
+            worst = max(worst, float(np.abs(
+                leaf[vS - pStart: vE - pStart][seen]
+                - X[: vE - vS, comp][seen]).max()))
+    return _global(worst, op=MPI.MAX)
+
+
+def test_removal_renumbers_the_star_forest():
+    dm = _refined_dm()
+    vS, vE = dm.getDepthStratum(0)
+    ncells, area = _owned_cells_and_area(dm)
+    assert _global(len(_owned(dm, range(*dm.getChart()))) ) > 0
+
+    out, n = reconnect.remove_vertices(dm, np.arange(vS, vE))
+
+    assert _global(n, op=MPI.MAX) > 0, (
+        "nothing was deleted on any rank, so the renumbering is untested")
+    assert _sf_coordinate_drift(out) == 0.0, (
+        "a leaf no longer resolves to its own coordinates; the compacted chart "
+        "was not propagated correctly")
+
+    ncells_after, area_after = _owned_cells_and_area(out)
+    assert _global(ncells_after) < _global(ncells), "no cell was removed"
+    assert _global(area_after) == pytest.approx(_global(area), rel=1e-12)
+    fS, fE = out.getHeightStratum(1)
+    assert _global(sum(1 for f in range(fS, fE)
+                       if len(out.getSupport(f)) > 2)) == 0
+
+
+def test_removal_leaves_the_seam_alone():
+    """No shared point may be deleted, which is what keeps the leaf set intact.
+
+    ``rebuild_without_vertices`` renumbers the star-forest but does not rebuild
+    it, so a deleted shared point would leave a leaf pointing at nothing. The
+    pass freezes any cavity touching the seam; this is that rule as a
+    postcondition, checked by coordinates because the numbering has moved.
+    """
+    dm = _refined_dm()
+    shared = reconnect._shared_points(dm)
+    pStart, _pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    seam = {tuple(X[v - vS]) for v in np.flatnonzero(shared) + pStart
+            if vS <= v < vE}
+    assert _global(len(seam)) > 0, "no vertex is shared; the rule is untested"
+
+    out, n = reconnect.remove_vertices(dm, np.arange(vS, vE))
+    assert _global(n, op=MPI.MAX) > 0
+
+    oS, oE = out.getDepthStratum(0)
+    Y = np.asarray(out.getCoordinatesLocal().array).reshape(-1, 2)[: oE - oS]
+    survived = {tuple(row) for row in Y}
+    assert all(p in survived for p in seam), (
+        f"rank {uw.mpi.rank}: a shared vertex was deleted")
+
+
+def test_reduced_mesh_still_solves():
+    """The only real proof the rebuilt forest and labels came through usable."""
+    dm = _refined_dm()
+    out, n = reconnect.remove_vertices(dm, np.arange(*dm.getDepthStratum(0)))
+    assert _global(n, op=MPI.MAX) > 0
+
+    mesh = uw.discretisation.Mesh(out, qdegree=2)
+    u = uw.discretisation.MeshVariable("u_del", mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(mesh, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 1.0
+    poisson.add_dirichlet_bc(0.0, "All_Boundaries")
+    poisson.solve()
+    assert poisson.snes.getConvergedReason() > 0
+
+    one = uw.discretisation.MeshVariable("one_del", mesh, 1, degree=1)
+    one.array[:, 0, 0] = 1.0
+    assert uw.maths.Integral(mesh, one.sym[0]).evaluate() == pytest.approx(
+        1.0, rel=1e-10)
diff --git a/tests/parallel/ptest_0845_fault_split_parallel.py b/tests/parallel/ptest_0845_fault_split_parallel.py
new file mode 100644
index 000000000..1315704d9
--- /dev/null
+++ b/tests/parallel/ptest_0845_fault_split_parallel.py
@@ -0,0 +1,274 @@
+"""Split-node faults in parallel: redistribute first, split rank-interior.
+
+The contract: the LOW-LEVEL splitter (``split_along_label``) is legal only
+when the fault's cell fans stay off the partition seam — the replicas are
+then rank-local, the star-forest leaf set is unchanged, and the renumbering
+broadcast of ``reconnect._rebuild_point_sf`` carries it over. A
+seam-touching fault at that level is REFUSED, with the same error on every
+rank. The USER-facing path (``Mesh.add_fault`` / ``split_fault``) never hits
+the refusal: it REDISTRIBUTES the fault's cell star (plus one growth layer)
+onto the rank that already owns most of it first, so the split always runs
+with serial topology — the same strategy the 3-D splitter ships.
+
+What is asserted:
+
+* **outcomes agree across ranks**, whatever they are — the collectivity
+  contract itself;
+* a fault interior to one rank splits cleanly, and the star-forest still
+  resolves every leaf to its own coordinates (`_sf_coordinate_drift`, the
+  check a mis-renumbered forest cannot pass while conformity, Euler and area
+  all stay rank-locally perfect);
+* globally, the split adds exactly its replicas: the owned-point Euler
+  characteristic drops from 1 (disc) to 0 (slit disc) and the total area is
+  unchanged;
+* a seam-straddling fault raises the seam refusal — not a chain-fragment
+  symptom — on EVERY rank at the low level, and ``add_fault`` splits the
+  SAME geometry cleanly via the redistribution;
+* a seam-crossing fault SPLITS AND SLIPS through ``add_fault`` at every
+  rank count — no skips, no tolerated refusals.
+
+Run with:
+    mpirun -n 2 python -m pytest --with-mpi tests/parallel/ptest_0845_fault_split_parallel.py
+    mpirun -n 3 python -m pytest --with-mpi tests/parallel/ptest_0845_fault_split_parallel.py
+"""
+import numpy as np
+import pytest
+from mpi4py import MPI
+
+import underworld3 as uw
+from underworld3.utilities.fault_split import split_along_label
+from underworld3.utilities.line_cut import cut_along_lines, pull_vertex_onto
+
+pytestmark = [pytest.mark.mpi(min_size=2), pytest.mark.level_2,
+              pytest.mark.tier_b, pytest.mark.timeout(600)]
+
+# A short fault tucked into a corner: at modest rank counts the partitioner
+# leaves its one-ring inside a single rank, which is the success path. If a
+# partition does land the seam on it, the split refuses collectively and the
+# success path is reported as skipped rather than silently untested.
+CORNER = (np.array([0.08, 0.10]), np.array([0.24, 0.17]))
+# Near-corner to near-corner: crosses any contiguous partition of the box.
+SPANNING = (np.array([0.06, 0.08]), np.array([0.94, 0.92]))
+
+FAULT, VALUE, PLUS, MINUS = "Flt", 30, 31, 32
+
+
+def _cut(tips):
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 16,
+        regular=False, qdegree=2)
+    dm = pull_vertex_onto(base.dm, np.vstack(tips))
+    dm, _info = cut_along_lines(dm, [np.vstack(tips)],
+                                label=FAULT, label_value=VALUE)
+    return dm
+
+
+def _attempt(dm):
+    """The split's outcome on this rank: ("ok", result) or ("seam", None).
+
+    Only the seam refusal is caught; any other error is a genuine failure and
+    propagates.
+    """
+    try:
+        result = split_along_label(dm, FAULT, VALUE,
+                                   f"{FAULT}Plus", PLUS,
+                                   f"{FAULT}Minus", MINUS)
+        return "ok", result
+    except RuntimeError as err:
+        if "seam" not in str(err):
+            raise
+        return "seam", None
+
+
+def _global(x, op=MPI.SUM):
+    return uw.mpi.comm.allreduce(x, op=op)
+
+
+def _owned(dm, points):
+    try:
+        _nroots, ilocal, _iremote = dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    leaves = set() if ilocal is None else {int(p) for p in ilocal}
+    return [p for p in points if p not in leaves]
+
+
+def _owned_euler(dm):
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    nc = len(_owned(dm, range(cS, cE)))
+    nv = len(_owned(dm, range(vS, vE)))
+    ne = len(_owned(dm, range(eS, eE)))
+    return _global(nv) - _global(ne) + _global(nc)
+
+
+def _owned_area(dm):
+    cS, cE = dm.getHeightStratum(0)
+    return _global(sum(abs(dm.computeCellGeometryFVM(c)[0])
+                       for c in _owned(dm, range(cS, cE))))
+
+
+def _sf_coordinate_drift(dm):
+    """Broadcast every vertex's coordinates root-to-leaf; leaves must agree.
+
+    Lifted from ``ptest_0844_reconnect_parallel``: the one check a
+    mis-renumbered star-forest cannot pass while every rank-local invariant
+    stays perfect.
+    """
+    pStart, pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    sf = dm.getPointSF()
+    worst = 0.0
+    for comp in range(2):
+        root = np.zeros(pEnd - pStart, dtype=np.float64)
+        root[vS - pStart: vE - pStart] = X[: vE - vS, comp]
+        leaf = np.full(pEnd - pStart, np.nan, dtype=np.float64)
+        sf.bcastBegin(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        sf.bcastEnd(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        seen = np.isfinite(leaf[vS - pStart: vE - pStart])
+        if seen.any():
+            worst = max(worst, float(np.abs(
+                leaf[vS - pStart: vE - pStart][seen]
+                - X[: vE - vS, comp][seen]).max()))
+    return _global(worst, op=MPI.MAX)
+
+
+def test_a_rank_interior_fault_splits_cleanly():
+    dm = _cut(CORNER)
+    assert _owned_euler(dm) == 1
+    area = _owned_area(dm)
+
+    outcome, result = _attempt(dm)
+    outcomes = uw.mpi.comm.allgather(outcome)
+    assert len(set(outcomes)) == 1, (
+        f"rank {uw.mpi.rank}: outcomes {outcomes} disagree — the refusal is "
+        "not collective")
+    if outcomes[0] == "seam":
+        pytest.skip(f"the corner fault touches the seam at np={uw.mpi.size}; "
+                    "the refusal contract is asserted separately")
+
+    out, _point_map, _clone_map = result
+    assert _sf_coordinate_drift(out) == 0.0, (
+        "a leaf no longer resolves to its own coordinates; the grown chart "
+        "was not propagated to the star-forest")
+    assert _owned_euler(out) == 0, "the slit did not open (or opened twice)"
+    assert _owned_area(out) == pytest.approx(area, rel=1e-12)
+
+    fS, fE = out.getHeightStratum(1)
+    assert _global(sum(1 for f in range(fS, fE)
+                       if len(out.getSupport(f)) > 2)) == 0
+
+    # The two sides carry the same number of facets, all one-sided.
+    counts = {}
+    for name, value in ((f"{FAULT}Plus", PLUS), (f"{FAULT}Minus", MINUS)):
+        # An empty stratum hands back a null IS that segfaults in
+        # getIndices(); a rank owning no part of the fault is the normal case.
+        facets = []
+        if out.hasLabel(name) and out.getLabel(name).getStratumSize(value) > 0:
+            facets = [int(p) for p in
+                      out.getLabel(name).getStratumIS(value).getIndices()]
+        assert all(len(out.getSupport(f)) == 1 for f in facets)
+        counts[name] = _global(len(_owned(out, facets)))
+    assert counts[f"{FAULT}Plus"] == counts[f"{FAULT}Minus"] > 0
+
+    uw.pprint(f"[ptest_0845] np={uw.mpi.size}: split "
+              f"{counts[f'{FAULT}Plus']} fault facets cleanly")
+
+
+def test_a_fault_may_run_close_to_the_seam():
+    """The refined seam rule: only a CHAIN VERTEX on the seam refuses.
+
+    A fault whose cell fans merely touch the seam is rank-local in every
+    point the split moves (an unshared vertex owns its whole fan), so it
+    must split cleanly — the original blanket star-based refusal rejected
+    these. The fault below reaches toward the box centre, where the np=2/3
+    partitions put their seams; whichever outcome the partition produces
+    must be collective, and a success must be a valid slit.
+    """
+    dm = _cut((np.array([0.10, 0.12]), np.array([0.46, 0.22])))
+    outcome, result = _attempt(dm)
+    outcomes = uw.mpi.comm.allgather(outcome)
+    assert len(set(outcomes)) == 1, f"outcomes {outcomes} disagree"
+    if outcomes[0] == "seam":
+        pytest.skip(f"a chain vertex landed on the np={uw.mpi.size} seam; "
+                    "the low-level splitter refuses (add_fault would "
+                    "redistribute — asserted in the crossing test)")
+    out, _pm, _cm = result
+    assert _sf_coordinate_drift(out) == 0.0
+    assert _owned_euler(out) == 0
+
+
+def test_an_organic_cut_across_the_seam_is_refused_then_redistributed():
+    """A raw cut straddling the seam is the configuration the LOW-LEVEL
+    splitter refuses (collectively, with the seam verdict — never a
+    chain-fragment symptom); the SAME geometry through Mesh.add_fault
+    splits cleanly, because add_fault redistributes the fault's cell star
+    onto one rank before splitting."""
+    dm = _cut(SPANNING)
+    outcome, _result = _attempt(dm)
+    outcomes = uw.mpi.comm.allgather(outcome)
+    assert len(set(outcomes)) == 1, (
+        f"rank {uw.mpi.rank}: outcomes {outcomes} disagree — a rank that "
+        "raises alone leaves its peers blocked in the next collective")
+    assert outcomes[0] == "seam", (
+        "a fault spanning the box did not touch the seam; the refusal "
+        "contract went untested")
+
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 16,
+        regular=False, qdegree=2)
+    split = base.add_fault(("Flt", np.vstack(SPANNING)))
+    assert _sf_coordinate_drift(split.dm) == 0.0
+    assert _owned_euler(split.dm) == 0, (
+        "add_fault did not open the slit on the redistributed mesh")
+
+
+def test_a_seam_crossing_fault_redistributes_and_slips():
+    """The redistribute-first strategy end to end, on the geometry that
+    used to exercise the (now removed) crossing machinery: add_fault moves
+    the fault's cell star onto one rank, the split runs with serial
+    topology, and a frictionless solve slips with machine-zero opening —
+    asserted as SUCCESS at every rank count, no tolerated refusals."""
+    from underworld3.utilities.fault_contact import fault_slip
+
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 16,
+        regular=False, qdegree=2)
+    pts = np.array([[0.15, 0.35], [0.85, 0.65]])
+    split = base.add_fault(("Flt", pts))
+
+    assert _sf_coordinate_drift(split.dm) == 0.0, (
+        "a leaf does not resolve to its own coordinates — the redistributed "
+        "split's star-forest is wrong")
+    assert _owned_euler(split.dm) == 0, "the slit did not open globally"
+    fS, fE = split.dm.getHeightStratum(1)
+    assert _global(sum(1 for f in range(fS, fE)
+                       if len(split.dm.getSupport(f)) > 2)) == 0
+
+    x, y = split.X
+    v = uw.discretisation.MeshVariable("vX", split, 2, degree=2)
+    p = uw.discretisation.MeshVariable("pX", split, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(split, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    stokes.tolerance = 1e-6
+    stokes.petsc_use_pressure_nullspace = True
+    for side in ("Top", "Bottom", "Left", "Right"):
+        stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+    stokes.add_fault_bc(0, "Flt")
+    stokes.solve()
+    info = stokes._rotated_freeslip_info
+    assert info["converged"]
+
+    _s, V, leak = fault_slip(stokes, "Flt", info)
+    leak_max = _global(float(np.abs(leak).max()) if len(leak) else 0.0,
+                       op=MPI.MAX)
+    peak = _global(float(np.abs(V).max()) if len(V) else 0.0, op=MPI.MAX)
+    assert leak_max < 1e-12, "a coincident pair opened"
+    half = 0.5 * float(np.linalg.norm(pts[1] - pts[0]))
+    assert peak > 0.15 * half, "the redistributed fault barely slips"
+    uw.pprint(f"[ptest_0845] np={uw.mpi.size}: redistributed fault slipped, "
+              f"peak {peak:.4f}, leak {leak_max:.1e}")
diff --git a/tests/parallel/ptest_0845_relax_pinned_band_parallel.py b/tests/parallel/ptest_0845_relax_pinned_band_parallel.py
new file mode 100644
index 000000000..7461c4db0
--- /dev/null
+++ b/tests/parallel/ptest_0845_relax_pinned_band_parallel.py
@@ -0,0 +1,113 @@
+"""``relax(pin_bands=...)`` in parallel.
+
+The band is chosen by a purely geometric test on the exact distance, so every
+rank labels its own copy of a shared vertex identically and the pinned set is a
+function of the geometry, not of the partition. That is the property this file
+asserts, because it is what makes the feature safe at np>1 and it is not
+self-evident from the serial tests:
+
+* the pinned set is **partition-independent** — the same vertices, identified by
+  coordinate, are pinned at every communicator size;
+* pinned vertices do not move, including pinned vertices that are SHARED between
+  ranks, which is the case a rank-local implementation would get wrong;
+* the domain boundary stays pinned.
+
+Run with:
+    mpirun -n 2 python -m pytest --with-mpi tests/parallel/ptest_0845_relax_pinned_band_parallel.py
+    mpirun -n 3 python -m pytest --with-mpi tests/parallel/ptest_0845_relax_pinned_band_parallel.py
+"""
+import numpy as np
+import pytest
+from mpi4py import MPI
+
+import underworld3 as uw
+
+pytestmark = [pytest.mark.mpi(min_size=2), pytest.mark.level_2,
+              pytest.mark.tier_b, pytest.mark.timeout(600)]
+
+POINTS = np.array([[0.12, 0.10, 0.0], [0.50, 0.52, 0.0], [0.88, 0.92, 0.0]])
+
+# Reference from the serial run, so a partition-dependent regression shows up as
+# a number rather than as a mysterious parallel failure.
+SERIAL_PINNED_COORDS = None      # filled by the first (serial-equivalent) gather
+
+
+def _fixture(cell_size=0.2):
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=cell_size,
+        regular=False, qdegree=2)
+    surface = uw.meshing.Surface("pinpar", mesh, POINTS, symbol="Pp")
+    surface.discretize()
+    return mesh, surface
+
+
+def _coords(mesh):
+    return np.asarray(mesh.dm.getCoordinatesLocal().array).reshape(-1, mesh.dim)
+
+
+def _pinned_indices(mesh, name):
+    vS, _vE = mesh.dm.getDepthStratum(0)
+    iset = mesh.dm.getLabel(name).getStratumIS(1)
+    if iset is None:
+        return np.zeros(0, dtype=np.int64)
+    return np.asarray(iset.getIndices(), dtype=np.int64) - vS
+
+
+def test_pinned_set_is_partition_independent():
+    mesh, surface = _fixture()
+    name = mesh.label_interface_band(surface, offset=0.0, halo=1)
+    X = _coords(mesh)
+    idx = _pinned_indices(mesh, name)
+
+    # Compare the pinned COORDINATES, not counts: a shared vertex is held by
+    # every rank on the seam, so a count double-counts it and would mask exactly
+    # the defect this test exists to catch.
+    local = {(round(float(x), 12), round(float(y), 12)) for x, y in X[idx]}
+    gathered = uw.mpi.comm.allgather(local)
+    union = set().union(*gathered)
+
+    total = uw.mpi.comm.allreduce(len(union), op=MPI.MAX)
+    assert len(union) == total
+    assert total > 0, "nothing pinned; the fixture is not exercising the band"
+
+
+def test_pinned_vertices_including_shared_ones_do_not_move():
+    mesh, surface = _fixture()
+    before = _coords(mesh).copy()
+    name = mesh.label_interface_band(surface, offset=0.0, halo=1)
+    idx = _pinned_indices(mesh, name)
+
+    # A pinned vertex that is also a star-forest leaf is the interesting one: it
+    # is owned by another rank, so a rank-local pin would let the owner move it.
+    try:
+        _n, ilocal, _r = mesh.dm.getPointSF().getGraph()
+    except (ValueError, TypeError):
+        ilocal = None
+    vS, _vE = mesh.dm.getDepthStratum(0)
+    leaves = set() if ilocal is None else {int(p) - vS for p in ilocal}
+    shared_pinned = [i for i in idx if int(i) in leaves]
+    assert uw.mpi.comm.allreduce(len(shared_pinned), op=MPI.SUM) > 0, (
+        "no pinned vertex is shared; this run cannot exercise the seam case")
+
+    mesh.relax(pin_bands=[surface], pin_halo=1)
+    after = _coords(mesh)
+
+    moved = np.linalg.norm(after - before, axis=1)
+    assert uw.mpi.comm.allreduce(float(moved[idx].max()), op=MPI.MAX) == 0.0
+    free = np.setdiff1d(np.arange(len(before)), idx)
+    assert uw.mpi.comm.allreduce(float(moved[free].max()) if len(free) else 0.0,
+                                 op=MPI.MAX) > 0.0, "the mover did nothing"
+
+
+def test_domain_boundary_stays_pinned():
+    mesh, surface = _fixture()
+    before = _coords(mesh).copy()
+    on_boundary = (np.isclose(before[:, 0], 0.0) | np.isclose(before[:, 0], 1.0)
+                   | np.isclose(before[:, 1], 0.0) | np.isclose(before[:, 1], 1.0))
+
+    mesh.relax(pin_bands=[surface])
+    after = _coords(mesh)
+
+    worst = float(np.abs(after[on_boundary] - before[on_boundary]).max()) \
+        if on_boundary.any() else 0.0
+    assert uw.mpi.comm.allreduce(worst, op=MPI.MAX) == 0.0
diff --git a/tests/parallel/ptest_0848_fault_split_3d_parallel.py b/tests/parallel/ptest_0848_fault_split_3d_parallel.py
new file mode 100644
index 000000000..45c750933
--- /dev/null
+++ b/tests/parallel/ptest_0848_fault_split_3d_parallel.py
@@ -0,0 +1,152 @@
+"""3-D split-node faults in parallel: fault-aware redistribution makes
+the split work at ANY rank count.
+
+Run with:  mpirun -np 2 python ptest_0848_fault_split_3d_parallel.py
+
+The v1 parallel contract for 3-D is deliberately conservative: the fault
+patch's whole cell star must be rank-interior (a 3-D seam crossing is a
+curve — a design of its own, deferred). This test proves both halves of
+the contract at np = 2:
+
+1. A patch interior to one rank splits cleanly — chart deltas match the
+   patch census on the owning rank, every rank rebuilds, the star forest
+   carries over with zero coordinate drift, and a P2 Poisson solve on
+   the split mesh shows the Plus datum does NOT leak onto the coincident
+   Minus DOFs.
+2. A patch straddling the seam raises the SAME RuntimeError on EVERY
+   rank — no rank continues into the collective rebuild and blocks.
+"""
+
+import numpy as np
+from mpi4py import MPI
+
+import underworld3 as uw
+from underworld3.utilities.fault_split import split_fault
+
+comm = MPI.COMM_WORLD
+rank, size = comm.rank, comm.size
+
+PASS, FAIL = [], []
+
+
+def check(name, ok):
+    (PASS if ok else FAIL).append(name)
+    uw.pprint(f"  [{'ok' if ok else 'FAIL'}] {name}")
+
+
+def sf_coordinate_drift(mesh):
+    """Broadcast every vertex coordinate root-to-leaf, one component per
+    pass (the SF's unit is one double per point); leaves must agree with
+    their own coordinates. Lifted from ``ptest_0845``."""
+    dm = mesh.dm
+    sf = dm.getPointSF()
+    try:
+        sf.getGraph()
+    except (ValueError, TypeError):
+        return 0.0
+    pStart, pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, mesh.dim)
+    worst = 0.0
+    for comp in range(mesh.dim):
+        root = np.zeros(pEnd - pStart, dtype=np.float64)
+        root[vS - pStart: vE - pStart] = X[: vE - vS, comp]
+        leaf = np.full(pEnd - pStart, np.nan, dtype=np.float64)
+        sf.bcastBegin(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        sf.bcastEnd(MPI.DOUBLE, root, leaf, MPI.REPLACE)
+        seen = np.isfinite(leaf[vS - pStart: vE - pStart])
+        if seen.any():
+            worst = max(worst, float(np.abs(
+                leaf[vS - pStart: vE - pStart][seen]
+                - X[: vE - vS, comp][seen]).max()))
+    return float(comm.allreduce(worst, MPI.MAX))
+
+
+# ---- case 1: rank-interior patch ------------------------------------------
+# The partitioner balances cell counts and its cut is ATTRACTED to
+# locally refined regions, so in a unit cube a patch is never safely
+# interior at np = 2. An ELONGATED box pins the cut across the long
+# axis (probed: shared band x in [0.8, 1.25]); a patch near one end
+# stays clear of it with a full cell-star margin.
+PATCH_IN = np.array([[0.4, 0.35, 0.35], [0.4, 0.65, 0.35],
+                     [0.4, 0.65, 0.65], [0.4, 0.35, 0.65]])
+mesh1 = uw.meshing.BoxInternalPatch(cellSize=0.15, minCoords=(0, 0, 0),
+                                    maxCoords=(2, 1, 1),
+                                    patch_points=PATCH_IN,
+                                    patch_name="FltA")
+# split_fault gathers the patch's cell star (plus one growth layer)
+# onto one rank before splitting, so this succeeds at ANY np — the
+# elongated box is kept only so the far field stays distributed.
+child = split_fault(mesh1, "FltA")
+check("interior patch splits", True)
+
+if child is not None:
+    n_plus_local = 0
+    value = int(child.boundaries["FltAPlus"].value)
+    if child.dm.hasLabel("FltAPlus") and \
+            child.dm.getLabel("FltAPlus").getStratumSize(value) > 0:
+        n_plus_local = child.dm.getLabel("FltAPlus").getStratumSize(value)
+    n_plus = comm.allreduce(n_plus_local, MPI.SUM)
+    check("plus faces exist globally", n_plus > 0)
+    check("fault is rank-interior (one owner)",
+          comm.allreduce(1 if n_plus_local else 0, MPI.SUM) == 1)
+    check("sf drift is zero", sf_coordinate_drift(child) == 0.0)
+
+    u = uw.discretisation.MeshVariable("u", child, 1, degree=2)
+    poisson = uw.systems.Poisson(child, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 0.0
+    for wall in ("Bottom", "Top", "Right", "Left", "Front", "Back"):
+        poisson.add_dirichlet_bc(0.0, wall)
+    poisson.add_dirichlet_bc(1.0, "FltAPlus")
+    poisson.solve()
+
+    vals = np.asarray(u.data[:, 0])
+    lo = float(comm.allreduce(vals.min() if vals.size else 1e30, MPI.MIN))
+    hi = float(comm.allreduce(vals.max() if vals.size else -1e30, MPI.MAX))
+    check("solution bounded by the data", lo >= -1e-9 and hi <= 1.0 + 1e-9)
+
+    n_pairs_local = len(child._fault_point_pairs["FltA"])
+    sec = child.dm.getLocalSection()
+    decoupled = 0
+    for q_minus, q_plus in child._fault_point_pairs["FltA"].items():
+        if sec.getFieldDof(q_minus, 0) == 0:
+            continue
+        d_minus = sec.getFieldOffset(q_minus, 0)
+        d_plus = sec.getFieldOffset(q_plus, 0)
+        if vals[d_plus] > vals[d_minus] + 1e-9:
+            decoupled += 1
+    check("minus DOFs decoupled from the plus datum",
+          comm.allreduce(decoupled, MPI.SUM) > 0)
+
+# ---- case 2: a seam-straddling patch is redistributed and splits -----------
+PATCH_SEAM = np.array([[1.0, 0.35, 0.35], [1.0, 0.65, 0.35],
+                       [1.0, 0.65, 0.65], [1.0, 0.35, 0.65]])
+# (the middle of the long axis, where the balance cut runs)
+mesh2 = uw.meshing.BoxInternalPatch(cellSize=0.15, minCoords=(0, 0, 0),
+                                    maxCoords=(2, 1, 1),
+                                    patch_points=PATCH_SEAM,
+                                    patch_name="FltB")
+# this patch sits exactly where the balance cut runs — the case that
+# used to refuse. The fault-aware redistribution must make it split,
+# single-owner, with a clean SF.
+child2 = split_fault(mesh2, "FltB")
+value2 = int(child2.boundaries["FltBPlus"].value)
+n2_local = 0
+if child2.dm.hasLabel("FltBPlus") and \
+        child2.dm.getLabel("FltBPlus").getStratumSize(value2) > 0:
+    n2_local = child2.dm.getLabel("FltBPlus").getStratumSize(value2)
+check("seam patch splits after redistribution",
+      comm.allreduce(n2_local, MPI.SUM) > 0)
+check("seam patch is single-owner",
+      comm.allreduce(1 if n2_local else 0, MPI.SUM) == 1)
+check("seam patch sf drift is zero", sf_coordinate_drift(child2) == 0.0)
+
+# ---- report ----------------------------------------------------------------
+n_fail = comm.allreduce(len(FAIL), MPI.SUM)
+uw.pprint(f"ptest_0848: {len(PASS)} passed, {len(FAIL)} failed "
+          f"(rank {rank})")
+if rank == 0:
+    print("PTEST_0848_RESULT:", "PASS" if n_fail == 0 else "FAIL")
+assert n_fail == 0
diff --git a/tests/test_0753_nested_mg_prolongation.py b/tests/test_0753_nested_mg_prolongation.py
index 56c38eda2..9f63ecc06 100644
--- a/tests/test_0753_nested_mg_prolongation.py
+++ b/tests/test_0753_nested_mg_prolongation.py
@@ -5,10 +5,31 @@
 is what made #424 possible (a coarse DOF with no fine image -> zero column
 -> singular coarse operator).
 
-The recorded transfer is the true P1 embedding: every fine vertex is an
-inherited coarse vertex (weight 1) or a midpoint (1/2, 1/2), composed
-through any closure cascade. The properties asserted here are what make it
-better than point location, not merely different.
+The recorded transfer is the true P1 embedding of the coarse space in the fine
+one. The properties asserted here are what make it better than point location,
+not merely different.
+
+One multigrid level now spans as many engine passes as it takes to halve `h`
+(``adapt(mg_coarsening_ratio=...)``), so a recorded transfer is the COMPOSITION
+of those passes. That widens two things:
+
+* a fine vertex need no longer lie on a coarse EDGE. Composing two bisections
+  can place it at the midpoint of a segment joining two midpoints, which is
+  strictly inside a coarse cell, where the reference is the coarse P1 value at
+  that position computed barycentrically;
+* a row holds up to ``dim+1`` entries rather than 2, because that is how many
+  coarse vertices a point inside a coarse cell depends on. It is still the exact
+  embedding, and still far sparser than a point-located row would be dense.
+
+**Both references are kept, and replacing the first with the second was a
+LOOSENING.** The barycentric reference was once justified as covering every fine
+vertex rather than "the ~64 % that lie on an edge" — but that 64 % belongs to the
+3-D case, and in 2-D nothing composes: one transfer, at most 2 entries per row,
+and 100 % of fine vertices on a coarse edge. The edge reference already covered
+everything that ran, and it catches something barycentric position cannot — a
+PHANTOM parent edge, two coarse vertices straddling the fine vertex without
+spanning any coarse edge. That is the 3-D defect, and a symmetric wrong pair also
+reproduces linear fields exactly, so the linear test is blind to it too.
 """
 import numpy as np
 import pytest
@@ -23,11 +44,88 @@ def _metric(centroids):
     return 1.0 / np.minimum(np.sqrt(0.05**2 + (2.0 * d) ** 2), 0.3) ** 2
 
 
-def _adapted(dim, cell_size):
+def _coarse_cell_vertices(cdm, dim):
+    """(n_cells, dim+1) vertex indices of every coarse cell."""
+    vS, vE = cdm.getDepthStratum(0)
+    cS, cE = cdm.getHeightStratum(0)
+    return np.array([[int(p) - vS for p in cdm.getTransitiveClosure(c)[0]
+                      if vS <= p < vE] for c in range(cS, cE)])
+
+
+def _coarse_p1_value(cx, cells, data, x, tol=1e-9):
+    """The coarse P1 field at ``x``, by barycentric interpolation.
+
+    Returns ``None`` if ``x`` lies in no coarse cell, which the caller treats as
+    a failure to cover rather than a pass. Computed here rather than through
+    `uw.function.evaluate`, which is wrong exactly on cell boundaries (#432) —
+    and a composed transfer puts many fine vertices there.
+    """
+    for verts in cells:
+        P0 = cx[verts[0]]
+        M = np.stack([cx[v] - P0 for v in verts[1:]], axis=1)
+        try:
+            lam = np.linalg.solve(M, x - P0)
+        except np.linalg.LinAlgError:      # degenerate cell; cannot contain x
+            continue
+        bary = np.concatenate([[1.0 - lam.sum()], lam])
+        if (bary > -tol).all() and (bary < 1.0 + tol).all():
+            return float(bary @ data[verts])
+    return None
+
+
+def _coarse_edges(cdm):
+    """(n_edges, 2) coarse vertex indices, for the edge-membership reference."""
+    vS, _vE = cdm.getDepthStratum(0)
+    eS, eE = cdm.getDepthStratum(1)
+    return np.array([[int(v) - vS for v in cdm.getCone(e)]
+                     for e in range(eS, eE)], dtype=np.int64)
+
+
+def _coarse_support_of(cx, edges, x, tol=1e-9):
+    """Where ``x`` sits in the coarse mesh: the vertices it can depend on.
+
+    Returns ``("vertex", (v,))``, ``("edge", (a, b))``, or ``("interior", ())``.
+
+    This is the reference the barycentric one REPLACED, and dropping it was a
+    loosening rather than the strengthening it was recorded as: in 2-D nothing
+    composes, every fine vertex lies on a coarse edge, and the barycentric check
+    is strictly weaker there because it cannot tell a correct parent edge from a
+    PHANTOM one — two coarse vertices that straddle the fine vertex without
+    spanning any coarse edge. That is exactly the 3-D defect, and it is why both
+    references are kept.
+    """
+    d = np.linalg.norm(cx - x, axis=1)
+    j = int(np.argmin(d))
+    if d[j] < tol:
+        return "vertex", (j,)
+
+    A, B = cx[edges[:, 0]], cx[edges[:, 1]]
+    seg = B - A
+    t = np.einsum("ij,ij->i", x - A, seg) / np.einsum("ij,ij->i", seg, seg)
+    foot = A + np.clip(t, 0.0, 1.0)[:, None] * seg
+    hit = np.flatnonzero((t > -tol) & (t < 1.0 + tol)
+                         & (np.linalg.norm(x - foot, axis=1) < tol))
+    if len(hit):
+        e = edges[hit[0]]
+        return "edge", (int(e[0]), int(e[1]))
+    return "interior", ()
+
+
+def _adapted(dim, cell_size, max_levels=2, ratio=2.0):
     base = uw.meshing.UnstructuredSimplexBox(
         minCoords=(0.0,) * dim, maxCoords=(1.0,) * dim,
         cellSize=cell_size, refinement=1, qdegree=2)
-    return base.adapt(_metric, max_levels=2)
+    return base.adapt(_metric, max_levels=max_levels, mg_coarsening_ratio=ratio)
+
+
+# The parametrisation the embedding tests run over. The third case is a 2-D
+# hierarchy that genuinely COMPOSES — three engine generations folded into one
+# multigrid level, max 3 nonzeros per row. Without it the docstring's claim
+# about composition is not exercised anywhere that runs: in the standard 2-D
+# case nothing composes (one transfer, max 2 per row, every fine vertex on a
+# coarse edge) and the only composing case was the 3-D one, which is xfailed.
+CASES = [(2, 0.2, 2, 2.0), (3, 0.4, 2, 2.0), (2, 0.3, 4, 4.0)]
+CASE_IDS = ["2d", "3d", "2d-composed"]
 
 
 def _levels(child):
@@ -41,19 +139,19 @@ def _as_matrix(entry, coarse_dm, fine_dm):
     return sp.csr_matrix((vals, (rows, cols)), shape=(fvE - fvS, cvE - cvS))
 
 
-@pytest.mark.parametrize("dim,cell_size", [(2, 0.2), (3, 0.4)])
-def test_every_pass_records_a_prolongation(dim, cell_size):
-    child = _adapted(dim, cell_size)
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_every_pass_records_a_prolongation(dim, cell_size, max_levels, ratio):
+    child = _adapted(dim, cell_size, max_levels, ratio)
     Ps = child._adapt_prolongation
     assert Ps, "adapt recorded no nested prolongations"
     assert all(P is not None for P in Ps), (
         "a refinement pass could not be expressed as a bisection embedding")
 
 
-@pytest.mark.parametrize("dim,cell_size", [(2, 0.2), (3, 0.4)])
-def test_partition_of_unity_and_no_zero_columns(dim, cell_size):
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_partition_of_unity_and_no_zero_columns(dim, cell_size, max_levels, ratio):
     """No zero column is the property that makes #424 impossible here."""
-    child = _adapted(dim, cell_size)
+    child = _adapted(dim, cell_size, max_levels, ratio)
     Ps = child._adapt_prolongation
     lvl = _levels(child)[-(len(Ps) + 1):]
     for k, entry in enumerate(Ps):
@@ -67,75 +165,125 @@ def test_partition_of_unity_and_no_zero_columns(dim, cell_size):
             f"zero-column failure the nested transfer is meant to preclude")
 
 
-@pytest.mark.parametrize("dim,cell_size", [(2, 0.2), (3, 0.4)])
-def test_reproduces_an_arbitrary_coarse_field(dim, cell_size):
-    """The transfer must be the coarse P1 EMBEDDING, not merely a linear
-    interpolant.
+def _embedding_report(dim, cell_size, max_levels, ratio):
+    """Per-row verdict on whether the recorded transfer is the P1 embedding.
 
-    Reproducing a globally linear field (the test below) is far too weak — any
-    local averaging of nearby values passes it, so a prolongation that
-    attributed weights to the wrong coarse cell would go undetected. This uses
-    a RANDOM coarse nodal field, where only the true embedding agrees.
-
-    The reference is computed independently: every bisection vertex lies on a
-    coarse edge, so the P1 value there is (1-t) u_a + t u_b along that edge.
-    Deliberately NOT `uw.function.evaluate`, which returns wrong values at
-    points lying exactly on cell boundaries (#432) — using it as the reference
-    produced a convincing false accusation against this code.
+    Returns ``(on_support, interior)``: lists of ``(pass, row, exact)`` for rows
+    whose fine vertex lies on a coarse vertex or edge, and for rows whose fine
+    vertex lies strictly inside a coarse cell. They are reported separately
+    because in 3-D only the second kind is broken, and lumping them together
+    loses the guarantee on the first — which is the majority.
     """
-    child = _adapted(dim, cell_size)
+    child = _adapted(dim, cell_size, max_levels, ratio)
     Ps = child._adapt_prolongation
     lvl = _levels(child)[-(len(Ps) + 1):]
     rng = np.random.default_rng(0)
+
+    on_support, interior = [], []
     for k, entry in enumerate(Ps):
         if entry is None:
             continue
         cdm, fdm = lvl[k], lvl[k + 1]
         P = _as_matrix(entry, cdm, fdm)
         cvS, cvE = cdm.getDepthStratum(0)
-        ceS, ceE = cdm.getDepthStratum(1)
         fvS, fvE = fdm.getDepthStratum(0)
         cx = cdm.getCoordinatesLocal().array.reshape(-1, dim)
         fx = fdm.getCoordinatesLocal().array.reshape(-1, dim)
         data = rng.standard_normal(cvE - cvS)
         got = P @ data
 
-        edges = np.asarray([[c[0] - cvS, c[1] - cvS]
-                            for e in range(ceS, ceE)
-                            for c in (cdm.getCone(e),)
-                            if len(c) == 2 and all(cvS <= q < cvE for q in c)])
-        A, B = cx[edges[:, 0]], cx[edges[:, 1]]
-        AB = B - A
-        L2 = np.einsum("ij,ij->i", AB, AB)
-        checked = 0
+        cells = _coarse_cell_vertices(cdm, dim)
+        edges = _coarse_edges(cdm)
         for r in range(fvE - fvS):
-            t = np.einsum("ij,ij->i", AB, fx[r][None, :] - A) / L2
-            on = (t > -1e-12) & (t < 1.0 + 1e-12)
-            if not on.any():
-                continue
-            resid = np.linalg.norm(A[on] + t[on, None] * AB[on] - fx[r], axis=1)
-            hit = np.nonzero(resid < 1e-12)[0]
-            if not len(hit):
-                continue
-            e0 = np.nonzero(on)[0][hit[0]]
-            t0 = t[on][hit[0]]
-            truth = (1 - t0) * data[edges[e0, 0]] + t0 * data[edges[e0, 1]]
-            assert abs(got[r] - truth) < 1e-10, (
-                f"pass {k}, fine vertex {r}: transfer {got[r]} != coarse P1 "
-                f"value {truth} on the edge it lies on — the prolongation is "
-                f"not the coarse embedding")
-            checked += 1
-        assert checked > 0.9 * (fvE - fvS), (
-            f"pass {k}: only {checked} of {fvE - fvS} vertices lay on a coarse "
-            f"edge; the test is not covering what it claims")
-
-
-@pytest.mark.parametrize("dim,cell_size", [(2, 0.2), (3, 0.4)])
-def test_reproduces_a_linear_field_exactly(dim, cell_size):
+            truth = _coarse_p1_value(cx, cells, data, fx[r])
+            assert truth is not None, (
+                f"pass {k}, fine vertex {r} lies in no coarse cell; the test is "
+                f"not covering what it claims")
+            exact = abs(got[r] - truth) < 1e-10
+            kind, support = _coarse_support_of(cx, edges, fx[r])
+            cols = set(int(c) for c in P.indices[P.indptr[r]:P.indptr[r + 1]])
+            if kind == "interior":
+                interior.append((k, r, exact))
+            else:
+                on_support.append((k, r, exact and cols <= set(support)))
+    return on_support, interior
+
+
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_a_fine_vertex_on_a_coarse_edge_depends_only_on_that_edge(
+        dim, cell_size, max_levels, ratio):
+    """Two references, not one — this is the edge-membership half.
+
+    A fine vertex that sits on a coarse vertex or a coarse EDGE must take its
+    value from exactly those coarse vertices. A barycentric-position reference
+    alone cannot see the failure this catches: a PHANTOM parent edge, whose two
+    endpoints straddle the fine vertex symmetrically without spanning any coarse
+    edge, reproduces the position and reproduces linear fields exactly while
+    being the wrong parentage. That is the 3-D defect, characterised: fine vertex
+    1780 carries the row ``{484: 0.5, 798: 0.5}`` while its true barycentric
+    position is ``(0, 0.25, 0.5, 0.25)``.
+
+    Holds in EVERY case including 3-D, where it is the guarantee on the majority
+    of rows that the interior-vertex bug would otherwise take down with it.
+    """
+    on_support, _interior = _embedding_report(dim, cell_size, max_levels, ratio)
+    assert on_support, "no fine vertex lay on a coarse vertex or edge"
+    bad = [(k, r) for k, r, ok in on_support if not ok]
+    assert not bad, (
+        f"{len(bad)} of {len(on_support)} rows whose fine vertex lies on a "
+        f"coarse edge are not supported on that edge: {bad[:5]}")
+
+
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_reproduces_an_arbitrary_coarse_field(dim, cell_size, max_levels, ratio):
+    """The transfer must be the coarse P1 EMBEDDING, not merely a linear
+    interpolant.
+
+    Reproducing a globally linear field (the test below) is far too weak — any
+    local averaging of nearby values passes it, so a prolongation that
+    attributed weights to the wrong coarse cell would go undetected. This uses
+    a RANDOM coarse nodal field, where only the true embedding agrees.
+
+    The reference is computed independently, by barycentric interpolation in the
+    coarse cell that contains the fine vertex. Deliberately NOT
+    `uw.function.evaluate`, which returns wrong values at points lying exactly on
+    cell boundaries (#432) — using it as the reference produced a convincing
+    false accusation against this code.
+
+    TODO(BUG) ``nvb.nested_prolongation`` is wrong in 3-D for vertices a closure
+    cascade places strictly INSIDE a coarse tet — worst error 1.19, measured per
+    generation with no composition involved, against 1.9e-15 in 2-D. The defect
+    is asserted POSITIVELY below rather than through ``xfail(strict=True)``: it
+    is carried by ONE row in 2336 of a gmsh mesh, so a strict xfail turns a gmsh
+    version bump into a hard failure, and it hides how narrow the breakage is.
+    When the bug is fixed this test fails and says so.
+    """
+    _on_support, interior = _embedding_report(dim, cell_size, max_levels, ratio)
+    wrong = [(k, r) for k, r, exact in interior if not exact]
+
+    if dim == 3:
+        assert wrong, (
+            "3-D interior-vertex rows are now exact — nvb.nested_prolongation "
+            "appears FIXED. Delete this branch and assert exactness for every "
+            "dimension.")
+        return
+
+    assert not wrong, (
+        f"{len(wrong)} of {len(interior)} rows whose fine vertex lies strictly "
+        f"inside a coarse cell are not the coarse P1 value there: {wrong[:5]}")
+
+
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_reproduces_a_linear_field_exactly(dim, cell_size, max_levels, ratio):
     """Necessary but WEAK — see the embedding test above. Kept because a
     failure here localises the problem to the arithmetic rather than the
-    parentage."""
-    child = _adapted(dim, cell_size)
+    parentage.
+
+    Provably BLIND to the 3-D defect above, which is why it cannot be the only
+    embedding check: a symmetric wrong pair of parents reproduces a linear field
+    exactly. Kept for localisation, not for coverage.
+    """
+    child = _adapted(dim, cell_size, max_levels, ratio)
     Ps = child._adapt_prolongation
     lvl = _levels(child)[-(len(Ps) + 1):]
     for k, entry in enumerate(Ps):
@@ -148,14 +296,36 @@ def test_reproduces_a_linear_field_exactly(dim, cell_size):
             f"pass {k}: prolongation does not reproduce a linear field")
 
 
-def test_transfer_is_sparser_than_point_location():
-    """1-2 nonzeros per row, vs dim+1 for a barycentric point-located row."""
-    child = _adapted(3, 0.4)
+@pytest.mark.parametrize("dim,cell_size,max_levels,ratio", CASES, ids=CASE_IDS)
+def test_transfer_is_sparser_than_point_location(dim, cell_size, max_levels, ratio):
+    """At most ``dim+1`` nonzeros in EVERY row, and fewer than that on average.
+
+    A single bisection gives 1-2 entries per row. A level that spans several
+    passes composes them, and a fine vertex strictly inside a coarse cell depends
+    on that cell's ``dim+1`` vertices — which is the bound, not a symptom.
+
+    Bounded PER ROW, not on the average. ``dim+1`` IS point-location density, so
+    a mean bounded by it cannot distinguish the recorded transfer from the thing
+    this test is named for beating: a mean of 4 tolerates a minority of rows with
+    20+ entries, which is precisely the "weights on the wrong coarse cell" mode.
+    The measured per-row maxima are 2 (2-D), 3 (2-D composed) and 4 (3-D) — tight
+    in two of the three, so the bound is doing work rather than being generous.
+    The mean is then required to be strictly below ``dim+1``, which is the actual
+    "sparser than point location" claim (measured 1.19 / 1.38 / 2.24).
+    """
+    child = _adapted(dim, cell_size, max_levels, ratio)
     Ps = child._adapt_prolongation
     lvl = _levels(child)[-(len(Ps) + 1):]
     for k, entry in enumerate(Ps):
         P = _as_matrix(entry, lvl[k], lvl[k + 1])
-        assert P.nnz / P.shape[0] <= 2.0
+        worst = int(np.diff(P.indptr).max())
+        assert worst <= dim + 1, (
+            f"{dim}D pass {k}: a row holds {worst} nonzeros, more than the "
+            f"{dim + 1} vertices a coarse cell can supply")
+        mean = P.nnz / P.shape[0]
+        assert mean < dim + 1, (
+            f"{dim}D pass {k}: {mean:.2f} nonzeros per row on average is "
+            f"point-location density; the recorded transfer should be sparser")
 
 
 def test_mg_actually_uses_the_recorded_transfer_for_degree_one():
diff --git a/tests/test_0836_nvb_graded_adapt.py b/tests/test_0836_nvb_graded_adapt.py
index f9e3bebbb..59cf0c81f 100644
--- a/tests/test_0836_nvb_graded_adapt.py
+++ b/tests/test_0836_nvb_graded_adapt.py
@@ -26,6 +26,7 @@
 import sympy
 import underworld3 as uw
 from underworld3.function import analytic as A
+from _mg_ladder import assert_coarsening_ladder
 from underworld3.utilities.nvb import NVBMesh
 
 pytestmark = [pytest.mark.level_2, pytest.mark.tier_b]
@@ -37,6 +38,18 @@ def _ev(fn, coords):
     return np.asarray(uw.function.evaluate(fn, np.asarray(coords))).reshape(-1)
 
 
+BAND_CENTRE, BAND_WIDTH = 0.5, 0.08
+
+
+def _in_band(pts):
+    """The region `_band_metric` asks to be refined."""
+    return np.abs(np.asarray(pts)[:, 0] - BAND_CENTRE) < BAND_WIDTH
+
+
+def _assert_coarsening_ladder(child, ratio=2.0):
+    return assert_coarsening_ladder(child, _in_band, ratio=ratio)
+
+
 def _ncell(mesh):
     cs, ce = mesh.dm.getHeightStratum(0)
     return ce - cs
@@ -187,8 +200,10 @@ def test_adapt_nvb_returns_graded_child():
     assert child._adapt_engine == "nvb"
     assert _ncell(child) > n0
     assert _ncell(base) == n0                         # base untouched
-    # 2·max_levels NVB generations -> base levels + (generations-1) intermediate
-    assert len(child._custom_mg_coarse_meshes) + 1 == len(base.dm_hierarchy) + 2
+    # Multigrid levels are one per DOUBLING of h, not one per NVB generation, so
+    # the count follows from mg_coarsening_ratio rather than from max_levels.
+    assert len(child._custom_mg_coarse_meshes) >= len(base.dm_hierarchy)
+    _assert_coarsening_ladder(child)
 
 
 def test_nvb_child_fewer_dofs_than_sbr_patch():
@@ -230,7 +245,8 @@ def test_poisson_fmg_on_nvb_child_matches_gamg():
     s = _poisson(child)
     s.solve()                                         # NO set_custom_fmg
     assert s.snes.getKSP().getPC().getType() == "mg"
-    assert s.snes.getKSP().getPC().getMGLevels() == len(base.dm_hierarchy) + 2
+    assert (s.snes.getKSP().getPC().getMGLevels()
+            == len(child._custom_mg_coarse_meshes) + 1)
     assert s.snes.getConvergedReason() > 0
 
     g = _poisson(child)
@@ -382,3 +398,51 @@ def metric(centroids):
     after = np.asarray(mesh.X.coords)
     assert np.array_equal(after[m0], before[m0]), "interface nodes moved"
     assert not np.allclose(after, before)      # the rest of the mesh did
+
+
+@pytest.mark.parametrize("ratio", [1.5, 2.0, 3.0])
+def test_mg_coarsening_ratio_sets_the_level_count(ratio):
+    """`mg_coarsening_ratio` is the user's handle on the grid sequence.
+
+    A larger ratio means fewer, more widely spaced levels. Measured on cut SolCx
+    at contrast 1e6, wall time fell monotonically from ratio 1.5 to 3.0 (12.2 ->
+    7.3 -> 4.8 s on NVB) for +1 velocity iteration and an unchanged solution, so
+    this is a knob worth having rather than a constant worth hiding.
+    """
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        refinement=1, qdegree=2)
+    child = base.adapt(_band_metric(base), max_levels=2, engine="nvb",
+                       mg_coarsening_ratio=ratio)
+
+    _assert_coarsening_ladder(child, ratio=ratio)
+    # One transfer per level, or custom_mg lines them up against the wrong levels.
+    assert len(child._adapt_prolongation) == len(
+        child._custom_mg_coarse_meshes) + 1 - len(base.dm_hierarchy)
+
+
+def test_a_larger_ratio_gives_strictly_fewer_levels():
+    """The knob has to change the hierarchy, not merely fail to grow it.
+
+    Non-increasing is satisfied by a CONSTANT: hard-code the ratio to 2.0 and the
+    counts become ``[3, 3, 3]``, still non-increasing, so the old assertion
+    passed with the knob stubbed out. Strict decrease across the range is what
+    demonstrates it is connected to anything.
+
+    Measured, and worth recording rather than hiding: ratios 1.5 and 2.0 produce
+    IDENTICAL hierarchies on this case (3 levels, the same steps to the last
+    digit). The knob is real but coarse-grained — it selects levels from the
+    generations an engine happens to produce, so it cannot resolve a difference
+    finer than one generation.
+    """
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        refinement=1, qdegree=2)
+    counts = [len(base.adapt(_band_metric(base), max_levels=2, engine="nvb",
+                             mg_coarsening_ratio=r)._custom_mg_coarse_meshes)
+              for r in (1.5, 2.0, 3.0)]
+    assert counts == sorted(counts, reverse=True), (
+        f"level counts {counts} are not non-increasing in the coarsening ratio")
+    assert counts[0] > counts[-1], (
+        f"level counts {counts} do not fall between ratio 1.5 and 3.0, so the "
+        f"knob is doing nothing over the range this test covers")
diff --git a/tests/test_0840_nvb_3d_serial_adapt.py b/tests/test_0840_nvb_3d_serial_adapt.py
index ac0216a45..71524f498 100644
--- a/tests/test_0840_nvb_3d_serial_adapt.py
+++ b/tests/test_0840_nvb_3d_serial_adapt.py
@@ -30,6 +30,7 @@
 import pytest
 import underworld3 as uw
 from petsc4py import PETSc
+from _mg_ladder import assert_coarsening_ladder
 from underworld3.utilities.nvb import TaggedBisectionMesh
 
 pytestmark = [pytest.mark.level_2, pytest.mark.tier_b]
@@ -38,6 +39,23 @@
              ("Front", 15), ("Back", 16)]
 
 
+# The region the ladder measures `h` in. `_ball_metric`'s fine CORE is r < 0.18,
+# but the coarsest base level has edges ~0.6 long and not one midpoint lands
+# inside a ball that small — the measurement would have no sample to take. 0.25
+# is the smallest radius that contains edges of every level, and it still sits
+# well inside the metric's ramp (r_core 0.18 + width 0.25).
+BALL_CORE = 0.25
+
+
+def _in_ball(pts):
+    """The region `_ball_metric` asks to be refined."""
+    return np.linalg.norm(np.asarray(pts) - 0.5, axis=1) < BALL_CORE
+
+
+def _assert_coarsening_ladder(child, ratio=2.0):
+    return assert_coarsening_ladder(child, _in_ball, ratio=ratio)
+
+
 def _ncell(mesh):
     cs, ce = mesh.dm.getHeightStratum(0)
     return ce - cs
@@ -165,8 +183,10 @@ def test_adapt_engineless_3d_returns_graded_child():
     # coarse levels = base hierarchy + (generations - 1) intermediates
     n_gens = len(child._adapt_markers)
     assert 1 <= n_gens <= 3                              # dim * max_levels
-    assert (len(child._custom_mg_coarse_meshes)
-            == len(base.dm_hierarchy) + n_gens - 1)
+    # Multigrid levels are one per DOUBLING of h, not one per generation: a
+    # generation is a 2^(1/dim) step, so `dim` of them make one level.
+    assert len(child._custom_mg_coarse_meshes) >= len(base.dm_hierarchy)
+    _assert_coarsening_ladder(child)
     # full PETSc consistency battery on the child, including the cell
     # ORIENTATION class (DMPlexCheckGeometry flags inverted cells) —
     # visualisation winding, outward normals and boundary integrals are
diff --git a/tests/test_0843_edge_split_adapt.py b/tests/test_0843_edge_split_adapt.py
new file mode 100644
index 000000000..37cc831cd
--- /dev/null
+++ b/tests/test_0843_edge_split_adapt.py
@@ -0,0 +1,188 @@
+"""Longest-edge refinement without a conforming closure (``engine="edge_split"``).
+
+The engine (:mod:`underworld3.utilities.edge_split`) splits the longest edge of
+every cell coarser than the metric asks for. Because splitting an edge divides
+*every* cell incident on it at the same new vertex there is no hanging node and
+no closure, so — unlike bisection — refinement cannot escape the marked region.
+It drives the compiled ``uwnvb_bisect`` :c:type:`DMPlexTransform`, the same
+primitive the newest-vertex engine uses for each of its sub-passes, so topology,
+coordinates, labels and the parallel star-forest are PETSc's.
+
+What is asserted, and why each test would have caught a real defect found while
+building this:
+
+- **conformity** — no over-shared facet, at every generation;
+- **the diameter is what converges** — the size field is expressed as a
+  diameter, and the volume proxy ``(dim!·vol)^(1/dim)`` is NOT a substitute: it
+  reported the target met while the mesh was 3.2x coarser across the feature on
+  a non-bisection engine. A regression to the proxy passes a naive cell-count
+  check and fails this one;
+- **no halo** — cells far from the feature are untouched. This is the property
+  the engine exists for, and the one a conforming closure gives up;
+- **the exact prolongation survives** — every inserted vertex is the exact float
+  midpoint of a parent edge, so the recorded 1/2,1/2 transfer applies and the
+  child carries one MG level per generation;
+- **partition independence** — the refined mesh is the same at any communicator
+  size. Three separate defects during development (a collective inside a
+  rank-local branch, an order-dependent greedy edge selection, and a mis-sized
+  star-forest reduce) all showed up here and nowhere else, so this is the
+  load-bearing test. The np>1 half lives in
+  ``tests/parallel/ptest_0843_edge_split_parallel.py``; this file records the
+  serial reference the parallel run must reproduce.
+"""
+import numpy as np
+import pytest
+import underworld3 as uw
+from underworld3.utilities import edge_split
+
+pytestmark = [pytest.mark.level_2, pytest.mark.tier_b]
+
+
+def _box(dim, cell_size, refinement=1):
+    lo = tuple([0.0] * dim)
+    hi = tuple([1.0] * dim)
+    return uw.meshing.UnstructuredSimplexBox(
+        minCoords=lo, maxCoords=hi, cellSize=cell_size,
+        refinement=refinement, qdegree=2)
+
+
+def _centroids(dm):
+    cS, cE = dm.getHeightStratum(0)
+    if cE == cS:
+        return np.zeros((0, dm.getCoordinateDim()))
+    return np.array([dm.computeCellGeometryFVM(c)[1] for c in range(cS, cE)])
+
+
+def _over_shared_facets(dm):
+    fS, fE = dm.getHeightStratum(1)
+    return sum(1 for f in range(fS, fE) if len(dm.getSupport(f)) > 2)
+
+
+def _refine_to(dm, h_of_centroid, max_passes=40):
+    """Drive the engine until the diameter target is met everywhere."""
+    passes = 0
+    while passes < max_passes:
+        cS, _cE = dm.getHeightStratum(0)
+        cen = _centroids(dm)
+        if cen.shape[0] == 0:
+            break
+        sel = np.flatnonzero(edge_split.cell_diameters(dm) > h_of_centroid(cen)) + cS
+        dm, n_split = edge_split.bisect_longest_edges(dm, sel)
+        if n_split == 0:
+            break
+        assert _over_shared_facets(dm) == 0, (
+            f"pass {passes} left a facet shared by more than two cells")
+        passes += 1
+    return dm, passes
+
+
+def _disc_target(centre, radius, h_near, h_far):
+    def h(cen):
+        d = np.linalg.norm(cen - np.asarray(centre), axis=1)
+        return np.where(d < radius, h_near, h_far)
+    return h
+
+
+@pytest.mark.parametrize("dim", [2, 3])
+def test_conforming_and_diameter_target_met(dim):
+    """The mesh stays conforming and the DIAMETER reaches the target."""
+    centre = np.array([0.35, 0.5] if dim == 2 else [0.35, 0.5, 0.6])
+    h_near, h_far = (0.06, 0.4) if dim == 2 else (0.15, 0.5)
+    target = _disc_target(centre, 0.25, h_near, h_far)
+
+    dm = _box(dim, 0.35 if dim == 2 else 0.5).dm_hierarchy[-1]
+    n0 = dm.getHeightStratum(0)[1]
+    dm, passes = _refine_to(dm, target)
+
+    assert dm.getHeightStratum(0)[1] > n0, "no refinement happened"
+    assert _over_shared_facets(dm) == 0
+
+    cen = _centroids(dm)
+    inside = np.linalg.norm(cen - centre, axis=1) < 0.25
+    diameter = edge_split.cell_diameters(dm)
+    # The engine converges the DIAMETER. The volume proxy is systematically
+    # smaller, so a regression to marking on it would leave these cells long.
+    assert diameter[inside].max() <= h_near * 1.001, (
+        f"largest diameter in the target region is {diameter[inside].max():.4f}, "
+        f"target {h_near}")
+    assert passes >= 1
+
+
+def test_refinement_does_not_escape_the_marked_region():
+    """No halo: cells far from the feature keep their original size.
+
+    A conforming closure necessarily refines beyond the marked set; this engine
+    must not. Measured against the coarsest cell size of the unrefined base, so
+    the test states a property rather than a magic number.
+    """
+    centre = np.array([0.3, 0.3])
+    target = _disc_target(centre, 0.15, 0.04, 1.0)
+
+    base = _box(2, 0.3)
+    dm0 = base.dm_hierarchy[-1]
+    far0 = _far_field_diameter(dm0, centre, 0.45)
+    dm, _passes = _refine_to(dm0, target)
+    far1 = _far_field_diameter(dm, centre, 0.45)
+
+    assert far1 == pytest.approx(far0, rel=1e-12), (
+        f"cells beyond r=0.45 changed size ({far0:.5f} -> {far1:.5f}); "
+        f"refinement escaped the marked region")
+
+
+def _far_field_diameter(dm, centre, radius):
+    cen = _centroids(dm)
+    far = np.linalg.norm(cen - np.asarray(centre), axis=1) > radius
+    return float(edge_split.cell_diameters(dm)[far].max()) if far.any() else 0.0
+
+
+def test_adapt_returns_child_with_graded_mg_tail():
+    """``mesh.adapt(engine="edge_split")`` carries the hierarchy and the exact
+    prolongation for every generation."""
+    base = _box(2, 0.2, refinement=2)
+    centre = np.array([0.4, 0.55])
+
+    def metric(cen):
+        d = np.linalg.norm(np.asarray(cen) - centre, axis=1)
+        h = np.where(d < 0.2, 0.03, 0.12)
+        return 1.0 / h**2
+
+    child = base.adapt(metric, max_levels=2, engine="edge_split")
+
+    assert child.parent is base
+    n_child = child.dm.getHeightStratum(0)[1]
+    assert n_child > base.dm_hierarchy[-1].getHeightStratum(0)[1]
+
+    tail = child._custom_mg_coarse_meshes
+    assert tail is not None and len(tail) >= 3, (
+        "the child must carry one MG level per refinement generation on top of "
+        "the base tail; without it the V-cycle count triples")
+
+    # Every inserted vertex is an exact float edge midpoint, so the recorded
+    # 1/2,1/2 transfer must be available for EVERY generation — a None here means
+    # coordinate identity was lost and the geometric builder would be used.
+    recorded = child._adapt_prolongation
+    assert recorded and all(P is not None for P in recorded), (
+        "exact prolongation missing for at least one generation")
+
+
+def test_unknown_engine_is_refused():
+    """The engine name is validated, so a typo cannot silently fall back."""
+    base = _box(2, 0.4, refinement=1)
+    with pytest.raises(ValueError, match="edge_split"):
+        base.adapt(lambda cen: np.ones(len(cen)), max_levels=1,
+                   engine="edgesplit")
+
+
+def test_serial_reference_for_parallel_confluence():
+    """Record the serial result the parallel test must reproduce exactly.
+
+    Kept in the serial file deliberately: the parallel counterpart asserts
+    equality against these numbers, and a change here is then visible as a
+    change to the contract rather than as a mysterious parallel failure.
+    """
+    centre = np.array([0.35, 0.6])
+    target = _disc_target(centre, 0.2, 0.05, 0.3)
+    dm = _box(2, 0.35).dm_hierarchy[-1]
+    assert dm.getHeightStratum(0)[1] == 104
+    dm, passes = _refine_to(dm, target)
+    assert (dm.getHeightStratum(0)[1], passes) == (412, 7)
diff --git a/tests/test_0844_line_cut.py b/tests/test_0844_line_cut.py
new file mode 100644
index 000000000..5392c26c8
--- /dev/null
+++ b/tests/test_0844_line_cut.py
@@ -0,0 +1,881 @@
+"""Conforming surfaces added on top of an existing mesh
+(:mod:`underworld3.utilities.line_cut`, :meth:`Mesh.add_conforming_surface`).
+
+Every edge the surface crosses is split **at the crossing point**, so the surface
+becomes a chain of element edges: no element straddles it, a material property can
+be assigned per cell and be exactly right, and the surface can carry a boundary
+condition because it is a labelled set of facets.
+
+It drives the compiled ``uwnvb_bisect`` transform in **passes of pairwise-
+independent edges**. The transform can also split two edges of one triangle at
+once, which produces the whole cut in a single pass — correct in serial, and
+wrong in parallel (it leaves the child point star-forest inconsistent and
+``Mesh()`` aborts at np>=3). Independent single splits still build the cut: the
+second pass joins its new vertex to the OPPOSITE vertex of the cell, which is the
+first pass's new vertex.
+
+What is asserted, and why each would have caught a defect found while building
+this:
+
+- **the geometric property** — every segment of the line between consecutive
+  crossings is an edge of the mesh. This is the thing being built; the stress
+  result is a consequence, so it is asserted first and separately.
+- **no straddling cell** — no cell has vertices on both sides. This is the
+  property a cell-wise viscosity needs in order to be *correct*, as opposed to
+  merely smooth.
+- **the cut is exactly on the line** — inserted vertices lie on it to machine
+  precision, not merely close.
+- **a vertex ON the line is used, not split beside** — gmsh puts boundary nodes
+  at multiples of the cell size, so an interface at x=0.5 has vertices ~1e-12
+  from it. An absolute "on the line" test on a knife edge missed them, split the
+  edge alongside, and produced a cell of area 1e-24 with a zero angle. The
+  along-edge snap fraction is what fixes it, and this test is what caught it.
+- **no inverted cell**, at any snap fraction the cut accepts.
+- **refusals are refusals** — a line ending inside the mesh is rejected rather
+  than silently bisected without cutting, which would give a mesh that looks
+  plausible and still leaks stress.
+- **the base mesh is untouched** — the surface's position is a design variable, so
+  re-cutting a moved surface against the same fixed base has to be possible;
+- **a boundary condition applies on the surface** — a label is only useful if a
+  solver actually constrains those DOFs, which is the point of the feature.
+
+Partition-independence and the parallel BC solve are in
+``tests/parallel/ptest_0844_line_cut_parallel.py``; the serial references it
+asserts against are produced here.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.line_cut import (CUT_LABEL, cell_areas,
+                                            cut_along_lines, min_angles,
+                                            pull_vertex_onto)
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+SLANTED = np.array([[-0.2, 0.317], [1.2, 0.683]])
+VERTICAL = np.array([[0.5, -0.2], [0.5, 1.2]])
+
+# Mirrored in tests/parallel/ptest_0844_line_cut_parallel.py.
+SERIAL_VERTICES = 224
+SERIAL_CELLS = 396
+SERIAL_COORD_SHA = "c68821fc041cf94c"
+SERIAL_BC_INTEGRAL = 0.3807400201042878
+SERIAL_SURFACE_FACETS = 26
+SERIAL_ZONE_SHA = "94b098f3d3153eb5"
+
+
+def _box(cell_size=1 / 16):
+    return uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0),
+        cellSize=cell_size, regular=False, qdegree=2)
+
+
+def _surf(name, mesh, points):
+    """A `Surface` for `add_conforming_surface`, which takes one rather than a
+    (points, name) pair: it is what `fault_metric` and
+    `refinement_metric_function` already take, so one object drives both the
+    refinement and the cut."""
+    return uw.meshing.Surface(name, mesh, np.asarray(points, dtype=float))
+
+
+def _coords(dm):
+    return np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+
+
+def _signed_distance(pts, line):
+    A, B = np.asarray(line[0], float), np.asarray(line[-1], float)
+    d = B - A
+    nrm = np.array([-d[1], d[0]]) / np.hypot(*d)
+    return (np.atleast_2d(pts) - A) @ nrm
+
+
+def _cell_vertex_indices(dm):
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    return np.array([[int(p) - vS for p in dm.getTransitiveClosure(c)[0]
+                      if vS <= p < vE] for c in range(cS, cE)])
+
+
+@pytest.mark.parametrize("line", [SLANTED, VERTICAL])
+def test_line_becomes_a_chain_of_mesh_edges(line):
+    """Consecutive crossings are joined by a mesh edge, and it is labelled."""
+    cut, info = cut_along_lines(_box().dm, [line])
+
+    X = _coords(cut)
+    s = _signed_distance(X, line).ravel()
+    on = np.flatnonzero(np.abs(s) < 1e-11)
+    assert len(on) == info["n_split"] + info["n_on_surface"]
+
+    edges = {frozenset(int(v) - cut.getDepthStratum(0)[0] for v in cut.getCone(e)): e
+             for e in range(*cut.getDepthStratum(1))}
+    labelled = set(cut.getLabel(CUT_LABEL).getStratumIS(1).getIndices())
+
+    A, B = np.asarray(line[0], float), np.asarray(line[-1], float)
+    d = B - A
+    order = on[np.argsort(((X[on] - A) @ d) / (d @ d))]
+    for u, v in zip(order[:-1], order[1:]):
+        e = edges.get(frozenset((int(u), int(v))))
+        assert e is not None, "a segment of the line is not a mesh edge"
+        assert e in labelled, "a cut edge is not labelled"
+
+
+@pytest.mark.parametrize("line", [SLANTED, VERTICAL])
+def test_no_cell_straddles_the_line(line):
+    """The property a cell-wise viscosity needs to be correct, not just smooth."""
+    cut, _info = cut_along_lines(_box().dm, [line])
+    s = _signed_distance(_coords(cut), line).ravel()[_cell_vertex_indices(cut)]
+    straddling = ((s > 1e-11).any(axis=1) & (s < -1e-11).any(axis=1)).sum()
+    assert straddling == 0
+
+
+def test_cut_vertices_lie_exactly_on_the_line():
+    cut, info = cut_along_lines(_box().dm, [SLANTED])
+    s = np.abs(_signed_distance(_coords(cut), SLANTED).ravel())
+    assert np.sort(s)[:info["n_split"] + info["n_on_surface"]].max() < 1e-13
+
+
+def test_vertices_already_on_the_line_are_used_not_split_beside():
+    """gmsh puts nodes at multiples of the cell size, so x=0.5 hits vertices.
+
+    Splitting the edge next to such a vertex gives a degenerate cell. Before the
+    along-edge snap criterion this produced an area of 1e-24 and a 0.00 degree
+    angle, which no positivity check catches because the area is still positive.
+    """
+    cut, info = cut_along_lines(_box().dm, [VERTICAL])
+    assert info["n_on_surface"] > 0, "the x=0.5 interface should meet mesh vertices"
+    assert info["min_angle"] > 5.0
+    assert info["min_area"] > 1e-8
+
+
+# Worst interior angle of the cut, per snap fraction, on the 1/16 box. This is
+# the table the module docstring uses to justify the 0.10 default, so it is
+# pinned rather than described.
+SERIAL_MIN_ANGLE = {0.0: 1.60, 0.05: 3.88, 0.1: 6.56, 0.2: 13.93}
+
+
+@pytest.mark.parametrize("snap_frac", [0.0, 0.05, 0.1, 0.2])
+def test_snapping_buys_the_documented_element_quality(snap_frac):
+    """The snap tolerance has to deliver the angles the default rests on.
+
+    Asserting positivity instead would assert nothing: ``cut_along_lines``
+    already raises on ``(areas <= 0).any()`` computed from the SAME
+    ``cell_areas``, so an inverted cell never reaches here, and ``min_angles``
+    returns ``arccos`` of a clipped value, which cannot be negative. Both
+    assertions were true by construction. The worst angle is the quantity that
+    actually varies, and it is what the solver pays for.
+    """
+    cut, info = cut_along_lines(_box().dm, [SLANTED], snap_frac=snap_frac)
+    assert (cell_areas(cut) > 0.0).all()
+
+    expected = SERIAL_MIN_ANGLE[snap_frac]
+    assert info["min_angle"] == pytest.approx(expected, abs=0.05), (
+        f"snap_frac={snap_frac}: worst angle {info['min_angle']:.2f} deg, "
+        f"documented {expected:.2f}")
+
+
+def test_the_worst_angle_rises_monotonically_with_the_snap_tolerance():
+    """The knob's whole justification: more snapping, better elements."""
+    angles = [cut_along_lines(_box().dm, [SLANTED], snap_frac=f)[1]["min_angle"]
+              for f in (0.0, 0.05, 0.1, 0.2)]
+    assert angles == sorted(angles), f"not monotone: {angles}"
+    assert angles[-1] > 5 * angles[0], (
+        f"snapping bought only {angles[-1] / angles[0]:.1f}x in the worst angle")
+
+
+@pytest.mark.parametrize("snap_frac,line", [
+    (0.0, SLANTED), (0.05, SLANTED), (0.1, SLANTED), (0.2, SLANTED),
+    (0.1, VERTICAL),
+])
+def test_the_cut_is_one_chain(snap_frac, line):
+    """``n_cut_edges == n_split + n_on_surface - 1``.
+
+    A single line crossing the mesh cuts ONE chain, so its facets number one
+    fewer than the vertices along it, and every vertex along it is either one the
+    routine inserted or one already on the line. An exact connectivity check that
+    costs nothing: a chain that broke in two, or a labelled edge that is not part
+    of it, breaks the identity immediately.
+    """
+    _cut, info = cut_along_lines(_box().dm, [line], snap_frac=snap_frac)
+    assert info["n_cut_edges"] == info["n_split"] + info["n_on_surface"] - 1, info
+
+
+def test_a_line_ending_inside_the_mesh_is_refused():
+    """A tip bisects without cutting; refusing beats mis-meshing it silently."""
+    with pytest.raises(ValueError, match="entered but not left"):
+        cut_along_lines(_box().dm, [np.array([[-0.2, 0.4], [0.5, 0.5]])])
+
+
+def test_the_base_mesh_is_not_modified():
+    """The line is a design variable: the base must survive being cut against."""
+    base = _box()
+    before_cells = base.dm.getHeightStratum(0)[1] - base.dm.getHeightStratum(0)[0]
+    before_coords = _coords(base.dm).copy()
+
+    cut_along_lines(base.dm, [SLANTED])
+    cut_along_lines(base.dm, [np.array([[-0.2, 0.5], [1.2, 0.5]])])
+
+    after_cells = base.dm.getHeightStratum(0)[1] - base.dm.getHeightStratum(0)[0]
+    assert after_cells == before_cells
+    assert np.array_equal(_coords(base.dm), before_coords)
+
+
+def test_the_surface_exists_on_the_finest_level_only():
+    """The stack-on invariant: nothing below the child is cut.
+
+    The surface's position is a design variable in an outer optimisation, so the
+    base and the multigrid hierarchy resting on it have to stay fixed while the
+    surface moves. The child's coarse tail is therefore the base's OWN levels,
+    the same objects, carrying neither the cut nor the label.
+
+    Nor would cutting them buy anything: custom-P sets ``pc_mg_galerkin=both``,
+    so every coarse operator is PᵀAP from the FINE operator and inherits the
+    material contrast whatever the coarse mesh looks like.
+    """
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3, refinement=2)
+    tail_before = base._coarse_level_meshes()
+    counts_before = [m.dm.getHeightStratum(0)[1] - m.dm.getHeightStratum(0)[0]
+                     for m in tail_before]
+
+    child = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+    assert child.dm.hasLabel("Fault")
+    for level in child._custom_mg_coarse_meshes:
+        assert not level.dm.hasLabel("Fault"), (
+            "a coarse level carries the surface; the base hierarchy must be "
+            "reusable unchanged when the surface moves")
+    counts_after = [m.dm.getHeightStratum(0)[1] - m.dm.getHeightStratum(0)[0]
+                    for m in base._coarse_level_meshes()]
+    assert counts_after == counts_before, "a coarse level gained cells"
+
+    # The child's tail is made of the base's own level objects, and the cut
+    # REPLACES the finest of them rather than sitting on top of it. A cut is not
+    # a refinement — it re-represents the same grid with the surface conformed —
+    # so the base finest and the child have the same resolution, and keeping
+    # both would record a multigrid level that coarsens nothing. That is the
+    # same test `adapt` applies to an engine pass, applied by the same routine.
+    assert len(child._custom_mg_coarse_meshes) == len(tail_before) - 1, (
+        "the cut was kept as a level of its own; it does not coarsen the mesh "
+        "it was cut from, so it should have replaced it")
+    finest = child._custom_mg_coarse_meshes[-1]
+    assert np.array_equal(_coords(finest.dm), _coords(base.dm_hierarchy[-2]))
+    assert _coords(finest.dm).shape[0] < _coords(child.dm).shape[0], (
+        "the coarse tail's finest level has as many vertices as the child, so "
+        "it is not an uncut base level")
+
+
+def test_surface_becomes_a_named_boundary():
+    """The delivered feature: the surface can carry a boundary condition."""
+    base = _box()
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+    assert cut.parent is base
+    assert "Fault" in [b.name for b in cut.boundaries]
+    value = cut.boundaries["Fault"].value
+    assert cut.dm.getLabel("Fault").getStratumSize(value) > 0
+    # UW_Boundaries is what the solver reads when resolving a boundary by name.
+    assert cut.dm.getLabel("UW_Boundaries").getStratumSize(value) > 0
+
+
+def test_a_dirichlet_condition_applies_on_the_surface():
+    """A label is only useful if a solver actually constrains those DOFs."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3, refinement=1)
+    mesh = base.add_conforming_surface(_surf("Fault", base, VERTICAL))
+
+    u = uw.discretisation.MeshVariable("u_bc", mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(mesh, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 0.0
+    for b in ("Left", "Right", "Top", "Bottom"):
+        poisson.add_dirichlet_bc(0.0, b)
+    poisson.add_dirichlet_bc(1.0, "Fault")
+    poisson.solve()
+
+    X, vals = np.asarray(u.coords), np.asarray(u.data[:, 0])
+    on = np.abs(X[:, 0] - 0.5) < 1e-11
+    assert on.sum() > 0
+    assert np.allclose(vals[on], 1.0, atol=1e-10), "the surface BC was not applied"
+    # And the solution is not simply the BC everywhere: the interior responds.
+    interior = (~on) & (X[:, 0] > 0.1) & (X[:, 0] < 0.4)
+    assert 0.0 < vals[interior].max() < 1.0
+
+
+def test_second_surface_can_be_added_by_chaining():
+    base = _box()
+    one = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+    two = one.add_conforming_surface(
+        _surf("Moho", one, np.array([[-0.2, 0.12], [1.2, 0.12]])))
+    names = [b.name for b in two.boundaries]
+    assert "Fault" in names and "Moho" in names
+    assert two.dm.getLabel("Fault").getStratumSize(
+        two.boundaries["Fault"].value) > 0, "the first surface was lost"
+
+
+def test_a_duplicate_surface_name_is_refused():
+    base = _box()
+    one = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+    with pytest.raises(ValueError, match="already has a boundary"):
+        one.add_conforming_surface(_surf("Fault", one, VERTICAL))
+
+
+def test_serial_reference_for_parallel_confluence():
+    """The numbers ``tests/parallel/ptest_0844_line_cut_parallel.py`` asserts.
+
+    Kept here so a deliberate change to the contract shows up as a failure in the
+    serial suite, rather than as a mysterious parallel-only failure.
+    """
+    import hashlib
+
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+    dm = cut.dm
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    X = _coords(dm)[: vE - vS]
+    Xs = X[np.lexsort((X[:, 1], X[:, 0]))]
+
+    assert (vE - vS, cE - cS) == (SERIAL_VERTICES, SERIAL_CELLS)
+    assert hashlib.sha256(np.round(Xs, 9).tobytes()).hexdigest()[:16] == SERIAL_COORD_SHA
+
+    # The BC-solve reference the parallel file asserts against, at the same tight
+    # tolerance, so the two files cannot drift apart silently.
+    bc_base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 12,
+        regular=False, qdegree=3, refinement=1)
+    bc_mesh = bc_base.add_conforming_surface(_surf("Fault", bc_base, VERTICAL))
+    w = uw.discretisation.MeshVariable("u_ref", bc_mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(bc_mesh, u_Field=w)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 1.0
+    for b in ("Left", "Right", "Top", "Bottom"):
+        poisson.add_dirichlet_bc(0.0, b)
+    poisson.add_dirichlet_bc(1.0, "Fault")
+    poisson.petsc_options["ksp_rtol"] = 1.0e-14
+    poisson.petsc_options["snes_rtol"] = 1.0e-14
+    poisson.solve()
+    assert abs(uw.maths.Integral(bc_mesh, w.sym[0]).evaluate()
+               - SERIAL_BC_INTEGRAL) < 1e-12
+
+    # The fault-zone reference the parallel file compares against.
+    import hashlib
+    zone = cut.cells_supporting("Fault")
+    assert cut.dm.getLabel("Fault").getStratumSize(
+        cut.boundaries["Fault"].value) == SERIAL_SURFACE_FACETS
+    assert int(zone.sum()) == 2 * SERIAL_SURFACE_FACETS
+    vS_, vE_ = dm.getDepthStratum(0)
+    cS_, _cE_ = dm.getHeightStratum(0)
+    cen = np.array([
+        _coords(dm)[[int(p) - vS_ for p in dm.getTransitiveClosure(cS_ + int(c))[0]
+                     if vS_ <= p < vE_]].mean(axis=0)
+        for c in np.flatnonzero(zone)])
+    cen = cen[np.lexsort((cen[:, 1], cen[:, 0]))]
+    assert hashlib.sha256(
+        np.round(cen, 9).tobytes()).hexdigest()[:16] == SERIAL_ZONE_SHA
+
+
+@pytest.mark.parametrize("branches", [
+    # Y: three arms from one junction. Two of them START there, which is the case
+    # that failed.
+    ([[-0.2, 0.20], [0.5, 0.5]], [[0.5, 0.5], [1.2, 0.30]],
+     [[0.5, 0.5], [0.55, 1.2]]),
+    # T: one fault abutting another.
+    ([[-0.2, 0.34], [1.2, 0.66]], [[0.5, 0.5], [0.62, 1.2]]),
+    # X: two faults crossing.
+    ([[-0.2, 0.22], [1.2, 0.78]], [[0.30, -0.2], [0.70, 1.2]]),
+])
+def test_a_fault_network_cuts_at_a_shared_junction(branches):
+    """Branching, abutting and crossing faults, joined at a shared vertex.
+
+    A junction is the same problem as a tip: a distinguished point of the network
+    that has to coincide with a mesh vertex, after which every branch arrives at
+    the already-legal "one crossed edge, one on-surface corner" case.
+
+    The Y case regressed on a real defect. `_resolve_snapping` initialised its
+    on-surface set to all-False and only added vertices it decided to SNAP, so a
+    vertex ALREADY on the surface — a junction — was invisible: the edges
+    radiating from it have signed distance exactly zero and register no strict
+    sign change, so nothing proposes them. The validation then read such a cell as
+    "entered but not left" and refused a legal branch.
+    """
+    junction = np.array([0.5, 0.5])
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 20,
+        regular=False, qdegree=3)
+    dm = pull_vertex_onto(base.dm, junction)
+
+    for k, br in enumerate(branches):
+        dm, _info = cut_along_lines(dm, [np.asarray(br, dtype=float)],
+                                    label=f"F{k}", label_value=20 + k)
+
+    X = _coords(dm)
+    vS = dm.getDepthStratum(0)[0]
+    edges = {frozenset(int(v) - vS for v in dm.getCone(e)): e
+             for e in range(*dm.getDepthStratum(1))}
+
+    zone = set()
+    cS, cE = dm.getHeightStratum(0)
+    for k, br in enumerate(branches):
+        a, b = np.asarray(br[0], float), np.asarray(br[-1], float)
+        d = b - a
+        n = np.array([-d[1], d[0]]) / np.hypot(*d)
+        s = (X - a) @ n
+        u = ((X - a) @ d) / (d @ d)
+        on = np.flatnonzero((np.abs(s) < 1e-10) & (u > -1e-9) & (u < 1.0 + 1e-9))
+        order = on[np.argsort(u[on])]
+        labelled = set(dm.getLabel(f"F{k}").getStratumIS(20 + k).getIndices())
+        for p, q in zip(order[:-1], order[1:]):
+            e = edges.get(frozenset((int(p), int(q))))
+            assert e is not None, f"branch {k}: a segment is not a mesh edge"
+            assert e in labelled, f"branch {k}: a segment is not labelled"
+        for e in labelled:
+            zone.update(int(c) for c in dm.getSupport(e) if cS <= c < cE)
+
+    # The fault zone of a network is the UNION of its branch zones — no geometry
+    # to reconcile at the junction, which is why this route suits networks.
+    assert 0 < len(zone) < cE - cS
+    assert (cell_areas(dm) > 0.0).all()
+
+
+# ---------------------------------------------------------------------------
+# The stress leak — the claim every docstring and commit message on this branch
+# rests on, and the reason the feature exists at all.
+# ---------------------------------------------------------------------------
+
+ETA_WEAK, ETA_STRONG = 1.0, 1.0e4
+
+
+def _barycentric_lattice(n=12, inset=1e-5):
+    """Equally spaced barycentric points STRICTLY INSIDE a triangle.
+
+    The inset is load-bearing, not hygiene. On a cut mesh the interface IS a cell
+    edge, so a lattice including that edge samples points where the material is
+    genuinely ambiguous: the signed distance is ~1e-16 and its sign is arbitrary.
+    A seventh of the samples then take the wrong side and the metric reports a
+    leak of 30 for a mesh whose true leak is zero. Pulling the lattice a hair
+    inside asks the question that was meant — what does this cell CONTAIN.
+    """
+    ls = np.array([(i / n, j / n, (n - i - j) / n)
+                   for i in range(n + 1) for j in range(n + 1 - i)])
+    return (ls + inset) / (1.0 + 3.0 * inset)
+
+
+def _cell_vertex_indices(dm):
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    return np.array([[int(p) - vS for p in dm.getTransitiveClosure(c)[0]
+                      if vS <= p < vE] for c in range(cS, cE)])
+
+
+def _solve_pure_shear(mesh, eta_fn, tag):
+    """Pure-shear Stokes with the given viscosity; return the P1 nodal strain rate."""
+    v = uw.discretisation.MeshVariable(f"Vk{tag}", mesh, mesh.dim, degree=2)
+    p = uw.discretisation.MeshVariable(f"Pk{tag}", mesh, 1, degree=1)
+    stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = eta_fn
+    stokes.add_dirichlet_bc((0.5, None), "Left")
+    stokes.add_dirichlet_bc((-0.5, None), "Right")
+    stokes.add_dirichlet_bc((None, -0.5), "Bottom")
+    stokes.add_dirichlet_bc((None, 0.5), "Top")
+    stokes.solve()
+
+    edot = uw.discretisation.MeshVariable(f"Ek{tag}", mesh, 1, degree=1)
+    proj = uw.systems.Projection(mesh, edot)
+    proj.uw_function = stokes.Unknowns.Einv2
+    proj.solve()
+    return np.asarray(edot.array[:, 0, 0]).ravel()
+
+
+def _leak(mesh, eta_nodal, eta_cellwise, edot_nodal, line):
+    """Stress a cell manufactures by misrepresenting the viscosity.
+
+    The cell average of :math:`2\\eta\\dot\\varepsilon` computed from the DISCRETE
+    viscosity, minus the same average using the TRUE step viscosity, with the
+    strain rate held fixed:
+
+        leak = 2 | <eta_h edot_h> - <eta_true edot_h> |
+
+    Comparing the discrete field against ITSELF — the covariance of eta and edot
+    over the cell's own vertices — cannot do this job: for a cell-wise viscosity
+    that covariance is zero by construction on ANY mesh, cut or not, so it would
+    report success without the mesh having to be right about anything. The true
+    field is the only honest reference.
+    """
+    lattice = _barycentric_lattice()
+    idx = _cell_vertex_indices(mesh.dm)
+    X = _coords(mesh.dm)
+    P = X[idx]                                            # (cells, 3, 2)
+
+    area = 0.5 * np.abs((P[:, 1, 0] - P[:, 0, 0]) * (P[:, 2, 1] - P[:, 0, 1])
+                        - (P[:, 2, 0] - P[:, 0, 0]) * (P[:, 1, 1] - P[:, 0, 1]))
+    xs = np.einsum("sk,ckd->csd", lattice, P)
+    edot_s = np.einsum("sk,ck->cs", lattice, edot_nodal[idx])
+    eta_true = np.where(
+        _signed_distance(xs.reshape(-1, 2), line).reshape(xs.shape[:2]) < 0.0,
+        ETA_WEAK, ETA_STRONG)
+
+    def integral(eta_s):
+        err = 2.0 * np.abs((eta_s * edot_s).mean(axis=1)
+                           - (eta_true * edot_s).mean(axis=1))
+        return float((err * area).sum())
+
+    s_nodes = _signed_distance(X, line).ravel()[idx]
+    straddle = int(((s_nodes > 1e-11).any(axis=1)
+                    & (s_nodes < -1e-11).any(axis=1)).sum())
+    return {
+        "straddle": straddle,
+        "nodal": integral(np.einsum("sk,ck->cs", lattice, eta_nodal[idx])),
+        "cellwise": integral(np.repeat(eta_cellwise[:, None], len(lattice), axis=1)),
+    }
+
+
+@pytest.mark.level_2
+def test_a_cut_mesh_carries_a_step_viscosity_without_leaking_stress():
+    """The headline claim, measured rather than argued.
+
+    A cell straddling a viscosity jump evaluates stress from the interpolated
+    viscosity times the interpolated strain rate, which differs from the honest
+    cell average by ``-2 Cov(eta, edot)``. Refinement shrinks the straddling band
+    but never empties it, so this is not a resolution problem — it is a
+    representation problem, and cutting is the cure.
+
+    Three things are asserted, and the middle one is the feature:
+
+    * a cell-wise viscosity on the CUT mesh leaks essentially nothing, because
+      every cell lies wholly on one side and can be given the true value;
+    * the same viscosity on the UNCUT mesh leaks a great deal;
+    * a continuous P1 viscosity leaks even on the cut mesh — the cut alone is NOT
+      enough. The nodes ON the interface are shared by both sides and a
+      continuous field has to take one value there. This is why the feature is
+      "cut AND assign per cell", not "cut".
+
+    Measured on a 1/16 box, viscosity 1 -> 1e4 across a slanted line:
+
+    =======  =========  ================  ===================
+    mesh     straddle   leak, P1 nodal    leak, cell-wise
+    =======  =========  ================  ===================
+    uncut    37         239.7             285.4
+    cut      0          298.7             0.0 exactly
+    =======  =========  ================  ===================
+
+    Stubbing ``add_conforming_surface`` to return the mesh unchanged fails the
+    first two assertions below, which is the check this suite has most needed.
+    """
+    base = _box(1 / 16)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+    out = {}
+    for name, mesh in (("uncut", base), ("cut", cut)):
+        X = np.asarray(mesh.X.coords)
+        s = _signed_distance(X, SLANTED).ravel()
+        eta_nodal = np.where(s < 0.0, ETA_WEAK, ETA_STRONG)
+        # An interface node belongs to both sides; a continuous field must pick
+        # one. Which one does not matter — that it must be picked is the point.
+        eta_nodal[np.abs(s) < 1e-11] = ETA_STRONG
+
+        idx = _cell_vertex_indices(mesh.dm)
+        centroids = _coords(mesh.dm)[idx].mean(axis=1)
+        eta_cellwise = np.where(
+            _signed_distance(centroids, SLANTED).ravel() < 0.0,
+            ETA_WEAK, ETA_STRONG)
+
+        eta_var = uw.discretisation.MeshVariable(f"etak_{name}", mesh, 1, degree=1)
+        eta_var.array[:, 0, 0] = eta_nodal
+        edot = _solve_pure_shear(mesh, eta_var.sym[0], name)
+        out[name] = _leak(mesh, eta_nodal, eta_cellwise, edot, SLANTED)
+
+    # The geometric precondition. Without this the rest is not interpretable.
+    assert out["cut"]["straddle"] == 0, "the cut left straddling cells"
+    assert out["uncut"]["straddle"] > 0, (
+        "the uncut mesh does not straddle the line, so there is nothing to fix "
+        "and this test is measuring nothing")
+
+    # THE CLAIM: cut + cell-wise viscosity carries the true material exactly.
+    assert out["cut"]["cellwise"] < 1e-9, (
+        f"cell-wise viscosity on the cut mesh leaked "
+        f"{out['cut']['cellwise']:.3e}; on a conforming mesh every cell lies "
+        f"wholly on one side, so this must be zero to round-off.")
+
+    # ... and it is the CUT doing the work, not the cell-wise assignment alone.
+    assert out["uncut"]["cellwise"] > 1.0, (
+        f"cell-wise viscosity on the UNCUT mesh leaked only "
+        f"{out['uncut']['cellwise']:.3e}. If a P0 viscosity were enough on any "
+        f"mesh, cutting would buy nothing and this feature would be pointless.")
+
+    # ... and cutting ALONE is not enough, which is why the docs insist on both.
+    assert out["cut"]["nodal"] > 1.0, (
+        f"a continuous P1 viscosity on the cut mesh leaked only "
+        f"{out['cut']['nodal']:.3e}, which contradicts the documented reason "
+        f"cell-wise assignment is required.")
+
+
+# ---------------------------------------------------------------------------
+# The fault zone: the cells in the SUPPORT of the labelled facets.
+# ---------------------------------------------------------------------------
+
+def _zone_geometry(mesh, name, trace):
+    """Zone mask, per-cell distance to the trace, and the LOCAL cell size."""
+    from underworld3.utilities.edge_split import cell_diameters
+
+    zone = mesh.cells_supporting(name)
+    dm = mesh.dm
+    idx = _cell_vertex_indices(dm)
+    centroids = _coords(dm)[idx].mean(axis=1)
+    distance = np.abs(_signed_distance(centroids, trace).ravel())
+    return zone, distance, float(cell_diameters(dm)[zone].mean())
+
+
+def test_the_fault_zone_is_the_support_of_its_facets():
+    """One element each side, and nothing else.
+
+    ``zone == 2 x facets`` exactly, because a cell carrying two labelled edges
+    would have been cut in two — so no cell is counted twice and every facet
+    contributes both its neighbours. That identity is what makes the definition
+    usable: the zone terminates automatically where the chain of facets ends, it
+    needs no end cap, and it says nothing about dimension.
+    """
+    base = _box(1 / 16)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+    zone, distance, _h = _zone_geometry(cut, "Fault", SLANTED)
+
+    facets = cut.dm.getLabel("Fault").getStratumSize(cut.boundaries["Fault"].value)
+    assert facets > 0
+    assert int(zone.sum()) == 2 * facets, (
+        f"{int(zone.sum())} zone cells for {facets} facets; the zone is the "
+        f"support of the facets, so it must be exactly twice as many")
+
+    # A zone cell is one that owns a labelled edge, and nothing in the zone
+    # straddles — a cell-wise viscosity on this set is therefore exactly right.
+    cS, cE = cut.dm.getHeightStratum(0)
+    labelled = set(cut.dm.getLabel("Fault").getStratumIS(
+        cut.boundaries["Fault"].value).getIndices())
+    for c in np.flatnonzero(zone):
+        assert set(cut.dm.getCone(cS + int(c))) & labelled, (
+            "a zone cell owns no labelled edge")
+
+    s = _signed_distance(_coords(cut.dm), SLANTED).ravel()[_cell_vertex_indices(cut.dm)]
+    assert int(((s > 1e-11).any(axis=1) & (s < -1e-11).any(axis=1)).sum()) == 0
+
+    assert 0 < zone.sum() < (cE - cS), "the zone is the whole mesh"
+    # Every zone cell is adjacent to the surface, so none sits far from it.
+    assert distance[zone].max() < 2.0 * _h
+
+
+def test_cells_supporting_is_in_p0_dof_order():
+    """The documented assignment pattern has to be valid.
+
+    ``cells_supporting`` returns plex cell order and the docstring assigns it
+    straight into a ``degree=0`` MeshVariable. If those orders differed the
+    viscosity would land on the wrong cells and every downstream result would be
+    quietly wrong while looking plausible, so it is checked rather than assumed.
+    """
+    base = _box(1 / 16)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+
+    eta = uw.discretisation.MeshVariable("eta_zone", cut, 1, degree=0)
+    idx = _cell_vertex_indices(cut.dm)
+    centroids = _coords(cut.dm)[idx].mean(axis=1)
+    assert np.abs(np.asarray(eta.coords) - centroids).max() < 1e-12, (
+        "degree-0 DOF order is not plex cell order; cells_supporting cannot be "
+        "assigned straight across")
+
+    zone = cut.cells_supporting("Fault")
+    eta.array[:, 0, 0] = np.where(zone, 1.0e-3, 1.0)
+    assert np.isclose(eta.array[:, 0, 0].min(), 1.0e-3)
+    assert int((eta.array[:, 0, 0] < 1.0).sum()) == int(zone.sum())
+
+
+# Mean distance from a zone cell's centroid to the trace, over the LOCAL cell
+# size in the zone. The MAX will not do: it is one outlier cell and it was
+# identical (0.01474) at two different adapt resolutions, reporting no scaling
+# at all where the mean shows it cleanly.
+ZONE_THICKNESS_OVER_H = 0.19
+
+
+@pytest.mark.parametrize("cell_size", [1 / 8, 1 / 16, 1 / 32])
+def test_the_fault_zone_is_one_element_wide_at_every_resolution(cell_size):
+    """Zone thickness tracks `h`, which is what makes width a refinement knob.
+
+    Measured 0.189 / 0.183 / 0.184 across a 4x refinement — constant, and the
+    price of the facet-support definition: thickness is no longer a physical
+    parameter. Under adapt-on-top that is the point rather than a defect, since
+    the local `h` is whatever the metric asks for (see the test below).
+    """
+    base = _box(cell_size)
+    cut = base.add_conforming_surface(_surf("Fault", base, SLANTED))
+    zone, distance, h = _zone_geometry(cut, "Fault", SLANTED)
+
+    facets = cut.dm.getLabel("Fault").getStratumSize(cut.boundaries["Fault"].value)
+    assert int(zone.sum()) == 2 * facets
+
+    ratio = distance[zone].mean() / h
+    assert ratio == pytest.approx(ZONE_THICKNESS_OVER_H, abs=0.03), (
+        f"cellSize={cell_size}: zone half-thickness is {ratio:.3f} h, not the "
+        f"~{ZONE_THICKNESS_OVER_H} h it is at every other resolution")
+
+
+@pytest.mark.level_2
+def test_the_fault_zone_narrows_with_the_adapt_metric():
+    """Fault width is a REFINEMENT parameter: the design this is all for.
+
+    The surface lives at the finest adapted level, so the zone is one element
+    wide *there* and the metric sets how wide that is — controlled locally and at
+    bounded cost. Measured: the same fault at h_near 0.03 / 0.02 / 0.015 gives
+    zone thicknesses in the same ratio, at 0.195 / 0.202 / 0.198 of the local `h`
+    throughout, and reaches the resolution of a uniform 1/32 mesh with about half
+    the cells.
+
+    Also checks the composition itself works — ``adapt`` then
+    ``add_conforming_surface`` — and that the child keeps its multigrid tail.
+    """
+    thickness = {}
+    for h_near in (0.03, 0.015):
+        base = uw.meshing.UnstructuredSimplexBox(
+            minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.1,
+            regular=False, refinement=1, qdegree=2)
+        fault = _surf("Fault", base, SLANTED)
+        fault.discretize()
+        child = base.adapt(
+            fault.refinement_metric_function(h_near=h_near, h_far=0.09,
+                                             width=0.06),
+            max_levels=3)
+        cut = child.add_conforming_surface(_surf("Fault", child, SLANTED))
+
+        zone, distance, h = _zone_geometry(cut, "Fault", SLANTED)
+        facets = cut.dm.getLabel("Fault").getStratumSize(
+            cut.boundaries["Fault"].value)
+        assert int(zone.sum()) == 2 * facets
+
+        # The cut child must keep the adapted hierarchy under it, or the solver
+        # loses multigrid exactly where the fault is.
+        assert len(cut._custom_mg_coarse_meshes) >= len(base.dm_hierarchy)
+
+        ratio = distance[zone].mean() / h
+        assert ratio == pytest.approx(ZONE_THICKNESS_OVER_H, abs=0.03), (
+            f"h_near={h_near}: zone is {ratio:.3f} h wide, not ~"
+            f"{ZONE_THICKNESS_OVER_H} h — one element each side is the claim")
+        thickness[h_near] = distance[zone].mean()
+
+    assert thickness[0.015] < 0.75 * thickness[0.03], (
+        f"halving the requested h_near barely narrowed the zone "
+        f"({thickness[0.03]:.5f} -> {thickness[0.015]:.5f}); fault width is "
+        f"supposed to follow the metric")
+
+
+# ---------------------------------------------------------------------------
+# The two snapping guards. Both exist because of what SPLITTING costs: a split
+# beside a vertex is what makes a sliver, so anything that replaces a split with
+# a vertex move helps, and anything that turns a move back into a split hurts.
+# ---------------------------------------------------------------------------
+
+def test_the_quality_guard_turns_a_refusal_into_a_cut():
+    """A tolerance large enough to flatten a cell must be survivable.
+
+    Snapping pulls every corner of a cell thinner than the tolerance band onto
+    the line, and the cell collapses: measured, all of them at snap_frac 0.4 had
+    all three corners snapped, from opposite sides. Without a guard the whole cut
+    is refused. With one, the offending moves are vetoed and those crossings are
+    split instead, which is the path that already works.
+
+    Note the guard must be on QUALITY, not on inversion. A flattened cell lands
+    at ~1e-16 of either sign, so an inversion test passes about half of them —
+    and then returns a mesh whose chain has silently broken.
+    """
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 8,
+        regular=False, qdegree=2)
+    line = np.array([[-0.1, 0.503], [1.1, 0.541]])
+
+    with pytest.raises(RuntimeError, match="inverted"):
+        cut_along_lines(mesh.dm, [line], snap_frac=0.48, snap_quality=None)
+
+    cut, info = cut_along_lines(mesh.dm, [line], snap_frac=0.48)
+    assert info["n_cut_edges"] == info["n_split"] + info["n_on_surface"] - 1
+    assert (cell_areas(cut) > 0.0).all()
+    assert info["min_angle"] > 1.0, (
+        f"guarded cut still has a {info['min_angle']:.3f} degree cell")
+
+
+def test_snap_dist_reaches_vertices_snap_frac_cannot():
+    """A vertex near the line whose edges are all crossed mid-way.
+
+    ``snap_frac`` is measured ALONG an edge, so it cannot see a vertex that sits
+    a fraction of an element from the line while every edge meeting it is crossed
+    near its midpoint. That vertex becomes the apex of a cell with one edge on
+    the cut, which is the cut's characteristic sliver — and no value of
+    ``snap_frac`` removes it. ``snap_dist`` proposes such a vertex directly.
+
+    The test is that at a FIXED along-edge tolerance it still finds vertices to
+    move, and trades splits for them.
+    """
+    mesh = _box(1 / 24)
+    base = cut_along_lines(mesh.dm, [SLANTED], snap_frac=0.30)[1]
+    reached = cut_along_lines(mesh.dm, [SLANTED], snap_frac=0.30,
+                              snap_dist=0.30)[1]
+    assert reached["n_on_surface"] > base["n_on_surface"], (
+        "snap_dist proposed no vertex the along-edge test had not already found")
+    assert reached["n_split"] < base["n_split"], (
+        f"splits did not fall: {base['n_split']} -> {reached['n_split']}")
+    assert (reached["n_cut_edges"]
+            == reached["n_split"] + reached["n_on_surface"] - 1)
+
+
+def test_repair_fixes_the_cells_the_cut_leaves_thin():
+    """``repair=True`` runs the two operations a cut does not have.
+
+    A cut can only snap a vertex onto the surface or split an edge it crosses,
+    so a crossing landing near a vertex either drags the vertex to it or carves
+    a thin cell beside it. Flipping fixes the ones whose point set is fine and
+    whose connectivity is not; deleting fixes the ones whose point set is the
+    problem.
+
+    The surface itself must come through untouched — that is the whole point of
+    both passes refusing to act on a labelled edge — so the facet count is
+    asserted, not just the quality.
+    """
+    # A GRADED mesh. On a uniform one the flip pass alone already clears the
+    # thin cells and deletion is offered nothing worth taking (measured: 26 -> 25
+    # cells under 15 degrees, 0 removals), so a uniform fixture would assert the
+    # feature while exercising half of it.
+    line = np.array([[-0.1, 0.37], [1.1, 0.63]])
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 6,
+        regular=False, qdegree=2, refinement=2)
+    surf = _surf("Grade", base, line)
+    surf.discretize()
+    mesh = base.adapt(surf.refinement_metric_function(
+        h_near=1 / 48, h_far=1 / 6, width=1 / 12), max_levels=3)
+
+    plain = mesh.add_conforming_surface(_surf("Rp", mesh, line), snap_frac=0.30)
+    fixed = mesh.add_conforming_surface(_surf("Rr", mesh, line), snap_frac=0.30,
+                                        repair=True)
+
+    a0, a1 = min_angles(plain.dm), min_angles(fixed.dm)
+    assert int((a1 < 15).sum()) < int((a0 < 15).sum()), (
+        "repair did not reduce the count of thin cells")
+    assert a1.min() >= a0.min() - 1e-12, "repair lowered the worst angle"
+
+    info = fixed._surface_info
+    assert info["n_repair_flips"] > 0 and info["n_repair_removals"] > 0, (
+        "one of the two passes did nothing, so this is not testing both")
+    assert info["min_angle"] == pytest.approx(float(a1.min())), (
+        "_surface_info still reports the angle from before the repair")
+
+    # The surface is a chain of the same facets, and deleting cells conserves area.
+    n_plain = plain.dm.getLabel("Rp").getStratumSize(
+        int(plain.boundaries["Rp"].value))
+    n_fixed = fixed.dm.getLabel("Rr").getStratumSize(
+        int(fixed.boundaries["Rr"].value))
+    assert n_fixed == n_plain, "repair changed the surface itself"
+    assert cell_areas(fixed.dm).sum() == pytest.approx(
+        cell_areas(plain.dm).sum(), rel=1e-13)
+    assert (cell_areas(fixed.dm) > 0).all()
diff --git a/tests/test_0844_reconnect_repair.py b/tests/test_0844_reconnect_repair.py
new file mode 100644
index 000000000..3fd740eef
--- /dev/null
+++ b/tests/test_0844_reconnect_repair.py
@@ -0,0 +1,454 @@
+"""Reconnection (Lawson flip) repair of a refined 2-D mesh.
+
+The load-bearing checks here are the ones that would pass for the wrong reason if
+they were written loosely:
+
+* the maximum angle must **improve**, and this is the check that earned its place.
+  The pass originally accepted a flip on the Delaunay criterion, and this
+  assertion is what caught that Delaunay maximises the *minimum* angle while P1
+  interpolation depends on the *maximum* — flipping a gmsh mesh towards Delaunay
+  raised the 99th-percentile maximum angle. Assert the quantity the method claims
+  to improve, not a proxy for it;
+* **volume conservation**, not orientation. Checking that the new cells are
+  positively oriented is worthless when they were built anticlockwise by
+  construction: the check can never fail. Equal total area is the real test;
+* the **point chart is unchanged**, which is the invariant that lets the parallel
+  path reuse the star-forest verbatim rather than reconstructing it.
+
+Note what the idempotence check below does *not* prove. A second pass flipping
+nothing shows the acceptance test is self-consistent, but an **inverted** criterion
+is equally idempotent — it would flip every good edge once and then find nothing
+more to do. That is exactly how the Delaunay criterion passed here while degrading
+the mesh. Idempotence catches oscillation, not a wrong objective.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities import edge_split, reconnect
+
+pytestmark = [pytest.mark.level_2, pytest.mark.tier_b]
+
+
+def _max_angles(dm):
+    """Largest interior angle of every cell, in degrees.
+
+    The maximum angle is the quantity a P1 interpolation bound depends on
+    (Babuska-Aziz); the minimum angle is not, so it is the wrong thing to assert.
+    """
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    out = []
+    for c in range(cS, cE):
+        v = [int(p) for p in dm.getTransitiveClosure(c)[0] if vS <= p < vE]
+        P = X[np.array(v) - vS]
+        angles = []
+        for i in range(3):
+            u1 = P[(i + 1) % 3] - P[i]
+            u2 = P[(i + 2) % 3] - P[i]
+            cos = np.dot(u1, u2) / (np.linalg.norm(u1) * np.linalg.norm(u2))
+            angles.append(np.degrees(np.arccos(np.clip(cos, -1.0, 1.0))))
+        out.append(max(angles))
+    return np.array(out)
+
+
+def _signed_areas(dm):
+    vS, vE = dm.getDepthStratum(0)
+    cS, cE = dm.getHeightStratum(0)
+    X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+    out = []
+    for c in range(cS, cE):
+        v = [int(p) for p in dm.getTransitiveClosure(c)[0] if vS <= p < vE]
+        a, b, d = X[np.array(v) - vS]
+        out.append(0.5 * ((b[0] - a[0]) * (d[1] - a[1])
+                          - (d[0] - a[0]) * (b[1] - a[1])))
+    return np.array(out)
+
+
+def _over_shared_facets(dm):
+    fS, fE = dm.getHeightStratum(1)
+    return sum(1 for f in range(fS, fE) if len(dm.getSupport(f)) > 2)
+
+
+def _refined_dm(cell_size=0.3, h_near=0.05, centre=(0.35, 0.6), radius=0.2):
+    """A box mesh refined by ``edge_split`` — the mesh repair is meant to fix."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=cell_size,
+        regular=False, qdegree=2)
+    dm = base.dm
+    for _ in range(20):
+        cS, cE = dm.getHeightStratum(0)
+        cen = np.array([dm.computeCellGeometryFVM(c)[1] for c in range(cS, cE)])
+        d = np.linalg.norm(cen - np.array(centre), axis=1)
+        target = np.where(d < radius, h_near, 0.4)
+        sel = np.flatnonzero(edge_split.cell_diameters(dm) > target) + cS
+        dm, n = edge_split.bisect_longest_edges(dm, sel)
+        if n == 0:
+            break
+    return dm
+
+
+def test_repair_conserves_area_and_conformity():
+    dm = _refined_dm()
+    ncells = dm.getHeightStratum(0)[1] - dm.getHeightStratum(0)[0]
+    chart = dm.getChart()
+    area = _signed_areas(dm).sum()
+
+    out, nflips = reconnect.flip_to_reduce_max_angle(dm)
+
+    assert nflips > 0, "nothing to repair — the fixture is not exercising the pass"
+    # A flip replaces two cells by two cells and adds no points, so both the cell
+    # count and the whole chart are invariant. The chart being invariant is what
+    # makes the parallel star-forest reusable.
+    assert out.getChart() == chart
+    assert out.getHeightStratum(0)[1] - out.getHeightStratum(0)[0] == ncells
+    assert _over_shared_facets(out) == 0
+    new_areas = _signed_areas(out)
+    assert (new_areas > 0).all(), "repair inverted a cell"
+    assert new_areas.sum() == pytest.approx(area, rel=1e-13)
+
+
+def test_repair_improves_the_maximum_angle():
+    dm = _refined_dm()
+    before = _max_angles(dm)
+    out, _ = reconnect.flip_to_reduce_max_angle(dm)
+    after = _max_angles(out)
+
+    assert np.percentile(after, 99) < np.percentile(before, 99)
+    assert after.max() <= before.max()
+
+
+def test_second_pass_flips_nothing():
+    """Idempotence: the control that catches an inconsistently signed predicate.
+
+    A kernel that keeps finding improvements in an already-repaired mesh is
+    reporting a predicate bug, and that bug would be invisible in every other
+    check here.
+    """
+    dm = _refined_dm()
+    once, n1 = reconnect.flip_to_reduce_max_angle(dm)
+    assert n1 > 0
+    twice, n2 = reconnect.flip_to_reduce_max_angle(once)
+    assert n2 == 0
+    assert twice is once, "a no-op pass must return the mesh it was given"
+
+
+def test_labels_survive_and_remain_usable():
+    dm = _refined_dm()
+    names = sorted(dm.getLabelName(i) for i in range(dm.getNumLabels()))
+    sizes = {}
+    for name in names:
+        if name in ("depth", "celltype"):
+            continue
+        sizes[name] = dm.getLabel(name).getStratumSize(
+            int(dm.getLabel(name).getValueIS().getIndices()[0]))
+
+    out, _ = reconnect.flip_to_reduce_max_angle(dm)
+
+    assert sorted(out.getLabelName(i) for i in range(out.getNumLabels())) == names
+    for name, size in sizes.items():
+        label = out.getLabel(name)
+        assert label.getStratumSize(
+            int(label.getValueIS().getIndices()[0])) == size
+
+    # Labels surviving as point sets is not the same as being usable: the real
+    # test is that a Dirichlet condition can still be imposed on one.
+    mesh = uw.discretisation.Mesh(out, qdegree=2)
+    u = uw.discretisation.MeshVariable("u_rec", mesh, 1, degree=1)
+    poisson = uw.systems.Poisson(mesh, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 1.0
+    poisson.add_dirichlet_bc(0.0, "All_Boundaries")
+    poisson.solve()
+    assert poisson.snes.getConvergedReason() > 0
+    assert u.array[:, 0, 0].max() > 0.0
+
+
+def test_bulk_cell_labels_do_not_lock_interior_edges():
+    """A bulk region label must not be mistaken for an interface.
+
+    Regression. ``Elements`` labels every cell of a gmsh mesh, and the
+    ``uwnvb_bisect`` transform propagates a parent's labels to its children — so
+    after refinement the new *interior edges* carry ``Elements`` too. Locking
+    every labelled point therefore locked 50.6 % of interior edges on a plain box
+    mesh, and repair silently did almost nothing on every real UW3 mesh while the
+    hand-built fixtures in this file still looked fine.
+
+    The discriminator: a label value carried by a **cell** describes a volume, not
+    an interface. Every genuine boundary or interface label marks zero cells.
+    """
+    dm = _refined_dm()
+    eS, eE = dm.getDepthStratum(1)
+    interior = [e for e in range(eS, eE) if len(dm.getSupport(e)) == 2]
+    locked = reconnect._interface_edges(dm)
+    pStart, _pEnd = dm.getChart()
+    n_locked = sum(1 for e in interior if locked[e - pStart])
+
+    assert n_locked == 0, (
+        f"{n_locked}/{len(interior)} interior edges are locked on a mesh with no "
+        f"interfaces; a bulk cell label is being read as one")
+
+
+def test_labelled_interior_edges_are_never_flipped():
+    """A labelled interior edge is an interface and must survive untouched.
+
+    This is what protects a fault or a material boundary from being reconnected
+    across.
+    """
+    dm = _refined_dm()
+    eS, eE = dm.getDepthStratum(1)
+    interior = [e for e in range(eS, eE) if len(dm.getSupport(e)) == 2]
+    # Lock a slice of interior edges, including ones the pass would otherwise flip.
+    dm.createLabel("test_interface")
+    label = dm.getLabel("test_interface")
+    locked = interior[::7]
+    for e in locked:
+        label.setValue(e, 1)
+    cones = {e: tuple(int(v) for v in dm.getCone(e)) for e in locked}
+
+    out, _ = reconnect.flip_to_reduce_max_angle(dm)
+
+    for e, cone in cones.items():
+        assert tuple(int(v) for v in out.getCone(e)) == cone, (
+            f"locked interface edge {e} was flipped")
+
+
+def test_orientation_predicate_never_invents_a_sign():
+    """Degenerate input must report UNRESOLVED, not a confident orientation.
+
+    Regression. The static filter reduces to ``0 >= 0`` whenever both products
+    vanish — which happens for any axis-aligned collinear triple, an ordinary
+    configuration on a structured mesh — and the predicate then returned -1,
+    a confident "clockwise", for points that are collinear. The caller declined
+    the flip either way, so nothing was corrupted; a predicate that reports a
+    sign it cannot justify is still a defect, and this one is module-private
+    precisely so it can be trusted by whatever calls it next.
+    """
+    assert reconnect._orient2d((0.0, 0.0), (0.0, 0.0), (0.0, 0.0)) == \
+        reconnect._UNCERTAIN
+    assert reconnect._orient2d((0.0, 0.0), (1.0, 0.0), (2.0, 0.0)) == \
+        reconnect._UNCERTAIN          # collinear along x: both products vanish
+    assert reconnect._orient2d((0.0, 0.0), (0.0, 1.0), (0.0, 2.0)) == \
+        reconnect._UNCERTAIN          # collinear along y
+    # Unambiguous cases must still be answered.
+    assert reconnect._orient2d((0.0, 0.0), (1.0, 0.0), (0.0, 1.0)) == 1
+    assert reconnect._orient2d((0.0, 0.0), (0.0, 1.0), (1.0, 0.0)) == -1
+
+
+def test_three_dimensions_is_refused():
+    """3-D must fail loudly: Delaunay is the wrong criterion, not merely untested."""
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0, 0.0), maxCoords=(1.0, 1.0, 1.0), cellSize=0.5,
+        regular=False, qdegree=2)
+    with pytest.raises(NotImplementedError, match="2-D only"):
+        reconnect.flip_to_reduce_max_angle(mesh.dm)
+
+
+def test_a_varying_bookkeeping_label_is_not_a_material_region():
+    """The newest-vertex slot label must not partition the mesh into regions.
+
+    Regression, and the sibling of
+    ``test_bulk_cell_labels_do_not_lock_interior_edges`` one level along.
+    ``_labelled_points`` learned to ignore a label carried by CELLS; that fixed
+    ``Elements``, which is uniform. ``uwnvb_refedge`` is not uniform — it records
+    which of a triangle's edges is its refinement edge, so it takes values 0/1/2
+    across any NVB-adapted mesh — and ``_cell_regions`` read those three values as
+    three material regions and locked every edge between them.
+
+    Measured on an adapted fault mesh: signatures of 2230/2184/134 cells, and of
+    the edges around a sliver, 113 declined as a "region interface" against 54
+    genuinely locked on the fault. Repair was therefore disabled over most of ANY
+    adapted mesh, cut or not — flips rose from 101 to 483 once it was excluded,
+    and cells below 15 degrees fell from 60 to 18.
+    """
+    # Through `adapt`, not `bisect_longest_edges`: the slot label belongs to the
+    # newest-vertex transform, and the fixture used elsewhere in this file does
+    # not go near it — which is precisely why the defect survived here.
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.2,
+        regular=False, refinement=1, qdegree=2)
+
+    def metric(points):
+        d = np.linalg.norm(np.asarray(points) - np.array([0.35, 0.6]), axis=1)
+        return 1.0 / np.where(d < 0.2, 0.05, 0.2) ** 2
+
+    dm = base.adapt(metric, max_levels=2).dm
+    names = [dm.getLabelName(i) for i in range(dm.getNumLabels())]
+    assert "uwnvb_refedge" in names, (
+        "fixture no longer carries the slot label, so this test proves nothing")
+
+    # The negative control: read as a region, it DOES split the mesh.
+    cS, cE = dm.getHeightStratum(0)
+    label = dm.getLabel("uwnvb_refedge")
+    values = [int(v) for v in label.getValueIS().getIndices()]
+    carrying = sum(1 for v in values
+                   if label.getStratumSize(v) > 0
+                   and ((np.asarray(label.getStratumIS(v).getIndices()) >= cS)
+                        & (np.asarray(label.getStratumIS(v).getIndices())
+                           < cE)).any())
+    assert carrying > 1, (
+        "the slot label takes one value here, so it could not have partitioned "
+        "anything and this fixture cannot see the defect")
+
+    assert reconnect._cell_regions(dm) is None, (
+        "a bookkeeping label that varies over cells is being read as a material "
+        "region; every edge between two values would be locked against repair")
+
+
+# ------------------------------------------------------- the removal primitive
+
+def test_a_vertex_blanket_label_is_not_an_interface():
+    """Negative control for the third instance of the labelling trap.
+
+    ``Null_Boundary`` marks every vertex of every UW3 mesh with the reserved
+    value 666, and ``UW_Boundaries`` re-packs every per-boundary stratum —
+    sentinel included — into one stacked label. Reading labelled *points* as
+    interfaces therefore locks the entire vertex stratum. That costs the flip
+    pass nothing, which asks only about edges, and it refused 1114 of 1114
+    candidates the first time the removal pass was offered a cut mesh.
+
+    The first assertion is the control: it fails if the fixture stops blanketing
+    the vertices, at which point the rest of this test proves nothing.
+    """
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.3,
+        regular=False, qdegree=2)
+    dm = mesh.dm
+    pStart, _pEnd = dm.getChart()
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+
+    blanket = set()
+    for name in ("Null_Boundary", "UW_Boundaries"):
+        label = dm.getLabel(name)
+        values = label.getValueIS()
+        if values is None:
+            continue
+        for val in values.getIndices():
+            points = label.getStratumIS(int(val))
+            if points is not None:
+                blanket.update(int(p) for p in points.getIndices()
+                               if vS <= p < vE)
+    assert len(blanket) == vE - vS, (
+        "the fixture no longer labels every vertex, so this test cannot show "
+        "that reading vertex labels as interfaces is fatal")
+
+    locked = reconnect._interface_edges(dm)
+    assert not locked[vS - pStart: vE - pStart].any(), (
+        "a vertex is flagged as an interface; every candidate the removal pass "
+        "is offered would be refused")
+    # The edges must still be read, or the fault would not be protected at all.
+    boundary = [e for e in range(eS, eE) if len(dm.getSupport(e)) == 1]
+    assert boundary and all(locked[e - pStart] for e in boundary)
+
+
+def test_removal_conserves_area_and_conformity():
+    dm = _refined_dm()
+    vS, vE = dm.getDepthStratum(0)
+    area = _signed_areas(dm).sum()
+
+    out, n = reconnect.remove_vertices(dm, np.arange(vS, vE))
+
+    assert n > 0, "nothing removed — the fixture is not exercising the pass"
+    # Unlike a flip, a deletion changes the chart: exactly ``n`` vertices go,
+    # and each cavity of ``k`` cells comes back as ``k - 2``.
+    assert out.getDepthStratum(0)[1] - out.getDepthStratum(0)[0] == vE - vS - n
+    assert (out.getHeightStratum(0)[1] - out.getHeightStratum(0)[0]
+            < dm.getHeightStratum(0)[1] - dm.getHeightStratum(0)[0])
+    assert _over_shared_facets(out) == 0
+
+    new_areas = _signed_areas(out)
+    assert (new_areas > 0).all(), "removal inverted a cell"
+    assert new_areas.sum() == pytest.approx(area, rel=1e-13)
+
+    nv = out.getDepthStratum(0)[1] - out.getDepthStratum(0)[0]
+    ne = out.getDepthStratum(1)[1] - out.getDepthStratum(1)[0]
+    nc = out.getHeightStratum(0)[1] - out.getHeightStratum(0)[0]
+    assert nv - ne + nc == 1, "the result is not a disc"
+
+
+def test_removal_cannot_degrade_either_shape_measure():
+    """The gain gate is per cavity; the invariant it buys is global.
+
+    Each pass deletes an independent set, so no two retriangulations interact,
+    and the default gate refuses any cavity whose largest angle would rise or
+    whose smallest would fall. The extremes over the whole mesh therefore cannot
+    move the wrong way.
+
+    Both halves are needed. Gating on the largest angle alone — the criterion
+    the flip pass uses, since the P1 interpolation bound depends on it — let the
+    minimum angle of a cut mesh fall from 10.80 to 10.23 degrees and *raised* the
+    count of cells under 15 degrees from 60 to 61, because a needle has one tiny
+    angle and two close to 90 and so never registers as obtuse.
+    """
+    from underworld3.utilities.line_cut import min_angles
+
+    dm = _refined_dm()
+    before_max, before_min = _max_angles(dm).max(), min_angles(dm).min()
+
+    out, n = reconnect.remove_vertices(dm, np.arange(*dm.getDepthStratum(0)))
+
+    assert n > 0
+    assert _max_angles(out).max() <= before_max + 1e-12
+    assert min_angles(out).min() >= before_min - 1e-12
+
+
+def test_removal_never_dissolves_a_labelled_interface():
+    """A vertex on an interface may not be deleted — its edges would go with it.
+
+    Deleting a vertex removes every edge incident on it, so a victim sitting in
+    the middle of a fault would leave a gap in the chain. The guard reads the
+    *edges*, which is the only reading that works: ``cut_along_lines`` labels the
+    cut's edges and not its vertices.
+
+    The control runs the same removal with the label absent and requires that at
+    least one of those vertices does go, so a guard that never had anything to
+    refuse cannot pass this quietly.
+    """
+    def interface_run(with_label):
+        dm = _refined_dm()
+        vS, vE = dm.getDepthStratum(0)
+        eS, eE = dm.getDepthStratum(1)
+        X = np.asarray(dm.getCoordinatesLocal().array).reshape(-1, 2)
+        interior = [e for e in range(eS, eE) if len(dm.getSupport(e)) == 2]
+        chosen = interior[::7]
+        ends = set()
+        for e in chosen:
+            ends.update(int(v) for v in dm.getCone(e))
+        marked = np.array(sorted(tuple(X[v - vS]) for v in ends))
+
+        if with_label:
+            dm.createLabel("test_interface")
+            label = dm.getLabel("test_interface")
+            for e in chosen:
+                label.setValue(int(e), 7)
+
+        out, n = reconnect.remove_vertices(dm, np.arange(vS, vE))
+        assert n > 0
+        oS, oE = out.getDepthStratum(0)
+        Y = np.asarray(out.getCoordinatesLocal().array).reshape(-1, 2)[: oE - oS]
+        survived = {tuple(row) for row in Y}
+        return sum(1 for row in marked if tuple(row) not in survived)
+
+    assert interface_run(with_label=False) > 0, (
+        "no vertex of the chosen edges was removable anyway, so the guard is "
+        "not being tested")
+    assert interface_run(with_label=True) == 0, (
+        "a vertex of a labelled interface was deleted; its edges went with it")
+
+
+def test_removal_declines_a_mesh_it_cannot_improve():
+    """Offered every vertex of a clean mesh, the pass must do nothing.
+
+    A deletion removes a degree of freedom, so a pass willing to act without a
+    shape gain would quietly coarsen any mesh it were pointed at.
+    """
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.12,
+        regular=False, refinement=1, qdegree=2)
+    out, n = reconnect.remove_vertices(mesh.dm,
+                                       np.arange(*mesh.dm.getDepthStratum(0)))
+    assert n == 0
+    assert out is mesh.dm
diff --git a/tests/test_0845_fault_split.py b/tests/test_0845_fault_split.py
new file mode 100644
index 000000000..7986ae51a
--- /dev/null
+++ b/tests/test_0845_fault_split.py
@@ -0,0 +1,326 @@
+"""Split-node faults (:mod:`underworld3.utilities.fault_split`).
+
+A conforming surface leaves the fault as facets the two flanking cells share;
+the split duplicates the chain's interior vertices and rewires the Minus-side
+cells to the replicas, so continuous FE spaces become discontinuous exactly
+across the fault. What is asserted, and the defect each assertion targets:
+
+- **conformity and support counts** — every facet keeps at most two support
+  cells, and each of the doubled fault facets has exactly one, where it had
+  two before. A mis-wired arc shows up here first.
+- **exact chart arithmetic** — a chain of m facets has k = m-1 interior
+  vertices, and the split adds exactly k vertices and m facets (each re-homed
+  Minus spoke replaces a dropped original one-for-one), taking the Euler
+  characteristic from 1 (disc) to 0 (slit disc = annulus). A missed or extra
+  duplication cannot pass this.
+- **geometry conserved** — cell count and total area unchanged, all areas
+  positive, replica coordinates bit-identical to their originals.
+- **DOF independence, the load-bearing one** — a Dirichlet value pinned on one
+  side of the fault must NOT appear on the coincident nodes of the other
+  side. If any degree of freedom were still shared, both sides would read the
+  pinned value and the fault would be welded shut at that node.
+- **labels** — the two side labels have equal facet counts with pairwise
+  coincident endpoints; the original surface name survives on BOTH copies (it
+  remains the whole-fault handle); the constructed Mesh stacks both sides
+  into ``UW_Boundaries``, which is what the solver resolves names against.
+- **refusals are refusals** — boundary-crossing chains, junctions,
+  single-facet chains, closed loops and double splits are rejected loudly.
+  Every one of these, mishandled silently, yields a mesh that looks plausible
+  and computes the wrong thing.
+- **re-applicability** — the fault position is a design variable and moves
+  during a run, so splitting must be a pure function of the base mesh:
+  cutting and splitting the same base at two positions must give two valid,
+  independent children.
+
+The parallel seam refusal and the star-forest check are in
+``tests/parallel/ptest_0845_fault_split_parallel.py``.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.fault_split import split_along_label, split_fault
+from underworld3.utilities.line_cut import (cell_areas, cut_along_lines,
+                                            pull_vertex_onto)
+from underworld3.utilities.reconnect import _coords
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+# An interior slanted segment: both tips inside the unit box, off any mesh
+# symmetry line. Tips are pulled onto mesh vertices first, which is the
+# supported way to terminate a cut inside the mesh.
+TIP_A = np.array([0.31, 0.42])
+TIP_B = np.array([0.72, 0.61])
+FAULT = "Flt"
+FAULT_VALUE = 30
+
+
+def _box(cell_size=1 / 16, qdegree=2):
+    return uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0),
+        cellSize=cell_size, regular=False, qdegree=qdegree)
+
+
+def _cut_dm(base_dm, tip_a=TIP_A, tip_b=TIP_B, name=FAULT, value=FAULT_VALUE):
+    dm = pull_vertex_onto(base_dm, np.vstack([tip_a, tip_b]))
+    dm, _info = cut_along_lines(dm, [np.vstack([tip_a, tip_b])],
+                                label=name, label_value=value)
+    return dm
+
+
+def _split(dm, name=FAULT, value=FAULT_VALUE):
+    return split_along_label(dm, name, value,
+                             f"{name}Plus", 31, f"{name}Minus", 32)
+
+
+def _strata_counts(dm):
+    cS, cE = dm.getHeightStratum(0)
+    vS, vE = dm.getDepthStratum(0)
+    eS, eE = dm.getDepthStratum(1)
+    return cE - cS, vE - vS, eE - eS
+
+
+def _fault_facets(dm, name, value):
+    eS, eE = dm.getDepthStratum(1)
+    points = dm.getLabel(name).getStratumIS(value)
+    return [int(p) for p in points.getIndices() if eS <= int(p) < eE]
+
+
+def test_split_doubles_the_fault_facets_and_nothing_else():
+    base = _box()
+    dm = _cut_dm(base.dm)
+    m = len(_fault_facets(dm, FAULT, FAULT_VALUE))
+    k = m - 1
+    nc, nv, ne = _strata_counts(dm)
+
+    out, point_map, clone_map = _split(dm)
+    nc2, nv2, ne2 = _strata_counts(out)
+
+    assert (nc2, nv2, ne2) == (nc, nv + k, ne + m)
+    # Euler characteristic: disc (1) -> slit disc, i.e. annulus (0),
+    # independently of the chain length.
+    assert nv - ne + nc == 1
+    assert nv2 - ne2 + nc2 == 0
+
+    # Conformity: no facet gained a third cell, and each of the doubled fault
+    # facets is now one-sided where its source was two-sided.
+    cS, cE = out.getHeightStratum(0)
+    for e in range(*out.getDepthStratum(1)):
+        assert len(out.getSupport(e)) <= 2
+    for side in ("FltPlus", "FltMinus"):
+        facets = _fault_facets(out, side, {"FltPlus": 31, "FltMinus": 32}[side])
+        assert len(facets) == m
+        for e in facets:
+            assert len(out.getSupport(e)) == 1
+
+    # The clone map records exactly the replicas: k vertices plus the re-homed
+    # Minus-side facets (m fault copies among them).
+    vS2, vE2 = out.getDepthStratum(0)
+    replica_vertices = [q for q in clone_map if vS2 <= q < vE2]
+    assert len(replica_vertices) == k
+    # point_map covers the whole source chart; only re-homed facets drop out.
+    eS, eE = dm.getDepthStratum(1)
+    dropped = np.flatnonzero(point_map < 0)
+    assert all(eS <= p < eE for p in dropped)
+
+
+def test_geometry_is_conserved_and_replicas_are_coincident():
+    base = _box()
+    dm = _cut_dm(base.dm)
+    areas = cell_areas(dm)
+
+    out, _point_map, clone_map = _split(dm)
+    areas2 = cell_areas(out)
+
+    assert (areas2 > 0).all()
+    assert np.isclose(areas2.sum(), areas.sum(), rtol=1e-13)
+    # Cells keep their source order, so per-cell data stays aligned.
+    assert np.allclose(areas2, areas)
+
+    X_old, X_new = _coords(dm), _coords(out)
+    vS, _vE = dm.getDepthStratum(0)
+    vS2, vE2 = out.getDepthStratum(0)
+    for q, p in clone_map.items():
+        if vS2 <= q < vE2:
+            assert (X_new[q - vS2] == X_old[p - vS]).all()
+
+
+def test_the_two_sides_share_no_dofs():
+    """The load-bearing property: a value pinned on Plus stays off Minus.
+
+    Solved rather than merely assembled, so the assertion covers the whole
+    path a slip condition takes: label -> enum -> essential BC -> solution.
+    """
+    base = _box(cell_size=1 / 16)
+    child = _cut_child(base)
+    split = split_fault(child, FAULT)
+
+    u = uw.discretisation.MeshVariable("u_split", split, 1, degree=1)
+    poisson = uw.systems.Poisson(split, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 0.0
+    for b in ("Left", "Right", "Top", "Bottom"):
+        poisson.add_dirichlet_bc(0.0, b)
+    poisson.add_dirichlet_bc(1.0, f"{FAULT}Plus")
+    poisson.solve()
+
+    X, vals = np.asarray(u.coords), np.asarray(u.data[:, 0])
+    tangent = TIP_B - TIP_A
+    normal = np.array([-tangent[1], tangent[0]]) / np.hypot(*tangent)
+    s = (X - TIP_A) @ normal
+    t = ((X - TIP_A) @ tangent) / (tangent @ tangent)
+    on = (np.abs(s) < 1e-11) & (t > -1e-9) & (t < 1 + 1e-9)
+
+    m = len(_fault_facets(split.dm, f"{FAULT}Plus",
+                          split.boundaries[f"{FAULT}Plus"].value))
+    k = m - 1
+    # k coincident pairs plus the two single tips.
+    assert on.sum() == 2 * k + 2
+
+    interior = on & (t > 1e-9) & (t < 1 - 1e-9)
+    plus_side = np.isclose(vals, 1.0, atol=1e-10)
+    pinned = interior & plus_side
+    free = interior & ~plus_side
+    # One of each coincident pair reads the pinned value, the other reads a
+    # genuine interior value strictly between the wall and the pin — it would
+    # read exactly 1.0 if any DOF were shared.
+    assert pinned.sum() == k
+    assert free.sum() == k
+    assert (vals[free] > 0.0).all() and (vals[free] < 1.0 - 1e-6).all()
+    # The tips are deliberately NOT split: both sides meet there.
+    tips = on & ~interior
+    assert tips.sum() == 2
+    assert np.allclose(vals[tips], 1.0, atol=1e-10)
+
+
+def test_labels_pair_up_and_reach_the_solver_stack():
+    base = _box()
+    child = _cut_child(base)
+    split = split_fault(child, FAULT)
+
+    plus_v = split.boundaries[f"{FAULT}Plus"].value
+    minus_v = split.boundaries[f"{FAULT}Minus"].value
+    plus = _fault_facets(split.dm, f"{FAULT}Plus", plus_v)
+    minus = _fault_facets(split.dm, f"{FAULT}Minus", minus_v)
+    assert len(plus) == len(minus) > 0
+
+    # Pairwise coincident: the multiset of endpoint coordinates matches.
+    X = _coords(split.dm)
+    vS, _vE = split.dm.getDepthStratum(0)
+
+    def endpoint_multiset(facets):
+        rows = []
+        for e in facets:
+            pts = sorted(tuple(np.round(X[int(v) - vS], 12))
+                         for v in split.dm.getCone(e))
+            rows.append(tuple(pts))
+        return sorted(rows)
+
+    assert endpoint_multiset(plus) == endpoint_multiset(minus)
+
+    # The original name survives on both copies: 2m facets.
+    fault_v = split.boundaries[FAULT].value
+    assert len(_fault_facets(split.dm, FAULT, fault_v)) == 2 * len(plus)
+
+    # UW_Boundaries is what the solver reads when resolving a name.
+    stack = split.dm.getLabel("UW_Boundaries")
+    assert stack.getStratumSize(plus_v) > 0
+    assert stack.getStratumSize(minus_v) > 0
+
+
+def test_refusals_are_refusals():
+    base = _box()
+
+    # A boundary-to-boundary chain: every vertex of a through-going cut sits
+    # in the star of a boundary facet at its two ends.
+    through, _info = cut_along_lines(
+        base.dm, [np.array([[-0.2, 0.37], [1.2, 0.63]])],
+        label="Thru", label_value=40)
+    with pytest.raises(ValueError, match="domain boundary"):
+        split_along_label(through, "Thru", 40, "ThruPlus", 41,
+                          "ThruMinus", 42)
+
+    # A single-facet chain has no interior vertex.
+    dm = _cut_dm(base.dm)
+    facets = _fault_facets(dm, FAULT, FAULT_VALUE)
+    dm.createLabel("Short")
+    dm.getLabel("Short").setValue(facets[0], 50)
+    with pytest.raises(ValueError, match="single facet"):
+        split_along_label(dm, "Short", 50, "SP", 51, "SM", 52)
+
+    # A junction: three arms meeting at one vertex.
+    junction = np.array([0.5, 0.5])
+    jdm = pull_vertex_onto(base.dm, junction)
+    for kk, arm in enumerate(([[-0.2, 0.20], [0.5, 0.5]],
+                              [[0.5, 0.5], [1.2, 0.30]],
+                              [[0.5, 0.5], [0.55, 1.2]])):
+        jdm, _ = cut_along_lines(jdm, [np.asarray(arm, dtype=float)],
+                                 label="Y", label_value=60)
+    with pytest.raises(ValueError, match="junction"):
+        split_along_label(jdm, "Y", 60, "YP", 61, "YM", 62)
+
+    # An unknown label.
+    with pytest.raises(ValueError, match="no facets carry"):
+        split_along_label(base.dm, "Nowhere", 7, "NP", 8, "NM", 9)
+
+    # A double split: after the first, the original name marks BOTH copies,
+    # which read as two parallel chains rather than one.
+    once, _pm, _cm = _split(_cut_dm(base.dm))
+    with pytest.raises(ValueError, match="single open chain"):
+        split_along_label(once, FAULT, FAULT_VALUE, "P2", 71, "M2", 72)
+
+    # The Mesh-level wrapper refuses a second split by name before touching
+    # the topology.
+    child = _cut_child(base)
+    split = split_fault(child, FAULT)
+    with pytest.raises(ValueError, match="split already"):
+        split_fault(split, FAULT)
+
+
+def test_the_split_reapplies_as_the_fault_moves():
+    """The fault is a design variable and migrates: same base, two positions."""
+    base = _box()
+    positions = [(TIP_A, TIP_B),
+                 (np.array([0.28, 0.55]), np.array([0.66, 0.38]))]
+    children = []
+    for a, b in positions:
+        child = _cut_child(base, a, b)
+        children.append(split_fault(child, FAULT))
+
+    for split in children:
+        nc, nv, ne = _strata_counts(split.dm)
+        assert nv - ne + nc == 0
+        areas = cell_areas(split.dm)
+        assert (areas > 0).all()
+        assert np.isclose(areas.sum(), 1.0, rtol=1e-12)
+    # Independent children: different faults, different meshes.
+    assert not np.array_equal(_coords(children[0].dm),
+                              _coords(children[1].dm))
+
+
+def _cut_child(base, tip_a=TIP_A, tip_b=TIP_B, name=FAULT):
+    """A cut child Mesh with interior tips, mirroring add_conforming_surface.
+
+    Tips are placed with `pull_vertex_onto` directly (the surface machinery's
+    own tip path takes a Surface object); the label value comes from the
+    extended enum FIRST, exactly as `add_conforming_surface` does, so the
+    facets the label marks are the facets the enum member resolves to.
+    """
+    boundaries = base._boundaries_with(name)
+    value = boundaries[name].value
+    dm = _cut_dm(base.dm, tip_a, tip_b, name=name, value=value)
+    mesh = uw.discretisation.Mesh(
+        dm,
+        simplex=True,
+        coordinate_system_type=base.CoordinateSystem.coordinate_type,
+        qdegree=base.qdegree,
+        boundaries=boundaries,
+        verbose=False,
+    )
+    mesh.parent = base
+    mesh._relationship_kind = "refinement"
+    mesh._refine_dofs_coincide = False
+    mesh.regions = base.regions
+    mesh._parent_mesh_version = base._mesh_version
+    return mesh
diff --git a/tests/test_0845_relax_pinned_band.py b/tests/test_0845_relax_pinned_band.py
new file mode 100644
index 000000000..9ae0a1dd7
--- /dev/null
+++ b/tests/test_0845_relax_pinned_band.py
@@ -0,0 +1,107 @@
+"""Relaxation with an interface band held fixed.
+
+Relaxation and interface-tracking refinement work against each other: the mover
+optimises element shape against an equilateral reference and knows nothing about
+where the material changes, so it slides the small cells that refinement placed
+on an interface *off* it. ``pin_bands`` is the fix, and these are the properties
+that make it a fix rather than just a way to switch the mover off:
+
+* the pinned vertices do not move **at all** — exactly, not approximately;
+* vertices away from the band **do** move, so the mover is still working;
+* the domain boundary stays pinned. That one is a real trap: passing
+  ``pinned_labels`` explicitly REPLACES the auto default of "pin every named
+  boundary", so a naive implementation that substituted the band label would
+  silently let the mover deform the box.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+
+pytestmark = [pytest.mark.level_2, pytest.mark.tier_b]
+
+
+def _coords(mesh):
+    return np.asarray(mesh.dm.getCoordinatesLocal().array).reshape(-1, mesh.dim)
+
+
+def _fixture(cell_size=0.2):
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=cell_size,
+        regular=False, qdegree=2)
+    points = np.array([[0.12, 0.10, 0.0], [0.50, 0.52, 0.0], [0.88, 0.92, 0.0]])
+    surface = uw.meshing.Surface("pinflt", mesh, points, symbol="Pf")
+    surface.discretize()
+    return mesh, surface
+
+
+def test_pinned_vertices_do_not_move_and_others_do():
+    mesh, surface = _fixture()
+    before = _coords(mesh).copy()
+
+    name = mesh.label_interface_band(surface, offset=0.0, halo=1)
+    label = mesh.dm.getLabel(name)
+    vS, vE = mesh.dm.getDepthStratum(0)
+    pinned = np.array(sorted(
+        int(p) for p in label.getStratumIS(1).getIndices())) - vS
+    assert len(pinned) > 0, "no band was labelled; the fixture is not exercising it"
+
+    mesh.relax(pin_bands=[surface], pin_halo=1)
+    after = _coords(mesh)
+
+    moved = np.linalg.norm(after - before, axis=1)
+    assert moved[pinned].max() == 0.0, (
+        f"{int((moved[pinned] > 0).sum())} pinned vertices moved")
+
+    free = np.setdiff1d(np.arange(len(before)), pinned)
+    assert moved[free].max() > 0.0, (
+        "nothing moved anywhere — pinning switched the mover off rather than "
+        "steering it")
+
+
+def test_domain_boundary_stays_pinned():
+    """``pin_bands`` must MERGE with the auto-pinned boundaries, not replace them."""
+    mesh, surface = _fixture()
+    before = _coords(mesh).copy()
+    on_boundary = (np.isclose(before[:, 0], 0.0) | np.isclose(before[:, 0], 1.0)
+                   | np.isclose(before[:, 1], 0.0) | np.isclose(before[:, 1], 1.0))
+
+    mesh.relax(pin_bands=[surface])
+    after = _coords(mesh)
+
+    assert np.allclose(after[on_boundary], before[on_boundary], atol=0.0), (
+        "the domain boundary moved; pin_bands replaced the auto-pinned labels "
+        "instead of adding to them")
+
+
+def test_offset_selects_the_weak_zone_margin():
+    """An offset band tracks the level set, not the surface."""
+    mesh, surface = _fixture()
+    at_surface = mesh.label_interface_band(surface, offset=0.0, halo=0,
+                                           name="band_zero")
+    at_margin = mesh.label_interface_band(surface, offset=0.15, halo=0,
+                                          name="band_margin")
+    vS, _vE = mesh.dm.getDepthStratum(0)
+    X = _coords(mesh)
+    d = surface.unsigned_distance(X)
+
+    for name, offset in ((at_surface, 0.0), (at_margin, 0.15)):
+        idx = np.array(sorted(int(p) for p in
+                              mesh.dm.getLabel(name).getStratumIS(1).getIndices()))
+        assert len(idx) > 0, f"{name} labelled nothing"
+        # Every pinned vertex belongs to a cell the level set cuts, so it must lie
+        # within a cell diameter of that level set.
+        assert np.abs(d[idx - vS] - offset).min() < 0.2
+
+    zero = {int(p) for p in mesh.dm.getLabel(at_surface).getStratumIS(1).getIndices()}
+    margin = {int(p) for p in mesh.dm.getLabel(at_margin).getStratumIS(1).getIndices()}
+    assert zero != margin, "the offset had no effect on which band was labelled"
+
+
+def test_halo_grows_the_pinned_set():
+    mesh, surface = _fixture()
+    sizes = []
+    for halo in (0, 1, 2):
+        name = mesh.label_interface_band(surface, halo=halo, name=f"h{halo}")
+        sizes.append(len(mesh.dm.getLabel(name).getStratumIS(1).getIndices()))
+    assert sizes[0] < sizes[1] < sizes[2], sizes
diff --git a/tests/test_0846_fault_contact.py b/tests/test_0846_fault_contact.py
new file mode 100644
index 000000000..d10b9d823
--- /dev/null
+++ b/tests/test_0846_fault_contact.py
@@ -0,0 +1,339 @@
+"""Frictionless contact on a split-node fault
+(:mod:`underworld3.utilities.fault_contact`).
+
+The perfectly slippery fault: no opening ([v]·n̂ = 0, strong) and zero shear
+traction, with the tangential slip EMERGING from the far-field load — the
+stress-driven crack, where the kinematic fault of the split-node gate
+prescribed both sides. The analytic mode-II crack in an incompressible medium
+under remote shear Δτ gives an elliptical velocity jump
+
+    V(x) = (Δτ/η)·sqrt(a² − x²),  peak V = Δτ·a/η,
+
+so the solved slip must be one-signed, elliptical in shape, vanish at the
+unsplit tips, and peak below-but-near Δτ·a/η (a finite box suppresses the
+far field and with it the peak). What is asserted, and what each would catch:
+
+- **the pairing is complete** — 2m−1 velocity-carrying pairs for a chain of m
+  facets (m−1 duplicated vertices + m doubled facets carrying the P2
+  midpoint DOFs). A missed pair is a welded node.
+- **leak is machine zero** — the strong jump-normal constraint, read through
+  the pairing (a coordinate query cannot distinguish the sides).
+- **slip profile** — sign, tip decay, elliptical fit, peak against the crack
+  value. A wrong pair block (sign, normalisation, row placement) distorts
+  the profile long before it breaks conformity or convergence.
+- **the solve genuinely converged** — the rotated loop's own verdict.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.fault_contact import (add_coulomb_fault_bc,
+                                                 add_frictionless_fault_bc,
+                                                 add_rate_state_fault_bc,
+                                                 add_viscous_fault_bc,
+                                                 fault_normal_traction,
+                                                 fault_slip, solve_with_fault,
+                                                 update_fault_state)
+from underworld3.utilities.fault_split import split_fault
+from underworld3.utilities.line_cut import cut_along_lines, pull_vertex_onto
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+TIP_A = np.array([0.30, 0.45])
+TIP_B = np.array([0.70, 0.55])
+HALF = 0.5 * np.linalg.norm(TIP_B - TIP_A)
+
+
+def _split_box(cell_size=1 / 24, name="Flt"):
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0),
+        cellSize=cell_size, regular=False, qdegree=2)
+    boundaries = base._boundaries_with(name)
+    dm = pull_vertex_onto(base.dm, np.vstack([TIP_A, TIP_B]))
+    dm, _info = cut_along_lines(dm, [np.vstack([TIP_A, TIP_B])],
+                                label=name,
+                                label_value=boundaries[name].value)
+    cut = uw.discretisation.Mesh(
+        dm, simplex=True,
+        coordinate_system_type=base.CoordinateSystem.coordinate_type,
+        qdegree=base.qdegree, boundaries=boundaries, verbose=False)
+    cut.parent = base
+    cut._relationship_kind = "refinement"
+    cut._refine_dofs_coincide = False
+    cut.regions = base.regions
+    cut._parent_mesh_version = base._mesh_version
+    return split_fault(cut, name)
+
+
+def test_frictionless_fault_slips_like_a_crack():
+    mesh = _split_box()
+    x, y = mesh.X
+
+    v = uw.discretisation.MeshVariable("vFC", mesh, 2, degree=2)
+    p = uw.discretisation.MeshVariable("pFC", mesh, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    stokes.tolerance = 1e-6
+    stokes.petsc_use_pressure_nullspace = True
+    for side in ("Top", "Bottom", "Left", "Right"):
+        stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+
+    add_frictionless_fault_bc(stokes, "Flt")
+    info = solve_with_fault(stokes)
+    assert info["converged"], "the rotated fault-contact solve did not converge"
+
+    # Pairing completeness: m facets -> (m-1) vertex pairs + m facet pairs.
+    m = mesh.dm.getLabel("FltPlus").getStratumSize(
+        mesh.boundaries["FltPlus"].value)
+    s, V, leak = fault_slip(stokes, "Flt", info)
+    assert len(s) == 2 * m - 1
+
+    # No opening, to machine precision, at every pair.
+    assert np.abs(leak).max() < 1e-13
+
+    # The slip: one-signed, tip-decaying, elliptical, near the crack peak.
+    Vmag = np.abs(V)
+    sign = np.sign(V[np.argmax(Vmag)])
+    assert ((sign * V) >= -1e-12 * Vmag.max()).all(), "slip changes sign"
+    assert Vmag.max() > 0.1 * HALF, "the fault barely slips — welded somewhere"
+    # ends (nearest pairs to the unsplit tips) carry much less than the peak
+    assert Vmag[0] < 0.5 * Vmag.max() and Vmag[-1] < 0.5 * Vmag.max()
+    # elliptical profile: V ~ Vmax * sqrt(1 - u^2) on the tip-to-tip span
+    u = 2.0 * (s - s.min()) / (s.max() - s.min() + 1e-30) - 1.0
+    # the span s covers pair nodes only; the true tips sit half a facet
+    # beyond each end, so stretch u accordingly before the fit
+    du = (s[1] - s[0]) / (s.max() - s.min() + 1e-30)
+    u = u / (1.0 + du)
+    ellipse = np.sqrt(np.clip(1.0 - u ** 2, 0.0, None))
+    fit = (sign * V) / Vmag.max()
+    misfit = np.sqrt(np.mean((fit - ellipse * fit.max()) ** 2))
+    assert misfit < 0.15, f"slip profile is not elliptical (rms {misfit:.3f})"
+    # peak against the analytic crack Δτ·a/η = HALF (Δτ = η = 1): below it
+    # (finite box), but the right size.
+    assert 0.4 * HALF < Vmag.max() < 1.05 * HALF, (
+        f"peak slip {Vmag.max():.4f} vs crack value {HALF:.4f}")
+
+
+def test_viscous_fault_bridges_welded_to_free():
+    """The linear interface law spans its two exact limits monotonically.
+
+    tau = eta_f * V: at eta_f = 0 the frictionless crack must be reproduced
+    bit-for-bit in character (same peak); at eta_f >> eta/a the fault welds
+    (slip collapses, the box shears as if uncut); in between the slip drops
+    monotonically through the compliance scale eta/a. The dashpot occupies
+    exactly the tangent slot a friction law will use, so this family is the
+    coupling machinery's calibration curve.
+    """
+    mesh = _split_box()
+    x, y = mesh.X
+
+    peaks = {}
+    for tag, eta_f in (("free", 0.0), ("mid", 1.0 / HALF), ("hard", 5.0e3)):
+        v = uw.discretisation.MeshVariable(f"v{tag}", mesh, 2, degree=2)
+        p = uw.discretisation.MeshVariable(f"p{tag}", mesh, 1, degree=0,
+                                           continuous=False)
+        stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+        stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+        stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+        stokes.tolerance = 1e-6
+        stokes.petsc_use_pressure_nullspace = True
+        for side in ("Top", "Bottom", "Left", "Right"):
+            stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+        add_viscous_fault_bc(stokes, eta_f, "Flt")
+        info = solve_with_fault(stokes)
+        assert info["converged"], f"eta_f={eta_f}: solve did not converge"
+        _s, V, leak = fault_slip(stokes, "Flt", info)
+        assert np.abs(leak).max() < 1e-13, (
+            f"eta_f={eta_f}: the no-opening constraint leaked")
+        peaks[tag] = float(np.abs(V).max())
+
+    assert peaks["free"] > 0.1 * HALF, "the eta_f=0 member does not slip"
+    # strict monotone bridging, with a genuinely intermediate middle member
+    assert peaks["free"] > peaks["mid"] > peaks["hard"]
+    assert 0.15 * peaks["free"] < peaks["mid"] < 0.9 * peaks["free"], (
+        f"eta_f = eta/a should sit mid-family: {peaks}")
+    assert peaks["hard"] < 0.02 * peaks["free"], (
+        f"a stiff dashpot should weld the fault: {peaks}")
+
+
+def test_coulomb_fault_slides_and_sticks():
+    """The first nonlinear law, against its two analytic regimes.
+
+    The fault plane here is ~14 deg to x, so the resolved driving shear is
+    tau_inf = cos(2*theta) ~ 0.88 of the unit far-field shear. A regularised
+    Coulomb fault with strength mu*sigma_n BELOW tau_inf slides at constant
+    stress drop: by superposition its slip is the frictionless crack's
+    scaled by (tau_inf - strength)/tau_inf. Strength ABOVE tau_inf sticks:
+    the slip collapses to the regularisation creep ~ V0, orders of
+    magnitude below the crack. Both regimes must come out of the SAME
+    consistent-Newton machinery — the tangent is sympy-derived from the
+    arctan law, and the loop must genuinely converge in each.
+    """
+    mesh = _split_box()
+    x, y = mesh.X
+    d = (TIP_B - TIP_A) / np.linalg.norm(TIP_B - TIP_A)
+    tau_inf = float(d[0] ** 2 - d[1] ** 2)      # cos(2*theta) resolved shear
+
+    def solve_case(tag, register):
+        v = uw.discretisation.MeshVariable(f"v{tag}", mesh, 2, degree=2)
+        p = uw.discretisation.MeshVariable(f"p{tag}", mesh, 1, degree=0,
+                                           continuous=False)
+        stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+        stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+        stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+        stokes.tolerance = 1e-6
+        stokes.petsc_use_pressure_nullspace = True
+        for side in ("Top", "Bottom", "Left", "Right"):
+            stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+        register(stokes)
+        info = solve_with_fault(stokes)
+        assert info["converged"], f"{tag}: did not converge"
+        _s, V, leak = fault_slip(stokes, "Flt", info)
+        assert np.abs(leak).max() < 1e-12
+        return float(np.abs(V).max()), info["nonlinear_iterations"]
+
+    V_free, _ = solve_case(
+        "cf", lambda st: add_frictionless_fault_bc(st, "Flt"))
+
+    # Sliding: strength = half the resolved driving shear.
+    strength = 0.5 * tau_inf
+    V_slide, its_slide = solve_case(
+        "cs", lambda st: add_coulomb_fault_bc(
+            st, 1.0, "Flt", sigma_n=strength, V0=1e-4 * V_free))
+    ratio = V_slide / V_free
+    assert 0.3 < ratio < 0.7, (
+        f"sliding slip ratio {ratio:.3f}; constant-stress-drop scaling "
+        f"predicts ~{(tau_inf - strength) / tau_inf:.2f}")
+    assert its_slide < 30, f"sliding solve took {its_slide} Newton iterations"
+
+    # Stuck: strength safely above the resolved driving shear.
+    V0_stick = 1e-6
+    V_stick, its_stick = solve_case(
+        "ck", lambda st: add_coulomb_fault_bc(
+            st, 1.0, "Flt", sigma_n=2.0, V0=V0_stick))
+    assert V_stick < 20 * V0_stick, (
+        f"stuck fault creeps at {V_stick:.2e}, far above the "
+        f"regularisation velocity {V0_stick:.0e}")
+    assert its_stick < 40, f"stick solve took {its_stick} Newton iterations"
+
+
+def test_reaction_fed_normal_stress():
+    """sigma_n from the no-opening constraint's reaction, not prescribed.
+
+    Two claims. (1) The recovery itself: on the frictionless fault under
+    unit far-field shear, the transmitted normal traction should match the
+    resolved background sigma_nn = 2 n_x n_y (mode-II slip perturbs the
+    normal traction antisymmetrically, so the MEAN along the fault stays at
+    the background value). (2) The law coupling: Coulomb with
+    sigma_n="reaction" must land between frictionless and a strong
+    prescribed fault, sliding at the strength the recovered compression
+    actually provides — with the whole sigma feedback Picard-lagged inside
+    the same Newton loop.
+    """
+    mesh = _split_box()
+    x, y = mesh.X
+    d = (TIP_B - TIP_A) / np.linalg.norm(TIP_B - TIP_A)
+    nrm = np.array([-d[1], d[0]])
+    sigma_bg = 2.0 * nrm[0] * nrm[1] * d[0] * d[1] / (d[0] * d[1])  # sign via components
+    sigma_bg = 2.0 * (-d[1]) * d[0]          # n_x n_y * 2 with n = (-dy, dx)
+    tau_inf = float(d[0] ** 2 - d[1] ** 2)
+
+    def solve_case(tag, register):
+        v = uw.discretisation.MeshVariable(f"v{tag}", mesh, 2, degree=2)
+        p = uw.discretisation.MeshVariable(f"p{tag}", mesh, 1, degree=0,
+                                           continuous=False)
+        stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+        stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+        stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+        stokes.tolerance = 1e-6
+        stokes.petsc_use_pressure_nullspace = True
+        for side in ("Top", "Bottom", "Left", "Right"):
+            stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+        register(stokes)
+        info = solve_with_fault(stokes)
+        assert info["converged"], f"{tag}: did not converge"
+        _s, V, leak = fault_slip(stokes, "Flt", info)
+        assert np.abs(leak).max() < 1e-12
+        return stokes, info, float(np.abs(V).max())
+
+    # (1) traction recovery against the resolved background
+    st_free, info_free, V_free = solve_case(
+        "rf", lambda st: add_frictionless_fault_bc(st, "Flt"))
+    _s, sig = fault_normal_traction(st_free, "Flt", info_free)
+    mean_sig = float(np.mean(sig))
+    assert np.sign(mean_sig) == np.sign(sigma_bg)
+    assert abs(mean_sig - sigma_bg) < 0.35 * abs(sigma_bg), (
+        f"recovered mean sigma_nn {mean_sig:.3f} vs background "
+        f"{sigma_bg:.3f}")
+
+    # (2) the reaction-fed Coulomb law
+    mu = 1.0
+    _st, info_rc, V_rc = solve_case(
+        "rc", lambda st: add_coulomb_fault_bc(
+            st, mu, "Flt", sigma_n="reaction", V0=1e-4 * V_free))
+    strength = mu * abs(sigma_bg)
+    predicted = max(tau_inf - strength, 0.0) / tau_inf
+    ratio = V_rc / V_free
+    assert 0.5 * predicted < ratio < min(1.6 * predicted + 0.05, 0.95), (
+        f"reaction-fed slip ratio {ratio:.3f} vs constant-stress-drop "
+        f"prediction {predicted:.3f} (strength {strength:.3f} from the "
+        f"recovered compression)")
+    assert info_rc["nonlinear_iterations"] < 40
+
+
+def test_rate_state_fault_evolves_to_steady_state():
+    """Rate-and-state on the split fault: solve <-> state-update cycling.
+
+    Velocity-strengthening parameters (a > b) under steady loading: each
+    solve is full Newton in V at frozen theta (sigma_n reaction-fed), the
+    ageing law then advances theta exactly for the solved slip rates. The
+    fixed point is theta = Dc/V (the monitor theta*V/Dc -> 1) with the slip
+    rate settling to the steady value of tau_ss = sigma(f0+(a-b)ln V/V0)
+    against the crack compliance. Six cycles with ~3 state e-folds each
+    must converge both the state and the slip.
+    """
+    mesh = _split_box()
+    x, y = mesh.X
+    v = uw.discretisation.MeshVariable("vRS", mesh, 2, degree=2)
+    p = uw.discretisation.MeshVariable("pRS", mesh, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    stokes.tolerance = 1e-6
+    stokes.petsc_use_pressure_nullspace = True
+    for side in ("Top", "Bottom", "Left", "Right"):
+        stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+    add_rate_state_fault_bc(stokes, 0.3, "Flt", a=0.020, b=0.010,
+                            V0=1e-3, Dc=2e-3, sigma_n="reaction")
+
+    peaks, monitors = [], []
+    for step in range(6):
+        info = solve_with_fault(stokes, zero_init_guess=(step == 0))
+        assert info["converged"], f"step {step} did not converge"
+        _s, V, leak = fault_slip(stokes, "Flt", info)
+        assert np.abs(leak).max() < 1e-12
+        peaks.append(float(np.abs(V).max()))
+        monitors.append(update_fault_state(stokes, "Flt", 0.05, info))
+
+    assert peaks[-1] > 0.02, "the strengthening fault should still slide"
+    assert abs(peaks[-1] - peaks[-2]) < 0.05 * peaks[-1], (
+        f"slip did not settle: {peaks}")
+    assert abs(monitors[-1] - 1.0) < 0.15, (
+        f"state did not reach Dc/V: monitors {monitors}")
+
+
+def test_registration_refuses_an_unsplit_mesh():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 8,
+        regular=False, qdegree=2)
+    v = uw.discretisation.MeshVariable("vNC", base, 2, degree=2)
+    p = uw.discretisation.MeshVariable("pNC", base, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(base, velocityField=v, pressureField=p)
+    with pytest.raises(ValueError, match="no split-fault pairing"):
+        add_frictionless_fault_bc(stokes, "Flt")
+    with pytest.raises(RuntimeError, match="no fault contact registered"):
+        solve_with_fault(stokes)
diff --git a/tests/test_0846_visualisation_native_mesh.py b/tests/test_0846_visualisation_native_mesh.py
new file mode 100644
index 000000000..4ad3bc48d
--- /dev/null
+++ b/tests/test_0846_visualisation_native_mesh.py
@@ -0,0 +1,111 @@
+"""A continuous P1 field is drawn on the mesh's OWN cells, not a Delaunay of them.
+
+``meshVariable_to_pv_mesh_object`` triangulates a variable's nodal points so that
+higher-order fields, whose DOFs the base mesh does not carry, can be plotted at
+all. For a continuous P1 field that is the wrong thing to do: the DOFs *are* the
+vertices, so the triangulation already exists, and re-deriving it is lossy.
+
+Lossy specifically, not merely wasteful. ``delaunay_2d`` takes one ``alpha`` for
+the whole domain and discards triangles whose circumradius exceeds it, so on a
+graded mesh it deletes the coarse cells and they render as blank holes in the
+middle of the field. That is why the fixture here is GRADED — on a uniform mesh
+the two routes agree and the regression cannot be seen.
+
+The point ORDER is asserted as well as the cell count, because the documented
+usage attaches values by DOF index::
+
+    pvm = vis.meshVariable_to_pv_mesh_object(T)
+    pvm.point_data["T"] = np.asarray(T.data[:, 0])
+
+Returning the right cells with the points in the DM's vertex order instead of the
+variable's would draw a plausible-looking field with the values shuffled.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+import underworld3.visualisation as vis
+from underworld3.utilities import edge_split
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_a]
+
+
+def _graded_mesh():
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.3,
+        regular=False, qdegree=2)
+    dm = base.dm
+    for _ in range(20):
+        cS, cE = dm.getHeightStratum(0)
+        cen = np.array([dm.computeCellGeometryFVM(c)[1] for c in range(cS, cE)])
+        d = np.linalg.norm(cen - np.array([0.35, 0.6]), axis=1)
+        target = np.where(d < 0.2, 0.03, 0.4)
+        sel = np.flatnonzero(edge_split.cell_diameters(dm) > target) + cS
+        dm, n = edge_split.bisect_longest_edges(dm, sel)
+        if n == 0:
+            break
+    return uw.discretisation.Mesh(dm, qdegree=2)
+
+
+def _n_cells(mesh):
+    cS, cE = mesh.dm.getHeightStratum(0)
+    return cE - cS
+
+
+def test_p1_uses_the_meshs_own_cells():
+    mesh = _graded_mesh()
+    p1 = uw.discretisation.MeshVariable("v1", mesh, 1, degree=1,
+                                        continuous=True)
+    pvm = vis.meshVariable_to_pv_mesh_object(p1)
+
+    assert pvm.n_cells == _n_cells(mesh), (
+        "the plotted mesh does not have the mesh's own cells")
+    assert pvm.n_points == p1.coords.shape[0]
+
+
+def test_delaunay_would_drop_cells_on_a_graded_mesh():
+    """The control. Without it the test above could pass by coincidence.
+
+    If this stops failing to reproduce the loss, the graded fixture has stopped
+    being graded enough and the test above proves nothing.
+    """
+    mesh = _graded_mesh()
+    p1 = uw.discretisation.MeshVariable("v2", mesh, 1, degree=1,
+                                        continuous=True)
+    cloud = vis.meshVariable_to_pv_cloud(p1)
+    pts = np.asarray(cloud.points)
+    alpha = (pts.max() - pts.min()) / max(10, len(pts) ** 0.5) * 2.0
+    dropped = _n_cells(mesh) - cloud.delaunay_2d(alpha=alpha).n_cells
+    assert dropped > 0, (
+        "the Delaunay route loses no cells on this fixture, so it is not "
+        "grading strongly enough to exercise the regression")
+
+
+def test_values_line_up_with_the_points():
+    """Attaching data by DOF index must land on the right vertices."""
+    mesh = _graded_mesh()
+    p1 = uw.discretisation.MeshVariable("v3", mesh, 1, degree=1,
+                                        continuous=True)
+    coords = np.asarray(p1.coords)
+    p1.array[:, 0, 0] = coords[:, 0] + 2.0 * coords[:, 1]
+
+    pvm = vis.meshVariable_to_pv_mesh_object(p1)
+    pvm.point_data["f"] = np.asarray(p1.data[:, 0]).reshape(-1)
+    exact = pvm.points[:, 0] + 2.0 * pvm.points[:, 1]
+
+    assert np.abs(pvm.point_data["f"] - exact).max() == pytest.approx(0.0,
+                                                                     abs=1e-12)
+
+
+@pytest.mark.parametrize("degree,continuous", [(2, True), (0, False)])
+def test_other_spaces_still_take_the_delaunay_route(degree, continuous):
+    """Higher-order and discontinuous fields have no native triangulation.
+
+    Their DOFs are not the vertices, so the mesh's cells cannot carry them and
+    the helper must decline rather than return something the wrong shape.
+    """
+    mesh = _graded_mesh()
+    var = uw.discretisation.MeshVariable(f"v4_{degree}", mesh, 1, degree=degree,
+                                         continuous=continuous)
+    assert vis.meshVariable_to_native_pv_mesh(var) is None
+    assert vis.meshVariable_to_pv_mesh_object(var).n_points > 0
diff --git a/tests/test_0847_fault_api.py b/tests/test_0847_fault_api.py
new file mode 100644
index 000000000..99e2b41ac
--- /dev/null
+++ b/tests/test_0847_fault_api.py
@@ -0,0 +1,246 @@
+"""The deployed fault interface: ``Mesh.add_fault`` + ``solver.add_fault_bc``
++ plain ``solve()``.
+
+The user-facing pipeline over the split-node backend, asserted end to end:
+
+- one call faults the mesh (tips placed, cut, split, pairing recorded) from
+  either a ``(name, points)`` pair or a ``uw.meshing.Surface``;
+- ``add_fault_bc(0, name)`` is the frictionless contact, ``add_fault_bc
+  (eta_f, name)`` the viscous interface, and an ORDINARY ``solve()``
+  dispatches to the rotated fault path — no special driver in user code;
+- a two-segment offset network (the J0 junction pattern of the deployment
+  design) works in one ``add_fault`` call: both faults slip, no opening
+  anywhere;
+- the guard/difficulty probes refuse loudly on the fault path, exactly as
+  they do for rotated free-slip.
+
+The physics itself (crack profile, compliance family) is validated in
+``test_0846_fault_contact.py``; here the assertions are that the INTERFACE
+delivers the same behaviour.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.fault_contact import fault_slip
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+TIP_A = np.array([0.30, 0.45])
+TIP_B = np.array([0.70, 0.55])
+HALF = 0.5 * np.linalg.norm(TIP_B - TIP_A)
+
+
+def _box(cell_size=1 / 24):
+    return uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0),
+        cellSize=cell_size, regular=False, qdegree=2)
+
+
+def _shear_stokes(mesh, tag):
+    x, y = mesh.X
+    v = uw.discretisation.MeshVariable(f"v{tag}", mesh, 2, degree=2)
+    p = uw.discretisation.MeshVariable(f"p{tag}", mesh, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    stokes.tolerance = 1e-6
+    stokes.petsc_use_pressure_nullspace = True
+    for side in ("Top", "Bottom", "Left", "Right"):
+        stokes.add_dirichlet_bc((y - 0.5, 0.0), side)
+    return stokes
+
+
+def test_one_call_fault_and_plain_solve():
+    """(name, points) -> add_fault -> add_fault_bc(0) -> solve()."""
+    split = _box().add_fault(("Flt", np.vstack([TIP_A, TIP_B])))
+    assert "FltPlus" in [b.name for b in split.boundaries]
+    assert "Flt" in split._fault_point_pairs
+
+    stokes = _shear_stokes(split, "A")
+    stokes.add_fault_bc(0, "Flt")
+    stokes.solve()
+
+    info = stokes._rotated_freeslip_info
+    assert info is not None and info["converged"]
+    _s, V, leak = fault_slip(stokes, "Flt", info)
+    assert np.abs(leak).max() < 1e-13
+    # the frictionless crack, as in test_0846
+    assert 0.4 * HALF < np.abs(V).max() < 1.05 * HALF
+
+    # the probes that cannot reach the rotated path refuse loudly
+    with pytest.raises(NotImplementedError, match="fault-contact"):
+        stokes.guard(wall_per_step=10.0)
+    with pytest.raises(NotImplementedError, match="fault-contact"):
+        stokes.estimate_difficulty(2)
+
+
+def test_viscous_law_through_the_solver_method():
+    split = _box().add_fault(("Flt", np.vstack([TIP_A, TIP_B])))
+
+    peaks = {}
+    for tag, eta_f in (("free", 0.0), ("visc", 1.0 / HALF)):
+        stokes = _shear_stokes(split, tag)
+        stokes.add_fault_bc(eta_f, "Flt")
+        stokes.solve()
+        _s, V, _leak = fault_slip(stokes, "Flt",
+                                  stokes._rotated_freeslip_info)
+        peaks[tag] = float(np.abs(V).max())
+    # eta_f = eta/a sits mid-family (the measured compliance curve)
+    assert 0.15 * peaks["free"] < peaks["visc"] < 0.9 * peaks["free"]
+
+
+def test_surface_object_input():
+    base = _box()
+    surface = uw.meshing.Surface("Flt", base, np.vstack([TIP_A, TIP_B]))
+    split = base.add_fault(surface)
+    assert "FltMinus" in [b.name for b in split.boundaries]
+    assert len(split._fault_point_pairs["Flt"]) > 0
+
+    # the object rides along, and normal="surface" spells the same
+    # frame in 2-D that a FaultSurface gives in 3-D: the smoothed
+    # normal of the object's own control polyline
+    assert split._fault_surfaces["Flt"] is surface
+    from underworld3.utilities.fault_contact import (_compile_normal_spec,
+                                                     _trace_normal_fn)
+    fn = _compile_normal_spec("surface", split, "Flt")
+    ref = _trace_normal_fn(np.vstack([TIP_A, TIP_B]))
+    mid = 0.5 * (TIP_A + TIP_B)
+    assert np.allclose(fn(mid), ref(mid))
+
+
+def test_offset_network_in_one_call():
+    """The J0 junction pattern: two en-echelon segments, one add_fault."""
+    A = ("FltA", np.array([[0.20, 0.42], [0.48, 0.49]]))
+    B = ("FltB", np.array([[0.55, 0.52], [0.82, 0.59]]))
+    split = _box().add_fault([A, B])
+    for name in ("FltA", "FltB"):
+        assert f"{name}Plus" in [b.name for b in split.boundaries]
+        assert len(split._fault_point_pairs[name]) > 0
+
+    stokes = _shear_stokes(split, "N")
+    stokes.add_fault_bc(0, "FltA")
+    stokes.add_fault_bc(0, "FltB")
+    stokes.solve()
+    info = stokes._rotated_freeslip_info
+    assert info["converged"]
+    for name in ("FltA", "FltB"):
+        _s, V, leak = fault_slip(stokes, name, info)
+        assert np.abs(leak).max() < 1e-13, f"{name} opened"
+        assert np.abs(V).max() > 0.02, f"{name} does not slip"
+
+
+def test_multi_fault_diagnostics_are_per_fault():
+    """Per-fault diagnostics on a two-fault network stay per-fault.
+
+    The regression (measured): with LAWS registered on both faults, the
+    diagnostic assembler walked every registered fault, so
+    ``fault_normal_traction(solver, "FltA", info)`` returned the UNION of
+    both faults' nodes — fault B's nodes interleaved into A's traction
+    profile as bogus arc-length samples — and ``update_fault_state`` wrote
+    fault B's point keys into fault A's theta store and mixed both faults
+    in its convergence monitor. The oracle for the correct count is
+    ``_fault_pair_nodes``, which was always per-fault.
+    """
+    from underworld3.utilities.fault_contact import (_fault_pair_nodes,
+                                                     fault_normal_traction,
+                                                     update_fault_state)
+
+    A = ("FltA", np.array([[0.20, 0.42], [0.48, 0.49]]))
+    B = ("FltB", np.array([[0.55, 0.52], [0.82, 0.59]]))
+    split = _box().add_fault([A, B])
+
+    stokes = _shear_stokes(split, "D")
+    # viscous laws on BOTH faults: the contamination walked the LAW
+    # registry, so a law must be present on the other fault to catch it
+    stokes.add_fault_bc(1.0 / HALF, "FltA")
+    stokes.add_fault_bc(1.0 / HALF, "FltB")
+    stokes.solve()
+    info = stokes._rotated_freeslip_info
+    assert info["converged"]
+
+    n_a = len(_fault_pair_nodes(stokes, "FltA"))
+    n_b = len(_fault_pair_nodes(stokes, "FltB"))
+    assert n_a > 0 and n_b > 0
+
+    s_a, sig_a = fault_normal_traction(stokes, "FltA", info)
+    s_b, sig_b = fault_normal_traction(stokes, "FltB", info)
+    assert len(sig_a) == n_a, (
+        f"fault A's traction profile has {len(sig_a)} rows where A has "
+        f"{n_a} pair nodes — the other fault's nodes leaked in")
+    assert len(sig_b) == n_b
+    # the arc-length axis must span A's own length, not the network's
+    assert s_a.max() <= 1.05 * float(np.linalg.norm(A[1][1] - A[1][0]))
+
+    # theta bookkeeping: keys written by an update for fault A must all be
+    # fault A's own (plus-side) points
+    stokes._fault_state = {"FltA": {"theta0": 1.0, "Dc": 1.0,
+                                    "by_point": {}}}
+    monitor = update_fault_state(stokes, "FltA", 0.1, info)
+    assert np.isfinite(monitor)
+    keys = set(stokes._fault_state["FltA"]["by_point"])
+    plus_a = set(split._fault_point_pairs["FltA"].values())
+    plus_b = set(split._fault_point_pairs["FltB"].values())
+    assert len(keys) == n_a
+    assert keys <= plus_a, "foreign points in fault A's theta store"
+    assert not (keys & plus_b)
+
+
+def test_analytic_normal_smooths_a_sampled_curve():
+    """``add_fault_bc(normal=...)`` on a polyline-sampled arc.
+
+    The facet-AVERAGED per-node normal zig-zags at the sampling kinks, so
+    the no-opening constraint forbids smooth slip past each kink — a
+    normal-traction sawtooth locked to the kink positions (the negative
+    control: it MUST be there, or this test can't see the fix). The
+    analytic arc normal on the SAME kinked mesh removes it. Measured at
+    h = 0.02 the ratio is ~7x; asserted at 3x. The exact-normal case runs
+    on the SECOND mesh of the test, which is the regression for the
+    unwrap coordinate re-tagging (issue #501's fault-side twin).
+    """
+    import sympy
+
+    from underworld3.utilities.fault_contact import fault_normal_traction
+
+    R, half_chord = 0.35, 0.22
+    alpha = np.arcsin(half_chord / R)
+    centre = np.array([0.5, 0.5 - R * np.cos(alpha)])
+    ang = np.linspace(np.pi / 2 + alpha, np.pi / 2 - alpha, 9)  # 8 segments
+    pts = centre + R * np.column_stack([np.cos(ang), np.sin(ang)])
+
+    rough = {}
+    for tag in ("avg", "exact", "trace"):
+        split = _box(0.02).add_fault(("Arc", pts))
+        stokes = _shear_stokes(split, f"an_{tag}")
+        if tag == "exact":
+            x, y = split.X
+            stokes.add_fault_bc(0, boundary="Arc", normal=sympy.Matrix(
+                [[x - centre[0], y - centre[1]]]))
+        elif tag == "trace":
+            # the smoothed normal built from the polyline itself — the
+            # analytic-formula-free route for digitized traces
+            stokes.add_fault_bc(0, boundary="Arc", normal="trace")
+        else:
+            stokes.add_fault_bc(0, boundary="Arc")
+        stokes.solve()
+        info = stokes._rotated_freeslip_info
+        _s, _V, leak = fault_slip(stokes, "Arc", info)
+        assert np.abs(leak).max() < 1e-10, f"{tag}: fault opened"
+        s_n, sig = fault_normal_traction(stokes, "Arc", info)
+        mid = (s_n > 0.08) & (s_n < s_n.max() - 0.08)
+        rough[tag] = float(np.sqrt(np.mean(np.diff(sig[mid], 2) ** 2)))
+
+    assert rough["avg"] > 3.0 * rough["exact"], (
+        f"analytic normal did not smooth the sampled curve: "
+        f"avg {rough['avg']:.4f} vs exact {rough['exact']:.4f}")
+    assert rough["avg"] > 3.0 * rough["trace"], (
+        f"trace-smoothed normal did not smooth the sampled curve: "
+        f"avg {rough['avg']:.4f} vs trace {rough['trace']:.4f}")
+
+    # a genuinely foreign symbol is still refused, and refusal must not
+    # corrupt the already-registered override
+    with pytest.raises(ValueError, match="not mesh coordinates"):
+        stokes.add_fault_bc(0, boundary="Arc", normal=sympy.Matrix(
+            [[sympy.Symbol("q_foreign"), 1]]))
+    assert "Arc" in stokes._fault_normal_overrides
diff --git a/tests/test_0847_mesh_hierarchy_plot.py b/tests/test_0847_mesh_hierarchy_plot.py
new file mode 100644
index 000000000..0e50baba1
--- /dev/null
+++ b/tests/test_0847_mesh_hierarchy_plot.py
@@ -0,0 +1,188 @@
+"""The standard hierarchy view: one actor per multigrid level, plus each fault.
+
+``plot_mesh_hierarchy`` is a figure routine, so what can be asserted is what it
+DREW, not what it looks like: the level count, that a fault the mesh carries
+becomes its own actor, and that it degrades sensibly on a mesh with no tail and
+in 3-D. Those are the ways it can silently draw the wrong thing — a hierarchy
+missing a level reads as a shallower mesh, and a fault that quietly contributed
+no actor reads as a mesh with no fault in it.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+import underworld3.visualisation as vis
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_a]
+
+
+def _actors(pl):
+    return len(pl.renderer.actors)
+
+
+def _plain_box():
+    return uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=0.35,
+        regular=False, qdegree=2)
+
+
+def _fault_mesh():
+    """An adapt child with a conforming surface — a real hierarchy and a label."""
+    base = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0), maxCoords=(1.0, 1.0), cellSize=1 / 6,
+        regular=False, qdegree=2, refinement=2)
+    line = np.array([[-0.1, 0.37], [1.1, 0.63]])
+    surf = uw.meshing.Surface("Grade", base, line)
+    surf.discretize()
+    child = base.adapt(surf.refinement_metric_function(
+        h_near=1 / 48, h_far=1 / 6, width=1 / 12), max_levels=3)
+    return child.add_conforming_surface(
+        uw.meshing.Surface("Flt", child, line), snap_frac=0.30)
+
+
+def test_one_actor_per_level_and_per_fault():
+    mesh = _fault_mesh()
+    levels = len(getattr(mesh, "_custom_mg_coarse_meshes", []) or []) + 1
+    assert levels > 1, "fixture has no multigrid tail, so nothing is being tested"
+
+    plain = vis.plot_mesh_hierarchy(mesh, nodes=False, legend=False)
+    assert _actors(plain) == levels
+
+    withfault = vis.plot_mesh_hierarchy(mesh, faults=("Flt",), nodes=False, legend=False)
+    assert _actors(withfault) == levels + 1, (
+        "the fault contributed no actor; it would be invisible in the figure")
+    plain.close()
+    withfault.close()
+
+
+def test_nodes_add_one_glyph_actor_per_level_and_fault():
+    """Every wireframe gets a matching set of node marks, or none does."""
+    mesh = _fault_mesh()
+    levels = len(getattr(mesh, "_custom_mg_coarse_meshes", []) or []) + 1
+
+    off = vis.plot_mesh_hierarchy(mesh, faults=("Flt",), nodes=False, legend=False)
+    on = vis.plot_mesh_hierarchy(mesh, faults=("Flt",), nodes=True, legend=False)
+    assert _actors(on) == 2 * _actors(off) == 2 * (levels + 1), (
+        "node glyphs did not appear for every level and every fault")
+    off.close()
+    on.close()
+
+
+def test_node_glyphs_mark_every_vertex_of_their_level():
+    """The marks must be the level's OWN nodes, not a subset or the wrong level.
+
+    A glyph set is one copy of the source geometry per point, so the vertex
+    count is recoverable from the glyphed mesh and can be checked against the
+    level it claims to represent.
+    """
+    import numpy as np
+    import pyvista as pv
+
+    mesh = _fault_mesh()
+    base = (getattr(mesh, "_custom_mg_coarse_meshes", []) or [mesh])[0]
+    src = pv.Polygon(center=(0.0, 0.0, 0.0), radius=0.5, normal=(0.0, 0.0, 1.0),
+                     n_sides=24)
+    cloud = pv.PolyData(np.column_stack(
+        [np.asarray(base.X.coords), np.zeros(len(base.X.coords))]))
+    glyphed = cloud.glyph(geom=src, scale=False, orient=False)
+    assert glyphed.n_points == cloud.n_points * src.n_points
+
+
+def test_facets_are_the_fault_and_cells_are_the_zone():
+    """The default must draw the fault, not the zone — they are different sets.
+
+    ``cells_supporting`` is every cell with a labelled facet, which is one
+    element on EACH side, so filling it makes a one-element fault look two or
+    three elements thick. The facets are the fault as the mesh represents it.
+    This asserts the two really do differ, so the default cannot quietly revert
+    to the fat one without failing.
+    """
+    mesh = _fault_mesh()
+    value = int(mesh.boundaries["Flt"].value)
+    n_facets = mesh.dm.getLabel("Flt").getStratumSize(value)
+    zone = np.asarray(mesh.cells_supporting("Flt"))
+    assert n_facets > 0 and zone.any()
+
+    facets = vis.labelled_facets_to_pv_mesh(mesh, "Flt")
+    # n_cells is the wrong counter: `pv.PolyData(points)` gives every point its
+    # own vertex cell, so n_cells is n_points + the lines. Count the lines (2-D)
+    # or faces (3-D) instead.
+    assert facets.n_lines + facets.n_faces_strict == n_facets
+
+    # The zone is strictly bigger: a facet has a cell on each side of it.
+    assert int(zone.sum()) > n_facets, (
+        "the zone is no larger than the facet chain, so this fixture cannot "
+        "show that the default picks the narrower set")
+
+
+def test_an_unknown_fault_style_is_refused():
+    mesh = _fault_mesh()
+    with pytest.raises(ValueError):
+        vis.plot_mesh_hierarchy(mesh, faults=("Flt",), fault_style="zone")
+
+
+def test_a_mesh_without_a_tail_is_drawn_alone():
+    """No hierarchy is not an error — a base mesh is a one-level hierarchy."""
+    pl = vis.plot_mesh_hierarchy(_plain_box(), nodes=False, legend=False)
+    assert _actors(pl) == 1
+    pl.close()
+
+
+def test_a_missing_fault_label_is_skipped_not_fatal():
+    mesh = _plain_box()
+    pl = vis.plot_mesh_hierarchy(mesh, faults=("All_Boundaries",))
+    assert _actors(pl) >= 1
+    pl.close()
+
+
+def test_three_dimensions_and_clipping():
+    """The 3-D path: surface wireframes, and a clip that opens the model.
+
+    Not a picture test — only that the dimension-dependent branches run and
+    still produce one actor per level, since that is what will be exercised the
+    moment there is a 3-D fault to look at.
+    """
+    mesh = uw.meshing.UnstructuredSimplexBox(
+        minCoords=(0.0, 0.0, 0.0), maxCoords=(1.0, 1.0, 1.0), cellSize=0.4,
+        regular=False, qdegree=2)
+    pl = vis.plot_mesh_hierarchy(mesh, nodes=False, legend=False)
+    assert _actors(pl) == 1
+    pl.close()
+
+    clipped = vis.plot_mesh_hierarchy(
+        mesh, clip=((1.0, 0.0, 0.0), (0.5, 0.5, 0.5)), nodes=False, legend=False)
+    assert _actors(clipped) == 1
+    clipped.close()
+
+    # The 3-D glyph branch is a different source geometry (sphere/cube/cone)
+    # and would otherwise only be exercised the day there is a 3-D fault.
+    marked = vis.plot_mesh_hierarchy(mesh, nodes=True, legend=False)
+    assert _actors(marked) == 2
+    marked.close()
+
+
+def test_the_legend_shapes_match_what_was_drawn():
+    """A key that contradicts its figure is worse than no key.
+
+    PyVista's default legend face is a triangle for EVERY entry, so a legend
+    built by hand shows triangles beside wireframes and beside square nodes.
+    This asserts each entry carries the face that was actually plotted.
+    """
+    mesh = _fault_mesh()
+    pl = vis.plot_mesh_hierarchy(mesh, faults=("Flt",), nodes=True)
+    key = {row[0]: row[2] for row in pl._uw_legend_key}
+
+    import pyvista as pv
+
+    # Wireframes carry their own line geometry: PyVista's named faces are only
+    # triangle / circle / rectangle / none, so without it a mesh level and a
+    # square node would key identically.
+    assert isinstance(key["level 0"], pv.PolyData), (
+        "wireframes must be keyed with a line, not a named face")
+    assert isinstance(key["Flt"], pv.PolyData)
+    assert key["base nodes"] == "circle"
+    assert key["stacked-on nodes"] == "rectangle"
+    assert key["fault nodes"] == "triangle"
+    assert len({str(v) for v in key.values()}) >= 4, (
+        "the key does not distinguish the things the figure distinguishes")
+    pl.close()
diff --git a/tests/test_0848_fault_split_3d.py b/tests/test_0848_fault_split_3d.py
new file mode 100644
index 000000000..fa3c98d43
--- /dev/null
+++ b/tests/test_0848_fault_split_3d.py
@@ -0,0 +1,316 @@
+"""Split-node faults in 3-D: the labelled patch becomes a discontinuity.
+
+The 3-D counterparts of the ``test_0845`` checks, one dimension up: exact
+chart deltas and the Euler-characteristic invariant (a ball with an interior
+slit gains the patch's interior characteristic, chi 1 -> 2 for a disc-like
+patch), conformity, coincident replica coordinates, volume conservation,
+label integrity — and the load-bearing DOF-independence solve, where a
+Dirichlet datum on the Plus side must NOT leak onto the coincident Minus
+DOFs while the (unsplit) rim reads it from both sides.
+"""
+
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.utilities.fault_split import split_fault
+
+PATCH = np.array([[0.5, 0.30, 0.30], [0.5, 0.70, 0.30],
+                  [0.5, 0.70, 0.70], [0.5, 0.30, 0.70]])
+
+
+@pytest.fixture(scope="module")
+def box_with_patch():
+    return uw.meshing.BoxInternalPatch(cellSize=0.15, patch_points=PATCH,
+                                       patch_name="FltA")
+
+
+@pytest.fixture(scope="module")
+def split_box(box_with_patch):
+    return split_fault(box_with_patch, "FltA")
+
+
+def _counts(dm):
+    return {key: b - a for key, (a, b) in dict(
+        c=dm.getHeightStratum(0), f=dm.getHeightStratum(1),
+        e=dm.getDepthStratum(1), v=dm.getDepthStratum(0)).items()}
+
+
+def _patch_census(dm, name, value):
+    """(faces, interior_edges, interior_verts) of the labelled patch."""
+    fS, fE = dm.getHeightStratum(1)
+    vS, vE = dm.getDepthStratum(0)
+    faces = [int(p) for p in
+             dm.getLabel(name).getStratumIS(int(value)).getIndices()
+             if fS <= int(p) < fE]
+    edge_use, rim_verts, all_verts = {}, set(), set()
+    for f in faces:
+        for e in dm.getCone(f):
+            edge_use[int(e)] = edge_use.get(int(e), 0) + 1
+        all_verts.update(int(p) for p in dm.getTransitiveClosure(f)[0]
+                         if vS <= int(p) < vE)
+    interior_edges = [e for e, n in edge_use.items() if n == 2]
+    for e, n in edge_use.items():
+        if n == 1:
+            rim_verts.update(int(q) for q in dm.getCone(e))
+    return faces, interior_edges, sorted(all_verts - rim_verts)
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_chart_deltas_and_euler(box_with_patch, split_box):
+    dm0, dm1 = box_with_patch.dm, split_box.dm
+    c0, c1 = _counts(dm0), _counts(dm1)
+    value = int(box_with_patch.boundaries["FltA"].value)
+    faces, interior_edges, interior_verts = _patch_census(dm0, "FltA", value)
+
+    assert c1["c"] == c0["c"]
+    assert c1["v"] - c0["v"] == len(interior_verts)
+    assert c1["e"] - c0["e"] == len(interior_edges)
+    assert c1["f"] - c0["f"] == len(faces)
+
+    chi0 = c0["v"] - c0["e"] + c0["f"] - c0["c"]
+    chi1 = c1["v"] - c1["e"] + c1["f"] - c1["c"]
+    # the slit adds the patch interior's characteristic: V_i - E_i + F,
+    # which is 1 for any disc-like patch, independent of resolution
+    assert chi0 == 1 and chi1 == 2
+    assert (chi1 - chi0) == (len(interior_verts) - len(interior_edges)
+                             + len(faces)) == 1
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_conformity_and_sides(split_box):
+    dm = split_box.dm
+    fS, fE = dm.getHeightStratum(1)
+    supports = np.array([dm.getSupportSize(f) for f in range(fS, fE)])
+    assert supports.max() <= 2
+
+    for side in ("FltAPlus", "FltAMinus"):
+        value = int(split_box.boundaries[side].value)
+        assert dm.getLabel(side).getStratumSize(value) > 0
+        pts = dm.getLabel(side).getStratumIS(value).getIndices()
+        assert all(dm.getSupportSize(int(p)) == 1 for p in pts)
+    n_plus = dm.getLabel("FltAPlus").getStratumSize(
+        int(split_box.boundaries["FltAPlus"].value))
+    n_minus = dm.getLabel("FltAMinus").getStratumSize(
+        int(split_box.boundaries["FltAMinus"].value))
+    assert n_plus == n_minus
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_volume_and_coincidence(box_with_patch, split_box):
+    def total_volume(dm):
+        dm.getCoordinatesLocal()
+        cS, cE = dm.getHeightStratum(0)
+        volumes = [dm.computeCellGeometryFVM(c)[0] for c in range(cS, cE)]
+        assert min(volumes) > 0
+        return sum(volumes)
+
+    v0, v1 = total_volume(box_with_patch.dm), total_volume(split_box.dm)
+    assert abs(v1 - v0) < 1e-12 * v0
+
+    vS0, _ = box_with_patch.dm.getDepthStratum(0)
+    vS1, _ = split_box.dm.getDepthStratum(0)
+    X0 = np.asarray(box_with_patch.dm.getCoordinatesLocal().array
+                    ).reshape(-1, 3)
+    X1 = np.asarray(split_box.dm.getCoordinatesLocal().array).reshape(-1, 3)
+    pairs = split_box._fault_point_pairs["FltA"]
+    n_vertex_pairs = 0
+    for q_minus, q_plus in pairs.items():
+        if split_box.dm.getPointDepth(q_minus) == 0:
+            assert (X1[q_minus - vS1] == X1[q_plus - vS1]).all()
+            n_vertex_pairs += 1
+    assert n_vertex_pairs > 0
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_pairing_census(box_with_patch, split_box):
+    value = int(box_with_patch.boundaries["FltA"].value)
+    faces, interior_edges, interior_verts = _patch_census(
+        box_with_patch.dm, "FltA", value)
+    pairs = split_box._fault_point_pairs["FltA"]
+    by_depth = {}
+    for q_minus in pairs:
+        d = split_box.dm.getPointDepth(q_minus)
+        by_depth[d] = by_depth.get(d, 0) + 1
+    # replica vertices + doubled interior edges (P2 midpoints) + doubled
+    # faces; re-homed minus spokes are excluded (their originals dropped)
+    assert by_depth == {0: len(interior_verts), 1: len(interior_edges),
+                        2: len(faces)}
+
+
+@pytest.mark.level_2
+@pytest.mark.tier_b
+def test_dof_independence_p2(split_box):
+    u = uw.discretisation.MeshVariable("u_0848", split_box, 1, degree=2)
+    poisson = uw.systems.Poisson(split_box, u_Field=u)
+    poisson.constitutive_model = uw.constitutive_models.DiffusionModel
+    poisson.constitutive_model.Parameters.diffusivity = 1.0
+    poisson.f = 0.0
+    for wall in ("Bottom", "Top", "Right", "Left", "Front", "Back"):
+        poisson.add_dirichlet_bc(0.0, wall)
+    poisson.add_dirichlet_bc(1.0, "FltAPlus")
+    poisson.solve()
+
+    vals = np.asarray(u.data[:, 0])
+    coords = u.coords
+    sec = split_box.dm.getLocalSection()
+
+    def dof_of(pt):
+        if sec.getFieldDof(pt, u.field_id) == 0:
+            return None
+        return sec.getFieldOffset(pt, u.field_id)
+
+    n_checked = 0
+    for q_minus, q_plus in split_box._fault_point_pairs["FltA"].items():
+        d_minus, d_plus = dof_of(q_minus), dof_of(q_plus)
+        if d_minus is None or d_plus is None:
+            continue
+        assert np.allclose(coords[d_minus], coords[d_plus])
+        assert abs(vals[d_plus] - 1.0) < 1e-9
+        # a shared DOF would read exactly 1.0 on the minus side too
+        assert 0.0 < vals[d_minus] < 1.0 - 1e-9
+        n_checked += 1
+    assert n_checked > 0
+
+    # the rim is UNSPLIT: every datum-side value there reads from both
+    # sides, so the whole-fault label's rim points sit at exactly 1
+    assert vals.min() >= 0.0 and vals.max() <= 1.0 + 1e-12
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_refusals(box_with_patch):
+    from underworld3.utilities.fault_split import split_along_label_3d
+
+    # missing label
+    with pytest.raises(ValueError, match="no faces carry label"):
+        split_along_label_3d(box_with_patch.dm, "NoSuchFault", 1,
+                             "P", 90, "M", 91)
+
+    # double split: the child's patch faces are one-sided boundaries now
+    child = split_fault(box_with_patch, "FltA")
+    with pytest.raises(ValueError):
+        split_fault(child, "FltA")
+
+
+def _stokes_on(split_box, drive, tag):
+    v = uw.discretisation.MeshVariable(f"v_{tag}", split_box, 3, degree=2)
+    p = uw.discretisation.MeshVariable(f"p_{tag}", split_box, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(split_box, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscousFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    stokes.bodyforce = [0.0, 0.0, 0.0]
+    for wall in ("Bottom", "Top", "Right", "Left", "Front", "Back"):
+        stokes.add_dirichlet_bc(drive, wall)
+    stokes.tolerance = 1e-6
+    return stokes
+
+
+def _slip_and_leak(stokes):
+    from underworld3.utilities import fault_contact
+
+    coords, jumps, normals = fault_contact.fault_pair_jumps(
+        stokes, "FltA", stokes._rotated_freeslip_info)
+    leak = np.einsum("ij,ij->i", jumps, normals)
+    slip = np.linalg.norm(jumps - leak[:, None] * normals, axis=1)
+    return coords, slip, leak
+
+
+@pytest.mark.level_2
+@pytest.mark.tier_b
+def test_viscous_family_3d(split_box):
+    """The interface dashpot in 3-D: slip monotone in eta_f, weld limit."""
+    x, y, z = split_box.X
+    shear = (0.0, x - 0.5, 0.0)
+    peaks = []
+    for tag, eta_f in (("vf0", 0.0), ("vf1", 5.0), ("vf2", 500.0)):
+        stokes = _stokes_on(split_box, shear, tag)
+        stokes.add_fault_bc(eta_f, boundary="FltA")
+        stokes.solve(verbose=False)
+        _coords, slip, leak = _slip_and_leak(stokes)
+        assert np.abs(leak).max() < 1e-10
+        peaks.append(slip.max())
+    assert peaks[0] > peaks[1] > peaks[2]
+    assert peaks[2] < 0.05 * peaks[0]          # the weld removes the fault
+
+
+@pytest.mark.level_2
+@pytest.mark.tier_b
+def test_coulomb_slide_stick_3d(split_box):
+    """Coulomb with reaction-fed sigma_n in 3-D: the drive
+    v = (-(x-c), (y-c) + gamma (x-c), 0) carries compression 2 eta onto
+    the patch and resolved shear gamma eta; against strength mu sigma_n
+    the fault slides at gamma = 2 and sticks (creep ~ V0) at 0.4."""
+    from underworld3.utilities import fault_contact
+
+    x, y, z = split_box.X
+    results = {}
+    for tag, gamma in (("cs2", 2.0), ("cs04", 0.4)):
+        drive = (-(x - 0.5), (y - 0.5) + gamma * (x - 0.5), 0.0)
+        stokes = _stokes_on(split_box, drive, tag)
+        fault_contact.add_coulomb_fault_bc(stokes, 0.6, "FltA",
+                                           sigma_n="reaction", V0=1e-3)
+        fault_contact.solve_with_fault(stokes, picard=2)
+        coords, slip, leak = _slip_and_leak(stokes)
+        assert np.abs(leak).max() < 1e-10
+        crds, sig = fault_contact.fault_normal_traction(
+            stokes, "FltA", stokes._rotated_freeslip_info)
+        inner = np.linalg.norm(crds[:, 1:] - 0.5, axis=1) < 0.12
+        # the de-smeared reaction recovers the driven compression
+        assert -3.5 < np.median(sig[inner]) < -1.2
+        results[gamma] = slip.max()
+    assert results[2.0] > 0.05                 # sliding
+    assert results[0.4] < 5e-3                 # stuck at ~V0 creep
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_daylighting_patch_refused():
+    # a patch reaching the wall is refused at mesh construction
+    spanning = np.array([[0.5, -0.1, 0.3], [0.5, 1.1, 0.3],
+                         [0.5, 1.1, 0.7], [0.5, -0.1, 0.7]])
+    with pytest.raises(ValueError, match="strictly inside"):
+        uw.meshing.BoxInternalPatch(cellSize=0.2, patch_points=spanning)
+
+
+@pytest.mark.level_1
+@pytest.mark.tier_b
+def test_fault_surface_route():
+    """The FaultSurface interface end to end: the object names the
+    patch, its rim polygon is the conforming embed, it rides onto the
+    split mesh, and normal="surface" compiles the constraint frame from
+    the surface's OWN face normals (exactly +-y for this planar patch).
+    """
+    xs = np.linspace(0.30, 0.60, 5)
+    zs = np.linspace(0.35, 0.65, 5)
+    XX, ZZ = np.meshgrid(xs, zs)
+    pts = np.column_stack([XX.ravel(), np.full(XX.size, 0.5), ZZ.ravel()])
+    fs = uw.meshing.FaultSurface("Rupture", pts)
+    fs.triangulate()
+
+    rim = fs.rim_polygon()
+    assert len(rim) == 16                       # the 5x5 grid's boundary
+    assert np.allclose(rim[:, 1], 0.5)
+
+    mesh = uw.meshing.BoxInternalPatch(cellSize=0.15, patch_points=fs)
+    assert "Rupture" in [b.name for b in mesh.boundaries]
+    child = split_fault(mesh, "Rupture")
+    assert "Rupture" in child._fault_surfaces
+
+    from underworld3.utilities.fault_contact import _compile_normal_spec
+    fn = _compile_normal_spec("surface", child, "Rupture")
+    n = fn(np.array([0.45, 0.5, 0.5]))
+    assert abs(abs(n[1]) - 1.0) < 1e-12 and abs(n[0]) < 1e-12
+
+    # a non-planar surface refuses the rim extraction, loudly
+    warped = pts.copy()
+    warped[:, 1] += 0.05 * np.sin(6 * warped[:, 0])
+    fs2 = uw.meshing.FaultSurface("Warped", warped)
+    fs2.triangulate()
+    with pytest.raises(NotImplementedError, match="planar"):
+        fs2.rim_polygon()
diff --git a/tests/test_0849_fault_network_prep.py b/tests/test_0849_fault_network_prep.py
new file mode 100644
index 000000000..340a3da4b
--- /dev/null
+++ b/tests/test_0849_fault_network_prep.py
@@ -0,0 +1,111 @@
+"""prepare_fault_network: crossings/abutments become splittable offset
+junctions with the promised Euclidean clearance.
+
+The split-node pipeline refuses shared vertices; imported trace sets
+cross and abut. The preparer's contract: every junction kind (X, T,
+near-miss) is converted, the prepared traces keep at least the ligament
+of Euclidean clearance (pull-backs are angle-corrected — an oblique
+junction pulls back by ligament / sin theta), and the result splits in
+one ``add_fault`` call.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+from underworld3.meshing.surfaces import prepare_fault_network
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+H, LIG_F = 0.02, 1.5
+LIG = LIG_F * H
+
+RAW = [
+    ("A", np.array([[0.2, 0.5], [0.8, 0.5]])),      # through-going
+    ("B", np.array([[0.5, 0.2], [0.5, 0.8]])),      # X crossing, 90 deg
+    ("C", np.array([[0.65, 0.5], [0.85, 0.75]])),   # oblique T abutment
+    ("E", np.array([[0.35, 0.51], [0.30, 0.80]])),  # near-miss abutment
+]
+
+
+def _poly_clearance(P, Q):
+    best = np.inf
+    for a, b in zip(Q[:-1], Q[1:]):
+        ab = b - a
+        t = np.clip(((P - a) @ ab) / (ab @ ab), 0, 1)
+        best = min(best, np.linalg.norm(
+            P - (a + t[:, None] * ab), axis=1).min())
+    return best
+
+
+def test_junctions_become_offset_form_and_split():
+    prepared, report = prepare_fault_network(
+        [(n, p.copy()) for n, p in RAW], spacing=H, ligament=LIG_F,
+        verbose=False)
+
+    kinds = " ".join(report)
+    assert "X crossing" in kinds
+    assert "T abutment" in kinds
+    assert "near-miss" in kinds
+    names = [n for n, _ in prepared]
+    # the X crossing cuts A; the T abutment does NOT (the through-going
+    # trace stays continuous, only the abutter is trimmed)
+    assert sum(n.startswith("A") for n in names) == 2
+    assert sum(n.startswith("B") for n in names) == 2
+
+    # the promised EUCLIDEAN clearance, everywhere (this is the check
+    # that caught the along-trace pull-back being too short at oblique
+    # junctions — the negative control for the angle correction)
+    for i in range(len(prepared)):
+        for j in range(i + 1, len(prepared)):
+            d = min(_poly_clearance(prepared[i][1], prepared[j][1]),
+                    _poly_clearance(prepared[j][1], prepared[i][1]))
+            assert d >= 0.95 * LIG, (
+                f"{names[i]} vs {names[j]}: clearance {d:.4f} < {LIG}")
+
+    # and the whole prepared set is splittable in one call
+    child = uw.meshing.UnstructuredSimplexBox(cellSize=H).add_fault(
+        prepared)
+    assert sorted(child._fault_point_pairs) == sorted(names)
+
+
+def test_through_master_stays_continuous():
+    """A declared master is never cut at an X crossing — the other
+    trace yields on both sides; two crossing masters is a hard error."""
+    A, B = RAW[0], RAW[1]
+    prepared, _rep = prepare_fault_network(
+        [(n, p.copy()) for n, p in (A, B)], spacing=H, ligament=LIG_F,
+        through=["A"], verbose=False)
+    names = [n for n, _ in prepared]
+    assert names.count("A") == 1                 # continuous
+    assert sum(n.startswith("B") for n in names) == 2
+    d = min(_poly_clearance(p, dict(prepared)["A"])
+            for n, p in prepared if n.startswith("B"))
+    assert d >= 0.95 * LIG
+
+    with pytest.raises(ValueError, match="through-going"):
+        prepare_fault_network([(n, p.copy()) for n, p in (A, B)],
+                              spacing=H, ligament=LIG_F,
+                              through=["A", "B"], verbose=False)
+
+
+def test_disjoint_traces_pass_through_unchanged():
+    faults = [("P", np.array([[0.2, 0.3], [0.6, 0.3]])),
+              ("Q", np.array([[0.2, 0.7], [0.6, 0.7]]))]
+    prepared, report = prepare_fault_network(
+        faults, spacing=H, ligament=LIG_F, verbose=False)
+    assert report == []
+    assert [n for n, _ in prepared] == ["P", "Q"]
+    for (n0, p0), (_n1, p1) in zip(faults, prepared):
+        assert np.array_equal(p0, p1)
+
+
+def test_touching_junction_refused_with_the_real_reason():
+    """Three chains terminating at ONE shared vertex: the second split
+    lands its tip on the first fault's slit. The refusal must name the
+    touching junction (and its physics), not 'the domain boundary'."""
+    J = np.array([0.50, 0.50])
+    faults = [("West", np.array([[0.15, 0.45], J])),
+              ("East", np.array([J, [0.85, 0.55]])),
+              ("Splay", np.array([J, [0.80, 0.76]]))]
+    with pytest.raises(ValueError, match="touching junction"):
+        uw.meshing.UnstructuredSimplexBox(cellSize=0.04).add_fault(faults)
diff --git a/tests/test_1067_newton_cold_start.py b/tests/test_1067_newton_cold_start.py
new file mode 100644
index 000000000..3d9165dd0
--- /dev/null
+++ b/tests/test_1067_newton_cold_start.py
@@ -0,0 +1,55 @@
+"""The consistent tangent must be finite at a state of rest.
+
+The regression (measured, issue #507): differentiating an unwrapped
+strain-rate invariant produces half-integer powers of
+(grad v : grad v) whose value or derivative is 0/0 at v = 0, so EVERY
+consistent-tangent assembly at a cold start filled the operator with
+NaN — surfacing as GAMG's "Computed maximum singular value as zero"
+(error 77) on the standard path, the rotated free-slip path, and the
+split-node fault path alike. The alpha-blended continuation kernel
+inherited it even in its Picard phase (IEEE 0*NaN = NaN). The guard in
+``_jacobian_unwrap`` regularises exactly the half-integer-power family
+(+1e-36 under the root), leaving the residual and the default Picard
+tangent bit-identical.
+"""
+import numpy as np
+import pytest
+
+import underworld3 as uw
+
+pytestmark = [pytest.mark.level_1, pytest.mark.tier_b]
+
+
+def _vp_box(tag, tangent):
+    mesh = uw.meshing.UnstructuredSimplexBox(cellSize=0.1)
+    x, y = mesh.X
+    v = uw.discretisation.MeshVariable(f"V{tag}", mesh, 2, degree=2)
+    p = uw.discretisation.MeshVariable(f"P{tag}", mesh, 1, degree=0,
+                                       continuous=False)
+    stokes = uw.systems.Stokes(mesh, velocityField=v, pressureField=p)
+    stokes.constitutive_model = uw.constitutive_models.ViscoPlasticFlowModel
+    stokes.constitutive_model.Parameters.shear_viscosity_0 = 1.0
+    # 1e4 never yields: the problem is secretly linear, which is exactly
+    # the corner the yield-homotopy campaigns never visited
+    stokes.constitutive_model.Parameters.yield_stress = 1.0e4
+    stokes.consistent_jacobian = tangent
+    stokes.bodyforce = [0.0, 0.0]
+    for wall in ("Left", "Right", "Top", "Bottom"):
+        stokes.add_dirichlet_bc((y - 0.5, 0.0), wall)
+    stokes.petsc_use_pressure_nullspace = True
+    stokes.tolerance = 1e-6
+    return stokes
+
+
+@pytest.mark.parametrize("tangent", [True, "continuation"])
+def test_cold_consistent_tangent_is_finite_and_solves(tangent):
+    stokes = _vp_box("a" if tangent is True else "b", tangent)
+    stokes.solve(verbose=False)          # cold start — used to raise 77
+
+    # and the assembled Jacobian at the rest state is finite
+    snes = stokes.snes
+    J = snes.getJacobian()[0].copy()
+    U = stokes.dm.getGlobalVec()
+    U.set(0.0)
+    snes.computeJacobian(U, J)
+    assert np.isfinite(J.norm()), "cold-state Jacobian contains NaN/Inf"