Model-focused card; release scope: EN-GJS-400-15 + G20Mn5, green sand; mesh-in API

README.md

@@ -17,7 +17,6 @@ tags:
   - metal-casting
   - foundry
   - solidification
-  - shrinkage
   - finite-element
   - fenicsx
   - pytorch-geometric
@@ -26,22 +25,19 @@ tags:
 
 # Casting solidification GNN (v5.1)
 
-This is a graph neural network surrogate for screening how metal castings solidify. You give it
-a STEP model, an alloy and a mold condition. The pipeline meshes the part, predicts the
-solidification time at every mesh node and marks the regions that freeze last. Those hot spots
-are where feeding problems and shrinkage defects usually start.
+A surrogate model for the solidification of metal castings in a sand mold. It takes a
+tetrahedral mesh of a casting together with the alloy and mold properties, and predicts the
+time at which every mesh node solidifies. The nodes that solidify last are the hot spots, where
+feeding problems and shrinkage defects usually start.
 
-A transient finite-element solve of the same field takes minutes to hours. Once the part is
-meshed, this model returns the field in seconds, which makes it useful early in design: you can
-compare concepts, see where the hot regions are, and decide which variants are worth a full
-simulation.
-
-It does not replace a calibrated process simulation or physical validation. A hot spot marks
-feeding difficulty and shrinkage risk. It is not a porosity label.
+A transient finite-element solve of the same field takes minutes to hours. The model returns it
+in seconds, which makes it useful for screening design variants before a full simulation. It
+does not replace a calibrated process simulation or physical validation, and a hot spot is a
+shrinkage-risk indicator, not a porosity label.
 
 <p align="center">
   <img src="assets/solidification.gif" alt="Predicted solidification playback" width="720"><br>
-  <em>Predicted solidification playback. Solidified material turns translucent while the
+  <em>A predicted field played back over time. Solidified material turns translucent while the
   remaining liquid contracts toward the hot spot.</em>
 </p>
 
@@ -49,262 +45,190 @@ feeding difficulty and shrinkage risk. It is not a porosity label.
 |---|---|
 | Version | v5.1, frozen on 31 July 2026 |
 | Task | Per-node regression on a tetrahedral mesh (graph ML) |
-| Inputs | STEP geometry in mm, alloy grade, mold system, optional chill and sleeve body roles |
-| Outputs | Solidification time per node, total time, top-10% hot-spot mask, out-of-distribution warnings, shrinkage screening fields |
-| Architecture | 12-block MeshGraphNet-style GNN with FiLM conditioning, plus two gradient-boosted heads |
-| Training data | FEniCSx enthalpy-method conduction simulations: about 9.7k primitive cases, 4.7k multi-alloy and multi-BC cases, 500 real-part cases |
-| Framework | PyTorch 2.3, PyTorch Geometric 2.7, scikit-learn 1.5.2, NumPy 2 |
+| Input | Tetrahedral mesh in mm (gmsh 2.2 format) with the cooling surface tagged; alloy `EN-GJS-400-15` or `G20Mn5`, or a custom property set; green-sand mold |
+| Output | Solidification time in seconds for every mesh node |
+| Architecture | 12-block MeshGraphNet-style GNN with FiLM conditioning, combined with two gradient-boosted heads |
+| Parameters | about 1.85 M (GNN) plus two `HistGradientBoostingRegressor` heads |
+| Training data | FEniCSx enthalpy-method conduction simulations: about 9.7k primitive cases, 4.7k multi-alloy cases, 500 real-part cases |
 | License | Apache-2.0 for code and weights |
-| Code | Included in this repository. Showcase on [GitHub](https://github.com/eugenmik/castsolid-gnn) |
+| Pipeline | STEP import, meshing and result export are documented on [GitHub](https://github.com/eugenmik/castsolid-gnn) |
 | Author | Eugen Miknevic, independent foundry engineer |
 
 ## Contents
 
-- [What is in this repository](#what-is-in-this-repository)
-- [Quick start](#quick-start)
-- [How the predictor works](#how-the-predictor-works)
+- [Input and output](#input-and-output)
+- [How to use](#how-to-use)
+- [Model architecture](#model-architecture)
+- [Files](#files)
 - [Training data](#training-data)
 - [Training procedure](#training-procedure)
 - [Evaluation](#evaluation)
 - [Intended use and limitations](#intended-use-and-limitations)
-- [The node-order bug](#the-node-order-bug)
 - [Reproducibility](#reproducibility)
 - [License and citation](#license-and-citation)
 
-## What is in this repository
+## Input and output
 
-The predictor combines three trained models. Use them together; none of them is meant to run
-alone.
+The model reads one casting at a time.
 
-| File | Size | Role |
-|---|---:|---|
-| `weights/gnn_v5.1.safetensors` | 7.4 MB | GNN weights, feature and target normalization, and the architecture config (stored in the safetensors metadata). Predicts the shape of the field |
-| `weights/gbm_total_v3.skops` | 0.6 MB | `HistGradientBoostingRegressor` on 16 features. Predicts the total solidification time of the part, which sets the absolute scale |
-| `weights/gbm_std_v2.skops` | 0.8 MB | `HistGradientBoostingRegressor` with absolute-error loss on 17 features. Predicts the spread (standard deviation) of the field |
-| `weights/ood_ranges.json` | <1 KB | Training envelope used by the geometry out-of-distribution check |
-| `weights/SHA256SUMS` | <1 KB | Checksums of the files above |
-| `src/` | | The full pipeline: CAD healing and meshing, features, GNN, recomposition, shrinkage screening, VTU export, training scripts and a local web viewer |
-| `tools/` | | Density-targeted STEP meshing, the property loader, the sleeve registry and the scripts that recover solver-to-mesh node order |
-| `data/properties/` | | Material, mold, chill and exothermic-sleeve tables read at inference |
-| `tests/` | | Deterministic unit tests that need neither weights nor simulation data |
+**Mesh.** A tetrahedral volume mesh in millimetres, in gmsh 2.2 ASCII format (`.msh`). Surface
+triangles that cool into the mold belong to a physical group named `Cooling`; in this release
+that is the whole outer surface. The model was trained on meshes of roughly 7,500 to 10,000
+nodes, and that is the density it should be given. It does not use node numbering or absolute
+coordinates: node inputs are distances, flags and volume-type quantities in millimetres, and
+edges carry only relative displacements between neighbouring nodes.
 
-None of the weight files can execute code when loaded. The GNN is stored as
-[safetensors](https://github.com/huggingface/safetensors) and the gradient-boosted heads as
-[skops](https://skops.readthedocs.io/). Before loading a skops file, `src/release_io.py` checks
-every type it names against an allowlist of scikit-learn and NumPy types. All three files were
-converted from the internal PyTorch and joblib pickles and checked against them (see
-[Reproducibility](#reproducibility)).
+**Alloy and mold.** Eight numbers describe the material and the mold: thermal conductivity,
+density, specific heat, latent heat, liquidus, solidus, pouring temperature and mold effusivity.
+Two alloys are tabulated in `data/properties/`, `EN-GJS-400-15` (ductile iron, the default) and
+`G20Mn5` (cast steel), together with one mold, green sand. You can also pass your own eight
+values.
 
-## Quick start
+**Output.** One number per node: the time in seconds at which that node cools through the
+solidus. The maximum over all nodes is the total solidification time, and the 10% of nodes with
+the largest times are the hot spots.
 
-### 1. Install
-
-Python 3.11 is recommended. Install PyTorch 2.3 for your hardware first (CPU works for
-inference), then the matching `torch-cluster` wheel, then the rest:
+## How to use
 
 ```bash
 hf download eugenmik/castsolid-gnn --local-dir castsolid-gnn
 cd castsolid-gnn
-
 python -m venv .venv && source .venv/bin/activate
 pip install "torch==2.3.0" --index-url https://download.pytorch.org/whl/cpu
 pip install torch-cluster -f https://data.pyg.org/whl/torch-2.3.0+cpu.html
 pip install -r requirements.txt
-pytest -q          # optional, no GPU needed
-```
-
-For a CUDA build, replace `cpu` with your CUDA tag (for example `cu121`) in both URLs.
-The `gmsh` Python wheel handles CAD healing and tetrahedral meshing. `pyvista` and `trame` are
-only needed for the browser viewer.
-
-### 2. Predict from the command line
-
-Run this from the repository root. The weight paths resolve on their own.
-
-```bash
-python -m src.predict_casting path/to/part.step --out-dir out \
-    --alloy EN-GJS-500-7 --mold green_sand
 ```
 
-It writes three files:
-
-- `out/<name>.vtu` is the tetrahedral mesh with point fields `solidification_time` (s),
-  `hotspot` (the 10% of nodes that solidify last), `niyama`, `porosity_risk` and
-  `macro_region_id`. Open it in ParaView.
-- `out/<name>_summary.txt` holds the total time, the coordinates of the five latest nodes, any
-  OOD warnings and the shrinkage screening summary.
-- `out/<name>.msh` is the mesh the prediction actually used.
-
-Meshing runs through the same pipeline that prepared the training parts: keep the largest
-solid, heal it with OpenCASCADE, then search the element size until the mesh has about 8,500
-nodes. A second run on the same STEP file reuses the cached mesh.
-
-### 3. Predict from Python
+Python 3.11 is recommended. For a GPU, replace `cpu` with your CUDA tag (for example `cu121`)
+in both URLs. Then, from the repository root:
 
 ```python
-from src.predict_casting import predict_casting
-from src.inference_props import list_alloys, list_molds
-
-print(list_alloys())   # 12 named grades: EN-GJL-200/250/300, EN-GJS-400-15/500-7/600-3/700-2,
-                       # GS-38, GS-45, GS-52, G20Mn5, G17CrMo5-5
-print(list_molds())    # ['green_sand', 'no_bake_furan_HTS']
-
-r = predict_casting("part.step", out_dir="out", alloy="EN-GJS-500-7", mold="green_sand")
-r["total_time_s"]      # predicted total solidification time, s
-r["hotspot_xyz"]       # (5, 3) mm coordinates of the latest-solidifying nodes
-r["ood_warnings"]      # an empty list means the part is inside the training envelope
-r["shrinkage"]         # Niyama and macro-shrinkage screening, with a confidence label
-```
+from src.model_api import CastSolidModel
 
-To use an alloy that is not in the table, pass a JSON file with exactly these keys (SI units,
-temperatures in °C):
+model = CastSolidModel()                         # loads the three weight files once
+t = model.predict("part.msh")                    # EN-GJS-400-15 in green sand
+t_steel = model.predict("part.msh", alloy="G20Mn5")
 
-```json
-{"k": 41.5, "rho": 7150.0, "cp": 535.0, "L_kJ_kg": 240.0,
- "TL": 1220.0, "TS": 1150.0, "Tpour": 1320.0, "mold_effusivity": 1018.0}
+t.max()                                          # total solidification time, s
+hot = CastSolidModel.hotspots(t)                 # boolean mask, top 10% of nodes
 ```
 
-```bash
-python -m src.predict_casting part.step --props my_alloy.json
-```
-
-### 4. Assemblies with chills or a feeder sleeve
-
-By default the whole outer surface cools into a sand mold. For a multi-body STEP you can say
-which solid is the casting and which ones are chills or a sleeve:
-
-```bash
-python -m src.assembly part.step                 # lists solids with id, volume, bounding box
-python -m src.predict_casting part.step --bodies bodies.json
-```
+`predict` returns a NumPy array in the node order of the `.msh` file. To use another alloy,
+pass `props_json="my_alloy.json"` with exactly these keys (SI units, temperatures in °C;
+1018 is the green-sand effusivity):
 
 ```json
-[{"solid_id": 1, "role": "casting"},
- {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}},
- {"solid_id": 3, "role": "chill", "params": {"material": "cast_iron"}}]
-```
-
-The roles are `casting`, `chill`, `insulating_sleeve`, `exo_sleeve` and `ignore`. Every
-training case had chills only, one sleeve only, or neither, so the code rejects any other
-combination instead of guessing. A sleeve is either named from
-`tools/sleeves/sleeve_registry.csv` (`{"sleeve": "FOSECO_P12_15K"}`) or given a manual modulus
-extension factor (`{"MEF": 1.55}`). Only `cast_iron` chills appear in the training data.
-
-### 5. Browser viewer (optional)
-
-```bash
-python -m src.webapp          # http://localhost:8080
+{"k": 32.9, "rho": 6800.0, "cp": 515.0, "L_kJ_kg": 220.0,
+ "TL": 1160.0, "TS": 1120.0, "Tpour": 1260.0, "mold_effusivity": 1018.0}
 ```
 
-This is a local trame and PyVista app. You upload a STEP file and run the prediction, then move
-a time slider (solidified material turns translucent), toggle the hot spots, or export a
-solidification GIF from the current camera angle.
+If you start from a STEP file, the
+[GitHub repository](https://github.com/eugenmik/castsolid-gnn) has the pipeline that heals the
+CAD, builds a mesh at the right density, runs this model and writes the result for ParaView.
+The same code is included here, so `python -m src.predict_casting part.step` works in this
+repository too.
 
-### Runtime
+## Model architecture
 
-The GNN itself runs in seconds on a CPU or GPU. CAD healing and meshing take most of the time,
-from seconds to a few minutes for typical parts. Very large or very detailed STEP files, with
-thousands of small faces, can run past the meshing time limit.
-
-## How the predictor works
+The model is a hybrid of three trained parts. The GNN predicts the spatial shape of the field;
+two gradient-boosted heads predict its overall level and its spread; a fixed recomposition step
+combines them. The GNN alone is less reliable about absolute magnitude, which depends strongly
+on alloy and part size. On the original benchmark of held-out geometry families, adding the
+heads brought nodal MAE down from 5.77 s to 4.26 s.
 
 ```mermaid
 flowchart LR
-  A[STEP + alloy + mold<br/>+ optional body roles] --> B[CAD healing +<br/>tetrahedral mesh]
-  B --> C[15 node features<br/>+ 5-value alloy/BC vector]
-  C --> D1[12-block GNN<br/>field shape]
-  C --> D2[GBM total head<br/>absolute scale]
-  C --> D3[GBM spread head<br/>field contrast]
-  D1 --> E[Soft-anchor<br/>recomposition]
-  D2 --> E
-  D3 --> E
-  E --> F[Time field + hot spots<br/>+ OOD + shrinkage screening]
-  F --> G[VTU / browser viewer]
+  M[Tetrahedral mesh] --> F[15 node features<br/>+ union graph]
+  P[Alloy + mold<br/>properties] --> G[5-value conditioning vector]
+  P --> D
+  F --> N[12-block GNN<br/>field shape]
+  G --> N
+  F --> D[Part descriptors]
+  D --> T[GBM total head]
+  D --> S[GBM spread head]
+  N --> R[Soft-anchor<br/>recomposition]
+  T --> R
+  S --> R
+  R --> O[Time per node, s]
 ```
 
-### Why three models
-
-The GNN gets the spatial pattern of solidification right more reliably than its absolute size.
-The size depends heavily on alloy, mold and part dimensions, and two small gradient-boosted
-models estimate it better from a handful of global descriptors. On the original benchmark with
-held-out geometry families, the hybrid brought nodal MAE down from 5.77 s (GNN alone) to
-4.26 s.
-
 ### Graph network
 
 Nodes are mesh vertices. Edges are the union of the tetrahedral mesh edges and the 16 nearest
 neighbours of each node. Each edge carries its displacement vector, its length and a flag that
-says whether it is a mesh edge, so the model sees geometry in millimetres but never absolute
-coordinates.
-
-Each node has 15 features. All of them come from the mesh and its boundary labels; file names
-and part identity are never used.
-
-- Geodesic distance through the mesh to the nearest cooling surface and to the nearest
-  adiabatic surface, plus straight-line distance to the surface and to adiabatic faces.
-- Cooling, adiabatic and interior flags.
-- Part volume, surface area and the fraction of surface that cools.
-- Local modulus: the volume-to-surface ratio inside geodesic balls of 5, 15 and 40 mm. This is
-  a local version of Chvorinov's modulus.
-- Two boundary-condition channels. `boundary_extraction` encodes heat drawn out by chills.
-  `exothermic_input` encodes heat from an exothermic sleeve, spread along the mesh with a
-  15 mm decay length.
-
-A vector `g` of five dimensionless numbers describes the alloy and the mold: Stefan number,
-normalized freezing range, thermal diffusivity ratio, normalized superheat and normalized mold
-effusivity. It conditions every processor block through FiLM (`h ← h·(1+γ(g)) + β(g)`).
+says whether it is a mesh edge.
+
+Each node gets 15 features computed from the mesh and its surface tags:
+
+- geodesic distance through the mesh to the nearest cooling surface and to the nearest
+  adiabatic surface, plus straight-line distance to the surface and to adiabatic faces;
+- cooling, adiabatic and interior flags;
+- part volume, surface area and the fraction of surface that cools;
+- local modulus, the volume-to-surface ratio inside geodesic balls of 5, 15 and 40 mm, which is
+  a local version of Chvorinov's modulus;
+- two boundary-condition channels from training, which are zero in this release because the
+  whole surface cools into the mold.
+
+The alloy and mold enter as five dimensionless numbers: Stefan number, normalized freezing
+range, thermal diffusivity ratio, normalized superheat and normalized mold effusivity. They
+condition every processor block through FiLM (`h ← h·(1+γ(g)) + β(g)`).
 
 The network follows the encode-process-decode design of
 [MeshGraphNets](https://arxiv.org/abs/2010.03409). MLP encoders embed nodes and edges, 12
 message-passing blocks (hidden width 128, residual connections, LayerNorm, mean aggregation)
 process them, and a two-head decoder predicts the per-node deviation and a graph-level scale
-separately. The model has about 1.85 M parameters. Its target is the standardized `log1p` of the
-time (s) at which each node cools through the solidus.
+separately. The training target is the standardized `log1p` of the solidification time.
 
 ### Gradient-boosted heads
 
-Both heads are scikit-learn `HistGradientBoostingRegressor` models. They see one row per part:
-alloy properties (k, ρ, cp, latent heat, liquidus, solidus, pouring temperature), the part's
-volume-to-area ratio, mold effusivity, a one-hot boundary regime (none, chills, insulating
-sleeve or exothermic sleeve), the number of chills, the sleeve MEF and the exothermic heat flux.
-The spread head also gets the fraction of boundary area covered by chills or a sleeve. The total
-head predicts `log1p` of the total solidification time; the spread head predicts `log1p` of the
-standard deviation of the nodal field and is trained with absolute-error loss.
+Both heads are scikit-learn `HistGradientBoostingRegressor` models with one row per part: the
+alloy properties, the part's volume-to-area ratio, the mold effusivity, and boundary-condition
+descriptors that are fixed to the plain sand mold in this release. The total head (16 inputs)
+predicts `log1p` of the total solidification time. The spread head (17 inputs, absolute-error
+loss) predicts `log1p` of the standard deviation of the nodal field.
 
 ### Soft-anchor recomposition
 
-The GNN field is scaled, shifted and clipped at zero:
+The GNN field is scaled, shifted and clipped at zero,
 
 ```
 pred(a, m) = max(0, a · (gnn − mean(gnn)) + m)
 ```
 
-The pair `(a, m)` minimizes
+with `(a, m)` chosen to minimize
 
 ```
 J = w_total · ((q99.5(pred) − T_total) / T_total)²  +  w_std · ((std(pred) − S) / S)²
 ```
 
 where `T_total` and `S` come from the two heads, `w_total = 1` and `w_std = 4`. When both
-targets can be met exactly, the result equals the closed-form affine solve. When clipping makes
-that impossible, the total anchor is allowed to move by a few percent so the spread stays close.
-The post-clip spread is not monotone in `a`, so the solver brackets the smallest root
-explicitly. The code is in `src/hybrid.py::hybrid_field_soft`.
+targets can be met exactly, this equals the closed-form affine solve. When clipping makes that
+impossible, the total anchor may move by a few percent so the spread stays close. The post-clip
+spread is not monotone in `a`, so the solver brackets the smallest root explicitly.
 
-### Shrinkage screening
+## Files
 
-`src/shrinkage.py` post-processes the predicted field. It computes a time-based Niyama proxy,
-finds macro-shrinkage regions (hot regions that liquid can no longer reach to feed them), places
-gravity-aware sinks and suggests feeder moduli. It is deterministic and adds about half a second
-per part. On parts with chills the Niyama result carries `niyama_confidence: "low"`, because a
-proxy built only from time cannot see the extra heat a chill pulls out locally. Pass
-`--no-shrinkage` to skip it.
+| File | Size | Content |
+|---|---:|---|
+| `weights/gnn_v5.1.safetensors` | 7.4 MB | GNN weights, feature and target normalization, and the architecture config (in the safetensors metadata) |
+| `weights/gbm_total_v3.skops` | 0.6 MB | Total-time head |
+| `weights/gbm_std_v2.skops` | 0.8 MB | Spread head |
+| `weights/ood_ranges.json` | <1 KB | Training envelope (part volume, size, distance to cooling) for out-of-distribution warnings |
+| `weights/SHA256SUMS` | <1 KB | Checksums |
+| `src/model_api.py` | | `CastSolidModel`, the mesh-in, field-out interface shown above |
+| `data/properties/` | | Alloy and mold tables ([README](data/properties/README.md)) |
+
+None of the weight files can execute code when loaded. The GNN is stored as
+[safetensors](https://github.com/huggingface/safetensors) and the heads as
+[skops](https://skops.readthedocs.io/); before loading a skops file, `src/release_io.py` checks
+every type it names against an allowlist of scikit-learn and NumPy types. The rest of `src/`,
+`tools/` and `tests/` is the supporting code, described on GitHub.
 
 ## Training data
 
 Every reference field was computed with [FEniCSx](https://fenicsproject.org/) (dolfinx) using an
-enthalpy-method model of transient heat conduction with latent heat. The model has no mold
-filling, flow, gas or stress.
+enthalpy-method model of transient heat conduction with latent heat. There is no mold filling,
+flow, gas or stress in it.
 
 <p align="center">
   <img src="assets/3dforms.png" alt="Examples of primitive training geometries" width="640"><br>
@@ -314,8 +238,8 @@ filling, flow, gas or stress.
 | Set | Cases | Content |
 |---|---:|---|
 | Primitives (original regime) | 9,710 | 42 parametric geometry families, a single alloy, sand mold, different assignments of cooling and adiabatic faces |
-| Multi-alloy and multi-BC (v4) | 4,727 | Realistic thick-walled castings in 12 named iron and steel grades plus sampled synthetic alloys. Boundary regimes: sand only, chills, insulating sleeves, exothermic sleeves |
-| Real-part assemblies (E) | 500 | Prepared production geometries with virtual chill and sleeve contact patches |
+| Multi-alloy (v4) | 4,727 | Realistic thick-walled castings in 12 named iron and steel grades plus sampled synthetic alloys, under several boundary-condition regimes |
+| Real parts (E) | 500 | Prepared production geometries with varied boundary conditions |
 
 <p align="center">
   <img src="assets/mesh.png" alt="Tetrahedral training mesh with tagged boundary groups" width="640"><br>
@@ -323,11 +247,9 @@ filling, flow, gas or stress.
   Adiabatic.</em>
 </p>
 
-The meshes are gmsh tetrahedral meshes with roughly 7,500 to 10,000 nodes. The target at each
-node is the time its temperature drops through the solidus. Material properties come from
-handbook data, and the subset used at inference is in `data/properties/`. The exothermic sleeve
-heat input is calibrated so that the modulus extension falls in vendor-published ranges. The
-raw simulation corpus (about 100 GB) is not distributed.
+Training meshes have roughly 7,500 to 10,000 nodes. The target at each node is the time its
+temperature drops through the solidus. Material properties come from handbook data. The raw
+simulation corpus (about 100 GB) is not distributed.
 
 ## Training procedure
 
@@ -335,19 +257,18 @@ v5.1 came out of a chain of fine-tunes, not a single training run.
 
 1. SP1 trained a 12-block two-head GNN from scratch on the primitive set, with the union graph,
    local-modulus features and a loss on both nodal and total time.
-2. FT2b fine-tuned it on the multi-alloy, multi-BC set. The FiLM layers started at zero, so
-   training began from exactly the SP1 function.
-3. Exo-fix re-encoded the exothermic channel. As a sparse indicator with +19σ spikes it had
-   been suppressed by the network; as a geodesic-diffused field it is used. Exothermic cases were
-   oversampled three times, and the checkpoint was picked on gate metrics instead of validation
-   loss alone.
-4. FT3 fine-tuned on the real-part assemblies (set E) with the normalization statistics frozen.
-   Its epoch-21 checkpoint is the v5.1 GNN.
-5. The BC-aware total head (v3), the absolute-error spread head (v2) and the soft anchor were
+2. FT2b fine-tuned it on the multi-alloy set. The FiLM layers started at zero, so training began
+   from exactly the SP1 function.
+3. A follow-up pass re-encoded one sparse boundary input as a field diffused along the mesh,
+   because the network had learned to suppress it, and picked the checkpoint on gate metrics
+   instead of validation loss alone.
+4. FT3 fine-tuned on real production geometries (set E) with the normalization statistics
+   frozen. Its epoch-21 checkpoint is the v5.1 GNN.
+5. The total head (v3), the absolute-error spread head (v2) and the recomposition weights were
    selected on held-out real-part validation rows.
 
 Training ran on one RTX 3060 (12 GB) with batch size 2, at 15 to 20 minutes per epoch. To be
-promoted, v5.1 had to pass four gates on held-out data: two gold-standard real assemblies, 24
+promoted, v5.1 had to pass four gates on held-out data: two gold-standard real parts, 24
 held-out real parts, an extrapolation split and a check against collapsed field variance.
 
 ## Evaluation
@@ -359,14 +280,12 @@ on real geometry they run to hundreds or thousands.
 |---|---:|---:|---:|---|
 | Held-out primitive geometry families | family split | 4.26 s | 0.917 | Generalization to unseen synthetic shape families in the original regime |
 | Unseen real single-body castings | 6 | 80.3 s median | 0.738 median | Generalization to new real geometry, scored against a FEniCSx reference on the same mesh |
-| Unseen real sleeve assemblies | 2 | 443.7 s median | 0.932 median | The hot regions rank well, but the field is too smooth (predicted spread is about 0.23 of the reference) and the absolute times are off |
 
 Hot-spot overlap compares the 10% of nodes that solidify last in the prediction with the same
 set in the reference. 1.0 means the two sets are identical.
 
-The real-geometry study started from 10 production CAD models. Two had self-intersecting
-B-reps and could not be meshed, which left eight scored parts. One single-body part reached a
-hot-spot overlap of only 0.035, so the median says nothing certain about any one part.
+One of the six real parts reached a hot-spot overlap of only 0.035, so the median says nothing
+certain about any one part.
 
 > **Important.** The training data and the real-geometry references come from the same FEniCSx
 > heat-transfer model, the same material database and the same boundary assumptions. These
@@ -377,7 +296,7 @@ hot-spot overlap of only 0.035, so the median says nothing certain about any one
 
 Good uses:
 
-- comparing early casting concepts and gating or feeding variants;
+- comparing early casting concepts;
 - finding candidate last-to-solidify regions;
 - deciding which designs need a full process simulation;
 - early quoting and design discussions, as long as the limitations stay visible.
@@ -392,41 +311,23 @@ Out of scope:
 
 Known limitations:
 
-1. The physics is pure conduction with latent heat, and the reference solver shares the
-   surrogate's property and boundary assumptions.
-2. STEP files must be in millimetres; units are not detected. STL is not supported, because
-   healing and face tagging need a B-rep.
-3. Invalid or very detailed B-reps can fail to mesh or run past the meshing time limit.
-4. The default density of about 8,500 nodes can under-resolve large thin-walled parts.
-5. On assemblies the predicted field is over-smoothed, even when the hot regions are ranked
-   well.
-6. The OOD check only covers part size and distance to cooling. It is not a calibrated
-   uncertainty estimate.
-7. The two mold systems currently share the same interim thermal properties, so choosing one
-   over the other does not change the prediction.
-8. The Niyama proxy has low confidence on parts with chills and is flagged that way.
-
-Treat each result as a screening hypothesis: where should an engineer look first, and is the
-concept ready for a full simulation? Keep the mesh, the inputs, the model version and the
-warnings together with every result. OOD, low-confidence and high-consequence cases belong in a
-calibrated simulation and a physical review.
-
-## The node-order bug
-
-The worst defect in this project was outside the neural network. The solver stored
-temperatures in dolfinx degree-of-freedom order, while coordinates and geometric features were
-in gmsh node order. About 60% of the nodal targets ended up attached to the wrong positions,
-silently, and every early model failure traced back to that.
-
-`tools/recovery/` rebuilds the permutation between the two orderings, and
-`src/build_dataset.py` applies it when it builds the graphs. If you work on simulation-to-ML
-pipelines, check node identity across every solver and mesh interface before you start tuning a
-model.
+1. The physics is pure conduction with latent heat, and the reference solver shares the model's
+   property and boundary assumptions.
+2. This release covers one setup: a single casting whose whole outer surface cools into a
+   green-sand mold, in `EN-GJS-400-15`, `G20Mn5` or a custom property set.
+3. Meshes much coarser or finer than the training density (about 7,500 to 10,000 nodes) are
+   outside what the model has seen. At that density, large thin-walled parts can be
+   under-resolved.
+4. The training envelope in `weights/ood_ranges.json` only covers part size and distance to
+   cooling. It is not a calibrated uncertainty estimate.
+
+Treat each prediction as a screening hypothesis: where should an engineer look first, and is
+the concept ready for a full simulation? Keep the mesh, the inputs and the model version with
+every result, and send high-consequence cases to a calibrated simulation and a physical review.
 
 ## Reproducibility
 
-`tools/export_release.py` converted the internal checkpoints with the functions in
-`src/release_io.py`:
+The published files were converted from the internal checkpoints by `tools/export_release.py`:
 
 | Release file | Internal artifact | Check |
 |---|---|---|
@@ -434,19 +335,15 @@ model.
 | `gbm_total_v3.skops` | `hgb_v3.joblib` | Identical predictions on 10,002 probe rows spanning each feature's training split range |
 | `gbm_std_v2.skops` | `hgb_std_v2.joblib` | Identical predictions on 10,002 probe rows spanning each feature's training split range |
 
-On a real test part, the release files and the internal pickles give the same predicted field.
-The training scripts are in `src/` (`train_gnn.py`, `train_ft2b.py`, `gbm_ft2b.py`), but the
-simulation corpus is not part of this release.
-
-Software used: Python 3.11, PyTorch 2.3.0, PyTorch Geometric 2.7.0, scikit-learn 1.5.2, NumPy 2.x,
-gmsh 4.13 or newer and SciPy. The gradient-boosted heads were trained with scikit-learn 1.5.2,
-and other versions may refuse to load them or load them with changed behaviour.
+On a real test mesh, the published files and the internal checkpoints give the same field. The
+heads were trained with scikit-learn 1.5.2, and other versions may refuse to load them or change
+their output. Other versions used: Python 3.11, PyTorch 2.3.0, PyTorch Geometric 2.7.0,
+NumPy 2.x.
 
 ## License and citation
 
 Code and weights are released under the [Apache License 2.0](LICENSE). The tables in
-`data/properties/` are modelling inputs, not certified material specifications. Check them
-against your actual alloy and process.
+`data/properties/` are modelling inputs, not certified material specifications.
 
 ```bibtex
 @software{miknevic_casting_gnn_2026,

data/properties/README.md

@@ -1,13 +1,25 @@
-# Public runtime property tables
+# Property tables
 
-These compact CSV files contain the numeric rows required by the public inference and unit-test
-code. They are a curated runtime subset of the project's larger property record.
+These two CSV files hold the material and mold rows that inference reads.
 
-- `materials.csv`: 12 named iron and steel grades.
-- `molds.csv`: two UI labels currently sharing the same interim thermal properties.
-- `chills.csv`: example chill materials; incomplete rows are skipped by the loader.
-- `exo_calibration.csv`: the MEF-to-heat-flux calibration used by the example sleeve path.
+- `materials.csv` has two grades: `EN-GJS-400-15` (ductile iron, the default) and `G20Mn5`
+  (cast steel). Columns: thermal conductivity `k_W_mK`, density `rho_kg_m3`, specific heat
+  `cp_J_kgK`, latent heat `L_kJ_kg`, liquidus `TL_C`, solidus `TS_C` and the pouring
+  temperature range `Tpour_lo_C`/`Tpour_hi_C`. The prediction uses the midpoint of that range.
+- `molds.csv` has one mold system, `green_sand`. The model reads its thermal effusivity
+  (`effusivity_W_s05_m2K`), which is the square root of the product of the conductivity,
+  density and specific heat in the same row.
 
-The values remain modeling inputs, not certified material specifications. A production user
-should replace or verify them for the actual alloy, mold and process and should retain the exact
-property row with every result.
+The values come from handbook data. They are modelling inputs, not certified material
+specifications. Check them against your actual alloy and process, and keep the exact row you
+used with every result.
+
+To try an alloy that is not listed, pass the properties directly instead of editing the table:
+
+```bash
+python -m src.predict_casting part.step --props my_alloy.json
+```
+
+`my_alloy.json` needs exactly these keys: `k`, `rho`, `cp`, `L_kJ_kg`, `TL`, `TS`, `Tpour`,
+`mold_effusivity`. The model was trained on iron and steel grades in sand molds; properties far
+from that range are extrapolation.

data/properties/chills.csv

@@ -1,5 +0,0 @@
-material,k_W_mK,rho_kg_m3,cp_J_kgK,effusivity_W_s05_m2K
-graphite,68.97,1922,1692,14978
-cast_iron,38.9,7150,515,11968
-steel,51.0,7860,486,13958
-copper,OWNER,OWNER,OWNER,OWNER

data/properties/exo_calibration.csv

@@ -1,13 +0,0 @@
-MEF,q0_W_m2,duration_s,t_sand_s,t_exo_s,ratio,ratio_target
-1.4,640000.0,105.68312000817032,352.2770666939011,639.1643789347195,1.814379757766347,1.9599999999999997
-1.45,960000.0,105.68312000817032,352.2770666939011,754.0987323561276,2.1406410000892153,2.1025
-1.49,960000.0,105.68312000817032,352.2770666939011,760.0587908504301,2.1575596674047954,2.2201
-1.54,960000.0,105.68312000817032,352.2770666939011,766.9076476958378,2.1770013441216016,2.3716
-1.58,1120000.0,105.68312000817032,352.2770666939011,827.4879309999664,2.348969062238114,2.4964000000000004
-1.63,1280000.0,105.68312000817032,352.2770666939011,890.1572505029782,2.5268668745798584,2.6569
-1.67,1280000.0,105.68312000817032,352.2770666939011,895.2697715970885,2.541379658912063,2.7889
-1.72,1920000.0,105.68312000817032,352.2770666939011,1131.8937331840514,3.2130781143569904,2.9583999999999997
-1.76,1920000.0,105.68312000817032,352.2770666939011,1138.063508699037,3.2305921000753584,3.0976
-1.81,1920000.0,105.68312000817032,352.2770666939011,1145.2364712168662,3.2509538073677096,3.2761
-1.85,1920000.0,105.68312000817032,352.2770666939011,1150.5882262573784,3.266145699053246,3.4225000000000003
-1.9,1920000.0,105.68312000817032,352.2770666939011,1156.8270113469869,3.2838555805058167,3.61

data/properties/materials.csv

@@ -1,13 +1,3 @@
 material_id,family,k_W_mK,rho_kg_m3,cp_J_kgK,L_kJ_kg,TL_C,TS_C,Tpour_lo_C,Tpour_hi_C
-EN-GJL-200,grey_iron,51.9,7000,535,240,1175,1150,1265,1285
-EN-GJL-250,grey_iron,41.5,7150,535,240,1220,1150,1310,1330
-EN-GJL-300,grey_iron,36.3,7300,535,240,1245,1150,1335,1355
 EN-GJS-400-15,ductile_iron,32.9,6800,515,220,1160,1120,1250,1270
-EN-GJS-500-7,ductile_iron,36.0,7100,515,220,1160,1120,1250,1270
-EN-GJS-600-3,ductile_iron,27.7,7250,515,220,1160,1120,1250,1270
-EN-GJS-700-2,ductile_iron,26.0,7400,515,220,1160,1120,1250,1270
-GS-38 (GE200),low_alloy_steel,51.0,7800,599,260,1530,1495,1620,1640
-GS-45 (GP240GH),low_alloy_steel,50.8,7800,586,260,1530,1495,1620,1640
-GS-52 (GE300),low_alloy_steel,50.7,7800,586,260,1530,1495,1620,1640
 G20Mn5,low_alloy_steel,48.4,7800,590,260,1530,1495,1620,1640
-G17CrMo5-5,low_alloy_steel,28.1,7800,595,251,1520,1420,1610,1630

data/properties/molds.csv

@@ -1,3 +1,2 @@
 mold_system,k_W_mK,rho_kg_m3,cp_J_kgK,effusivity_W_s05_m2K
 green_sand,0.607,1520,1123,1018
-no_bake_furan_HTS,0.607,1520,1123,1018

src/assembly.py

@@ -1,904 +0,0 @@
-"""Multi-body STEP assembly tooling -- Part B Task 1.
-
-Two pieces:
-  - `list_solids(step_path)` -- the assembly inspector: fresh gmsh/OCC
-    session, imports a (possibly multi-solid) STEP file with entity names
-    preserved (`Geometry.OCCImportLabels=1`, set BEFORE `importShapes` --
-    setting it after import is a no-op), and reports one row per 3-D solid
-    (id/name/volume/bbox/center-of-mass), sorted by volume descending. This
-    is the data source for the later "role menu" (casting / chill /
-    insulating sleeve / exothermic sleeve) that a human or heuristic
-    assigns per solid.
-  - `compose_assembly(base_step, attachments, out_step)` -- a test/fixture
-    helper (used by this task's own tests and by all later Part B fixtures,
-    e.g. proximity classification, BC-patch tagging) that builds a
-    synthetic multi-body STEP: import a base part, then place one OCC
-    primitive (box/cylinder) per attachment spec at one of the base's
-    bounding-box faces. NO boolean operations are performed -- the
-    attachment is written as an independent solid, deliberately overlapping
-    the base by `overlap_mm` (default 2.0mm) along the face normal. This is
-    intentional, not a bug: downstream, these bodies are never meshed
-    together (only the casting solid is meshed); the attachments exist
-    purely so their bounding boxes/faces can drive proximity/contact
-    classification against the casting, and a few mm of geometric overlap
-    is harmless for that purpose while guaranteeing the two solids actually
-    register as "touching" rather than floating a hair apart.
-
-All lengths in mm, all gmsh sessions are fresh (`gmsh.initialize()` /
-`gmsh.finalize()` in a try/finally per call) -- never share state across
-calls, matching the pattern in `tools/doe/prep_parts.py` /
-`src/step_mesh.py`.
-"""
-from __future__ import annotations
-
-import argparse
-import csv
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Sequence
-
-import numpy as np
-
-_AXIS_INDEX = {"x": 0, "y": 1, "z": 2}
-_VALID_SHAPES = {"box", "cylinder"}
-
-
-# --------------------------------------------------------------------------
-# Assembly inspection
-# --------------------------------------------------------------------------
-def list_solids(step_path: str) -> list[dict]:
-    """Import `step_path` in a fresh gmsh/OCC session and return one dict
-    per 3-D solid entity, sorted by `volume_mm3` descending (largest first
-    -- in practice the casting itself, since attached chills/sleeves are
-    normally much smaller):
-
-        {"solid_id": <gmsh tag, int>, "name": <STEP entity name or "">,
-         "volume_mm3": <float>, "bbox": [xmin, ymin, zmin, xmax, ymax, zmax],
-         "com": [cx, cy, cz]}
-
-    `Geometry.OCCImportLabels` MUST be set to 1 BEFORE `importShapes` --
-    that's the only way gmsh preserves STEP entity names (product names
-    from the CAD export) for `gmsh.model.getEntityName` to read; setting it
-    afterwards has no effect on an already-imported model. Solids with no
-    STEP name (or on any importer that doesn't preserve one) get `name=""`
-    rather than raising -- callers decide how to label an unnamed solid in
-    a role menu.
-    """
-    import gmsh
-
-    gmsh.initialize()
-    try:
-        gmsh.option.setNumber("General.Terminal", 0)
-        gmsh.option.setNumber("Geometry.OCCImportLabels", 1)
-        gmsh.model.add("assembly_inspect")
-        gmsh.model.occ.importShapes(step_path)
-        gmsh.model.occ.synchronize()
-
-        rows: list[dict] = []
-        for (_dim, tag) in gmsh.model.getEntities(3):
-            name = gmsh.model.getEntityName(3, tag) or ""
-            volume_mm3 = float(gmsh.model.occ.getMass(3, tag))
-            bbox = list(gmsh.model.getBoundingBox(3, tag))
-            com = list(gmsh.model.occ.getCenterOfMass(3, tag))
-            rows.append({
-                "solid_id": tag,
-                "name": name,
-                "volume_mm3": volume_mm3,
-                "bbox": bbox,
-                "com": com,
-            })
-        rows.sort(key=lambda r: r["volume_mm3"], reverse=True)
-        return rows
-    finally:
-        gmsh.finalize()
-
-
-# --------------------------------------------------------------------------
-# Assembly composer (test/fixture helper)
-# --------------------------------------------------------------------------
-def _parse_face(at_face: str) -> tuple[int, float]:
-    """`"+x"/"-x"/"+y"/"-y"/"+z"/"-z"` -> (axis_index, sign)."""
-    if len(at_face) != 2 or at_face[0] not in "+-" or at_face[1] not in _AXIS_INDEX:
-        raise ValueError(
-            f"invalid at_face {at_face!r}; expected one of +x -x +y -y +z -z")
-    return _AXIS_INDEX[at_face[1]], (1.0 if at_face[0] == "+" else -1.0)
-
-
-def _place_attachment(att: dict, bbox_min: Sequence[float], bbox_max: Sequence[float],
-                       center: Sequence[float]) -> None:
-    """Add ONE primitive (box or cylinder) to the currently-open OCC model,
-    positioned at the base's bbox face named by `att["at_face"]`, sunk
-    `att.get("overlap_mm", 2.0)` INTO the base along the face normal (see
-    module docstring for why a positive overlap is intentional). Does not
-    synchronize/write -- the caller does that once after all attachments
-    are placed."""
-    import gmsh
-
-    shape = att.get("shape")
-    if shape not in _VALID_SHAPES:
-        raise ValueError(f"invalid shape {shape!r}; expected one of {sorted(_VALID_SHAPES)}")
-    if "size" not in att:
-        raise ValueError(f"attachment missing required 'size': {att!r}")
-    if "at_face" not in att:
-        raise ValueError(f"attachment missing required 'at_face': {att!r}")
-
-    axis, sign = _parse_face(att["at_face"])
-    overlap_mm = float(att.get("overlap_mm", 2.0))
-    du, dv = att.get("offset", (0.0, 0.0))
-    perp_axes = [i for i in range(3) if i != axis]
-    face_coord = bbox_max[axis] if sign > 0 else bbox_min[axis]
-
-    if shape == "box":
-        dx, dy, dz = att["size"]
-        size_by_axis = [dx, dy, dz]
-        perp_size = size_by_axis[axis]
-
-        if sign > 0:
-            lo_axis = face_coord - overlap_mm
-        else:
-            lo_axis = face_coord + overlap_mm - perp_size
-
-        coords = [0.0, 0.0, 0.0]
-        extents = [0.0, 0.0, 0.0]
-        coords[axis] = lo_axis
-        extents[axis] = perp_size
-        for i, u in zip(perp_axes, (du, dv)):
-            extents[i] = size_by_axis[i]
-            coords[i] = center[i] - size_by_axis[i] / 2.0 + u
-
-        gmsh.model.occ.addBox(coords[0], coords[1], coords[2],
-                               extents[0], extents[1], extents[2])
-    else:  # cylinder
-        radius, height = att["size"]
-        base_point = [0.0, 0.0, 0.0]
-        axis_vec = [0.0, 0.0, 0.0]
-        base_point[axis] = face_coord - sign * overlap_mm
-        axis_vec[axis] = sign * height
-        for i, u in zip(perp_axes, (du, dv)):
-            base_point[i] = center[i] + u
-
-        gmsh.model.occ.addCylinder(base_point[0], base_point[1], base_point[2],
-                                    axis_vec[0], axis_vec[1], axis_vec[2], radius)
-
-
-def compose_assembly(base_step: str, attachments: list[dict], out_step: str) -> int:
-    """Build a synthetic multi-body STEP: import `base_step`, then add one
-    OCC primitive per `attachments` entry (see module docstring for the
-    overlap/no-boolean-ops contract), and write the result (all solids,
-    unmerged) to `out_step`. Returns the number of 3-D solids written
-    (1 + len(attachments) in the normal case where `base_step` itself is
-    single-solid).
-
-    Each attachment dict:
-        {"shape": "box" | "cylinder",
-         "size": (dx, dy, dz) for a box, (radius, height) for a cylinder,
-         "at_face": "+x" | "-x" | "+y" | "-y" | "+z" | "-z",
-         "overlap_mm": float, default 2.0,
-         "offset": (du, dv) in the face plane, default (0.0, 0.0) (centered)}
-
-    For a box, `size[axis]` (the dimension along the face normal) is the
-    part that gets sunk `overlap_mm` into the base; the other two `size`
-    entries lie in the face plane. For a cylinder, the axis runs along the
-    face normal (`height`) and `radius` is in the face plane. `offset`
-    shifts the attachment's center within the face plane, in the same
-    (u, v) order as the two non-normal world axes (e.g. for "+z"/"-z",
-    (u, v) = (x, y); for "+x"/"-x", (u, v) = (y, z); for "+y"/"-y",
-    (u, v) = (x, z)).
-
-    NOTE for `tag_contact_patches` callers: a positive `overlap_mm` is a
-    fixed geometric gap that `tol_mm` must exceed just to detect the patch
-    at all, and any `tol_mm` beyond that dilates the classified patch past
-    the true footprint edge (see `tag_contact_patches`'s CAVEAT). A
-    synthetic fixture whose `overlap_mm` is large relative to its footprint
-    size will over-classify noticeably; real assemblies (near-zero contact
-    or a sub-mm clearance, not several mm sunk in) only need a small
-    `tol_mm`, where this dilation is negligible.
-    """
-    import gmsh
-
-    gmsh.initialize()
-    try:
-        gmsh.option.setNumber("General.Terminal", 0)
-        gmsh.model.add("assembly_compose")
-        gmsh.model.occ.importShapes(base_step)
-        gmsh.model.occ.synchronize()
-
-        xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.getBoundingBox(-1, -1)
-        bbox_min = [xmin, ymin, zmin]
-        bbox_max = [xmax, ymax, zmax]
-        center = [(bbox_min[i] + bbox_max[i]) / 2.0 for i in range(3)]
-
-        for att in attachments:
-            _place_attachment(att, bbox_min, bbox_max, center)
-
-        gmsh.model.occ.synchronize()
-        gmsh.write(out_step)
-        return len(gmsh.model.getEntities(3))
-    finally:
-        gmsh.finalize()
-
-
-# --------------------------------------------------------------------------
-# Body spec -- Part B Task 2: user-assigned solid roles -> the exact BC
-# parameters the v4 model was trained on (BcPlan), via the same registries
-# `tools/doe/doe.py` used to build the training manifest.
-# --------------------------------------------------------------------------
-_VALID_ROLES = {"casting", "chill", "insulating_sleeve", "exo_sleeve", "ignore"}
-_SLEEVE_ROLES = {"insulating_sleeve", "exo_sleeve"}
-_DEFAULT_CHILL_MATERIAL = "cast_iron"
-
-
-@dataclass
-class BcPlan:
-    """The resolved boundary-condition plan for one casting body, in the
-    exact shape `_node_features(version=4)` and `gbm_v2_total_seconds`
-    expect (see `feature_spec`/`gbm_bc_spec`). Produced by `validate_bodies`
-    -- never construct this by hand from unvalidated user input."""
-    bc_config: str            # "none" | "chills" | "insulating_sleeve" | "exo_sleeve"
-    casting_solid_id: int
-    role_solid_ids: list[int] = field(default_factory=list)  # bodies forming the patch
-    n_chills: int = 0
-    chill_effusivity: float = 0.0
-    sleeve_MEF: float = 0.0
-    exo_q0: float = 0.0       # W/m^2 (training units)
-    # Part-B roles task (2026-08-03): per-BODY role, `{solid_id: role}` for
-    # every id in `role_solid_ids` (e.g. all-"chill" for the chills branch,
-    # the single sleeve id -> its bc_config for the sleeve branch, empty for
-    # "none"). Lets a caller (e.g. `predict_casting`'s feed-node selection)
-    # decide per BODY ROLE rather than per global `bc_config` -- necessary
-    # groundwork for a future mixed-role regime even though `validate_bodies`
-    # itself still only ever produces a single-role mapping today.
-    role_by_solid: dict[int, str] = field(default_factory=dict)
-    # SP4 ADDENDUM (2026-08-08): several sleeve bodies are the norm on real
-    # castings. When they all resolve to one MEF it is used exactly and these
-    # stay at their defaults. When they differ, `sleeve_MEF` is the
-    # contact-area-weighted mean, `mef_weighted` is True, and `mef_spread`
-    # carries max(MEF) - min(MEF) so the report can state the spread the
-    # single scalar channel is standing in for rather than hiding it.
-    mef_weighted: bool = False
-    mef_spread: float = 0.0
-
-    def feature_spec(self, mold_effusivity: float) -> dict:
-        """The `spec` dict `src.features._node_features(version=4, spec=...)`
-        reads -- keys match `Global Constraints` in
-        `docs/superpowers/plans/2026-07-29-part-b-multibody.md` exactly."""
-        return {
-            "mold_effusivity": mold_effusivity,
-            "bc_config": self.bc_config,
-            "chill_effusivity": self.chill_effusivity,
-            "sleeve_MEF": self.sleeve_MEF,
-            "exo_q0": self.exo_q0,
-        }
-
-    def gbm_bc_spec(self) -> dict:
-        """The `bc_spec` dict `src.gbm_ft2b.gbm_v2_total_seconds` reads."""
-        return {
-            "bc_config": self.bc_config,
-            "n_chills": self.n_chills,
-            "sleeve_MEF": self.sleeve_MEF,
-            "exo_q0_MW": self.exo_q0 / 1e6,
-        }
-
-
-def _load_sleeve_registry(csv_path: str) -> dict[str, dict]:
-    """{sleeve name: {"MEF": float, "type": str}} from
-    `tools/sleeves/sleeve_registry.csv` -- `type` is "exo" or "insulating"
-    and is used to cross-check a registry-resolved sleeve's physics against
-    the declared role (see `validate_bodies`)."""
-    out: dict[str, dict] = {}
-    with open(csv_path, newline="") as f:
-        for row in csv.DictReader(f):
-            out[row["name"]] = {"MEF": float(row["MEF"]), "type": row["type"]}
-    return out
-
-
-# Declared role -> the sleeve_registry.csv `type` value it requires when the
-# sleeve is resolved BY REGISTRY NAME. Without this check, a registry
-# collision (two products landing on the same MEF, e.g. FOSECO_V88E
-# type=insulating MEF=1.45 vs the exo_calibration.csv row at MEF=1.45) lets
-# a plain insulating sleeve silently resolve a confident nonzero exo_q0 --
-# a silent-wrong-physics path, not merely a cosmetic mismatch.
-_ROLE_TO_SLEEVE_TYPE = {"exo_sleeve": "exo", "insulating_sleeve": "insulating"}
-
-# Two sleeves whose MEFs differ by less than this are treated as identical --
-# the registry stores MEF to 2 decimals, so anything below it is float noise,
-# not a real difference in sleeve product.
-_MEF_AGREEMENT_TOL = 1e-6
-
-
-def _resolve_chill_material(params: dict | None) -> str:
-    params = params or {}
-    return (params.get("material") or _DEFAULT_CHILL_MATERIAL).strip()
-
-
-def validate_bodies(bodies: list[dict],
-                     chills_csv: str = "data/properties/chills.csv",
-                     sleeve_registry_csv: str = "tools/sleeves/sleeve_registry.csv",
-                     exo_calibration_csv: str = "data/properties/exo_calibration.csv",
-                     tol: float = 0.05,
-                     mef_weights: dict[int, float] | None = None) -> BcPlan:
-    """Validate a user-assigned role list and resolve it into a `BcPlan`.
-
-    `bodies` rows: `{"solid_id": int, "role": <see _VALID_ROLES>,
-    "params": dict (optional, role-dependent)}`. `ignore` rows are dropped
-    before anything else. Enforces the training-regime restriction (owner,
-    2026-07-29): EXACTLY one casting; then either >=1 `chill` bodies
-    (bc_config="chills") OR one or more sleeve bodies that share a single role
-    (`insulating_sleeve`/`exo_sleeve`, bc_config = that role; mixing the two
-    roles raises) OR neither (bc_config="none").
-    Chills+sleeve mixed, two sleeves, or a casting count != 1 all raise a
-    loud `ValueError` explaining the restriction -- the trained model has no
-    BC channel for anything else, so silently coercing one regime into
-    another would produce a confidently wrong prediction.
-
-    Chill params: `{"material": str}` (default "cast_iron"); an unknown
-    material raises `ValueError` listing `load_chill_effusivities()`'s known
-    materials. Multiple chills MUST share one material -- the trained model
-    has a single scalar `chill_effusivity` channel, not one per chill, so
-    differing materials raise `ValueError` (single chill_effusivity per
-    training convention).
-
-    Sleeve params: exactly one of `{"sleeve": <sleeve_registry.csv name>}`
-    (MEF looked up in the registry) or `{"MEF": float}` (manual override) --
-    both or neither present raises `ValueError`. An unknown registry name
-    raises `ValueError` listing the known names. When resolved BY NAME, the
-    registry row's `type` column ("exo" or "insulating") MUST match the
-    declared role (`exo_sleeve` requires type=="exo", `insulating_sleeve`
-    requires type=="insulating") -- a mismatch raises `ValueError` naming
-    both, since two products can share the same MEF (a registry collision)
-    while being physically different (an insulating sleeve has no
-    exothermic heat release), and resolving one under the other's role
-    would silently produce a confidently wrong prediction. Manual
-    `{"MEF": float}` overrides BYPASS this check entirely (no registry row
-    to check against) -- this is expert mode: the caller is asserting the
-    physics directly and is trusted to pick the right role. For `bc_config
-    == "exo_sleeve"`, the resolved MEF is turned into a calibrated `exo_q0`
-    via `tools.doe.load_properties.resolve_exo_q0_by_mef` (same nearest-MEF
-    lookup `src.build_dataset._resolve_exo_q0_v4` uses for training data --
-    raises `ValueError` if no calibration point is within `tol`).
-
-    Several sleeves (SP4 ADDENDUM, 2026-08-08): real castings carry 3-8
-    sleeves, so N bodies of one role are accepted, mirroring the chills
-    branch. When every sleeve resolves to the same MEF it is used exactly
-    (`mef_weighted=False`, `mef_spread=0.0`). When they differ -- e.g. an
-    assembly with two sleeve sizes -- the model's single scalar channel
-    cannot hold both, so `mef_weights` (contact-patch area per solid_id,
-    exactly `tag_contact_patches`'s `per_body_patch_area_mm2`) MUST be
-    supplied and the effective MEF is their area-weighted mean, with
-    `mef_weighted=True` and `mef_spread` recording what was approximated.
-    Omitting the weights on a mixed set raises rather than silently picking
-    one sleeve's MEF or an unweighted mean.
-    """
-    from tools.doe.load_properties import (load_chill_effusivities,
-                                            resolve_exo_q0_by_mef)
-
-    active = [b for b in bodies if (b.get("role") or "") != "ignore"]
-
-    for b in active:
-        role = b.get("role")
-        if role not in _VALID_ROLES:
-            raise ValueError(
-                f"body solid_id={b.get('solid_id')!r}: unknown role {role!r} "
-                f"(expected one of {sorted(_VALID_ROLES)})")
-
-    castings = [b for b in active if b["role"] == "casting"]
-    chills = [b for b in active if b["role"] == "chill"]
-    sleeves = [b for b in active if b["role"] in _SLEEVE_ROLES]
-
-    if len(castings) != 1:
-        raise ValueError(
-            f"training-regime restriction: expected exactly one body with "
-            f"role='casting', found {len(castings)}")
-    casting_solid_id = castings[0]["solid_id"]
-
-    if chills and sleeves:
-        raise ValueError(
-            "training-regime restriction: chills and a sleeve cannot be "
-            "combined -- the trained model has no mixed chills+sleeve BC "
-            "channel in the current training regimes")
-    if sleeves:
-        sleeve_roles = {b["role"] for b in sleeves}
-        if len(sleeve_roles) > 1:
-            raise ValueError(
-                f"training-regime restriction: all sleeve bodies must share "
-                f"one role, got {sorted(sleeve_roles)} -- the trained model "
-                f"has a single sleeve BC channel and cannot represent an "
-                f"insulating and an exothermic sleeve at once")
-
-    if chills:
-        materials = {_resolve_chill_material(b.get("params")) for b in chills}
-        effs = load_chill_effusivities(chills_csv)
-        for material in materials:
-            if material not in effs:
-                raise ValueError(
-                    f"unknown chill material {material!r} (known: "
-                    f"{sorted(effs)})")
-        if len(materials) > 1:
-            raise ValueError(
-                f"training-regime restriction: all chills must share one "
-                f"material (single chill_effusivity per training "
-                f"convention), got {sorted(materials)}")
-        material = next(iter(materials))
-        chill_ids = [b["solid_id"] for b in chills]
-        return BcPlan(
-            bc_config="chills",
-            casting_solid_id=casting_solid_id,
-            role_solid_ids=chill_ids,
-            n_chills=len(chills),
-            chill_effusivity=float(effs[material]),
-            role_by_solid={sid: "chill" for sid in chill_ids},
-        )
-
-    if sleeves:
-        bc_config = sleeves[0]["role"]
-        registry = None
-        mef_by_solid: dict[int, float] = {}
-        for sleeve in sleeves:
-            params = sleeve.get("params") or {}
-            has_name = "sleeve" in params
-            has_mef = "MEF" in params
-            if has_name and has_mef:
-                raise ValueError(
-                    f"sleeve solid_id={sleeve['solid_id']!r}: specify either "
-                    f"'sleeve' (registry name) or 'MEF' (manual override), not "
-                    f"both")
-            if not has_name and not has_mef:
-                raise ValueError(
-                    f"sleeve solid_id={sleeve['solid_id']!r}: params must "
-                    f"contain either 'sleeve' (registry name) or 'MEF' (manual "
-                    f"override)")
-            if has_name:
-                if registry is None:
-                    registry = _load_sleeve_registry(sleeve_registry_csv)
-                name = params["sleeve"]
-                if name not in registry:
-                    raise ValueError(
-                        f"unknown sleeve name {name!r} (known: "
-                        f"{sorted(registry)})")
-                entry = registry[name]
-                expected_type = _ROLE_TO_SLEEVE_TYPE[bc_config]
-                if entry["type"] != expected_type:
-                    raise ValueError(
-                        f"sleeve {name!r} is type={entry['type']} but was "
-                        f"assigned role {bc_config} (expected "
-                        f"type={expected_type!r})")
-                mef_by_solid[sleeve["solid_id"]] = float(entry["MEF"])
-            else:
-                mef_by_solid[sleeve["solid_id"]] = float(params["MEF"])
-
-        sleeve_ids = [b["solid_id"] for b in sleeves]
-        mefs = [mef_by_solid[sid] for sid in sleeve_ids]
-        spread = float(max(mefs) - min(mefs))
-        if spread <= _MEF_AGREEMENT_TOL:
-            sleeve_mef = float(mefs[0])
-            weighted = False
-            spread = 0.0
-        else:
-            if mef_weights is None:
-                raise ValueError(
-                    f"sleeve bodies {sleeve_ids} resolve to differing MEF "
-                    f"{sorted(set(mefs))} (spread {spread:.4f}) -- the model has "
-                    f"a single scalar sleeve_MEF channel, so a mixed set needs "
-                    f"explicit `mef_weights` (contact-patch area per solid_id, "
-                    f"as returned by `tag_contact_patches`'s "
-                    f"'per_body_patch_area_mm2'). Refusing to guess a "
-                    f"weighting. Contact-patch areas only exist after meshing "
-                    f"and tagging, so a caller that only has `bodies` (e.g. "
-                    f"`predict_casting`'s CLI/webapp entry point) cannot supply "
-                    f"them here -- mesh and tag the part first (`get_or_mesh` "
-                    f"+ `tag_contact_patches`), then call `validate_bodies` "
-                    f"again with `mef_weights=per_body_patch_area_mm2`, as "
-                    f"`tools/sp4/prep.py` and `tools/sp4/score.py` do for the "
-                    f"SP4 gold set.")
-            missing = [sid for sid in sleeve_ids if sid not in mef_weights]
-            if missing:
-                raise ValueError(
-                    f"mef_weights is missing solid_id(s) {missing} -- every "
-                    f"sleeve body needs a weight, got keys "
-                    f"{sorted(mef_weights)}")
-            weights = [float(mef_weights[sid]) for sid in sleeve_ids]
-            if any(w <= 0.0 for w in weights):
-                raise ValueError(
-                    f"mef_weights must all be positive contact areas, got "
-                    f"{dict(zip(sleeve_ids, weights))}")
-            total_w = sum(weights)
-            sleeve_mef = float(sum(m * w for m, w in zip(mefs, weights)) / total_w)
-            weighted = True
-
-        exo_q0 = 0.0
-        if bc_config == "exo_sleeve":
-            exo_q0 = resolve_exo_q0_by_mef(sleeve_mef, exo_calibration_csv, tol)
-
-        return BcPlan(
-            bc_config=bc_config,
-            casting_solid_id=casting_solid_id,
-            role_solid_ids=sleeve_ids,
-            sleeve_MEF=sleeve_mef,
-            exo_q0=exo_q0,
-            role_by_solid={sid: bc_config for sid in sleeve_ids},
-            mef_weighted=weighted,
-            mef_spread=spread,
-        )
-
-    return BcPlan(bc_config="none", casting_solid_id=casting_solid_id, role_solid_ids=[])
-
-
-# --------------------------------------------------------------------------
-# Contact-patch tagging -- Part B Task 3: mesh the user-designated casting
-# solid, classify its surface triangles by proximity to the role bodies'
-# BReps, and rewrite the mesh's facet groups so the contact patch becomes
-# "Adiabatic" (the exact BC-patch convention `_node_features(version=4)` /
-# `fenicsx_solver.solve_case` read -- see the module docstring's B3 design
-# reference).
-# --------------------------------------------------------------------------
-_ADIABATIC_PHYS_TAG = 3   # alongside prep_parts._VOLUME_PHYS_TAG=1 / _COOLING_PHYS_TAG=2
-
-
-def _triangle_areas(node_xyz: np.ndarray, tris: np.ndarray) -> np.ndarray:
-    """(M,) triangle areas (mm^2) via the standard half cross-product
-    magnitude -- `tris` is (M, 3) 0-based vertex indices into `node_xyz`."""
-    p0 = node_xyz[tris[:, 0]]
-    p1 = node_xyz[tris[:, 1]]
-    p2 = node_xyz[tris[:, 2]]
-    cross = np.cross(p1 - p0, p2 - p0)
-    return 0.5 * np.linalg.norm(cross, axis=1)
-
-
-def _sample_solid_surface_points(solid_id: int) -> np.ndarray:
-    """Assumes a fresh gmsh/OCC session already has the model imported,
-    synchronized, AND 2-D-meshed (`gmsh.model.mesh.generate(2)` already ran
-    -- done ONCE per `tag_contact_patches` call, not per body, since it
-    covers every solid's boundary surfaces in one pass). Returns (P, 3) the
-    coordinates of every mesh node lying on any boundary surface
-    (`gmsh.model.getBoundary`) of 3-D entity `solid_id`."""
-    import gmsh
-
-    boundary = gmsh.model.getBoundary([(3, solid_id)], oriented=False)
-    surf_tags = [t for (d, t) in boundary if d == 2]
-    if not surf_tags:
-        raise ValueError(f"role body {solid_id}: no boundary surfaces found (not a 3-D solid?)")
-
-    pts = []
-    for surf_tag in surf_tags:
-        _node_tags, coords, _param = gmsh.model.mesh.getNodes(2, surf_tag, includeBoundary=True)
-        pts.append(np.asarray(coords, dtype=np.float64).reshape(-1, 3))
-    points = np.concatenate(pts, axis=0)
-    if points.shape[0] == 0:
-        raise ValueError(f"role body {solid_id}: surface sampling yielded 0 points")
-    return points
-
-
-def _distances_to_solid(points: np.ndarray, centroids: np.ndarray) -> np.ndarray:
-    """(M,) nearest-neighbor distance from each row of `centroids` (M, 3, mm)
-    to the sampled boundary point cloud `points` (P, 3, mm) of one role
-    solid, via `scipy.spatial.cKDTree`.
-
-    WHY sampled points + KDTree, not `gmsh.model.getClosestPoint` directly
-    on the centroids: probed first (as the brief suggested trying), and
-    found to be not just slower but WRONG for axis-aligned primitive faces
-    (the chill/sleeve boxes and cylinders this module builds and that real
-    role bodies resemble) -- `getClosestPoint`'s orthogonal projection lands
-    on the face's UNDERLYING (untrimmed) surface, not the actual bounded
-    patch (`isInside()` on the returned point came back False in every case
-    probed), so a query point far outside a face's true extent can still
-    project to a deceptively small distance whenever it happens to share
-    that face's plane (e.g. a base box's OWN top face reported ~2mm to a
-    chill's bottom-face plane from a corner ~15mm from the chill's actual
-    footprint). Meshing the role solids' real (trimmed) boundary at a size
-    tied to `tol_mm` and taking nearest-neighbor distance to those sampled
-    points respects the true finite geometry and reproduces the expected
-    footprint exactly in this task's synthetic fixtures (measured
-    corner-case distance corrected from a wrong ~2mm to the correct
-    ~11.2mm). Timing (composer fixture, `Mesh.MeshSizeMax = tol_mm/2`,
-    2-D-meshing the WHOLE imported model once): 0.16-0.9s total for
-    408-11019-node castings (656-8328 Cooling triangles) -- see
-    task-3-report.md for the full measurement."""
-    from scipy.spatial import cKDTree
-
-    tree = cKDTree(points)
-    dist, _ = tree.query(centroids)
-    return np.asarray(dist, dtype=np.float64)
-
-
-def _parse_physical_names_block(lines: list[str], start_idx: int):
-    """`lines[start_idx]` must be the bare `"$PhysicalNames"` marker line.
-    Returns `(count_idx, entries, end_idx)`: `count_idx` is the index of the
-    entry-count line, `entries` is a list of `(dim, tag, name)` (name
-    unquoted), and `end_idx` is the index of the `"$EndPhysicalNames"`
-    line."""
-    count_idx = start_idx + 1
-    cnt = int(lines[count_idx].strip())
-    entries = []
-    for k in range(cnt):
-        dim_s, tag_s, name_s = lines[count_idx + 1 + k].split(maxsplit=2)
-        entries.append((int(dim_s), int(tag_s), name_s.strip().strip('"')))
-    end_idx = count_idx + 1 + cnt
-    return count_idx, entries, end_idx
-
-
-def rewrite_msh_adiabatic(msh_path: str, is_adiabatic: np.ndarray) -> None:
-    """Rewrite `msh_path` in place so that the Cooling-tagged surface
-    triangles flagged True in `is_adiabatic` (same length AND order as
-    `src.msh_parse.parse_msh(msh_path).tris["Cooling"]` -- both this
-    function's own `$Elements` scan and `parse_msh` walk the file's
-    triangle elements in on-disk order, so the two arrays line up
-    positionally) move to a new "Adiabatic" physical group (pinned tag
-    `_ADIABATIC_PHYS_TAG`, reusing an existing "Adiabatic" group's tag if
-    the mesh already has one).
-
-    Deliberately edits the raw text rather than reimporting through gmsh:
-    `$Nodes` is never touched and every `$Elements` line is copied through
-    unchanged except the physical-group tag (first tag) of the flagged
-    triangle lines -- this is what guarantees node ids/coords and tet
-    connectivity survive EXACTLY (features/geodesics depend on it; verified
-    by the caller re-parsing and comparing `node_xyz`/`tets`). Raises
-    loudly (`ValueError`/`AssertionError`) on any structural surprise --
-    missing sections, a malformed `$PhysicalNames` block, tag-3 already
-    bound to a different name, or an `is_adiabatic` length that doesn't
-    match the number of Cooling-tagged triangle elements actually found --
-    rather than silently writing a mismatched mesh."""
-    from src.msh_parse import _TRI_TYPE
-
-    lines = Path(msh_path).read_text().splitlines()
-
-    try:
-        phn_idx = lines.index("$PhysicalNames")
-    except ValueError:
-        raise ValueError(f"{msh_path}: missing $PhysicalNames section")
-    count_idx, entries, end_idx = _parse_physical_names_block(lines, phn_idx)
-    if lines[end_idx].strip() != "$EndPhysicalNames":
-        raise ValueError(f"{msh_path}: malformed $PhysicalNames block (no $EndPhysicalNames "
-                          f"at the expected offset)")
-
-    cooling_entries = [e for e in entries if e[0] == 2 and e[2] == "Cooling"]
-    if not cooling_entries:
-        raise ValueError(f"{msh_path}: no dim=2 'Cooling' physical group found")
-    cooling_tag = cooling_entries[0][1]
-
-    existing_adiabatic = [e for e in entries if e[0] == 2 and e[2] == "Adiabatic"]
-    if existing_adiabatic:
-        adiabatic_tag = existing_adiabatic[0][1]
-        new_entries = entries
-    else:
-        collision = [e for e in entries if e[0] == 2 and e[1] == _ADIABATIC_PHYS_TAG]
-        if collision:
-            raise ValueError(f"{msh_path}: physical tag {_ADIABATIC_PHYS_TAG} is already "
-                              f"bound to {collision[0][2]!r}; cannot pin 'Adiabatic' there")
-        adiabatic_tag = _ADIABATIC_PHYS_TAG
-        new_entries = entries + [(2, adiabatic_tag, "Adiabatic")]
-
-    new_phys_lines = [str(len(new_entries))] + [
-        f'{d} {t} "{nm}"' for (d, t, nm) in new_entries
-    ]
-
-    try:
-        elem_idx = lines.index("$Elements")
-    except ValueError:
-        raise ValueError(f"{msh_path}: missing $Elements section")
-    elem_count_idx = elem_idx + 1
-    elem_cnt = int(lines[elem_count_idx].strip())
-    elem_lines = lines[elem_count_idx + 1: elem_count_idx + 1 + elem_cnt]
-
-    flags = is_adiabatic.tolist()
-    n_flags = len(flags)
-    flag_i = 0
-    new_elem_lines = []
-    for ln in elem_lines:
-        parts = ln.split()
-        etype = int(parts[1])
-        if etype == _TRI_TYPE and int(parts[3]) == cooling_tag:
-            if flag_i >= n_flags:
-                raise AssertionError(
-                    f"{msh_path}: is_adiabatic has only {n_flags} flag(s) -- fewer than the "
-                    f"Cooling-tagged triangle elements found in $Elements -- refusing to write "
-                    f"a mismatched mesh")
-            if flags[flag_i]:
-                parts[3] = str(adiabatic_tag)
-                ln = " ".join(parts)
-            flag_i += 1
-        new_elem_lines.append(ln)
-    if flag_i != n_flags:
-        raise AssertionError(
-            f"{msh_path}: is_adiabatic has {n_flags - flag_i} more flag(s) than Cooling-tagged "
-            f"triangle elements found in $Elements -- refusing to write a mismatched mesh")
-
-    new_lines = (
-        lines[:count_idx] + new_phys_lines + lines[end_idx:elem_count_idx]
-        + [str(elem_cnt)] + new_elem_lines + lines[elem_count_idx + 1 + elem_cnt:]
-    )
-    Path(msh_path).write_text("\n".join(new_lines) + "\n")
-
-
-# Back-compat alias -- this function was originally private (`_rewrite_msh_
-# adiabatic`); FT3's `tools/doe/virtual_patches.py` reuses it under the
-# promoted public name `rewrite_msh_adiabatic`, but existing call sites/tests
-# (this module's own `tag_contact_patches`, `tests/test_assembly.py`) still
-# reference the old private name, so both names resolve to the same function.
-_rewrite_msh_adiabatic = rewrite_msh_adiabatic
-
-
-def tag_contact_patches(msh_path: str, step_path: str, role_solid_ids: Sequence[int],
-                         tol_mm: float | None = None) -> dict:
-    """Classify the casting mesh's (`msh_path`) "Cooling" surface triangles
-    by proximity to each of `role_solid_ids`'s BReps in `step_path` (a fresh
-    gmsh/OCC session, distinct from the casting mesh's own session --
-    `step_path` is the ORIGINAL multi-body assembly STEP the role bodies'
-    tags came from, e.g. `list_solids`' `solid_id`, not the reduced
-    single-solid STEP the casting was meshed from); triangles within
-    `tol_mm` of ANY role body move from "Cooling" to a new "Adiabatic"
-    facet group (see `_rewrite_msh_adiabatic`), rewriting `msh_path` IN
-    PLACE. Distance-to-body samples each role solid's real (trimmed)
-    boundary surfaces into a point cloud (one shared `gmsh.model.mesh.
-    generate(2)` pass over the whole imported model, sized off `tol_mm`)
-    and takes the nearest-neighbor distance via `scipy.spatial.cKDTree`
-    (`_sample_solid_surface_points` + `_distances_to_solid`) -- see
-    `_distances_to_solid`'s docstring for why a direct
-    `gmsh.model.getClosestPoint` probe was rejected (not just slower, but
-    wrong for bounded planar faces).
-
-    `tol_mm`, if `None` (default), is `0.5 * elem_est` where `elem_est =
-    bbox_diag / n_nodes**(1/3)` of the casting mesh (all nodes, matching
-    `heal_and_mesh`'s own whole-model bbox convention) -- a rough local
-    element-size estimate, so the tolerance scales with mesh density rather
-    than being a fixed physical distance that's too tight for a coarse mesh
-    or too loose for a fine one.
-
-    CAVEAT -- tol_mm dilates the detected patch past the true contact
-    footprint: since classification is "distance to body <= tol_mm", any
-    positive tol_mm grows the patch outward from the geometric contact edge
-    by roughly `perimeter * tol_mm + pi * tol_mm**2` (a rectangular-
-    footprint Minkowski-sum estimate). This matters most for the SYNTHETIC
-    fixtures `compose_assembly` builds with a large POSITIVE `overlap_mm`
-    (sunk INTO the base -- see that function's docstring): `tol_mm` must
-    exceed `overlap_mm` just to detect the patch at all, and when
-    `overlap_mm` is a large fraction of the footprint size, the resulting
-    dilation can be a large fraction of the footprint's own area (measured
-    up to +140% on a 10x10mm footprint with a 2mm overlap -- see
-    task-3-report.md). Real assemblies -- where role bodies sit at
-    near-zero contact or a sub-mm clearance rather than several mm sunk in
-    -- only need a small `tol_mm` to bridge that gap, so this dilation
-    stays a small fraction of a realistic contact-patch area; it is a
-    synthetic-fixture-scale concern, not a production one.
-
-    A role body whose patch comes out EMPTY (no Cooling triangle centroid
-    within `tol_mm`) raises `ValueError` naming that body and `tol_mm` --
-    never a silent all-sand prediction for a body the caller explicitly
-    assigned a role to. Symmetrically, if EVERY Cooling triangle ends up
-    classified Adiabatic (role bodies + tol_mm cover the entire casting
-    surface), this raises `ValueError` too, rather than silently handing
-    downstream feature code (`geodesic_d_cool` et al., see
-    `src.features`) a casting mesh with no cooling surface at all to
-    measure geodesic distance to -- which would silently degrade to
-    bbox_diag-derived constants (confidently wrong physics, not a loud
-    failure).
-
-    Returns `{"per_body_patch_area_mm2": {solid_id: float}, "n_adiab_tris":
-    int, "nodes_by_solid": {solid_id: sorted list[int]}}`.
-    `per_body_patch_area_mm2` sums each body's own classified
-    triangle areas INDEPENDENTLY -- a triangle within `tol_mm` of more than
-    one role body (their tolerance zones overlap) is counted once per such
-    body, i.e. DOUBLE-COUNTED across `per_body_patch_area_mm2`'s entries,
-    even though it is relabeled to "Adiabatic" exactly once; `n_adiab_tris`
-    counts each such triangle once (via the union `is_adiabatic` mask), so
-    `sum(per_body_patch_area_mm2.values())` can exceed the true total
-    Adiabatic area when role bodies' patches overlap.
-
-    `nodes_by_solid` (Part-B roles task, 2026-08-03): the sorted-unique node
-    ids (0-based, into `mesh.node_xyz` -- the SAME indexing as every other
-    node id this module and `src.msh_parse` use) of each role body's own
-    classified triangles -- computed from the SAME per-body `close` mask as
-    `per_body_patch_area_mm2`, so it shares its double-counting property (a
-    triangle within `tol_mm` of more than one body contributes its nodes to
-    EVERY such body's entry). This is an IN-MEMORY-only piece of metadata:
-    it is never written into `msh_path` itself (the `.msh` physical groups,
-    node order, and this function's cache-relevant hashes/tags are all
-    unchanged by its addition) -- callers needing a role-aware node
-    selection (e.g. `predict_casting`'s shrinkage-screening feed-node logic)
-    combine this per-SOLID mapping with their own solid_id -> role lookup
-    (e.g. `BcPlan.role_by_solid`) themselves; `tag_contact_patches` has no
-    opinion on role semantics, only geometry. After rewriting,
-    re-parses `msh_path` and asserts `node_xyz` is unchanged (`np.allclose`)
-    and `tets` is unchanged (`np.array_equal`) -- the node-order/tet-
-    connectivity invariant features/geodesics depend on (see the module
-    docstring's caution and `_rewrite_msh_adiabatic`)."""
-    from src.msh_parse import parse_msh
-    import gmsh
-
-    mesh = parse_msh(msh_path)
-    cooling_tris = mesh.tris.get("Cooling")
-    if cooling_tris is None or cooling_tris.shape[0] == 0:
-        raise ValueError(f"{msh_path}: no 'Cooling' surface triangles to classify")
-
-    centroids = mesh.node_xyz[cooling_tris].mean(axis=1)
-    tri_areas = _triangle_areas(mesh.node_xyz, cooling_tris)
-
-    if tol_mm is None:
-        bbox_min = mesh.node_xyz.min(axis=0)
-        bbox_max = mesh.node_xyz.max(axis=0)
-        bbox_diag_mm = float(np.linalg.norm(bbox_max - bbox_min))
-        n_nodes = mesh.node_xyz.shape[0]
-        elem_est = bbox_diag_mm / (n_nodes ** (1.0 / 3.0))
-        tol_mm = 0.5 * elem_est
-
-    gmsh.initialize()
-    try:
-        gmsh.option.setNumber("General.Terminal", 0)
-        gmsh.model.add("tag_contact_patches")
-        gmsh.model.occ.importShapes(step_path)
-        gmsh.model.occ.synchronize()
-
-        # One shared 2-D surface mesh (not per-body) -- covers every role
-        # solid's boundary in a single pass. Sized off tol_mm/2 so sampled
-        # points are dense enough relative to the tolerance to not miss or
-        # blur the true footprint.
-        sample_size_mm = max(tol_mm / 2.0, 1e-3)
-        gmsh.option.setNumber("Mesh.MeshSizeMin", sample_size_mm)
-        gmsh.option.setNumber("Mesh.MeshSizeMax", sample_size_mm)
-        gmsh.model.mesh.generate(2)
-
-        dist_by_body = {}
-        for solid_id in role_solid_ids:
-            points = _sample_solid_surface_points(solid_id)
-            dist_by_body[solid_id] = _distances_to_solid(points, centroids)
-    finally:
-        gmsh.finalize()
-
-    is_adiabatic = np.zeros(cooling_tris.shape[0], dtype=bool)
-    per_body_patch_area_mm2: dict[int, float] = {}
-    nodes_by_solid: dict[int, list[int]] = {}
-    for solid_id, dist in dist_by_body.items():
-        close = dist <= tol_mm
-        area = float(tri_areas[close].sum())
-        if area <= 0.0:
-            raise ValueError(f"body {solid_id} does not touch the casting within "
-                              f"tol={tol_mm:.4f}mm")
-        per_body_patch_area_mm2[solid_id] = area
-        nodes_by_solid[solid_id] = sorted(
-            int(n) for n in np.unique(cooling_tris[close].reshape(-1)))
-        is_adiabatic |= close
-
-    if bool(is_adiabatic.all()):
-        raise ValueError(
-            "role bodies cover the entire casting surface; no cooling surface remains "
-            f"-- check roles/tol (tol={tol_mm:.4f}mm)")
-
-    rewrite_msh_adiabatic(msh_path, is_adiabatic)
-
-    mesh_after = parse_msh(msh_path)
-    if not np.allclose(mesh_after.node_xyz, mesh.node_xyz):
-        raise AssertionError(f"{msh_path}: node_xyz changed after Adiabatic rewrite "
-                              f"(node order/coords must be byte-identical)")
-    if mesh_after.tets.shape != mesh.tets.shape or not np.array_equal(mesh_after.tets, mesh.tets):
-        raise AssertionError(f"{msh_path}: tets changed after Adiabatic rewrite "
-                              f"(tet connectivity must be byte-identical)")
-
-    return {"per_body_patch_area_mm2": per_body_patch_area_mm2,
-            "n_adiab_tris": int(is_adiabatic.sum()),
-            "nodes_by_solid": nodes_by_solid}
-
-
-# --------------------------------------------------------------------------
-# CLI printer
-# --------------------------------------------------------------------------
-def main(argv: list[str] | None = None) -> int:
-    ap = argparse.ArgumentParser(
-        description="List the 3-D solids in a (possibly multi-body) STEP file.")
-    ap.add_argument("step_path", help="path to a .step/.stp file")
-    args = ap.parse_args(argv)
-
-    rows = list_solids(args.step_path)
-    header = f"{'solid_id':>8}  {'name':<24}  {'volume_mm3':>14}  {'bbox (mm)':<48}  {'com (mm)':<30}"
-    print(header)
-    print("-" * len(header))
-    for row in rows:
-        bbox_str = "[" + ", ".join(f"{v:.1f}" for v in row["bbox"]) + "]"
-        com_str = "[" + ", ".join(f"{v:.1f}" for v in row["com"]) + "]"
-        name = row["name"] or "<unnamed>"
-        print(f"{row['solid_id']:>8}  {name:<24}  {row['volume_mm3']:>14.2f}  "
-              f"{bbox_str:<48}  {com_str:<30}")
-    print(f"\n{len(rows)} solid(s) total.")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

src/inference_props.py

@@ -19,7 +19,7 @@ from pathlib import Path
 
 from tools.doe.load_properties import load_materials
 
-DEFAULT_ALLOY = "EN-GJL-250"
+DEFAULT_ALLOY = "EN-GJS-400-15"
 
 _REQUIRED_KEYS = ("k", "rho", "cp", "L_kJ_kg", "TL", "TS", "Tpour", "mold_effusivity")
 

src/model_api.py

@@ -0,0 +1,53 @@
+"""Mesh-in, field-out entry point for the published v5.1 model.
+
+    from src.model_api import CastSolidModel
+    model = CastSolidModel()                       # loads weights/ once
+    seconds = model.predict("part.msh", alloy="G20Mn5")
+
+`predict` takes a gmsh 2.2 ASCII tetrahedral mesh (path or a parsed
+`src.msh_parse.Mesh`) and returns the solidification time in seconds for every
+node, in the mesh's node order. Getting from a STEP file to such a mesh (CAD
+healing, density-targeted meshing) is the job of `src.predict_casting`.
+"""
+from __future__ import annotations
+
+import os
+
+import numpy as np
+
+from src.inference_props import resolve_props
+from src.msh_parse import Mesh, parse_msh
+from src.predict_casting import DEFAULT_W_STD, DEFAULT_W_TOTAL, load_hybrid, predict_field
+
+
+class CastSolidModel:
+    def __init__(self, weights_dir: str = "weights", device: str | None = None):
+        w = lambda name: os.path.join(weights_dir, name)
+        self.device = device
+        (self.gnn, self.gbm_total, self.norm, self.cfg, _,
+         self.gbm_std) = load_hybrid(w("gnn_v5.1.safetensors"), w("gbm_total_v3.skops"),
+                                     device, hgb_std_path=w("gbm_std_v2.skops"))
+        self.device = device or next(self.gnn.parameters()).device.type
+
+    def predict(self, mesh: str | Mesh, alloy: str | None = None, mold: str = "green_sand",
+                props_json: str | None = None) -> np.ndarray:
+        """Per-node solidification time (s) for `mesh`.
+
+        `alloy`/`mold` name rows of `data/properties/` (default EN-GJS-400-15
+        in green sand); `props_json` replaces both with a custom property set.
+        """
+        if not isinstance(mesh, Mesh):
+            mesh = parse_msh(os.fspath(mesh))
+        props = resolve_props(alloy=alloy, mold=mold, props_json=props_json)
+        seconds, _ = predict_field(mesh, self.gnn, self.gbm_total, self.norm, cfg=self.cfg,
+                                   device=self.device, props=props, hgb_std=self.gbm_std,
+                                   w_total=DEFAULT_W_TOTAL, w_std=DEFAULT_W_STD)
+        return np.asarray(seconds)
+
+    @staticmethod
+    def hotspots(seconds: np.ndarray, top_frac: float = 0.1) -> np.ndarray:
+        """Boolean mask of the `top_frac` latest-solidifying nodes (the same
+        rule as the `hotspot` field `src.predict_casting.write_vtu` writes)."""
+        seconds = np.asarray(seconds, dtype=np.float32)
+        k = max(1, int(round(seconds.shape[0] * top_frac)))
+        return seconds >= np.sort(seconds)[-k]

src/predict_casting.py

@@ -84,10 +84,7 @@ then feeds those into `src.shrinkage.screen_casting`'s exact Niyama branch
 instead of the time-only proxy, and relabels the result `niyama_source=
 "learned"` (screen_casting's own "exact" label is reserved for a real cached
 solver field). Absent entirely for a headless checkpoint -- byte-identical
-to the pre-Task-3 proxy-only behavior. The chill low-confidence
-`niyama_confidence` marking (spec ADDENDUM 2) is UNCHANGED by this -- still
-keyed only on `plan.bc_config == "chills"`, regardless of `niyama_source`;
-retiring that scoping is a later (promotion-step) task.
+to the pre-Task-3 proxy-only behavior.
 
 bc-reach Task 4 (cfg-driven v5 feature building at inference): the film
 branch's `compute_features_inference` call now reads
@@ -102,8 +99,7 @@ independent of but in practice equal to `node_in`), so loading one through
 `exo_mid`/`exo_long`/`chill_short`/`chill_mid`/`chill_long`) with NO other
 change to this module -- `compute_bc_reach_channels` (features v5) already
 resolves its chill/exo source patch off the SAME `spec`/`bc_spec` dicts
-this module already builds from `bc_plan.feature_spec(...)`/the all-sand
-literal, so the reach channels see EXACTLY the same source magnitudes the
+this module already builds from the all-sand literal, so the reach channels see EXACTLY the same source magnitudes the
 training builder (`src.build_dataset.build_v5`) does. A v4 (or absent)
 `cfg["feature_version"]` is byte-identical to the pre-Task-4 code (defaults
 to `4`, same as before this dispatch existed)."""
@@ -230,18 +226,12 @@ def _std_row_for_predict_field(row_16: np.ndarray, X: np.ndarray, n_features: in
 
 
 def predict_field(mesh, gnn_model, hgb_model, norm, cfg=None, device=None, tta=0,
-                  k=16, baseline_norm=None, props=None, bc_plan=None, hgb_std=None,
+                  k=16, baseline_norm=None, props=None, hgb_std=None,
                   lambda_shrink: float = 1.0, w_total: float = DEFAULT_W_TOTAL,
                   w_std: float = DEFAULT_W_STD) -> tuple:
-    """`bc_plan` (Part B Task 4): an optional `src.assembly.BcPlan`, resolved
-    by `validate_bodies` from a multi-body role assignment. `None` (the
-    default) is byte-identical to the pre-Part-B behavior -- the film
-    branch's `spec` stays the all-sand literal and `gbm_v2_total_seconds` is
-    called with `bc_spec=None` (its own "plain sand mold" default). When
-    given, the film branch's `spec` comes from `bc_plan.feature_spec(...)`
-    (carries `chill_effusivity`/`sleeve_MEF`/`exo_q0`/`bc_config`) and
-    `gbm_v2_total_seconds` gets `bc_spec=bc_plan.gbm_bc_spec()`. Ignored
-    entirely by the non-film (SP1) path -- SP1 has no BC channel at all.
+    """The film branch always uses the all-sand boundary spec: the whole
+    outer surface cools into the mold, and the model's chill/sleeve input
+    channels stay at zero (this release supports the sand-mold regime only).
 
     `hgb_std` (variance-recomposition Task 3, recomposition swapped to
     `hybrid_field_soft` by soft-anchor Task 3): an optional loaded GBM
@@ -311,13 +301,9 @@ def predict_field(mesh, gnn_model, hgb_model, norm, cfg=None, device=None, tta=0
                 "(the v2-total GBM scale head) -- got None")
         _check_hgb_dim(hgb_model, N_GBM_V2_FEATURES, "film (v4)")
 
-        if bc_plan is not None:
-            spec = bc_plan.feature_spec(props["mold_effusivity"])
-            bc_spec = bc_plan.gbm_bc_spec()
-        else:
-            spec = {"mold_effusivity": props["mold_effusivity"], "bc_config": "none",
-                    "chill_effusivity": 0.0, "sleeve_MEF": 0.0, "exo_q0": 0.0}
-            bc_spec = None
+        spec = {"mold_effusivity": props["mold_effusivity"], "bc_config": "none",
+                "chill_effusivity": 0.0, "sleeve_MEF": 0.0, "exo_q0": 0.0}
+        bc_spec = None
         feat = compute_features_inference(mesh, version=cfg.get("feature_version", 4), spec=spec)
         X, pos = feat["X"], feat["pos"]
         g_vec = alloy_g_vector(props)
@@ -437,156 +423,6 @@ def _shrinkage_surface_and_feed_nodes(mesh):
     return surface_nodes.astype(np.int64), feed_nodes.astype(np.int64)
 
 
-# --------------------------------------------------------------------------- #
-# Part-B roles task (2026-08-03): role-aware feed-node selection, replacing
-# review finding I1's coarse `plan.bc_config == "chills"` special case (which
-# forced feed_nodes empty for the WHOLE input whenever any chill role was
-# present, rather than excluding just the chill bodies' own patch nodes).
-# `src.assembly.tag_contact_patches` relabels EVERY role body's contact patch
-# "Adiabatic" regardless of role (chills included) -- these two pure helpers
-# recover the per-BODY-role distinction from `tag_contact_patches`'s
-# `nodes_by_solid` output (per-solid, geometry-only) + a solid_id -> role
-# lookup (`BcPlan.role_by_solid`), so the exclusion decision is made per
-# body, never per global `bc_config`.
-#
-# Investigation note (binding on the design below): in bodies mode the
-# casting mesh handed to `tag_contact_patches` never carries a PRE-EXISTING
-# "Adiabatic" group of its own. `bodies` requires `mesh_mode="prep"` (see the
-# guard above `predict_casting` raises), and `tools.doe.prep_parts.
-# heal_and_mesh` -- the only meshing path "prep" mode uses -- tags every
-# casting surface "Cooling" uniformly with no Adiabatic seed at all (verified
-# in `tools/doe/prep_parts.py` and `src/step_mesh.py`: neither ever calls
-# `setPhysicalName(2, ..., "Adiabatic")`; the ONLY producer of an "Adiabatic"
-# physical group anywhere in this codebase is `src.assembly.
-# rewrite_msh_adiabatic`, i.e. THIS tagging pass itself, or FT3's training-
-# data patch simulator `tools/doe/virtual_patches.py`, which never runs at
-# inference time). So every "Adiabatic" triangle on a bodies-mode inference
-# mesh is a role-body contact patch -- there is no separate "genuine riser"
-# contribution that could coexist with role patches and would need unioning
-# in on top of the per-role mapping below. The bare/all-sand path (no
-# `bodies`) is therefore UNCHANGED by this task: `_shrinkage_surface_and_
-# feed_nodes`'s "Adiabatic" union (if the mesh has one at all -- only
-# possible via `mesh_mode="raw"` or a training `.msh` with real user-tagged
-# riser faces) keeps meaning exactly what it always has.
-# --------------------------------------------------------------------------- #
-def _nodes_by_role_from_tagging(nodes_by_solid: dict, role_by_solid: dict) -> dict:
-    """Group `tag_contact_patches`'s per-solid contact-patch node ids
-    (`nodes_by_solid`, `{solid_id: node ids}` -- solid_id keys may arrive as
-    `str` after a mesh-cache JSON round-trip on a cache HIT, handled here via
-    `int()`) by each solid's declared role (`role_by_solid`, `{solid_id:
-    role}`, e.g. `BcPlan.role_by_solid`).
-
-    A solid_id present in `nodes_by_solid` with no entry in `role_by_solid`
-    is dropped rather than raising, but LOUDLY (`logger.warning`, naming the
-    solid_id) -- review round 1, M1: silently dropping it would silently
-    mis-attribute (or simply lose) that body's contact-patch nodes. In the
-    normal `predict_casting` call path this warning never actually fires:
-    `_role_aware_feed_nodes` (review round 1, H1) only calls this function
-    after confirming `nodes_by_solid` covers every id in `plan.
-    role_solid_ids`, and `role_by_solid` covers exactly those same ids by
-    construction in `validate_bodies` -- this is a defense-in-depth net for
-    any future/direct caller that skips that completeness check, not a code
-    path this module exercises today.
-
-    Returns `{role: sorted node ids}`.
-
-    NOTE on shared-node precedence (L3, review round 1): if a node's
-    contact-patch membership spans more than one role (two role bodies'
-    `tol_mm` zones overlap on the casting surface -- see `tag_contact_
-    patches`'s documented double-counting of `per_body_patch_area_mm2`),
-    this function keeps it under EVERY role it was classified into, and
-    `_feed_nodes_from_role_patches` below then unions in whichever of those
-    roles is a sleeve role -- i.e. a node shared between a chill patch and a
-    sleeve patch counts as fed ("sleeve wins"), matching the spec's literal
-    per-role union rule. `validate_bodies` forbids a chills+sleeve mix today
-    so this can never actually occur via the validated path (only via a
-    directly-constructed mapping that bypasses it, e.g. this module's own
-    mixed-mapping unit test). A FUTURE mixed-role regime might instead want
-    "chill wins" for a shared node (the more physically conservative choice
-    -- proximity to a chill accelerates freezing there regardless of a
-    nearby sleeve) -- flagged here for that future design, not implemented
-    now."""
-    grouped: dict[str, set] = {}
-    for sid_key, nodes in nodes_by_solid.items():
-        sid = int(sid_key)
-        role = role_by_solid.get(sid)
-        if role is None:
-            logger.warning(
-                f"_nodes_by_role_from_tagging: solid_id={sid} has classified "
-                f"contact-patch nodes but no entry in role_by_solid -- "
-                f"dropping it from the per-role feed-node mapping rather than "
-                f"silently mis-attributing it to some other role")
-            continue
-        grouped.setdefault(role, set()).update(int(n) for n in nodes)
-    return {role: sorted(ids) for role, ids in grouped.items()}
-
-
-def _feed_nodes_from_role_patches(nodes_by_role: dict) -> np.ndarray:
-    """The sorted-unique union of every SLEEVE role's nodes
-    (`src.assembly._SLEEVE_ROLES` = `insulating_sleeve`/`exo_sleeve`) in
-    `nodes_by_role` (`{role: iterable of node ids}`) -- a chill patch, or any
-    other non-sleeve role, NEVER contributes a feed node. Pure function of
-    its argument, with NO `BcPlan`/`bc_config` involved at all: it stays
-    correct even fed a directly-constructed mapping mixing roles that
-    `validate_bodies` itself would reject (chills + a sleeve combined) --
-    the decision is per body role, not per global config. See
-    `_nodes_by_role_from_tagging`'s docstring (L3, review round 1) for the
-    shared-node ("sleeve wins") precedence this union implies when a node is
-    classified into more than one role."""
-    feed: set = set()
-    for role, nodes in nodes_by_role.items():
-        if role in _SLEEVE_ROLES:
-            feed.update(int(n) for n in nodes)
-    return np.asarray(sorted(feed), dtype=np.int64)
-
-
-def _role_aware_feed_nodes(step_path: str, nodes_by_solid: dict, plan,
-                           fallback_feed_nodes: np.ndarray) -> np.ndarray:
-    """Review round 1, H1: `nodes_by_solid` is only present in `prep_info`
-    when `tag_contact_patches` actually ran on THIS call. A mesh-cache HIT
-    served from a side-car JSON written BEFORE the Part-B roles task never
-    had `nodes_by_solid` written into it at all (the key didn't exist yet),
-    and even a post-task entry could in principle cover only some of
-    `plan.role_solid_ids`. `MESH_PIPELINE_VERSION` is deliberately NOT
-    bumped for this task (cache keys are binding, per the task brief), so
-    such LEGACY entries are genuinely reachable today -- `runs/mesh_cache/`
-    already holds pre-task assembly entries, including both gold parts.
-    Naively grouping incomplete/absent `nodes_by_solid` data would silently
-    degrade `feed_nodes` to empty for EVERY `bc_config` (not just chills),
-    a silent regression on exactly the sleeve inputs this task's own byte-
-    identity test binds. `plan.role_solid_ids` MUST all be present as keys
-    of `nodes_by_solid` (after normalizing str keys) for the new per-role
-    path to run at all; otherwise this loudly (`logger.warning`, naming
-    `step_path`) falls back to the PRE-CHANGE rule: empty for `bc_config ==
-    "chills"`, the passed-through `fallback_feed_nodes` (the plain
-    "Adiabatic"-tag node union `_shrinkage_surface_and_feed_nodes` already
-    computed) for every other config -- i.e. exactly review finding I1's
-    original fix, byte-identical to `predict_casting`'s behavior before this
-    task. Recommends refreshing/clearing the mesh-cache entry for
-    `step_path` (see `src.mesh_cache.clear_mesh_cache`) so a later run gets
-    full per-role accuracy."""
-    required_ids = set(plan.role_solid_ids)
-    covered_ids = {int(k) for k in nodes_by_solid}
-    if not required_ids.issubset(covered_ids):
-        logger.warning(
-            f"predict_casting: role-aware contact-patch node metadata is "
-            f"missing or incomplete for step_path={step_path!r} "
-            f"(nodes_by_solid covers solid_id(s) {sorted(covered_ids)}, but "
-            f"plan.role_solid_ids requires {sorted(required_ids)}) -- this is "
-            f"almost certainly a LEGACY runs/mesh_cache/ entry written before "
-            f"the Part-B roles task (nodes_by_solid didn't exist yet). "
-            f"Falling back to the pre-change feed-node rule (empty for "
-            f"bc_config=='chills', the Adiabatic-tag union otherwise) rather "
-            f"than silently zeroing every config's feed_nodes. Recommend "
-            f"clearing/refreshing the mesh-cache entry for this STEP file "
-            f"(see src.mesh_cache.clear_mesh_cache) to restore full per-role "
-            f"feed-node accuracy on the next run.")
-        return (np.zeros(0, dtype=np.int64) if plan.bc_config == "chills"
-                else fallback_feed_nodes)
-    nodes_by_role = _nodes_by_role_from_tagging(nodes_by_solid, plan.role_by_solid)
-    return _feed_nodes_from_role_patches(nodes_by_role)
-
-
 def _shrinkage_result_for_return(screen: dict) -> dict:
     """Directive 6: the `screen_casting` result MINUS its bulky per-node
     arrays (`niyama`/`porosity_risk` dropped), plus summary counts +
@@ -633,37 +469,6 @@ def _write_shrinkage_summary_block(f, shrinkage) -> None:
         return
     f.write("shrinkage screening:\n")
     f.write(f"  niyama_source: {shrinkage['niyama_source']}\n")
-    if shrinkage.get("niyama_confidence") == "low":
-        # Spec ADDENDUM 2 (2026-08-01, owner-approved scoped ship): Gate C
-        # passed both floors on the all-sand slice (sleeves owner-accepted as
-        # intermediate: rho 0.768/0.691, below the 0.8 floor) but failed on the
-        # chill-bearing slice (Spearman rho 0.313) -- the proxy Niyama
-        # identity `Tdot_proxy = (TL-TS)/t_s` has no way to see a chill's
-        # locally-enhanced cooling rate, so its Niyama ranking on a
-        # chill-bearing input is not trustworthy the way it is on a bare or
-        # sleeve-only casting. Macro-shrinkage/sinks/feeders don't depend on
-        # Niyama at all and keep full confidence regardless.
-        #
-        # Learned-heads Task 3 review round 1, F3: the marking itself
-        # (`niyama_confidence == "low"` on any chill-bearing input) STAYS as
-        # is until the promote step (per the spec's own retirement plan) --
-        # only the CAVEAT TEXT is now conditional on `niyama_source`. The
-        # proxy's specific failure mode (and its Gate C rho number) is a
-        # claim about the PROXY identity, not about a learned checkpoint's
-        # heads -- citing "rho 0.313" next to a learned-source result would
-        # misattribute the proxy's own measured shortfall to a different
-        # (not yet slice-validated) source. A learned checkpoint gets a
-        # neutral caveat instead, pending its own Gate C learned-mode slice
-        # numbers (`tools/gate_c.py field_source="learned"`).
-        if shrinkage["niyama_source"] == "proxy":
-            f.write("  niyama confidence: LOW (chill-bearing input; proxy Niyama cannot see "
-                   "chill-local cooling rates — Gate C chills slice rho 0.313)\n")
-        elif shrinkage["niyama_source"] == "learned":
-            f.write("  niyama confidence: LOW (chill-bearing input; learned-head Niyama "
-                   "pending slice validation)\n")
-        else:
-            f.write(f"  niyama confidence: LOW (chill-bearing input; "
-                   f"niyama_source={shrinkage['niyama_source']!r})\n")
     flagged_line = f"  flagged nodes: {shrinkage['flagged_frac'] * 100.0:.1f}%"
     if shrinkage["niyama_source"] == "proxy":
         # Review round 1, finding 4: the proxy path's risk mask is
@@ -819,47 +624,16 @@ from src.step_mesh import mesh_step
 from src.msh_parse import parse_msh
 from src import ood as _ood
 from src.mesh_cache import get_or_mesh
-from src.assembly import validate_bodies, tag_contact_patches, _SLEEVE_ROLES
 from tools.doe.prep_parts import DEFAULT_TARGET_NODES
 
 
-def _bodies_cache_key(bodies: list, plan) -> str:
-    """Part B Task 4: a normalized-content hash of `bodies`, folding in the
-    resolved `BcPlan` scalars (`chill_effusivity`/`sleeve_MEF`/`exo_q0`) for
-    whichever body ids are `plan.role_solid_ids` -- NOT the raw role/params
-    text the caller typed -- so a `sleeve_registry.csv`/`chills.csv` edit
-    changes the mesh-cache key even for a byte-identical `bodies.json` (the
-    key means "this exact resolved BC plan", not just "this exact JSON
-    text"). Order-invariant (sorted by `solid_id`) and role-sensitive (a
-    role change always changes that row, even for a body with no numeric
-    params of its own, e.g. `"casting"` or `"ignore"`)."""
-    role_ids = set(plan.role_solid_ids)
-    rows = []
-    for i, b in enumerate(bodies):
-        if "solid_id" not in b:
-            raise ValueError(
-                f"_bodies_cache_key: bodies[{i}] (role={b.get('role')!r}) is "
-                f"missing 'solid_id' -- every row, including 'ignore' rows, "
-                f"must carry a solid_id")
-        row = {"solid_id": b["solid_id"], "role": b.get("role")}
-        if b["solid_id"] in role_ids:
-            if plan.bc_config == "chills":
-                row["chill_effusivity"] = plan.chill_effusivity
-            elif plan.bc_config in ("insulating_sleeve", "exo_sleeve"):
-                row["sleeve_MEF"] = plan.sleeve_MEF
-                row["exo_q0"] = plan.exo_q0
-        rows.append(row)
-    rows.sort(key=lambda r: r["solid_id"])
-    return hashlib.sha256(json.dumps(rows, sort_keys=True).encode("utf-8")).hexdigest()
-
-
 def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
                     mesh_mode="prep",
                     gnn_ckpt=DEFAULT_GNN_CKPT,
                     hgb_path=DEFAULT_HGB,
                     ood_json="data/features_v2/ood_ranges.json", device=None,
                     tta=0, alloy=None, mold="green_sand", props_json=None,
-                    bodies=None, target_nodes: int = DEFAULT_TARGET_NODES,
+                    target_nodes: int = DEFAULT_TARGET_NODES,
                     hgb_std_path=_USE_DEFAULT,
                     lambda_shrink: float = 1.0, w_total: float = DEFAULT_W_TOTAL,
                     w_std: float = DEFAULT_W_STD, screen_shrinkage: bool = True,
@@ -887,24 +661,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     explicit `elem_size` raises `ValueError` rather than being ignored --
     `elem_size` forces "raw", which never runs the density search at all.
 
-    `bodies` (Part B Task 4): a multi-body STEP's role assignment -- either
-    a list of `{"solid_id": int, "role": ..., "params": {...}}` dicts (see
-    `src.assembly.validate_bodies`) or a `str`/path-like path to a JSON file
-    holding that list (loaded via `json.load`). `None` (the default) is
-    byte-identical to the pre-Part-B behavior: no `validate_bodies` call,
-    `keep_solid_id=None`/`bodies_key="none"` into `get_or_mesh`, no
-    `tag_contact_patches` call, and the film spec/gbm bc_spec stay at their
-    all-sand-mold defaults (see `predict_field`). When given, the flow is
-    `validate_bodies` -> `get_or_mesh(..., keep_solid_id=plan.casting_solid_id,
-    bodies_key=<normalized hash>, post_mesh=<tag_contact_patches closure>)`
-    -> `predict_field(..., bc_plan=plan)`; the resolved `bc_config` and any
-    contact-patch areas are added to the result dict and the summary file.
-    Requires `mesh_mode="prep"` (the effective mode after any `elem_size`
-    override) -- role-based casting-solid selection and contact tagging
-    only run through that pipeline; combining `bodies` with the "raw" mesh
-    path raises `ValueError` rather than silently ignoring the role
-    assignment.
-
     `hgb_std_path` (variance-recomposition Task 3; default changed in Task 6;
     recomposition swapped to `hybrid_field_soft` by soft-anchor Task 3): an
     optional path to a `joblib`-dumped GBM std-head model
@@ -921,8 +677,8 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     form), to force the quantile-anchor recomposition on ANY checkpoint,
     including the new default film one -- this is byte-identical to the
     pre-Task-3 code. Passing an explicit path (or an already-loaded model
-    object) still requires a film-capable checkpoint (same reasoning as
-    `bodies`: SP1 has no scale-head std target) -- raises `ValueError`
+    object) still requires a film-capable checkpoint (SP1 has no
+    scale-head std target) -- raises `ValueError`
     otherwise, BEFORE meshing. When the soft-anchor recomposition is active,
     the summary file gains a `soft recomposition: a=..., m=...,
     target_unreachable=..., clip_frac=...` line (`target_unreachable`
@@ -981,29 +737,14 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     `shrinkage screening:` block in the summary, and a `"shrinkage"` key in
     the return dict (the `screen_casting` result minus its bulky per-node
     `niyama`/`porosity_risk` arrays, plus `flagged_frac`/`n_macro_regions`/
-    `n_sinks`/`n_feeders` counts).
-
-    Shrinkage-screening spec ADDENDUM 2 (2026-08-01, owner-approved SCOPED
-    SHIP): the shrinkage dict always carries `"niyama_confidence"` (`"full"`
-    or `"low"`). Gate C (the proxy-Niyama validation) passed both floors on
-    all-sand only (sleeve slices are an owner-accepted intermediate: rho
-    0.768/0.691, below the 0.8 floor) and FAILED on the chill-bearing slice (Spearman rho
-    0.313 -- the proxy `Tdot ~ (TL-TS)/t_s` identity has no way to see a
-    chill's local cooling-rate enhancement). Whenever `bodies` resolves to a
-    `BcPlan` with `bc_config == "chills"`, `"niyama_confidence"` is `"low"`
-    and the summary gains a caveat line naming the Gate C number; bare/
-    all-sand and sleeve-only inputs (`bc_config` `"none"`/
-    `"insulating_sleeve"`/`"exo_sleeve"`) stay `"full"`. The `niyama`/
-    `porosity_risk` VTU fields and the return dict still populate either way
-    (screening stays informative, just honestly labeled) -- macro-shrinkage/
-    top-sink/feeder outputs never depended on Niyama and are unaffected by
-    this label.
-    `False` skips all of that entirely --
-    `"shrinkage"` is `None` and the VTU/summary are byte-identical to the
-    pre-Task-4 contract (no extra fields, no extra summary lines at all --
-    the `shrinkage screening: disabled` line only appears when screening
-    was attempted but internally skipped, e.g. a mesh with no surface nodes
-    to place a feeder against, never for this explicit opt-out).
+    `n_sinks`/`n_feeders` counts). The shrinkage dict carries
+    `"niyama_confidence": "full"` (this release supports the all-sand regime
+    only, where the proxy passed its validation gate). `False` skips all of
+    that entirely -- `"shrinkage"` is `None` and the VTU/summary carry no
+    extra fields (the `shrinkage screening: disabled` line only appears when
+    screening was attempted but internally skipped, e.g. a mesh with no
+    surface nodes to place a feeder against, never for this explicit
+    opt-out).
 
     `gravity` (CLI `--gravity x,y,z`, parsed by `_parse_gravity`): forwarded
     straight to `screen_casting`'s `gravity_vec` (top-sink/feeder placement
@@ -1033,31 +774,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     # fail fast, before potentially lengthy meshing.
     props = resolve_props(alloy=alloy, mold=mold, props_json=props_json)
 
-    plan = None
-    bodies_key = "none"
-    if bodies is not None:
-        if isinstance(bodies, (str, os.PathLike)):
-            with open(osp.expanduser(bodies)) as f:
-                bodies = json.load(f)
-        # No `mef_weights` here (SP4 review I3, 2026-08-08): a mixed-MEF
-        # sleeve set needs contact-patch areas per solid_id, but those only
-        # exist after meshing + `tag_contact_patches`, which have not run
-        # yet at this point -- `validate_bodies` is called here specifically
-        # to build the mesh-cache key (`_bodies_cache_key` below) before any
-        # mesh exists. This is not a regression (every mixed-MEF assembly
-        # was rejected outright before the multi-sleeve ADDENDUM), but it
-        # does mean this CLI/webapp entry point cannot resolve a mixed-MEF
-        # assembly -- it raises naming `mef_weights`, a parameter neither
-        # surface accepts. A caller that needs a mixed-MEF assembly must
-        # mesh and tag first, then call `validate_bodies` again with
-        # `mef_weights=per_body_patch_area_mm2`, exactly as `tools/sp4/
-        # prep.py` + `tools/sp4/score.py` do for the SP4 gold set. Known
-        # gap, not fixed here -- restructuring this function's meshing flow
-        # to do that two-pass resolution is separate work; see the spec's
-        # multi-sleeve ADDENDUM.
-        plan = validate_bodies(bodies)
-        bodies_key = _bodies_cache_key(bodies, plan)
-
     effective_mode = "raw" if elem_size is not None else mesh_mode
     if target_nodes != DEFAULT_TARGET_NODES and effective_mode != "prep":
         raise ValueError(
@@ -1066,24 +782,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
             f"elem_size={elem_size!r} forces mesh_mode='raw' -- pinning an "
             f"element size and searching towards a node count are mutually "
             f"exclusive requests. Drop one.")
-    if bodies is not None and effective_mode != "prep":
-        raise ValueError(
-            f"predict_casting: `bodies` requires mesh_mode='prep' (got "
-            f"mesh_mode={mesh_mode!r}, effective_mode={effective_mode!r} -- "
-            f"an explicit elem_size forces 'raw') -- role-based casting-solid "
-            f"selection and contact-patch tagging only run through the "
-            f"prep/get_or_mesh pipeline")
-
-    # Loaded BEFORE meshing so a bodies/non-film-checkpoint mismatch (below)
-    # is caught before tag_contact_patches ever runs -- not merely before
-    # its result is used. A resolved BcPlan (chills/sleeve roles) means
-    # tag_contact_patches would relabel the contact patch "Adiabatic", which
-    # a non-film (SP1) checkpoint's geometry features read AS PHYSICAL
-    # INSULATION. For a chill, that's backwards physics (a chill COOLS,
-    # Adiabatic INSULATES); for a sleeve it's merely uncalibrated. Either
-    # way, SP1 has no BC channel to honor the role assignment at all, so
-    # silently proceeding would both report bc_config as if honored AND
-    # leave a wrong-physics tagged mesh sitting in the mesh cache.
     gnn_ckpt, hgb_path = resolve_artifact(gnn_ckpt), resolve_artifact(hgb_path)
     gnn, hgb, norm, cfg, baseline_norm, hgb_std = load_hybrid(
         gnn_ckpt, hgb_path, device, hgb_std_path=hgb_std_path)
@@ -1096,11 +794,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
         hgb_std_path_label = resolve_artifact(DEFAULT_HGB_STD)
     else:
         hgb_std_path_label = str(hgb_std_path)
-    if plan is not None and not cfg.get("film", False):
-        raise ValueError(
-            "predict_casting: bodies/BC roles require the film-conditioned "
-            "v4 stack; the selected checkpoint is not film-capable -- rerun "
-            "without --bodies or with the v4 checkpoints")
     if hgb_std is not None and not cfg.get("film", False):
         raise ValueError(
             "predict_casting: --hgb-std requires the film-conditioned v4 "
@@ -1113,15 +806,7 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
         minfo = {"n_nodes": raw_info["n_nodes"], "n_tets": raw_info["n_tets"],
                 "elem_size": raw_info["elem_size"], "bbox_mm": raw_info["bbox_mm"]}
     elif effective_mode == "prep":
-        keep_solid_id = plan.casting_solid_id if plan is not None else None
-        post_mesh = None
-        if plan is not None and plan.role_solid_ids:
-            def post_mesh(msh_path, _step_path=step_path, _role_ids=plan.role_solid_ids):
-                return tag_contact_patches(msh_path, _step_path, _role_ids)
-
-        prep_info = get_or_mesh(step_path, out_msh, target_nodes=target_nodes,
-                                keep_solid_id=keep_solid_id, bodies_key=bodies_key,
-                                post_mesh=post_mesh)
+        prep_info = get_or_mesh(step_path, out_msh, target_nodes=target_nodes)
         if not prep_info.get("ok", False):
             raise RuntimeError(
                 f"predict_casting: prep meshing pipeline (get_or_mesh) failed for "
@@ -1131,17 +816,11 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
         cache = prep_info.get("cache", "unknown")
         minfo = {"n_nodes": prep_info["n_nodes"], "n_tets": int(mesh.tets.shape[0]),
                 "elem_size": None, "bbox_mm": bbox_mm, "cache": cache}
-        if "per_body_patch_area_mm2" in prep_info:
-            # A cache HIT round-trips through JSON, turning int dict keys
-            # into str -- normalize back to int so callers (and the summary
-            # below) see one consistent shape regardless of hit vs. miss.
-            minfo["per_body_patch_area_mm2"] = {
-                int(k): v for k, v in prep_info["per_body_patch_area_mm2"].items()}
     else:
         raise ValueError(f"predict_casting: mesh_mode must be 'prep' or 'raw', got {mesh_mode!r}")
 
     seconds, feat = predict_field(mesh, gnn, hgb, norm, cfg=cfg, device=device, tta=tta,
-                                  baseline_norm=baseline_norm, props=props, bc_plan=plan,
+                                  baseline_norm=baseline_norm, props=props,
                                   hgb_std=hgb_std, lambda_shrink=lambda_shrink,
                                   w_total=w_total, w_std=w_std)
 
@@ -1162,21 +841,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     shrinkage_extra_point_data = None
     if screen_shrinkage:
         surface_nodes, feed_nodes = _shrinkage_surface_and_feed_nodes(mesh)
-        if plan is not None and plan.role_solid_ids:
-            # Part-B roles task (2026-08-03, replaces review finding I1's
-            # coarse `bc_config == "chills"` special case): recompute
-            # feed_nodes PER BODY ROLE rather than zeroing it out for the
-            # whole input -- only the SLEEVE roles' nodes are ever a feed
-            # source, a chill patch never is, regardless of `bc_config`. See
-            # `_feed_nodes_from_role_patches`'s docstring and this module's
-            # own investigation note (above `_nodes_by_role_from_tagging`)
-            # for why no separate "pre-existing Adiabatic" contribution
-            # needs unioning in here. `_role_aware_feed_nodes` (review round
-            # 1, H1) additionally guards against a LEGACY mesh-cache HIT
-            # whose side-car predates this task (no `nodes_by_solid` at
-            # all) -- see its own docstring.
-            nodes_by_solid = prep_info.get("nodes_by_solid", {})
-            feed_nodes = _role_aware_feed_nodes(step_path, nodes_by_solid, plan, feed_nodes)
         if surface_nodes.size == 0:
             logger.warning(
                 "predict_casting: no surface nodes found on the meshed part -- "
@@ -1212,18 +876,9 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
                 shrinkage["niyama_source"] = "learned"
             if alloy_family_assumed:
                 shrinkage["alloy_family_assumed"] = True
-            # Spec ADDENDUM 2 (2026-08-01, owner-approved scoped ship): Gate C
-            # failed on the chill-bearing slice (rho 0.313) -- proxy Niyama
-            # cannot see a chill's local cooling-rate enhancement, so mark it
-            # low-confidence whenever the input's BC plan has a CHILL role
-            # (`plan.bc_config == "chills"`; bare/all-sand and sleeve-only
-            # inputs, whose bc_config is "none"/"insulating_sleeve"/
-            # "exo_sleeve", are unaffected and stay "full"). Macro-shrinkage/
-            # sinks/feeders don't depend on Niyama at all and keep full scope
-            # regardless -- only this confidence LABEL changes, no output is
-            # withheld ("screening stays informative").
-            shrinkage["niyama_confidence"] = (
-                "low" if (plan is not None and plan.bc_config == "chills") else "full")
+            # This release covers the all-sand regime only, where the
+            # proxy Niyama passed its validation gate.
+            shrinkage["niyama_confidence"] = "full"
             shrinkage_extra_point_data = _shrinkage_extra_point_data(mesh, shrinkage_full)
 
     vtu = osp.join(out_dir, f"{name}.vtu")
@@ -1241,8 +896,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     elem_size_label = (f"{minfo['elem_size']:.2f} mm" if minfo["elem_size"] is not None
                        else "n/a (density-searched)")
     cache_label = minfo.get("cache") if effective_mode == "prep" else "n/a (raw mode)"
-    bc_config = plan.bc_config if plan is not None else "none"
-    patch_areas = minfo.get("per_body_patch_area_mm2", {})
     with open(summary, "w") as f:
         f.write(f"casting: {name}\n")
         f.write(f"total solidification time: {total:.1f} s\n")
@@ -1251,16 +904,6 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
         f.write(f"mesh_mode: {effective_mode}  cache: {cache_label}  nodes: {minfo['n_nodes']}  "
                 f"tets: {minfo['n_tets']}  elem_size: {elem_size_label}  bbox_mm: "
                 f"{tuple(round(v,1) for v in minfo['bbox_mm'])}\n")
-        f.write(f"bc_config: {bc_config}\n")
-        if plan is not None:
-            for b in bodies:
-                sid = b.get("solid_id")
-                line = f"  body solid_id={sid} role={b.get('role')}"
-                if b.get("params"):
-                    line += f" params={b['params']}"
-                if sid in patch_areas:
-                    line += f" patch_area_mm2={patch_areas[sid]:.1f}"
-                f.write(line + "\n")
         if feat.get("recomposition") == "soft":
             info = feat["recomposition_info"]
             line = (f"soft recomposition: a={info['a']:.4f}, m={info['m']:.4f}, "
@@ -1310,8 +953,7 @@ def predict_casting(step_path, out_dir="runs/castings", elem_size=None,
     result = {"name": name, "vtu": vtu, "summary": summary, "total_time_s": total,
               "mesh_mode": effective_mode, "n_nodes": minfo["n_nodes"],
               "elem_size": minfo["elem_size"], "ood_warnings": warnings,
-              "hotspot_xyz": hot_xyz, "bc_config": bc_config,
-              "per_body_patch_area_mm2": patch_areas,
+              "hotspot_xyz": hot_xyz,
               "recomposition": recomposition,
               "recomposition_info": recomposition_info,
               "shrinkage": shrinkage}
@@ -1370,16 +1012,6 @@ if __name__ == "__main__":
                     help="named mold system; only used by film/v4 checkpoints")
     ap.add_argument("--props", dest="props_json", default=None,
                     help="path to a JSON file overriding alloy/mold with raw material properties")
-    ap.add_argument("--bodies", dest="bodies_json", default=None,
-                    help="path to a JSON file describing a multi-body STEP's role "
-                         "assignment (Part B): a list of {\"solid_id\": int, \"role\": "
-                         "\"casting\"|\"chill\"|\"insulating_sleeve\"|\"exo_sleeve\"|"
-                         "\"ignore\", \"params\": {...} (optional, role-dependent)}. "
-                         "Example: [{\"solid_id\": 1, \"role\": \"casting\"}, "
-                         "{\"solid_id\": 2, \"role\": \"chill\", \"params\": "
-                         "{\"material\": \"cast_iron\"}}]. Requires --mesh-mode prep "
-                         "(the default) -- role-based casting-solid selection and "
-                         "contact-patch tagging only run through that pipeline.")
     ap.add_argument("--no-shrinkage", dest="screen_shrinkage", action="store_false",
                     help="disable shrinkage-porosity screening (SP2): by default, "
                          "predict_casting runs src.shrinkage.screen_casting on the "
@@ -1399,11 +1031,11 @@ if __name__ == "__main__":
                         mesh_mode=a.mesh_mode,
                         gnn_ckpt=a.gnn_ckpt, hgb_path=a.hgb_path,
                         alloy=a.alloy, mold=a.mold, props_json=a.props_json,
-                        bodies=a.bodies_json, hgb_std_path=a.hgb_std_path,
+                        hgb_std_path=a.hgb_std_path,
                         lambda_shrink=a.lambda_shrink, w_total=a.w_total, w_std=a.w_std,
                         screen_shrinkage=a.screen_shrinkage,
                         gravity=a.gravity)
     print(f"{r['name']}: total {r['total_time_s']:.1f}s  mesh_mode {r['mesh_mode']}  "
-          f"nodes {r['n_nodes']}  bc_config {r['bc_config']}  -> {r['vtu']}")
+          f"nodes {r['n_nodes']}  -> {r['vtu']}")
     for w in r["ood_warnings"]:
         print("WARNING:", w)

src/webapp.py

@@ -2,11 +2,8 @@
 prediction, and view the solidification field with a time slider (solidified =
 ghost, liquid = opaque) and a hot-spot toggle. Run: python -m src.webapp
 
-Part B Task 5 adds an assembly mode: a multi-solid STEP upload shows a body
-table (role + params per solid) and a role-colored 3-D preview instead of
-auto-running the prediction; a single-solid upload keeps the original flow
-untouched."""
-import csv
+A multi-solid STEP is meshed through the same prep pipeline as the CLI, which
+keeps the largest solid as the casting."""
 import os
 import os.path as osp
 
@@ -18,13 +15,10 @@ from trame.widgets import html, vuetify3
 from pyvista.trame.ui import plotter_ui
 
 from src import viz
-from src.assembly import list_solids, validate_bodies
 from src.inference_props import DEFAULT_ALLOY, list_alloys, list_molds
 from src.predict_casting import predict_casting
-from tools.doe.load_properties import load_chill_effusivities
 
 DEFAULT_MOLD = "green_sand"
-SLEEVE_REGISTRY_CSV = "tools/sleeves/sleeve_registry.csv"
 
 pv.OFF_SCREEN = True
 
@@ -61,23 +55,6 @@ HOTSPOT_COLOR = "#0092b8"   # deep cyan/teal marker: falls in the middle of turb
                             # range but is rendered as small spheres (not a field
                             # color), so it still reads as an overlay/alert
 
-# --- assembly mode (Part B Task 5) -----------------------------------------
-# One row per solid in a multi-body STEP upload: role dropdown (defaults
-# largest solid = casting, everything else = ignore) + role-dependent params
-# (chill material / sleeve name) feeding `src.assembly.validate_bodies` and
-# `predict_casting(..., bodies=...)`. The 3-D preview colors each solid's
-# coarse tessellation by its currently-selected role; "ignore" bodies stay
-# the casting's neutral grey but at the same faint GHOST_OPACITY used for the
-# solidified-region ghost actor elsewhere in this file.
-ROLE_OPTIONS = ["casting", "chill", "insulating_sleeve", "exo_sleeve", "ignore"]
-ROLE_COLORS = {
-    "casting": "#9e9e9e",
-    "chill": "#2196f3",
-    "insulating_sleeve": "#ffc107",
-    "exo_sleeve": "#f44336",
-    "ignore": "#9e9e9e",
-}
-
 _MONO_STACK = ('"JetBrains Mono", ui-monospace, "SFMono-Regular", '
               "Menlo, Consolas, monospace")
 _COND_STACK = '"Roboto Condensed", "Arial Narrow", sans-serif'
@@ -203,151 +180,16 @@ def summary_text(result: dict, alloy: str = None, mold: str = None) -> str:
 INITIAL_SUMMARY = "(upload a STEP file)"
 
 
-def _run_prediction(step_path, out_dir, alloy, mold, bodies=None):
-    """Thin wrapper around `predict_casting` forwarding alloy/mold conditioning
-    and (Part B Task 5) an optional multi-body role assignment.
+def _run_prediction(step_path, out_dir, alloy, mold):
+    """Thin wrapper around `predict_casting` forwarding alloy/mold conditioning.
 
     Extracted so the upload handler's predict call is unit-testable without
     driving the full trame upload flow (module-level lookup of
     `predict_casting` so tests can monkeypatch `src.webapp.predict_casting`).
-    `bodies` is only forwarded as a keyword when given (not merely `None`),
-    so the pre-Part-B single-solid call shape (no `bodies` kwarg at all)
-    stays byte-identical -- some callers (this module's own existing tests)
-    monkeypatch `predict_casting` with a fake that doesn't accept `bodies`.
     """
-    if bodies is not None:
-        return predict_casting(step_path, out_dir=out_dir, alloy=alloy, mold=mold, bodies=bodies)
     return predict_casting(step_path, out_dir=out_dir, alloy=alloy, mold=mold)
 
 
-def _load_sleeve_names_by_type(csv_path=SLEEVE_REGISTRY_CSV):
-    """{"exo": [name, ...], "insulating": [name, ...]} from
-    `tools/sleeves/sleeve_registry.csv`'s `name`/`type` columns, sorted --
-    the source of the sleeve-name dropdown options for the assembly panel,
-    pre-filtered by role so the UI never offers a sleeve `validate_bodies`
-    would reject for a type mismatch (see `src.assembly.validate_bodies`'s
-    `_ROLE_TO_SLEEVE_TYPE` cross-check)."""
-    out: dict[str, list[str]] = {"exo": [], "insulating": []}
-    try:
-        with open(csv_path, newline="") as f:
-            for row in csv.DictReader(f):
-                names = out.setdefault(row["type"], [])
-                names.append(row["name"])
-    except FileNotFoundError:
-        pass
-    for names in out.values():
-        names.sort()
-    return out
-
-
-def _assemble_bodies_from_state(state_like) -> list:
-    """Pure builder: the assembly panel's per-row state (`state_like.
-    assembly_bodies`, one dict per solid with at least `solid_id` and
-    `role`, plus an optional `params`) -> the plain `bodies` list
-    `src.assembly.validate_bodies`/`predict_casting(..., bodies=...)`
-    expect (`{"solid_id", "role", "params"}`, UI-only fields like `name`/
-    `volume_mm3` dropped). Takes anything with attribute access
-    (`state_like.assembly_bodies`) so it is testable with a plain
-    `SimpleNamespace`/fake as well as the real trame state -- no gmsh, no
-    validation (that's `validate_bodies`'s job, called separately as a
-    pre-flight check by the Run-assembly handler)."""
-    rows = state_like.assembly_bodies or []
-    bodies = []
-    for row in rows:
-        body = {"solid_id": row["solid_id"], "role": row.get("role", "ignore")}
-        params = row.get("params")
-        if params:
-            body["params"] = params
-        bodies.append(body)
-    return bodies
-
-
-def _solid_preview_meshes(step_path):
-    """Coarse per-solid surface tessellation for the assembly 3-D preview:
-    one fresh gmsh/OCC session imports `step_path` and generates a SINGLE
-    2-D surface mesh over the whole model, but sized PER SOLID (each
-    solid's own boundary points get their own target size, its OWN bbox
-    diagonal / 15, via `gmsh.model.mesh.setSize` + gmsh's default
-    `Mesh.MeshSizeExtendFromBoundary` sizing field) -- a large casting
-    tessellates at its own coarse scale while a small chill/sleeve still
-    gets enough triangles to read as a shape, instead of one uniform size
-    forcing every solid into whichever end of the size range is wrong for
-    it (a small uniform size on a big casting is a triangle-count blowup;
-    a uniform size sized for the casting leaves a small role body a
-    handful of degenerate facets). Returns one `(solid_id,
-    pyvista.PolyData)` per 3-D solid (its own boundary surfaces' triangles
-    + nodes). `solid_id` matches what `list_solids` reports for the SAME
-    STEP file, since both walk a fresh `gmsh.model.occ.importShapes` +
-    `gmsh.model.getEntities(3)` and gmsh assigns solid tags
-    deterministically from import order.
-
-    Real-gmsh, no mocking -- callers should expect this to be slow-ish (a
-    full 2-D mesh pass) but bounded for the coarse sizes used here."""
-    import gmsh
-
-    gmsh.initialize()
-    try:
-        gmsh.option.setNumber("General.Terminal", 0)
-        gmsh.model.add("assembly_preview")
-        gmsh.model.occ.importShapes(step_path)
-        gmsh.model.occ.synchronize()
-
-        solids = gmsh.model.getEntities(3)
-        if not solids:
-            return []
-
-        size_by_tag = {}
-        for (_dim, tag) in solids:
-            xmin, ymin, zmin, xmax, ymax, zmax = gmsh.model.getBoundingBox(3, tag)
-            diag = float(np.linalg.norm([xmax - xmin, ymax - ymin, zmax - zmin]))
-            size_by_tag[tag] = max(diag / 15.0, 1e-3)
-
-        # Global bounds only fence in gmsh's implicit sizing AWAY from any
-        # explicitly-sized point (e.g. deep in a solid's interior); the
-        # per-solid setSize calls below are what actually drive each
-        # solid's own coarse scale.
-        gmsh.option.setNumber("Mesh.MeshSizeMin", min(size_by_tag.values()))
-        gmsh.option.setNumber("Mesh.MeshSizeMax", max(size_by_tag.values()))
-        gmsh.option.setNumber("Mesh.MeshSizeExtendFromBoundary", 1)
-        for (_dim, tag) in solids:
-            boundary_pts = gmsh.model.getBoundary([(3, tag)], recursive=True)
-            point_dimtags = [(d, t) for (d, t) in boundary_pts if d == 0]
-            if point_dimtags:
-                gmsh.model.mesh.setSize(point_dimtags, size_by_tag[tag])
-        gmsh.model.mesh.generate(2)
-
-        out = []
-        for (_dim, tag) in solids:
-            boundary = gmsh.model.getBoundary([(3, tag)], oriented=False)
-            surf_tags = [t for (d, t) in boundary if d == 2]
-            node_xyz_by_id = {}
-            tri_blocks = []
-            for surf_tag in surf_tags:
-                node_tags, coords, _param = gmsh.model.mesh.getNodes(
-                    2, surf_tag, includeBoundary=True)
-                coords = np.asarray(coords, dtype=np.float64).reshape(-1, 3)
-                for nid, xyz in zip(node_tags, coords):
-                    node_xyz_by_id.setdefault(int(nid), xyz)
-                elem_types, _elem_tags, elem_node_tags = gmsh.model.mesh.getElements(2, surf_tag)
-                for etype, enodes in zip(elem_types, elem_node_tags):
-                    if etype != 2:   # gmsh type 2 = 3-node triangle
-                        continue
-                    tri_blocks.append(np.asarray(enodes, dtype=np.int64).reshape(-1, 3))
-            if not tri_blocks or not node_xyz_by_id:
-                continue
-            tris = np.concatenate(tri_blocks, axis=0)
-            node_ids = sorted(node_xyz_by_id)
-            local_index = {nid: i for i, nid in enumerate(node_ids)}
-            points = np.array([node_xyz_by_id[nid] for nid in node_ids], dtype=np.float64)
-            local_tris = np.vectorize(local_index.get)(tris)
-            faces = np.hstack(
-                [np.full((local_tris.shape[0], 1), 3, dtype=np.int64), local_tris])
-            out.append((tag, pv.PolyData(points, faces)))
-        return out
-    finally:
-        gmsh.finalize()
-
-
 def _rebuild_hotspots(app):
     """(Re)build the hot-spot point actor from the current cutoff/size state.
     Called on load and whenever the size or cutoff slider moves."""
@@ -379,105 +221,12 @@ def _remove_scalar_bar(plotter):
         pass
 
 
-def _render_assembly_preview(app):
-    """(Re)draw every cached assembly-preview mesh (`app["assembly_meshes"]`,
-    built once by `_enter_assembly_mode`), colored/opacity'd by each body's
-    CURRENT role in `state.assembly_bodies` (see `ROLE_COLORS`/
-    `GHOST_OPACITY`). Called on entering assembly mode and again whenever
-    `assembly_bodies` changes (role edits) -- cheap, since it only touches
-    actors, never re-tessellates."""
-    plotter, server = app["plotter"], app["server"]
-    state, ctrl = server.state, server.controller
-    plotter.clear_actors()
-    _remove_scalar_bar(plotter)
-    roles = {b["solid_id"]: b.get("role", "ignore") for b in (state.assembly_bodies or [])}
-    meshes = app.get("assembly_meshes") or []
-    for solid_id, mesh in meshes:
-        role = roles.get(solid_id, "ignore")
-        color = ROLE_COLORS.get(role, ROLE_COLORS["ignore"])
-        opacity = GHOST_OPACITY if role == "ignore" else 1.0
-        plotter.add_mesh(mesh, color=color, opacity=opacity,
-                         name=f"assembly_solid_{solid_id}", smooth_shading=True)
-    if meshes:
-        plotter.reset_camera()
-    ctrl.view_update()
-
-
-def _enter_assembly_mode(app, step_path, rows):
-    """Switch the viewer into assembly mode for a multi-solid STEP upload:
-    builds the role-colored 3-D preview meshes FIRST (`_solid_preview_meshes`
-    into `app["assembly_meshes"]`), THEN seeds `state.assembly_bodies` from
-    `list_solids`' rows (default roles -- largest solid = casting, everything
-    else = ignore, per the brief) and renders (`_render_assembly_preview`).
-    This order matters: `state.assembly_bodies` is watched
-    (`_on_assembly_bodies_change` -> `_render_assembly_preview`), so setting
-    it BEFORE `app["assembly_meshes"]` is refreshed would briefly recolor
-    whatever meshes happened to be cached from a PRIOR upload (e.g. a
-    multi -> single -> multi upload sequence) against the new roles -- a
-    stale-preview flash. A preview failure (e.g. a STEP gmsh can list solids
-    for but not re-tessellate) is surfaced in `state.assembly_error` rather
-    than raised -- the body table/role panel still works without a 3-D
-    preview."""
-    server = app["server"]
-    state = server.state
-    app["grid"] = None
-    app["hotspot_actor"] = None
-    state.loaded = False
-    state.summary = INITIAL_SUMMARY
-    state.assembly_step_path = step_path
-    state.assembly_error = ""
-
-    try:
-        app["assembly_meshes"] = _solid_preview_meshes(step_path)
-    except Exception as e:
-        app["assembly_meshes"] = []
-        state.assembly_error = f"3D preview failed: {e}"
-
-    bodies = []
-    for i, row in enumerate(rows):
-        bodies.append({
-            "solid_id": row["solid_id"],
-            "name": row["name"] or f"solid {row['solid_id']}",
-            "volume_mm3": row["volume_mm3"],
-            "role": "casting" if i == 0 else "ignore",
-            "params": {},
-        })
-    state.assembly_mode = True
-    state.assembly_bodies = bodies
-    _render_assembly_preview(app)
-
-
 def _process_upload(app, step_path, alloy, mold):
     """Core upload logic, extracted from the `uploaded_file` state-change
     handler so it is testable without a browser/file-upload round trip:
-    inspects `step_path` via `list_solids`; >1 solid enters assembly mode
-    (`_enter_assembly_mode` -- role panel + 3-D preview, prediction deferred
-    to the Run-assembly button); exactly 1 solid (or a STEP `list_solids`
-    itself can't parse -- fails soft here so it falls through to the SAME
-    meshing/healing pipeline `predict_casting` always used) runs the
-    original single-solid predict-and-render flow, byte-identical to
-    pre-Part-B behavior."""
+    run the prediction and render it, keeping the UI alive on failure."""
     server = app["server"]
     state = server.state
-    try:
-        rows = list_solids(step_path)
-    except Exception:
-        rows = []   # fall back to the pre-Part-B single-body flow untouched
-
-    if len(rows) > 1:
-        _enter_assembly_mode(app, step_path, rows)
-        return
-
-    # Single-solid (or unlistable) upload: leave no assembly-mode residue
-    # behind -- mirrors clear_casting()'s reset of the same four fields, so
-    # a LATER multi-solid upload starts from a clean slate rather than
-    # _enter_assembly_mode briefly recoloring stale meshes/rows from a
-    # previous assembly session (see _enter_assembly_mode's docstring).
-    state.assembly_mode = False
-    state.assembly_bodies = []
-    state.assembly_error = ""
-    state.assembly_step_path = None
-    app["assembly_meshes"] = []
     plotter = app["plotter"]
     out_dir = "runs/castings"
     try:
@@ -559,7 +308,6 @@ def build_app(server=None):
             },
         },
     }
-    sleeve_names_by_type = _load_sleeve_names_by_type()
     for k, v in dict(tau=0.0, tmin=0.0, tmax=1.0, show_hotspots=False,
                      summary=INITIAL_SUMMARY, loaded=False, uploaded_file=None,
                      loading=False, hotspot_size=DEFAULT_HOTSPOT_SIZE,
@@ -567,13 +315,6 @@ def build_app(server=None):
                      anim_uri="", anim_name="solidification.gif",
                      alloy=DEFAULT_ALLOY, mold=DEFAULT_MOLD,
                      alloy_options=list_alloys(), mold_options=list_molds(),
-                     # Assembly mode (Part B Task 5): populated by
-                     # _enter_assembly_mode() on a multi-solid STEP upload.
-                     assembly_mode=False, assembly_bodies=[], assembly_error="",
-                     assembly_step_path=None, role_options=ROLE_OPTIONS,
-                     chill_material_options=sorted(load_chill_effusivities()),
-                     exo_sleeve_options=sleeve_names_by_type["exo"],
-                     insulating_sleeve_options=sleeve_names_by_type["insulating"],
                      ).items():
         state.setdefault(k, v)
 
@@ -621,64 +362,12 @@ def build_app(server=None):
             state.loading = False
             ctrl.view_update()
 
-    @state.change("assembly_bodies")
-    def _on_assembly_bodies_change(**kwargs):
-        # Fires on every role/param edit in the body table (trame syncs the
-        # whole reactive list back on any nested-item mutation) -- just
-        # recolor the already-tessellated preview, never re-tessellate.
-        if state.assembly_mode:
-            _render_assembly_preview(app)
-
-    def run_assembly_prediction():
-        """The assembly panel's "Run" button: build the bodies list from the
-        current panel state, pre-flight it through `validate_bodies` so a
-        training-regime violation (see `src.assembly.validate_bodies`) shows
-        up in the panel (`state.assembly_error`) WITHOUT ever calling
-        `predict_casting` -- never a crash for a bad role combination.
-        `_assemble_bodies_from_state` itself is inside this same try/except:
-        a malformed row (e.g. a missing `solid_id`) is a caller/state bug,
-        not a training-regime violation, but it should surface in the panel
-        exactly the same way -- never a raw traceback, and never a
-        `predict_casting` call on a bodies list that failed to even build."""
-        try:
-            bodies = _assemble_bodies_from_state(state)
-            validate_bodies(bodies)
-        except Exception as e:
-            state.assembly_error = str(e)
-            ctrl.view_update()
-            return
-        state.assembly_error = ""
-        state.loading = True
-        state.flush()
-        try:
-            result = _run_prediction(state.assembly_step_path, "runs/castings",
-                                     state.alloy, state.mold, bodies=bodies)
-            grid = viz.load_prediction(result["vtu"])
-            app["name"] = result["name"]
-            state.assembly_mode = False
-            render_prediction(app, grid, summary_text(result, alloy=state.alloy, mold=state.mold))
-        except Exception as e:            # keep the UI alive on a bad assembly/prediction
-            plotter.clear_actors()
-            _remove_scalar_bar(plotter)
-            app["grid"] = None
-            app["hotspot_actor"] = None
-            state.loaded = False
-            state.summary = f"Prediction failed:\n{e}"
-        finally:
-            state.loading = False
-            ctrl.view_update()
-
-    # Exposed on the controller so the Run button (and tests) can invoke it
-    # without a browser round trip.
-    ctrl.run_assembly_prediction = run_assembly_prediction
-
     def clear_casting():
         """Drop the loaded casting and return to a ready-for-upload state."""
         plotter.clear_actors()
         _remove_scalar_bar(plotter)
         app["grid"] = None
         app["hotspot_actor"] = None
-        app["assembly_meshes"] = []
         state.loaded = False
         state.summary = INITIAL_SUMMARY
         state.uploaded_file = None
@@ -687,10 +376,6 @@ def build_app(server=None):
         state.anim_ready = False
         state.anim_uri = ""
         state.animating = False
-        state.assembly_mode = False
-        state.assembly_bodies = []
-        state.assembly_error = ""
-        state.assembly_step_path = None
         ctrl.view_update()
 
     # Exposed on the controller so tests (and any future non-UI caller) can
@@ -784,57 +469,6 @@ def build_app(server=None):
                                   size="small", color="secondary", disabled=("!loaded",),
                                   classes="mt-2", block=True)
 
-                # Assembly mode (Part B Task 5): shown instead of an
-                # auto-run prediction whenever the STEP upload has >1
-                # solid. One row per body -- role dropdown (defaults
-                # largest=casting/rest=ignore, set by _enter_assembly_mode)
-                # + a role-dependent params select (chill material / sleeve
-                # name, the latter pre-filtered by sleeve type so the UI
-                # never offers a pairing validate_bodies would reject).
-                # `v_model="body.<path>"` (a literal string, not a
-                # (name, default) tuple) is trame's standard per-row
-                # editable-table idiom: it binds directly to the `body`
-                # loop variable from `v_for`, and edits to `assembly_bodies`
-                # sync back to the server as a whole (see
-                # `_on_assembly_bodies_change`).
-                with html.Div(classes="neuralcast-section", v_show=("assembly_mode",)):
-                    html.Div("Assembly (multi-body STEP)",
-                             classes="neuralcast-section-label")
-                    with html.Template(v_for="body in assembly_bodies", key="body.solid_id"):
-                        with html.Div(classes="mb-3"):
-                            html.Div(
-                                "{{ body.name || ('solid ' + body.solid_id) }} "
-                                "— {{ Number(body.volume_mm3).toFixed(0) }} mm³",
-                                style=f"font-size:.75rem; color:{TEXT_MUTED}; "
-                                      "margin-bottom:2px;",
-                            )
-                            vuetify3.VSelect(v_model="body.role", items=("role_options",),
-                                             label="role", density="compact",
-                                             variant="outlined", hide_details=True,
-                                             classes="mb-1")
-                            vuetify3.VSelect(v_model="body.params.material",
-                                             items=("chill_material_options",),
-                                             label="chill material", density="compact",
-                                             variant="outlined", hide_details=True,
-                                             v_if="body.role === 'chill'")
-                            vuetify3.VSelect(v_model="body.params.sleeve",
-                                             items=("exo_sleeve_options",),
-                                             label="sleeve (exo)", density="compact",
-                                             variant="outlined", hide_details=True,
-                                             v_if="body.role === 'exo_sleeve'")
-                            vuetify3.VSelect(v_model="body.params.sleeve",
-                                             items=("insulating_sleeve_options",),
-                                             label="sleeve (insulating)", density="compact",
-                                             variant="outlined", hide_details=True,
-                                             v_if="body.role === 'insulating_sleeve'")
-                    html.Div("{{ assembly_error }}", v_show=("assembly_error",),
-                             style=f"color:{ACCENT_MOLTEN}; font-size:.75rem; "
-                                   "margin:4px 0 8px;")
-                    vuetify3.VBtn("Run Assembly Prediction",
-                                  click=ctrl.run_assembly_prediction,
-                                  variant="tonal", size="small", color="primary",
-                                  disabled=("loading",), loading=("loading",), block=True)
-
                 with html.Div(classes="neuralcast-section"):
                     html.Div("Playback", classes="neuralcast-section-label")
                     vuetify3.VSlider(v_model=("tau",), min=("tmin",), max=("tmax",),

tests/test_assembly.py

@@ -1,732 +0,0 @@
-"""Tests for src/assembly.py -- Part B Task 1: assembly inspection
-(`list_solids`) + the `compose_assembly` test/fixture helper used by later
-Part B fixtures (proximity classification, BC-patch tagging, etc.), and
-Part B Task 2: `validate_bodies -> BcPlan` (no gmsh needed for Task 2)."""
-from __future__ import annotations
-
-import numpy as np
-import pytest
-
-from src.assembly import (BcPlan, list_solids, compose_assembly, main, validate_bodies,
-                           tag_contact_patches, _triangle_areas, _rewrite_msh_adiabatic)
-from src.msh_parse import parse_msh
-from tests.test_prep_parts import _make_one_box_step
-from tools.doe.load_properties import resolve_exo_q0_by_mef
-from tools.doe.prep_parts import heal_and_mesh
-
-
-def test_compose_and_list_two_solid_assembly(tmp_path):
-    """Base box (30x20x10, the "casting") + a smaller box (10x10x6, a
-    "chill") attached at the +z face. `compose_assembly` places the chill
-    sunk `overlap_mm` into the base (default 2.0mm) -- NO boolean op, so the
-    chill's own reported volume is its full analytic 10*10*6, unaffected by
-    the intentional overlap with the base solid. `list_solids` must report
-    both solids, sorted by volume descending (casting first)."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 30.0, 20.0, 10.0)
-
-    out_step = tmp_path / "assembly.step"
-    attachments = [
-        {"shape": "box", "size": (10.0, 10.0, 6.0), "at_face": "+z"},
-    ]
-    n = compose_assembly(str(base_step), attachments, str(out_step))
-    assert n == 2
-
-    rows = list_solids(str(out_step))
-    assert len(rows) == 2
-    assert rows[0]["volume_mm3"] == pytest.approx(30.0 * 20.0 * 10.0, rel=0.05)
-    assert rows[1]["volume_mm3"] == pytest.approx(10.0 * 10.0 * 6.0, rel=0.05)
-    # sorted desc by volume
-    assert rows[0]["volume_mm3"] >= rows[1]["volume_mm3"]
-    for row in rows:
-        assert set(row.keys()) == {"solid_id", "name", "volume_mm3", "bbox", "com"}
-        assert len(row["bbox"]) == 6
-        assert len(row["com"]) == 3
-
-
-def test_list_solids_single_solid(tmp_path):
-    """A plain single-solid STEP (reusing the existing box fixture from
-    tests/test_prep_parts.py) must yield exactly 1 row."""
-    step = tmp_path / "one_box.step"
-    _make_one_box_step(step, 20.0, 20.0, 20.0)
-
-    rows = list_solids(str(step))
-    assert len(rows) == 1
-    assert rows[0]["volume_mm3"] == pytest.approx(20.0 ** 3, rel=0.05)
-
-
-def test_compose_assembly_cylinder_attachment(tmp_path):
-    """Cylinder-shaped attachment (radius, height) at a different face,
-    exercised end to end -- also confirms non-"+z" faces work."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 30.0, 20.0, 10.0)
-
-    out_step = tmp_path / "assembly.step"
-    attachments = [
-        {"shape": "cylinder", "size": (3.0, 15.0), "at_face": "+x", "overlap_mm": 1.5},
-    ]
-    n = compose_assembly(str(base_step), attachments, str(out_step))
-    assert n == 2
-
-    rows = list_solids(str(out_step))
-    assert len(rows) == 2
-    import math
-    cyl_vol = math.pi * 3.0 ** 2 * 15.0
-    volumes = sorted(row["volume_mm3"] for row in rows)
-    assert volumes[0] == pytest.approx(cyl_vol, rel=0.05)
-    assert volumes[1] == pytest.approx(30.0 * 20.0 * 10.0, rel=0.05)
-
-
-def test_main_prints_solid_ids(tmp_path, capsys):
-    """`python -m src.assembly part.step` (exercised here via a direct
-    `main()` call rather than a real subprocess, to keep the test fast)
-    prints a table that includes both solids' ids."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 30.0, 20.0, 10.0)
-    out_step = tmp_path / "assembly.step"
-    compose_assembly(str(base_step),
-                      [{"shape": "box", "size": (10.0, 10.0, 6.0), "at_face": "+z"}],
-                      str(out_step))
-
-    rows = list_solids(str(out_step))
-    rc = main([str(out_step)])
-    captured = capsys.readouterr()
-
-    assert rc == 0
-    for row in rows:
-        assert str(row["solid_id"]) in captured.out
-
-
-# ---------------------------------------------------------------------- #
-# Part B Task 2 -- validate_bodies -> BcPlan (no gmsh; pure dict/CSV logic).
-# All tests use the real, committed registries (data/properties/chills.csv,
-# tools/sleeves/sleeve_registry.csv, data/properties/exo_calibration.csv)
-# since those ARE the production registries and their values are pinned
-# (see module docstrings): cast_iron effusivity 11968, sleeve "SD_4_7K"
-# MEF 1.547 (2026-08-09 sleeve-mef-correction: catalog_klx/catalog_geom =
-# 1.16/0.75, was the synthetic-spread value 1.49 before the fix -- see
-# tools/sleeves/gen_sleeves.py's module docstring).
-# ---------------------------------------------------------------------- #
-def test_validate_bodies_casting_plus_two_chills():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "chill"},
-        {"solid_id": 3, "role": "chill"},
-    ]
-    plan = validate_bodies(bodies)
-    assert isinstance(plan, BcPlan)
-    assert plan.bc_config == "chills"
-    assert plan.casting_solid_id == 1
-    assert sorted(plan.role_solid_ids) == [2, 3]
-    assert plan.n_chills == 2
-    assert plan.chill_effusivity == pytest.approx(11968.0)
-    assert plan.sleeve_MEF == 0.0
-    assert plan.exo_q0 == 0.0
-
-
-def test_validate_bodies_chills_explicit_material_matches_default():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "chills"
-    assert plan.n_chills == 1
-    assert plan.chill_effusivity == pytest.approx(11968.0)
-
-
-def test_validate_bodies_chills_differing_materials_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}},
-        {"solid_id": 3, "role": "chill", "params": {"material": "graphite"}},
-    ]
-    with pytest.raises(ValueError, match="all chills must share one material"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_unknown_chill_material_raises_listing_options():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "chill", "params": {"material": "unobtainium"}},
-    ]
-    with pytest.raises(ValueError) as exc_info:
-        validate_bodies(bodies)
-    msg = str(exc_info.value)
-    assert "unobtainium" in msg
-    assert "cast_iron" in msg  # a known material is listed
-
-
-def test_validate_bodies_exo_sleeve_by_registry_name():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "exo_sleeve"
-    assert plan.role_solid_ids == [2]
-    assert plan.sleeve_MEF == pytest.approx(1.547)
-    assert plan.exo_q0 > 0.0
-    assert plan.exo_q0 == pytest.approx(resolve_exo_q0_by_mef(1.547))
-
-
-def test_validate_bodies_exo_sleeve_manual_mef_override():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"MEF": 1.49}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "exo_sleeve"
-    assert plan.sleeve_MEF == pytest.approx(1.49)
-    assert plan.exo_q0 == pytest.approx(resolve_exo_q0_by_mef(1.49))
-
-
-def test_validate_bodies_insulating_sleeve_no_exo_q0():
-    # FOSECO_V90L is registry type=insulating -- matches role insulating_sleeve.
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "insulating_sleeve", "params": {"sleeve": "FOSECO_V90L"}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "insulating_sleeve"
-    assert plan.sleeve_MEF == pytest.approx(1.15)
-    assert plan.exo_q0 == 0.0
-
-
-def test_validate_bodies_sleeve_both_name_and_mef_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve",
-         "params": {"sleeve": "SD_4_7K", "MEF": 1.49}},
-    ]
-    with pytest.raises(ValueError, match="not both"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_sleeve_neither_name_nor_mef_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {}},
-    ]
-    with pytest.raises(ValueError, match="'sleeve'.*'MEF'|'MEF'.*'sleeve'"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_exo_role_with_insulating_typed_sleeve_raises():
-    # FOSECO_V88E is registry type=insulating, MEF=1.45 -- collides with an
-    # exo_calibration.csv row at MEF=1.45, so without the type cross-check
-    # this would silently resolve a confident nonzero exo_q0 for a
-    # non-exothermic product.
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "FOSECO_V88E"}},
-    ]
-    with pytest.raises(ValueError, match="FOSECO_V88E.*type=insulating"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_insulating_role_with_exo_typed_sleeve_raises():
-    # SD_4_7K is registry type=exo -- must not be accepted under
-    # insulating_sleeve.
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "insulating_sleeve", "params": {"sleeve": "SD_4_7K"}},
-    ]
-    with pytest.raises(ValueError, match="SD_4_7K.*type=exo"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_sleeve_type_matches_role_ok():
-    # exo role + exo-typed sleeve, and insulating role + insulating-typed
-    # sleeve, both resolve cleanly (matched pairs).
-    exo_bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-    ]
-    plan = validate_bodies(exo_bodies)
-    assert plan.bc_config == "exo_sleeve"
-    assert plan.sleeve_MEF == pytest.approx(1.547)
-
-    insulating_bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "insulating_sleeve", "params": {"sleeve": "FOSECO_V88E"}},
-    ]
-    plan2 = validate_bodies(insulating_bodies)
-    assert plan2.bc_config == "insulating_sleeve"
-    assert plan2.sleeve_MEF == pytest.approx(1.45)
-
-
-def test_validate_bodies_manual_mef_bypasses_type_check_either_role():
-    # Manual MEF override has no registry row to check against -- expert
-    # mode, allowed under either sleeve role.
-    exo_bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"MEF": 1.45}},
-    ]
-    plan = validate_bodies(exo_bodies)
-    assert plan.bc_config == "exo_sleeve"
-    assert plan.sleeve_MEF == pytest.approx(1.45)
-
-    insulating_bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "insulating_sleeve", "params": {"MEF": 1.49}},
-    ]
-    plan2 = validate_bodies(insulating_bodies)
-    assert plan2.bc_config == "insulating_sleeve"
-    assert plan2.sleeve_MEF == pytest.approx(1.49)
-    assert plan2.exo_q0 == 0.0
-
-
-def test_validate_bodies_unknown_sleeve_name_raises_listing_options():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "NOT_A_SLEEVE"}},
-    ]
-    with pytest.raises(ValueError) as exc_info:
-        validate_bodies(bodies)
-    msg = str(exc_info.value)
-    assert "NOT_A_SLEEVE" in msg
-    assert "SD_4_7K" in msg
-
-
-def test_validate_bodies_casting_only_bc_none():
-    bodies = [{"solid_id": 1, "role": "casting"}]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "none"
-    assert plan.casting_solid_id == 1
-    assert plan.role_solid_ids == []
-    assert plan.n_chills == 0
-    assert plan.chill_effusivity == 0.0
-    assert plan.sleeve_MEF == 0.0
-    assert plan.exo_q0 == 0.0
-
-
-def test_validate_bodies_ignore_bodies_dropped():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "ignore"},
-        {"solid_id": 3, "role": "ignore", "params": {"whatever": 1}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "none"
-    assert plan.casting_solid_id == 1
-
-
-def test_validate_bodies_zero_castings_raises():
-    bodies = [{"solid_id": 2, "role": "chill"}]
-    with pytest.raises(ValueError, match="exactly one"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_two_castings_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "casting"},
-    ]
-    with pytest.raises(ValueError, match="exactly one"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_chills_plus_sleeve_mixed_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "chill"},
-        {"solid_id": 3, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-    ]
-    with pytest.raises(ValueError, match="chills and a sleeve cannot be combined"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_mixed_sleeve_roles_raises():
-    # SP4 ADDENDUM (2026-08-08): N sleeve bodies are accepted now, but only
-    # when they share one role -- an exo_sleeve + an insulating_sleeve still
-    # raises, because the model has a single sleeve BC channel and cannot
-    # represent both kinds of sleeve heat exchange at once.
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-        {"solid_id": 3, "role": "insulating_sleeve", "params": {"sleeve": "FOSECO_V90L"}},
-    ]
-    with pytest.raises(ValueError, match="one role"):
-        validate_bodies(bodies)
-
-
-def test_validate_bodies_two_same_role_sleeves_resolve():
-    # SP4 ADDENDUM (2026-08-08): two sleeve bodies of the SAME role and the
-    # SAME registry-resolved MEF must now be accepted (this used to raise
-    # "at most one sleeve body is supported"), resolving to that single MEF
-    # exactly and covering both solid_ids in role_solid_ids.
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-        {"solid_id": 3, "role": "exo_sleeve", "params": {"sleeve": "SD_4_7K"}},
-    ]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "exo_sleeve"
-    assert sorted(plan.role_solid_ids) == [2, 3]
-    assert plan.sleeve_MEF == pytest.approx(1.547)
-    assert plan.mef_weighted is False
-    assert plan.mef_spread == pytest.approx(0.0)
-
-
-def test_validate_bodies_unknown_role_raises():
-    bodies = [
-        {"solid_id": 1, "role": "casting"},
-        {"solid_id": 2, "role": "typo_role"},
-    ]
-    with pytest.raises(ValueError, match="unknown role"):
-        validate_bodies(bodies)
-
-
-def test_bcplan_feature_spec_keys_and_values():
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=11968.0)
-    spec = plan.feature_spec(mold_effusivity=1250.0)
-    assert spec == {
-        "mold_effusivity": 1250.0,
-        "bc_config": "chills",
-        "chill_effusivity": 11968.0,
-        "sleeve_MEF": 0.0,
-        "exo_q0": 0.0,
-    }
-
-
-def test_bcplan_gbm_bc_spec_keys_and_exo_q0_mw_conversion():
-    plan = BcPlan(bc_config="exo_sleeve", casting_solid_id=1, role_solid_ids=[2],
-                  sleeve_MEF=1.49, exo_q0=960000.0)
-    spec = plan.gbm_bc_spec()
-    assert spec == {
-        "bc_config": "exo_sleeve",
-        "n_chills": 0,
-        "sleeve_MEF": 1.49,
-        "exo_q0_MW": pytest.approx(0.96),
-    }
-
-
-# ---------------------------------------------------------------------- #
-# Part B Task 3 -- tag_contact_patches: mesh the user-designated casting
-# solid (via prep_parts' new `keep_solid_id`), classify its "Cooling"
-# triangles by proximity to role bodies, and rewrite the mesh's Adiabatic
-# facet group. Real gmsh throughout -- these build a fresh composer fixture
-# each time (see `src.assembly.compose_assembly`'s module docstring for why
-# a few mm of intentional overlap is the fixture convention, not a bug).
-# ---------------------------------------------------------------------- #
-def _elem_est_mm(mesh) -> float:
-    """Same `bbox_diag / n_nodes**(1/3)` local element-size estimate
-    `tag_contact_patches` uses for its default `tol_mm` -- used here only to
-    size test assertion margins, not to drive the function itself."""
-    bbox_diag = float(np.linalg.norm(mesh.node_xyz.max(axis=0) - mesh.node_xyz.min(axis=0)))
-    return bbox_diag / (mesh.node_xyz.shape[0] ** (1.0 / 3.0))
-
-
-def _build_chill_assembly(tmp_path, base_size=(30.0, 20.0, 10.0), chill_size=(10.0, 10.0, 6.0),
-                           overlap_mm=2.0, target_nodes=500):
-    """Base box (the "casting") + a smaller box (the "chill") attached at
-    the "+z" face, exactly the `compose_assembly` fixture pattern used
-    throughout this file. Meshes ONLY the casting (`keep_solid_id`, Task 3's
-    other new capability -- the casting need not be the largest solid in
-    general, though it is here) and returns
-    `(casting_msh_path, assembly_step_path, casting_id, chill_id,
-    heal_and_mesh_result)`."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, *base_size)
-
-    assembly_step = tmp_path / "assembly.step"
-    attachments = [{"shape": "box", "size": chill_size, "at_face": "+z", "overlap_mm": overlap_mm}]
-    compose_assembly(str(base_step), attachments, str(assembly_step))
-
-    rows = list_solids(str(assembly_step))
-    casting_id = max(rows, key=lambda r: r["volume_mm3"])["solid_id"]
-    chill_id = min(rows, key=lambda r: r["volume_mm3"])["solid_id"]
-
-    out_msh = tmp_path / "casting.msh"
-    result = heal_and_mesh(str(assembly_step), str(out_msh), target_nodes=target_nodes,
-                            keep_solid_id=casting_id)
-    assert result["ok"] is True
-    return str(out_msh), str(assembly_step), casting_id, chill_id, result
-
-
-def test_tag_contact_patches_exact_contact_matches_chill_footprint(tmp_path):
-    """Overlap 2mm box chill at "+z" center (compose_assembly's own default
-    overlap) -- the Adiabatic patch must land on the chill's footprint: every
-    Adiabatic centroid within the footprint's xy extent (+- a couple of
-    element widths, since a nonzero tol_mm necessarily dilates the detected
-    region a little past the true edge) and at the casting's top z; total
-    patch area within 30% of the chill's analytic contact-face area. A
-    large-relative-to-tol footprint (40x40mm chill on a 60x50x15mm base) is
-    used so the fixed ~2mm overlap gap doesn't force a tol_mm whose
-    Minkowski-dilation ring is a big fraction of a small footprint's area
-    (verified numerically while writing this test: a 10x10mm footprint blows
-    well past 30% at any tol_mm large enough to bridge a 2mm gap)."""
-    base_size = (60.0, 50.0, 15.0)
-    chill_size = (40.0, 40.0, 6.0)
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(
-        tmp_path, base_size=base_size, chill_size=chill_size, overlap_mm=2.0,
-        target_nodes=3000)
-
-    mesh_before = parse_msh(out_msh)
-    elem_est = _elem_est_mm(mesh_before)
-    tol_mm = 2.5   # > the 2mm overlap gap, small relative to the 40x40 footprint
-
-    tag_result = tag_contact_patches(out_msh, assembly_step, [chill_id], tol_mm=tol_mm)
-
-    assert tag_result["n_adiab_tris"] > 0
-    chill_contact_area = chill_size[0] * chill_size[1]   # dx * dy of the chill footprint
-    assert tag_result["per_body_patch_area_mm2"][chill_id] == pytest.approx(
-        chill_contact_area, rel=0.30)
-
-    mesh_after = parse_msh(out_msh)
-    adiab = mesh_after.tris["Adiabatic"]
-    assert adiab.shape[0] == tag_result["n_adiab_tris"]
-    centroids = mesh_after.node_xyz[adiab].mean(axis=1)
-
-    # Footprint is centered on the base's top face: x in [10, 50], y in [5, 45]
-    # (base 60x50, chill 40x40 centered -> (60-40)/2=10, (50-40)/2=5).
-    margin = tol_mm + elem_est
-    fx_lo, fx_hi = (base_size[0] - chill_size[0]) / 2.0, (base_size[0] + chill_size[0]) / 2.0
-    fy_lo, fy_hi = (base_size[1] - chill_size[1]) / 2.0, (base_size[1] + chill_size[1]) / 2.0
-    assert np.all(centroids[:, 0] >= fx_lo - margin)
-    assert np.all(centroids[:, 0] <= fx_hi + margin)
-    assert np.all(centroids[:, 1] >= fy_lo - margin)
-    assert np.all(centroids[:, 1] <= fy_hi + margin)
-    # at the casting's top face
-    assert np.allclose(centroids[:, 2], base_size[2], atol=margin)
-
-
-def test_tag_contact_patches_nodes_by_solid_matches_adiabatic_group(tmp_path):
-    """Part-B roles task (2026-08-03): `nodes_by_solid` -- the in-memory
-    per-solid contact-patch node-id mapping `tag_contact_patches` now also
-    returns -- must, for a single role body, exactly equal the node ids of
-    the "Adiabatic" group the SAME call wrote to `out_msh` (with only one
-    body, that body's own `close` mask IS the Adiabatic union)."""
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(
-        tmp_path, overlap_mm=2.0, target_nodes=500)
-
-    tag_result = tag_contact_patches(out_msh, assembly_step, [chill_id], tol_mm=3.0)
-
-    assert set(tag_result["nodes_by_solid"]) == {chill_id}
-    mesh_after = parse_msh(out_msh)
-    adiab_nodes = sorted(set(mesh_after.tris["Adiabatic"].reshape(-1).tolist()))
-    assert tag_result["nodes_by_solid"][chill_id] == adiab_nodes
-    # sorted, unique, and does not mutate the .msh/node-order contract --
-    # covered independently by test_tag_contact_patches_preserves_node_
-    # order_and_tets; here just confirm it's genuinely sorted+unique.
-    assert tag_result["nodes_by_solid"][chill_id] == sorted(
-        set(tag_result["nodes_by_solid"][chill_id]))
-
-
-def test_tag_contact_patches_small_clearance_still_found(tmp_path):
-    """0.1mm CLEARANCE (overlap_mm=-0.1, a hair short of touching) with
-    tol_mm >= 0.5mm must still find the patch."""
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(
-        tmp_path, overlap_mm=-0.1, target_nodes=500)
-
-    tag_result = tag_contact_patches(out_msh, assembly_step, [chill_id], tol_mm=0.5)
-
-    assert tag_result["n_adiab_tris"] > 0
-    assert tag_result["per_body_patch_area_mm2"][chill_id] > 0.0
-
-
-def test_tag_contact_patches_far_body_raises(tmp_path):
-    """A body 10mm away with tol_mm=1mm must raise -- never a silent
-    all-sand prediction for a body the caller explicitly assigned a role
-    to."""
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(
-        tmp_path, overlap_mm=-10.0, target_nodes=500)
-
-    with pytest.raises(ValueError, match=f"body {chill_id} does not touch"):
-        tag_contact_patches(out_msh, assembly_step, [chill_id], tol_mm=1.0)
-
-
-def test_tag_contact_patches_preserves_node_order_and_tets(tmp_path):
-    """The rewritten mesh's node ids/coords and tet connectivity must be
-    EXACTLY unchanged -- features/geodesics depend on it (see the module
-    docstring's node-order caution). Parses before AND after, independently
-    of `tag_contact_patches`'s own internal round-trip assertion."""
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(
-        tmp_path, overlap_mm=2.0, target_nodes=500)
-
-    mesh_before = parse_msh(out_msh)
-
-    tag_contact_patches(out_msh, assembly_step, [chill_id], tol_mm=3.0)
-
-    mesh_after = parse_msh(out_msh)
-    assert np.allclose(mesh_after.node_xyz, mesh_before.node_xyz)
-    assert mesh_after.tets.shape == mesh_before.tets.shape
-    assert np.array_equal(mesh_after.tets, mesh_before.tets)
-    # sanity: some Cooling triangles actually migrated to Adiabatic
-    assert "Adiabatic" in mesh_after.tris
-    assert mesh_after.tris["Cooling"].shape[0] < mesh_before.tris["Cooling"].shape[0]
-    assert (mesh_before.tris["Cooling"].shape[0]
-            == mesh_after.tris["Cooling"].shape[0] + mesh_after.tris["Adiabatic"].shape[0])
-
-
-def test_tag_contact_patches_unknown_role_solid_id_raises(tmp_path):
-    """A role `solid_id` that doesn't exist in `step_path` at all must fail
-    loudly (whatever form that takes -- gmsh itself raises when asked for
-    the boundary of a nonexistent entity), never silently produce an empty
-    or wrong patch."""
-    out_msh, assembly_step, casting_id, chill_id, _result = _build_chill_assembly(tmp_path)
-
-    with pytest.raises(Exception):
-        tag_contact_patches(out_msh, assembly_step, [9999], tol_mm=3.0)
-
-
-def test_heal_and_mesh_keep_solid_id_meshes_small_chill_from_assembly(tmp_path):
-    """Part B Task 3's other change: `heal_and_mesh(..., keep_solid_id=...)`
-    meshes the SMALL (chill) solid out of a composed multi-body assembly
-    (n_nodes/volume consistent with its own size), while the largest-solid
-    default on the SAME input is untouched (still meshes the big casting)."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 30.0, 20.0, 10.0)
-    assembly_step = tmp_path / "assembly.step"
-    compose_assembly(str(base_step),
-                      [{"shape": "box", "size": (10.0, 10.0, 6.0), "at_face": "+z"}],
-                      str(assembly_step))
-
-    rows = list_solids(str(assembly_step))
-    casting_row = max(rows, key=lambda r: r["volume_mm3"])
-    chill_row = min(rows, key=lambda r: r["volume_mm3"])
-
-    out_msh_chill = tmp_path / "chill.msh"
-    result_chill = heal_and_mesh(str(assembly_step), str(out_msh_chill), target_nodes=300,
-                                  keep_solid_id=chill_row["solid_id"])
-    assert result_chill["ok"] is True
-    assert result_chill["volume_mm3"] == pytest.approx(chill_row["volume_mm3"], rel=0.05)
-
-    out_msh_default = tmp_path / "default.msh"
-    result_default = heal_and_mesh(str(assembly_step), str(out_msh_default), target_nodes=300)
-    assert result_default["ok"] is True
-    assert result_default["volume_mm3"] == pytest.approx(casting_row["volume_mm3"], rel=0.05)
-
-
-# ---------------------------------------------------------------------- #
-# Code-review follow-ups (2026-07-29): total-Cooling-consumption guard,
-# per_body_patch_area_mm2's documented double-counting behavior, and the
-# clean (no bare StopIteration) too-few-flags path in
-# `_rewrite_msh_adiabatic`.
-# ---------------------------------------------------------------------- #
-def test_tag_contact_patches_enveloping_body_raises_no_cooling_remains(tmp_path):
-    """A role body that tightly ENVELOPES the entire casting (every Cooling
-    triangle ends up within tol_mm of it) must raise loudly -- if every
-    triangle were silently relabeled Adiabatic, `geodesic_d_cool` (see
-    `src.features`) would have no "Cooling" surface left to measure
-    distance to and would silently degrade to bbox_diag-derived constants
-    (confidently wrong physics, not a loud failure)."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 30.0, 20.0, 10.0)
-
-    assembly_step = tmp_path / "assembly.step"
-    # A box attached at "+z" with overlap_mm >= its own along-normal size
-    # sinks past the base's bottom too, and a face-plane size well past the
-    # base's own x/y extent -- the result envelopes the base on all 6 sides
-    # with a uniform ~5mm margin (worked out analytically: dz=20,
-    # overlap_mm=15 -> z in [-5, 15] vs the base's [0, 10]; dx=40, dy=30
-    # centered on the base's own center -> x in [-5, 35] vs [0, 30], y in
-    # [-5, 25] vs [0, 20]).
-    envelope = {"shape": "box", "size": (40.0, 30.0, 20.0), "at_face": "+z", "overlap_mm": 15.0}
-    compose_assembly(str(base_step), [envelope], str(assembly_step))
-
-    rows = list_solids(str(assembly_step))
-    casting_id = max(rows, key=lambda r: r["volume_mm3"])["solid_id"]
-    envelope_id = min(rows, key=lambda r: r["volume_mm3"])["solid_id"]
-
-    out_msh = tmp_path / "casting.msh"
-    result = heal_and_mesh(str(assembly_step), str(out_msh), target_nodes=500,
-                            keep_solid_id=casting_id)
-    assert result["ok"] is True
-
-    with pytest.raises(ValueError, match="cover the entire casting surface"):
-        tag_contact_patches(str(out_msh), str(assembly_step), [envelope_id], tol_mm=8.0)
-
-
-def test_tag_contact_patches_two_bodies_double_count_area_single_count_tris(tmp_path):
-    """Two role bodies whose tolerance zones overlap on the casting surface:
-    `per_body_patch_area_mm2` sums each body's own area INDEPENDENTLY (the
-    shared triangles counted once per body -- documented double-counting),
-    while `n_adiab_tris` (and the actual rewritten "Adiabatic" group) counts
-    each such triangle exactly once, via the union mask."""
-    base_step = tmp_path / "base.step"
-    _make_one_box_step(base_step, 60.0, 50.0, 15.0)
-
-    assembly_step = tmp_path / "assembly.step"
-    # Two 40x40x6 chills at "+z", offset +-10mm in x -- footprints
-    # [0,40] and [20,60] in x (both y in [5,45]) overlap in a 20mm-wide
-    # x in [20,40] band.
-    attachments = [
-        {"shape": "box", "size": (40.0, 40.0, 6.0), "at_face": "+z", "offset": (-10.0, 0.0)},
-        {"shape": "box", "size": (40.0, 40.0, 6.0), "at_face": "+z", "offset": (10.0, 0.0)},
-    ]
-    compose_assembly(str(base_step), attachments, str(assembly_step))
-
-    rows = list_solids(str(assembly_step))
-    casting_id = max(rows, key=lambda r: r["volume_mm3"])["solid_id"]
-    role_ids = sorted(r["solid_id"] for r in rows if r["solid_id"] != casting_id)
-    assert len(role_ids) == 2
-
-    out_msh = tmp_path / "casting.msh"
-    result = heal_and_mesh(str(assembly_step), str(out_msh), target_nodes=3000,
-                            keep_solid_id=casting_id)
-    assert result["ok"] is True
-
-    tag_result = tag_contact_patches(str(out_msh), str(assembly_step), role_ids, tol_mm=2.5)
-
-    areas = tag_result["per_body_patch_area_mm2"]
-    assert set(areas) == set(role_ids)
-    for solid_id in role_ids:
-        assert areas[solid_id] > 0.0
-    # symmetric footprints (mirrored offsets) -> roughly equal per-body areas
-    assert areas[role_ids[0]] == pytest.approx(areas[role_ids[1]], rel=0.05)
-
-    mesh_after = parse_msh(str(out_msh))
-    adiab = mesh_after.tris["Adiabatic"]
-    assert adiab.shape[0] == tag_result["n_adiab_tris"]
-
-    true_union_area = float(_triangle_areas(mesh_after.node_xyz, adiab).sum())
-    # The overlap region's triangles are counted in BOTH bodies' areas, so
-    # the sum across bodies must exceed the true (single-counted) union
-    # area -- pins the documented double-counting behavior.
-    assert sum(areas.values()) > true_union_area * 1.10
-
-    # nodes_by_solid (Part-B roles task): each body's own node set may share
-    # nodes with the other's (the overlap band's shared triangles), but the
-    # UNION across both bodies' node sets must equal exactly the true
-    # Adiabatic node set -- no node is dropped or invented.
-    assert set(tag_result["nodes_by_solid"]) == set(role_ids)
-    nodes_union = set()
-    for solid_id in role_ids:
-        nodes_union.update(tag_result["nodes_by_solid"][solid_id])
-    assert nodes_union == set(adiab.reshape(-1).tolist())
-
-
-def test_rewrite_msh_adiabatic_too_few_flags_raises_clean_assertion_error(tmp_path):
-    """A flag array SHORTER than the number of Cooling-tagged triangle
-    elements in the file must raise a clean `AssertionError` -- not a bare
-    `StopIteration` (the old `next(flags)`-inside-the-loop bug: exhausting
-    an iterator this way raises `StopIteration`, which is not a deliberate,
-    documented failure mode)."""
-    step = tmp_path / "box.step"
-    _make_one_box_step(step, 30.0, 20.0, 10.0)
-    out_msh = tmp_path / "box.msh"
-    result = heal_and_mesh(str(step), str(out_msh), target_nodes=300)
-    assert result["ok"] is True
-
-    n_cooling = parse_msh(str(out_msh)).tris["Cooling"].shape[0]
-    too_few = np.zeros(n_cooling - 1, dtype=bool)   # one short
-
-    with pytest.raises(AssertionError, match="fewer"):
-        _rewrite_msh_adiabatic(str(out_msh), too_few)
-
-
-def test_rewrite_msh_adiabatic_too_many_flags_raises_clean_assertion_error(tmp_path):
-    step = tmp_path / "box.step"
-    _make_one_box_step(step, 30.0, 20.0, 10.0)
-    out_msh = tmp_path / "box.msh"
-    result = heal_and_mesh(str(step), str(out_msh), target_nodes=300)
-    assert result["ok"] is True
-
-    n_cooling = parse_msh(str(out_msh)).tris["Cooling"].shape[0]
-    too_many = np.zeros(n_cooling + 1, dtype=bool)   # one extra
-
-    with pytest.raises(AssertionError, match="more flag"):
-        _rewrite_msh_adiabatic(str(out_msh), too_many)

tests/test_assembly_multisleeve.py

@@ -1,105 +0,0 @@
-"""Multi-sleeve resolution (SP4 spec ADDENDUM).
-
-Real castings carry several sleeves; the pre-SP4 code accepted exactly one.
-These tests pin the three cases: identical sleeves resolve exactly, differing
-sleeves need explicit weights, and mixed sleeve ROLES still raise.
-"""
-import pytest
-
-from src.assembly import validate_bodies
-
-CASTING = {"solid_id": 1, "role": "casting"}
-
-
-def _exo(solid_id, sleeve):
-    return {"solid_id": solid_id, "role": "exo_sleeve", "params": {"sleeve": sleeve}}
-
-
-def test_three_identical_sleeves_resolve_exactly():
-    plan = validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_4_7K"),
-                            _exo(4, "SD_4_7K")])
-    assert plan.bc_config == "exo_sleeve"
-    assert sorted(plan.role_solid_ids) == [2, 3, 4]
-    assert plan.sleeve_MEF == pytest.approx(1.547)
-    assert plan.mef_weighted is False
-    assert plan.mef_spread == pytest.approx(0.0)
-    assert plan.exo_q0 > 0.0
-    assert plan.role_by_solid == {2: "exo_sleeve", 3: "exo_sleeve", 4: "exo_sleeve"}
-
-
-def test_differing_mef_without_weights_raises():
-    with pytest.raises(ValueError, match="differing MEF"):
-        validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_5_8K")])
-
-
-def test_differing_mef_error_points_at_the_two_pass_path():
-    """Review I3: `predict_casting` cannot supply `mef_weights` (contact-
-    patch areas don't exist until after meshing/tagging), so the message a
-    user actually sees must not just name the missing parameter -- it must
-    say where areas come from and which callers already do the two-pass
-    resolution correctly."""
-    with pytest.raises(ValueError, match="tag_contact_patches") as exc:
-        validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_5_8K")])
-    msg = str(exc.value)
-    assert "tools/sp4/prep.py" in msg
-    assert "tools/sp4/score.py" in msg
-
-
-def test_differing_mef_area_weighted():
-    # SD_4_7K MEF 1.547 over 300 mm2, SD_5_8K MEF 1.579 over 100 mm2
-    # (2026-08-09 sleeve-mef-correction: catalog_klx/catalog_geom, was
-    # 1.49/1.63 before the fix) -> (1.547*300 + 1.579*100) / 400 = 1.555
-    plan = validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_5_8K")],
-                           mef_weights={2: 300.0, 3: 100.0})
-    assert plan.sleeve_MEF == pytest.approx(1.555)
-    assert plan.mef_weighted is True
-    assert plan.mef_spread == pytest.approx(1.579 - 1.547)
-    assert sorted(plan.role_solid_ids) == [2, 3]
-
-
-def test_weights_missing_a_sleeve_raises():
-    with pytest.raises(ValueError, match="mef_weights"):
-        validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_5_8K")],
-                        mef_weights={2: 300.0})
-
-
-def test_nonpositive_weight_raises():
-    with pytest.raises(ValueError, match="positive"):
-        validate_bodies([CASTING, _exo(2, "SD_4_7K"), _exo(3, "SD_5_8K")],
-                        mef_weights={2: 300.0, 3: 0.0})
-
-
-def test_mixed_sleeve_roles_still_raise():
-    bodies = [CASTING, _exo(2, "SD_4_7K"),
-              {"solid_id": 3, "role": "insulating_sleeve",
-               "params": {"sleeve": "FOSECO_V90L"}}]
-    with pytest.raises(ValueError, match="one role"):
-        validate_bodies(bodies)
-
-
-def test_single_sleeve_unchanged():
-    """The pre-SP4 single-sleeve path must be byte-identical."""
-    plan = validate_bodies([CASTING, _exo(2, "SD_4_7K")])
-    assert plan.role_solid_ids == [2]
-    assert plan.sleeve_MEF == pytest.approx(1.547)
-    assert plan.mef_weighted is False
-    assert plan.mef_spread == pytest.approx(0.0)
-
-
-def test_manual_mef_override_across_several_sleeves():
-    bodies = [CASTING,
-              {"solid_id": 2, "role": "exo_sleeve", "params": {"MEF": 1.49}},
-              {"solid_id": 3, "role": "exo_sleeve", "params": {"MEF": 1.49}}]
-    plan = validate_bodies(bodies)
-    assert plan.sleeve_MEF == pytest.approx(1.49)
-    assert plan.mef_weighted is False
-
-
-def test_chills_path_unchanged():
-    bodies = [CASTING,
-              {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}},
-              {"solid_id": 3, "role": "chill", "params": {"material": "cast_iron"}}]
-    plan = validate_bodies(bodies)
-    assert plan.bc_config == "chills"
-    assert plan.n_chills == 2
-    assert plan.mef_weighted is False

tests/test_inference_props.py

@@ -5,20 +5,22 @@ from src.shrinkage import SHRINKAGE_PCT
 
 REQ = {"k", "rho", "cp", "L_kJ_kg", "TL", "TS", "Tpour", "mold_effusivity"}
 
-def test_default_is_gjl250_green_sand():
+def test_default_is_gjs400_green_sand():
     p = resolve_props()
     assert set(p) == REQ and all(isinstance(v, float) for v in p.values())
-    assert p["TL"] == 1220.0 and p["TS"] == 1150.0          # EN-GJL-250 row
-    assert p["Tpour"] == pytest.approx((1310 + 1330) / 2)    # midpoint rule
+    assert p["TL"] == 1160.0 and p["TS"] == 1120.0          # EN-GJS-400-15 row
+    assert p["Tpour"] == pytest.approx((1250 + 1270) / 2)    # midpoint rule
     assert p["mold_effusivity"] == pytest.approx(1018.0)     # molds.csv, NOT 1250
 
 def test_named_alloy_and_lists():
-    assert DEFAULT_ALLOY in list_alloys() and "green_sand" in list_molds()
-    p = resolve_props(alloy="EN-GJS-400-15")
-    assert p["TS"] == 1120.0
+    assert DEFAULT_ALLOY in list_alloys()
+    assert list_alloys() == ["EN-GJS-400-15", "G20Mn5"]
+    assert list_molds() == ["green_sand"]
+    p = resolve_props(alloy="G20Mn5")
+    assert p["TS"] == 1495.0
 
 def test_unknown_names_raise_listing_options():
-    with pytest.raises(ValueError, match="EN-GJL-250"):
+    with pytest.raises(ValueError, match="EN-GJS-400-15"):
         resolve_props(alloy="unobtainium")
     with pytest.raises(ValueError, match="green_sand"):
         resolve_props(mold="vacuum")
@@ -61,8 +63,9 @@ def test_named_alloy_tl_ts_still_valid_after_i2_guard():
     # validated by tools.doe.load_properties.load_materials's own TS<TL<Tpour
     # check at CSV-load time -- this just proves resolve_props's OWN check
     # doesn't double-reject a legitimately-ordered grade).
-    p = resolve_props(alloy="EN-GJL-250")
-    assert p["TL"] > p["TS"]
+    for grade in list_alloys():
+        p = resolve_props(alloy=grade)
+        assert p["TL"] > p["TS"]
 
 
 # --------------------------------------------------------------------------- #
@@ -83,8 +86,8 @@ def test_resolve_alloy_family_known_prefixes():
 
 
 def test_resolve_alloy_family_default_alloy_when_none():
-    # None -> DEFAULT_ALLOY (EN-GJL-250) -> grey_iron, not assumed.
-    assert resolve_alloy_family(None) == ("grey_iron", False)
+    # None -> DEFAULT_ALLOY (EN-GJS-400-15) -> ductile_iron, not assumed.
+    assert resolve_alloy_family(None) == ("ductile_iron", False)
 
 
 def test_resolve_alloy_family_unknown_prefix_falls_back_loud():

tests/test_model_api.py

@@ -0,0 +1,25 @@
+"""CastSolidModel: mesh in, per-node seconds out (needs the published weights)."""
+import os
+
+import numpy as np
+import pytest
+
+from src.model_api import CastSolidModel
+
+WEIGHTS = "weights/gnn_v5.1.safetensors"
+
+
+def test_hotspots_matches_top_fraction():
+    t = np.arange(100, dtype=np.float32)
+    mask = CastSolidModel.hotspots(t)
+    assert mask.sum() == 10 and mask[-10:].all()
+
+
+@pytest.mark.skipif(not os.path.exists(WEIGHTS), reason="published weights not present")
+def test_predict_on_mesh(mini_msh_file):
+    model = CastSolidModel(device="cpu")
+    t_iron = model.predict(mini_msh_file)
+    t_steel = model.predict(mini_msh_file, alloy="G20Mn5")
+    assert t_iron.shape == t_steel.shape and t_iron.ndim == 1
+    assert np.all(np.isfinite(t_iron)) and np.all(t_iron >= 0)
+    assert not np.allclose(t_iron, t_steel)

tests/test_predict_casting_v4.py

@@ -13,13 +13,6 @@ by default (`mesh_mode="prep"`), with `mesh_mode="raw"` (or an explicit
 path. The routing tests below monkeypatch both meshing functions as
 recorders (plus `load_hybrid`/`predict_field`) -- no real gmsh/model
 checkpoints are touched.
-
-Part B Task 4: `predict_casting(bodies=...)` wiring -- `validate_bodies` ->
-mesh via the cache with `keep_solid_id`/`bodies_key` -> `tag_contact_patches`
-(cached as a `post_mesh` hook) -> the film spec/gbm bc_spec carry the
-resolved `BcPlan`. All of it is exercised with monkeypatched recorders
-(`validate_bodies`/`tag_contact_patches`/`get_or_mesh`/`predict_field`) --
-no real gmsh/model checkpoints are touched here either.
 """
 import json
 import logging
@@ -135,8 +128,8 @@ def test_film_path_changing_alloy_changes_field():
     gnn = _make_film_gnn(seed=0)
     hgb = _StubHGB(n_features_in_=16, total_seconds=50.0)
 
-    props_a = resolve_props(alloy="EN-GJL-250")
-    props_b = resolve_props(alloy="EN-GJS-500-7")
+    props_a = resolve_props(alloy="EN-GJS-400-15")
+    props_b = resolve_props(alloy="G20Mn5")
     out_a, _ = predict_field(mesh, gnn, hgb, _norm15(), cfg=_film_cfg(),
                              device="cpu", props=props_a)
     out_b, _ = predict_field(mesh, gnn, hgb, _norm15(), cfg=_film_cfg(),
@@ -151,50 +144,6 @@ def test_film_path_changing_alloy_changes_field():
     assert not np.allclose(out_a, out_b)
 
 
-def test_film_path_with_bc_plan_uses_plan_feature_spec_and_gbm_bc_spec(monkeypatch):
-    """Part B Task 4: `predict_field(bc_plan=...)` feeds the film branch
-    `plan.feature_spec(...)` (the chill/sleeve spec) instead of the
-    all-sand literal, and `plan.gbm_bc_spec()` into `gbm_v2_total_seconds`.
-    Spies on the module-level `compute_features_inference` / `gbm_v2_total_seconds`
-    (both real, just observed) to capture exactly what spec/bc_spec were
-    built, without needing a real multi-body mesh."""
-    from src.assembly import BcPlan
-
-    mesh = _all_cooling_cube()
-    gnn = _make_film_gnn(seed=0)
-    hgb = _StubHGB(n_features_in_=16, total_seconds=50.0)
-    props = resolve_props()
-
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=2, chill_effusivity=9876.5)
-
-    captured_spec = {}
-    real_compute = pc_mod.compute_features_inference
-
-    def spy_compute(mesh_, version=2, spec=None):
-        captured_spec["spec"] = spec
-        return real_compute(mesh_, version=version, spec=spec)
-
-    captured_bc_spec = {}
-    real_gbm = pc_mod.gbm_v2_total_seconds
-
-    def spy_gbm(hgb_model, props_, v_over_a, bc_spec=None):
-        captured_bc_spec["bc_spec"] = bc_spec
-        return real_gbm(hgb_model, props_, v_over_a, bc_spec=bc_spec)
-
-    monkeypatch.setattr(pc_mod, "compute_features_inference", spy_compute)
-    monkeypatch.setattr(pc_mod, "gbm_v2_total_seconds", spy_gbm)
-
-    predict_field(mesh, gnn, hgb, _norm15(), cfg=_film_cfg(), device="cpu",
-                 props=props, bc_plan=plan)
-
-    assert captured_spec["spec"]["bc_config"] == "chills"
-    assert captured_spec["spec"]["chill_effusivity"] == pytest.approx(9876.5)
-    assert captured_spec["spec"]["mold_effusivity"] == pytest.approx(props["mold_effusivity"])
-    assert captured_bc_spec["bc_spec"]["bc_config"] == "chills"
-    assert captured_bc_spec["bc_spec"]["n_chills"] == 2
-
-
 def test_film_path_without_bc_plan_spec_stays_all_sand_literal(monkeypatch):
     """`bc_plan=None` (the default) -- byte-identical to the pre-Part-B
     behavior: the all-sand literal spec, and `bc_spec=None` into the GBM
@@ -261,22 +210,6 @@ def test_film_cfg_without_props_raises():
 N_COLS_V5 = 20
 
 
-def _cube_with_bc_patch(n=5, a=20.0):
-    """Same fixture as tests/test_features_v5.py: a Delaunay cube with the
-    z=0 face tagged 'Adiabatic' (BC patch) and every other hull face
-    'Cooling' -- needed (unlike `_all_cooling_cube`) so a bc_plan's
-    chill/exo source patch has somewhere to sit."""
-    lin = np.linspace(0.0, a, n)
-    pts = np.array([[x, y, z] for x in lin for y in lin for z in lin], float)
-    dt = Delaunay(pts)
-    tets = dt.simplices.astype(np.int64)
-    hull = dt.convex_hull.astype(np.int64)
-    is_bottom = np.isclose(pts[hull, 2], 0.0).all(axis=1)
-    adiab_tri = hull[is_bottom]
-    cool_tri = hull[~is_bottom]
-    return Mesh(node_xyz=pts, tris={"Cooling": cool_tri, "Adiabatic": adiab_tri}, tets=tets)
-
-
 def _make_film_gnn_v5(seed=0):
     """`_make_film_gnn` at node_in=N_COLS_V5 (20) -- otherwise identical
     (non-zero-init FiLM last layer, so `g` is not a no-op)."""
@@ -358,56 +291,6 @@ def test_v5_cfg_film_path_builds_20_column_x_all_sand_last_five_zero():
     assert (X[:, 15:] == 0.0).all()
 
 
-def test_v5_cfg_bodies_exo_patch_populates_exo_channels_not_chill(monkeypatch):
-    """(c) A bodies/BcPlan exo_sleeve patch resolved EXACTLY the way the
-    training builder does (`bc_plan.feature_spec(...)`, same spec keys)
-    must populate exo_mid/exo_long nonzero while leaving every chill
-    channel exactly zero -- the SAME spec resolution `compute_features_
-    inference`'s v4 branch already uses, now flowing into
-    `compute_bc_reach_channels` via the version=5 dispatch."""
-    from src.assembly import BcPlan
-
-    mesh = _cube_with_bc_patch()
-    gnn = _make_film_gnn_v5(seed=0)
-    hgb = _StubHGB(n_features_in_=16, total_seconds=50.0)
-    props = resolve_props()
-    plan = BcPlan(bc_config="exo_sleeve", casting_solid_id=1, role_solid_ids=[2],
-                  sleeve_MEF=2.0, exo_q0=5000.0)
-
-    out, feat = predict_field(mesh, gnn, hgb, _norm20(), cfg=_film_cfg_v5(),
-                              device="cpu", props=props, bc_plan=plan)
-    X = feat["X"]
-    idx = {n: i for i, n in enumerate(FEATURE_NAMES_V5)}
-    assert X[:, idx["exo_mid"]].max() > 0.0
-    assert X[:, idx["exo_long"]].max() > 0.0
-    assert (X[:, idx["chill_short"]] == 0.0).all()
-    assert (X[:, idx["chill_mid"]] == 0.0).all()
-    assert (X[:, idx["chill_long"]] == 0.0).all()
-
-
-def test_v5_cfg_bodies_chill_patch_populates_chill_channels_not_exo(monkeypatch):
-    """(c), vice versa: a chills BcPlan populates chill_short/mid/long
-    nonzero while exo_mid/exo_long stay exactly zero."""
-    from src.assembly import BcPlan
-
-    mesh = _cube_with_bc_patch()
-    gnn = _make_film_gnn_v5(seed=0)
-    hgb = _StubHGB(n_features_in_=16, total_seconds=50.0)
-    props = resolve_props()
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=2, chill_effusivity=9876.5)
-
-    out, feat = predict_field(mesh, gnn, hgb, _norm20(), cfg=_film_cfg_v5(),
-                              device="cpu", props=props, bc_plan=plan)
-    X = feat["X"]
-    idx = {n: i for i, n in enumerate(FEATURE_NAMES_V5)}
-    assert X[:, idx["chill_short"]].max() > 0.0
-    assert X[:, idx["chill_mid"]].max() > 0.0
-    assert X[:, idx["chill_long"]].max() > 0.0
-    assert (X[:, idx["exo_mid"]] == 0.0).all()
-    assert (X[:, idx["exo_long"]] == 0.0).all()
-
-
 # --------------------------------------------------------------------------- #
 # SP1 (non-film) path: byte-identical regression
 # --------------------------------------------------------------------------- #
@@ -517,22 +400,6 @@ def _fake_get_or_mesh(calls, mini_msh_file, ok=True, cache="miss"):
     return _fn
 
 
-def _fake_tag_contact_patches(calls, per_body_patch_area_mm2=None, n_adiab_tris=7,
-                              nodes_by_solid=None):
-    per_body_patch_area_mm2 = per_body_patch_area_mm2 or {2: 42.0}
-
-    def _fn(msh_path, step_path, role_solid_ids, tol_mm=None):
-        calls.setdefault("tag_contact_patches", []).append(
-            dict(msh_path=msh_path, step_path=step_path,
-                 role_solid_ids=list(role_solid_ids), tol_mm=tol_mm))
-        result = {"per_body_patch_area_mm2": dict(per_body_patch_area_mm2),
-                  "n_adiab_tris": n_adiab_tris}
-        if nodes_by_solid is not None:
-            result["nodes_by_solid"] = {k: list(v) for k, v in nodes_by_solid.items()}
-        return result
-    return _fn
-
-
 def _fake_mesh_step(calls, mini_msh_file):
     def _fn(step_path, out_msh, elem_size=None):
         calls["mesh_step"] = dict(step_path=step_path, out_msh=out_msh, elem_size=elem_size)
@@ -617,618 +484,6 @@ def test_predict_casting_includes_cache_hit_in_result(
     assert out["cache"] == "hit"
 
 
-# --------------------------------------------------------------------------- #
-# Part B Task 4: predict_casting(bodies=...) wiring -- monkeypatched
-# recorders for validate_bodies/tag_contact_patches/get_or_mesh/predict_field,
-# no real gmsh/model checkpoints touched.
-# --------------------------------------------------------------------------- #
-def _fake_validate_bodies(calls, plan):
-    def _fn(bodies, **kw):
-        calls["validate_bodies_arg"] = bodies
-        return plan
-    return _fn
-
-
-def test_bodies_given_wires_keep_solid_id_bodies_key_and_tagging(
-        monkeypatch, mini_msh_file, tmp_path):
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0)
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-
-    captured = {}
-
-    def fake_predict_field(mesh, gnn_model, hgb_model, norm, cfg=None, device=None, tta=0,
-                           baseline_norm=None, props=None, bc_plan=None, hgb_std=None,
-                           lambda_shrink=1.0, w_total=1.0, w_std=1.0):
-        captured["bc_plan"] = bc_plan
-        return np.arange(5, dtype=np.float64) + 1.0, {"X": np.zeros((5, 9))}
-
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field", fake_predict_field)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    assert calls["validate_bodies_arg"] == bodies
-    assert calls["get_or_mesh"]["keep_solid_id"] == 1
-    assert calls["get_or_mesh"]["bodies_key"] != "none"
-    assert "tag_contact_patches" in calls
-    assert calls["tag_contact_patches"][0]["role_solid_ids"] == [2]
-    assert captured["bc_plan"] is plan
-    assert out["bc_config"] == "chills"
-    assert out["per_body_patch_area_mm2"] == {2: 42.0}
-
-
-# --------------------------------------------------------------------------- #
-# Shrinkage-screening spec ADDENDUM 2 (2026-08-01, owner-approved SCOPED
-# SHIP): Gate C passed on all-sand/sleeve-only inputs but FAILED on the
-# chill-bearing slice (rho 0.313) -- a chill-bearing BC plan
-# (`bc_config == "chills"`) must mark "niyama_confidence": "low" + a summary
-# caveat; sleeve-only/bare inputs stay "full". Follows the same
-# validate_bodies/BcPlan monkeypatch pattern as the Part B tests above.
-# --------------------------------------------------------------------------- #
-def test_bodies_chill_role_marks_niyama_confidence_low_with_summary_caveat(
-        monkeypatch, mini_msh_file, tmp_path):
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0)
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    assert out["shrinkage"] is not None
-    assert out["shrinkage"]["niyama_confidence"] == "low"
-    with open(out["summary"]) as f:
-        summary_text = f.read()
-    assert "niyama confidence: LOW" in summary_text
-    assert "rho 0.313" in summary_text
-
-
-def test_bodies_sleeve_only_role_keeps_niyama_confidence_full_no_caveat(
-        monkeypatch, mini_msh_file, tmp_path):
-    """A sleeve-only BC plan (bc_config="insulating_sleeve", no chill role
-    at all) is UNAFFECTED by the chills-only Gate C gap -- stays "full",
-    no caveat line."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="insulating_sleeve", casting_solid_id=1, role_solid_ids=[2])
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "insulating_sleeve"}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    assert out["shrinkage"] is not None
-    assert out["shrinkage"]["niyama_confidence"] == "full"
-    with open(out["summary"]) as f:
-        summary_text = f.read()
-    assert "niyama confidence: LOW" not in summary_text
-    assert "rho 0.313" not in summary_text
-
-
-def test_bodies_chill_role_learned_niyama_source_uses_neutral_caveat(
-        monkeypatch, mini_msh_file, tmp_path):
-    """Learned-heads Task 3 review round 1, F3: when `predict_field`'s
-    `feat` carries learned `gradT`/`dTdt` (so `niyama_source` is "learned",
-    not "proxy"), the chill-bearing low-confidence caveat text must be the
-    NEUTRAL "learned-head Niyama pending slice validation" -- NOT the
-    proxy-specific "rho 0.313" text, a claim about the PROXY identity's own
-    measured Gate C shortfall that has nothing to do with a learned
-    checkpoint's heads. The marking itself ("low") is UNCHANGED -- still
-    keyed only on `plan.bc_config == "chills"`, per the brief ("stays until
-    the promote step")."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0)
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-
-    def fake_predict_field(mesh, *a, **kw):
-        n = 5
-        seconds = np.arange(n, dtype=np.float64) + 1.0
-        feat = {"X": np.zeros((n, 9)), "gradT": np.full(n, 500.0), "dTdt": np.full(n, 2.0)}
-        return seconds, feat
-
-    monkeypatch.setattr(pc_mod, "predict_field", fake_predict_field)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    assert out["shrinkage"] is not None
-    assert out["shrinkage"]["niyama_confidence"] == "low"
-    assert out["shrinkage"]["niyama_source"] == "learned"
-    with open(out["summary"]) as f:
-        summary_text = f.read()
-    assert "niyama confidence: LOW" in summary_text
-    assert "learned-head Niyama pending slice validation" in summary_text
-    assert "rho 0.313" not in summary_text
-
-
-# --------------------------------------------------------------------------- #
-# Part-B roles task (2026-08-03): role-aware feed-node selection, replacing
-# review finding I1's coarse `plan.bc_config == "chills"` special case (which
-# forced feed_nodes empty for the WHOLE input, rather than per body role).
-# `tag_contact_patches` relabels EVERY role body's contact patch "Adiabatic"
-# -- chills included -- so on a chill-bearing input every "Adiabatic"
-# triangle is a chill footprint, not a riser/sleeve; on a sleeve-bearing
-# input it genuinely is a feed patch. `mini_msh_file` already carries one
-# real "Adiabatic" tri (0-indexed nodes 1,2,3 -- file node ids 2,3,4), so
-# both branches are exercised against the SAME underlying mesh, with the
-# fake `tag_contact_patches` now also returning `nodes_by_solid={2: [1, 2,
-# 3]}` (what the real tagging pass would have found for that one role body)
-# and each `BcPlan` carrying the matching `role_by_solid` -- only the ROLE
-# differs between the two tests, not merely `bc_config`.
-# --------------------------------------------------------------------------- #
-def _spy_screen_casting(monkeypatch, captured):
-    real_screen_casting = pc_mod.screen_casting
-
-    def _fn(*args, **kwargs):
-        captured["feed_nodes"] = kwargs.get("feed_nodes")
-        return real_screen_casting(*args, **kwargs)
-
-    monkeypatch.setattr(pc_mod, "screen_casting", _fn)
-
-
-def test_bodies_chill_role_forces_feed_nodes_empty(monkeypatch, mini_msh_file, tmp_path):
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0, role_by_solid={2: "chill"})
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches",
-                        _fake_tag_contact_patches(calls, nodes_by_solid={2: [1, 2, 3]}))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-    captured = {}
-    _spy_screen_casting(monkeypatch, captured)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    # the chill body's own patch DID find nodes (1,2,3) -- they are simply
-    # never fed nodes, proving this is a real per-role exclusion and not an
-    # accident of an empty/missing nodes_by_solid.
-    assert captured["feed_nodes"].size == 0
-    # with feed_nodes forced empty, is_fed is always False -- EVERY hot
-    # region hot_regions itself finds must survive into macro_shrinkage
-    # (none silently dropped as "fed" by a chill contact patch).
-    from src.shrinkage import hot_regions
-    mesh = parse_msh(osp.join(str(tmp_path), f"{out['name']}.msh"))
-    seconds = np.arange(mesh.node_xyz.shape[0], dtype=np.float64) + 1.0
-    all_hot_regions = hot_regions(mesh.node_xyz, mesh.tets, seconds)
-    assert out["shrinkage"]["n_macro_regions"] == len(all_hot_regions)
-
-
-def test_bodies_sleeve_role_keeps_adiabatic_feed_nodes(monkeypatch, mini_msh_file, tmp_path):
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="insulating_sleeve", casting_solid_id=1, role_solid_ids=[2],
-                  role_by_solid={2: "insulating_sleeve"})
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches",
-                        _fake_tag_contact_patches(calls, nodes_by_solid={2: [1, 2, 3]}))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-    captured = {}
-    _spy_screen_casting(monkeypatch, captured)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "insulating_sleeve"}]
-
-    pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                          ood_json="does-not-exist.json", bodies=bodies)
-
-    # sleeve assembly -> feed == that patch's nodes EXACTLY (spec §3).
-    assert captured["feed_nodes"].tolist() == [1, 2, 3]
-
-
-def test_bodies_sleeve_role_feed_nodes_byte_identical_to_pre_change_adiabatic_union(
-        monkeypatch, mini_msh_file, tmp_path):
-    """Screening byte-identity (spec §3): on a legal (single-role, non-mixed)
-    sleeve input, the NEW per-role feed_nodes selection must produce EXACTLY
-    the same result as the pre-change code (`_shrinkage_surface_and_feed_
-    nodes`'s plain "Adiabatic"-tag node union, which is what `predict_
-    casting` used unconditionally for any non-chills bc_config before this
-    task)."""
-    from src.assembly import BcPlan
-    from src.msh_parse import parse_msh as _parse_msh
-
-    calls = {}
-    plan = BcPlan(bc_config="exo_sleeve", casting_solid_id=1, role_solid_ids=[2],
-                  role_by_solid={2: "exo_sleeve"})
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches",
-                        _fake_tag_contact_patches(calls, nodes_by_solid={2: [1, 2, 3]}))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-    captured = {}
-    _spy_screen_casting(monkeypatch, captured)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "exo_sleeve"}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    old_mesh = _parse_msh(osp.join(str(tmp_path), f"{out['name']}.msh"))
-    _old_surface, old_feed_nodes = pc_mod._shrinkage_surface_and_feed_nodes(old_mesh)
-
-    assert np.array_equal(captured["feed_nodes"], old_feed_nodes)
-
-
-def test_bodies_legacy_cache_hit_sleeve_falls_back_to_adiabatic_union_with_warning(
-        monkeypatch, mini_msh_file, tmp_path, caplog):
-    """Review round 1, H1: a mesh-cache HIT served from a side-car written
-    BEFORE the Part-B roles task never had `nodes_by_solid` at all --
-    `runs/mesh_cache/` holds exactly such legacy entries today (`per_body_
-    patch_area_mm2` present, `nodes_by_solid` absent), incl. both gold
-    parts. On a sleeve plan, feed_nodes must fall back to the PRE-CHANGE
-    rule (the plain "Adiabatic"-tag node union) rather than silently going
-    empty, and a loud warning naming the legacy situation must fire."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="insulating_sleeve", casting_solid_id=1, role_solid_ids=[2],
-                  role_by_solid={2: "insulating_sleeve"})
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh",
-                        _fake_get_or_mesh_hit_with_str_keys(calls, mini_msh_file, {"2": 42.0}))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-    captured = {}
-    _spy_screen_casting(monkeypatch, captured)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "insulating_sleeve"}]
-
-    with caplog.at_level(logging.WARNING):
-        out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                     ood_json="does-not-exist.json", bodies=bodies)
-
-    mesh = parse_msh(osp.join(str(tmp_path), f"{out['name']}.msh"))
-    _surface, expected_adiab_union = pc_mod._shrinkage_surface_and_feed_nodes(mesh)
-    assert expected_adiab_union.size > 0   # sanity: mini_msh_file's real Adiabatic tri
-    assert np.array_equal(captured["feed_nodes"], expected_adiab_union)
-    assert any("legacy" in rec.message.lower() for rec in caplog.records)
-
-
-def test_bodies_legacy_cache_hit_chills_falls_back_to_empty_with_warning(
-        monkeypatch, mini_msh_file, tmp_path, caplog):
-    """Same legacy-cache-HIT scenario as above, chills plan: falls back to
-    empty feed_nodes (the pre-change chills rule), with the same loud
-    warning -- and the warning fires regardless of `bc_config`."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0, role_by_solid={2: "chill"})
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh",
-                        _fake_get_or_mesh_hit_with_str_keys(calls, mini_msh_file, {"2": 42.0}))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-    captured = {}
-    _spy_screen_casting(monkeypatch, captured)
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    with caplog.at_level(logging.WARNING):
-        pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                               ood_json="does-not-exist.json", bodies=bodies)
-
-    assert captured["feed_nodes"].size == 0
-    assert any("legacy" in rec.message.lower() for rec in caplog.records)
-
-
-def test_nodes_by_role_from_tagging_incomplete_role_by_solid_warns_and_drops(caplog):
-    """Review round 1, M1: a solid_id present in `nodes_by_solid` but absent
-    from `role_by_solid` must be dropped LOUDLY (not silently) -- defense in
-    depth for any caller other than `_role_aware_feed_nodes` (which, in the
-    normal `predict_casting` path, never lets an incomplete mapping reach
-    this function at all -- see its own docstring)."""
-    with caplog.at_level(logging.WARNING):
-        grouped = pc_mod._nodes_by_role_from_tagging(
-            {2: [1, 2, 3], 5: [7, 8]}, {2: "insulating_sleeve"})
-
-    assert grouped == {"insulating_sleeve": [1, 2, 3]}
-    assert any("solid_id=5" in rec.message for rec in caplog.records)
-
-
-def test_feed_nodes_from_role_patches_mixed_mapping_bypassing_validate_bodies():
-    """A directly-constructed mixed role -> nodes mapping (spec §3) --
-    `validate_bodies` itself forbids combining chills with a sleeve, but
-    `_feed_nodes_from_role_patches` takes no `BcPlan`/`bc_config` at all, so
-    it must still exclude the chill nodes and keep only the sleeve nodes
-    even when both roles co-occur in the same mapping."""
-    nodes_by_role = {"chill": [10, 11, 12], "insulating_sleeve": [11, 20],
-                     "exo_sleeve": [30]}
-
-    feed = pc_mod._feed_nodes_from_role_patches(nodes_by_role)
-
-    assert feed.tolist() == [11, 20, 30]
-    assert 10 not in feed.tolist() and 12 not in feed.tolist()
-
-
-def test_nodes_by_role_from_tagging_bare_mesh_empty_mapping_is_empty():
-    """Bare mesh (spec §3): no role bodies at all -> an empty `nodes_by_solid`
-    (or `role_by_solid`) grouping produces an empty per-role mapping, and
-    `_feed_nodes_from_role_patches` on that empty mapping stays empty --
-    matching `predict_casting`'s `if plan is not None and plan.role_solid_
-    ids:` guard, which never even enters this code path for a bare/bodies=
-    None input."""
-    assert pc_mod._nodes_by_role_from_tagging({}, {}) == {}
-    assert pc_mod._feed_nodes_from_role_patches({}).size == 0
-
-
-def test_nodes_by_role_from_tagging_normalizes_string_solid_id_keys():
-    """A mesh-cache HIT round-trips `nodes_by_solid` through JSON, turning
-    int solid_id keys into str -- `_nodes_by_role_from_tagging` must still
-    match them against `role_by_solid`'s int keys."""
-    grouped = pc_mod._nodes_by_role_from_tagging(
-        {"2": [1, 2, 3]}, {2: "insulating_sleeve"})
-    assert grouped == {"insulating_sleeve": [1, 2, 3]}
-
-
-def _fake_get_or_mesh_hit_with_str_keys(calls, mini_msh_file, per_body_patch_area_mm2):
-    """Simulates a real cache HIT: `per_body_patch_area_mm2` comes back with
-    STRING solid_id keys (the JSON-round-trip artifact -- see
-    tests/test_mesh_cache.py), and `post_mesh` is never called (a HIT never
-    re-tags)."""
-    def _fn(step_path, out_msh, target_nodes=None, cache_dir=None,
-            keep_solid_id=None, bodies_key="none", post_mesh=None):
-        calls["get_or_mesh"] = dict(step_path=step_path, out_msh=out_msh,
-                                    target_nodes=target_nodes, cache_dir=cache_dir,
-                                    keep_solid_id=keep_solid_id, bodies_key=bodies_key,
-                                    post_mesh=post_mesh)
-        shutil.copy(mini_msh_file, out_msh)
-        return dict(n_solids=1, volume_mm3=1.0, bbox_diag_mm=17.3, n_nodes=5,
-                    ok=True, healed=False, notes="", cache="hit",
-                    per_body_patch_area_mm2=dict(per_body_patch_area_mm2), n_adiab_tris=3)
-    return _fn
-
-
-def test_bodies_cache_hit_normalizes_string_keys_to_int(
-        monkeypatch, mini_msh_file, tmp_path):
-    """Review fix (LOW): a cache HIT's `per_body_patch_area_mm2` comes back
-    with STRING dict keys (json.dump has no int-key mode) -- predict_casting
-    must normalize these back to int in its result dict, and must NOT call
-    tag_contact_patches again on a HIT."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0)
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh",
-                        _fake_get_or_mesh_hit_with_str_keys(calls, mini_msh_file, {"2": 99.5}))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=bodies)
-
-    assert "tag_contact_patches" not in calls          # HIT never re-tags
-    assert out["cache"] == "hit"
-    assert out["per_body_patch_area_mm2"] == {2: 99.5}
-    assert all(isinstance(k, int) for k in out["per_body_patch_area_mm2"])
-
-
-def test_bodies_none_never_calls_tag_contact_patches_and_default_bc_config(
-        monkeypatch, mini_msh_file, tmp_path):
-    calls = {}
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    _stub_prediction_stage(monkeypatch, n_nodes=5)
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json")
-
-    assert "tag_contact_patches" not in calls
-    assert calls["get_or_mesh"]["keep_solid_id"] is None
-    assert calls["get_or_mesh"]["bodies_key"] == "none"
-    assert out["bc_config"] == "none"
-    assert out["per_body_patch_area_mm2"] == {}
-
-
-def test_bodies_as_json_path_loads(monkeypatch, mini_msh_file, tmp_path):
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="none", casting_solid_id=1, role_solid_ids=[])
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    # bodies requires a film-capable checkpoint (see the guard test below) --
-    # this test is only about JSON-path loading, so stub a film-capable cfg.
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"film": True}, None, None))
-    monkeypatch.setattr(pc_mod, "predict_field",
-                        lambda mesh, *a, **kw: (np.arange(5, dtype=np.float64) + 1.0,
-                                                {"X": np.zeros((5, 9))}))
-
-    bodies = [{"solid_id": 1, "role": "casting"}]
-    bodies_path = tmp_path / "bodies.json"
-    bodies_path.write_text(json.dumps(bodies))
-
-    out = pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                                 ood_json="does-not-exist.json", bodies=str(bodies_path))
-
-    assert calls["validate_bodies_arg"] == bodies
-    assert calls["get_or_mesh"]["keep_solid_id"] == 1
-
-
-def test_bodies_with_raw_mesh_mode_raises(monkeypatch, mini_msh_file, tmp_path):
-    """`bodies` requires the prep/get_or_mesh pipeline (role-based casting
-    solid selection + tagging) -- combining it with mesh_mode='raw' (or an
-    explicit elem_size, which forces raw) must fail loudly rather than
-    silently ignore the role assignment."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="none", casting_solid_id=1, role_solid_ids=[])
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    _stub_prediction_stage(monkeypatch, n_nodes=5)
-
-    bodies = [{"solid_id": 1, "role": "casting"}]
-    with pytest.raises(ValueError):
-        pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                               ood_json="does-not-exist.json", bodies=bodies,
-                               mesh_mode="raw")
-
-
-def test_bodies_with_non_film_checkpoint_raises_and_never_tags(
-        monkeypatch, mini_msh_file, tmp_path):
-    """Review fix (MEDIUM): `bodies` with chill/sleeve roles + a NON-film
-    checkpoint (e.g. SP1 via --gnn) must fail loudly, not silently proceed.
-    A resolved BcPlan means tag_contact_patches would relabel the contact
-    patch "Adiabatic" -- for a chill that's backwards physics (a chill
-    COOLS, Adiabatic INSULATES) -- and SP1 has no BC channel to honor the
-    role assignment at all. The check runs BEFORE meshing (load_hybrid is
-    called first), so tag_contact_patches must never even be invoked."""
-    from src.assembly import BcPlan
-
-    calls = {}
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2],
-                  n_chills=1, chill_effusivity=12345.0)
-
-    monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step(calls, mini_msh_file))
-    monkeypatch.setattr(pc_mod, "validate_bodies", _fake_validate_bodies(calls, plan))
-    monkeypatch.setattr(pc_mod, "tag_contact_patches", _fake_tag_contact_patches(calls))
-    # A non-film (SP1-shaped) cfg -- no "film" key at all, matching a real
-    # SP1 checkpoint's cfg.
-    monkeypatch.setattr(pc_mod, "load_hybrid",
-                        lambda *a, **kw: (None, None, {}, {"hidden": 16}, None, None))
-
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill", "params": {"material": "cast_iron"}}]
-
-    with pytest.raises(ValueError, match="film-conditioned"):
-        pc_mod.predict_casting("fake_part.step", out_dir=str(tmp_path),
-                               ood_json="does-not-exist.json", bodies=bodies)
-
-    assert "tag_contact_patches" not in calls
-    assert "get_or_mesh" not in calls
-
-
-def test_bodies_cache_key_order_invariant_and_role_sensitive():
-    from src.assembly import BcPlan
-
-    plan = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[2, 3],
-                  n_chills=2, chill_effusivity=12345.0)
-    bodies = [{"solid_id": 1, "role": "casting"},
-             {"solid_id": 2, "role": "chill"},
-             {"solid_id": 3, "role": "chill"}]
-    bodies_reordered = [bodies[2], bodies[0], bodies[1]]
-
-    k1 = pc_mod._bodies_cache_key(bodies, plan)
-    k2 = pc_mod._bodies_cache_key(bodies_reordered, plan)
-    assert k1 == k2
-
-    plan2 = BcPlan(bc_config="chills", casting_solid_id=1, role_solid_ids=[3],
-                   n_chills=1, chill_effusivity=12345.0)
-    bodies_role_changed = [{"solid_id": 1, "role": "casting"},
-                          {"solid_id": 2, "role": "ignore"},
-                          {"solid_id": 3, "role": "chill"}]
-    k3 = pc_mod._bodies_cache_key(bodies_role_changed, plan2)
-    assert k3 != k1
 
 
 # --------------------------------------------------------------------------
@@ -1237,8 +492,7 @@ def test_bodies_cache_key_order_invariant_and_role_sensitive():
 # `get_or_mesh`/`heal_and_mesh` have honoured `target_nodes` all along and it is
 # part of the mesh-cache key, but `predict_casting` pinned it to the default, so
 # no caller could choose a mesh density without dropping to the legacy `raw`
-# path via `elem_size` -- which in turn is refused when `bodies` is present.
-# Density and per-body roles were therefore mutually exclusive from outside.
+# path via `elem_size`.
 # --------------------------------------------------------------------------
 
 
@@ -1260,8 +514,7 @@ def test_target_nodes_with_an_explicit_elem_size_raises(monkeypatch, mini_msh_fi
 
     `elem_size` forces the `raw` path, which never calls `get_or_mesh`, so a
     silently ignored `target_nodes` would mean the caller asked for a mesh
-    density and got a different one with no indication. Same reasoning as the
-    existing `bodies`-with-`raw` guard, and the same loud failure.
+    density and got a different one with no indication, so it fails loudly.
     """
     monkeypatch.setattr(pc_mod, "get_or_mesh", _fake_get_or_mesh({}, mini_msh_file))
     monkeypatch.setattr(pc_mod, "mesh_step", _fake_mesh_step({}, mini_msh_file))

tools/sleeves/sleeve_registry.csv

@@ -1,15 +0,0 @@
-name,source,type,d1_mm,d2_mm,H_mm,t_mm,V_cm3,A_cm2,M_geom_cm,MEF,M_eff_cm,mef_source
-SYNTH_M050,synthetic,exo,27.952,24.202,42.950,5.710,22.978,45.956,0.5000,1.400,0.7000,synthetic_spread
-SYNTH_M065,synthetic,exo,36.337,31.463,55.835,7.423,50.483,77.666,0.6500,1.650,1.0725,synthetic_spread
-SD_4_7K,catalog,exo,41.000,35.500,63.000,8.375,72.517,98.877,0.7334,1.547,1.1343,catalog_ratio
-SD_4_95K,catalog,exo,42.000,36.000,84.000,8.750,100.544,127.017,0.7916,1.562,1.2368,catalog_ratio
-SD_5_8K,catalog,exo,51.000,47.500,69.500,10.250,132.455,145.716,0.9090,1.579,1.4353,catalog_ratio
-FOSECO_P5_8K,foseco_step,exo,,,,,,,0.9500,1.580,1.5000,datasheet
-SYNTH_M080,synthetic,exo,44.723,38.723,68.720,9.135,94.119,117.648,0.8000,1.900,1.5200,synthetic_spread
-FOSECO_P7_10K,foseco_step,exo,,,,,,,1.2500,1.560,1.9500,datasheet
-FOSECO_P8_11K,foseco_step,exo,,,,,,,1.4000,1.570,2.2000,datasheet
-FOSECO_ZP912K14QC,foseco_step,exo,,,,,,,1.5500,1.550,2.4000,datasheet
-FOSECO_P10_13K,foseco_step,exo,,,,,,,1.7500,1.540,2.7000,datasheet
-FOSECO_P12_15K,foseco_step,exo,,,,,,,2.0000,1.550,3.1000,datasheet
-FOSECO_V90L,foseco_step,insulating,,,,,,,,1.150,1.7000,unverified
-FOSECO_V88E,foseco_step,insulating,,,,,,,,1.450,1.7000,unverified