Simplify layout and add bilingual ExtFoamBench introduction

Highlight ExtFoamBench tasks, geometry assets and evaluation metrics. Bundle optional tools and consolidate documentation. Scientific data and scoring implementation remain unchanged.

GUIDE.md

@@ -0,0 +1,71 @@
+# Usage guide / 使用指南
+
+[English overview](README.md) · [中文介绍](README_zh.md)
+
+## Files and task identity / 文件与任务标识
+
+`data/extended.jsonl` is the 100-task ExtFoamBench catalog. Each row has `task_id`, `track`, `case_id`, `family`, `task_origin`, `usr_requirement`, and `external_asset_ids`. Use `(track, case_id)` to join task records to the `cases` mappings in reference-QoI and numerical-statistics JSON files. Basic/Advanced catalogs follow the same format and retain upstream attribution.
+
+`data/extended.jsonl` 是 100 条 Ext 原创任务的索引，包含上述字段。使用 `(track, case_id)` 与参考 QoI、数值统计中的 `cases` 条目对应；Basic/Advanced 采用相同格式，并注明上游来源。
+
+Reference input JSONs contain OpenFOAM file text, such as `0/U`, `system/controlDict` and `Allrun`; some Extended tasks have `reference_subcases`. Geometry declarations resolve through `benchmarks/assets/manifest.json`. Keep reference inputs and answers outside the solving agent's accessible workspace.
+
+参考输入 JSON 保存 OpenFOAM 文件内容，部分 Ext 任务还包含多个参考分支。几何声明通过资产清单关联文件。参考输入与答案应置于求解智能体无法读取的位置。
+
+## Optional evaluator / 可选评估器
+
+The scorer, schemas and scripts are bundled in `tools/evaluation-tools.zip`. Extract it **into the downloaded repository root**, preserving its paths. Use Python 3.11/3.12 and a dedicated evaluator environment; current HF `datasets` dependencies may require a different NumPy version.
+
+评估器、格式定义和脚本集中在工具包中。请将其**解压到下载的仓库根目录**，保留相对路径。使用 Python 3.11/3.12 和独立评估环境，避免与最新 HF 数据加载依赖的 NumPy 版本冲突。
+
+```bash
+python -m zipfile -e tools/evaluation-tools.zip .
+python -m pip install -r requirements.txt
+python -m benchmarks.evaluation validate-profile --profile benchmarks/evaluation/profiles/extended.json
+python examples/inspect_task.py --track extended --case-id nozzleCDV/1
+```
+
+These commands inspect data without running a model or CFD solver. The inspection output includes evaluator-side information; it is not an agent prompt.
+
+上述命令只检查数据，不调用模型或 CFD 求解器。任务查看命令包含评价侧信息，不应直接作为智能体提示词。
+
+To export one reference input without solving it / 导出一个参考算例输入：
+
+```bash
+python benchmarks/scripts/materialize_benchmark.py --benchmark benchmarks/FoamBench_extended_openfoam13_fixed.json --case-id nozzleCDV/1 --output-root outputs/reference-input
+```
+
+To evaluate an existing compatible run, replace `/path/to/run` with your retained artifacts / 评价已有运行结果时，将路径换成实际结果目录：
+
+```bash
+python -m benchmarks.evaluation evaluate --profile benchmarks/evaluation/profiles/extended.json --adapter easyfoam --run-root /path/to/run --output outputs/evaluation
+```
+
+Other adapters: `foamagent`, `chatcfd`, `coding-agent`. Their required layouts are defined in the extracted `benchmarks/evaluation/adapters/`. Full-profile evaluation counts missing tasks as failures; a single-task run does not reproduce a full-benchmark score.
+
+其他适配器支持上述三种布局，具体输入结构见解压后的目录。完整配置会将未运行任务计为失败，单任务运行不代表完整基准成绩。
+
+## Metric fields and protocol / 指标字段与协议
+
+| Metric / 指标 | Field under `overall` / 汇总字段 |
+| --- | --- |
+| ECR | `execution_pass_rate` |
+| Numerical acceptance / 数值接受率 | `numerical_pass_rate_all_tasks` |
+| QoI acceptance / 物理接受率 | `physics_grounded_qoi_pass_rate_all_tasks` |
+| TAR | `end_to_end_pass_rate` |
+
+Rates use all assigned tasks and range from 0 to 1. Execution gates Numerical/QoI acceptance; all mandatory criteria must pass. Conditional rates and partial-quality scores are supplementary. The Extended rules retain their declared `provisional` tolerance status. In the supplied Basic/Advanced scorer, physical ranges/signatures are mandatory, while profiles/history/shock locations are reference-agreement diagnostics; check manuscript-to-version alignment before claiming identical historical scores. Spatial coverage counts profile-field combinations; early-convergence markers can satisfy the stop condition.
+
+上述比例均以全部指定任务为分母，范围为 0–1。数值和物理接受以执行通过为前提，所有必需准则均需通过；条件通过率和部分质量分数属于辅助信息。Ext 保留原有 `provisional` 容差状态。当前 Basic/Advanced 实现将物理范围／特征作为必需准则，曲线、历史与激波位置作为参考一致性诊断；如需复现历史论文分数，应核对具体版本。空间覆盖按曲线与场的组合统计，执行终止条件允许提前收敛标记。
+
+Actual simulations require OpenFOAM **Foundation 13**. Offline extraction uses retained data, but some missing measurement fields or topology-changing geometries require native `foamPostProcess`. `--prepare` writes derived fields; `--check-mesh` enables a fresh mesh audit. Use copies of valuable run artifacts when preparing measurements.
+
+真实仿真需要 OpenFOAM **Foundation 13**。离线提取通常读取留存数据，但部分测量场或拓扑变化几何需要原生后处理工具。`--prepare` 会写入派生场，`--check-mesh` 可启动网格检查；处理重要运行结果时建议使用副本。
+
+## Coverage, provenance and versions / 覆盖、来源与版本
+
+- All 226 tasks have reference-QoI entries; 215 have nonempty numerical statistics. Missing: `nozzleCDV/4` and all ten `riemann2D` tasks. See [coverage](metadata/coverage.json). / 226 个任务均有参考 QoI 条目；215 个有非空数值统计，11 个缺失条目已明确记录。
+- References are simulation-derived. Raw solution fields/logs, historical agent trajectories/checkpoints, and raw repeatability/negative-control/sensitivity experiment archives are not included. / 参考数据由仿真生成；本包未包含完整原始场、日志、历史智能体轨迹／检查点和重复验证、负对照、敏感性实验原始归档。
+- Ext task design, evaluation resources and offline reference data are EasyFoam contributions. Basic/Advanced task definitions come from [FoamBench](https://github.com/NLR-Theseus/cfdllmbench). CFD source attribution is detailed in the paper's Appendix A; the asset manifest records OpenFOAM tutorial sources and checksums. / Ext 任务设计、评价资源和离线参考数据属于 EasyFoam 贡献；Basic/Advanced 任务来自 FoamBench，CFD 来源见论文附录 A，几何来源见资产清单。
+- [Source manifest](metadata/source_manifest.json) identifies unchanged source files, including those inside the optional ZIP. [Validation](metadata/validation.json) records packaging checks. Run `python scripts/verify_release.py` to verify this release without extracting the tools. / 来源清单包含工具包内部文件的哈希；验证报告记录检查结果，无需解压工具即可运行完整性检查。
+- **1.1.0** changes documentation and packaging only. **1.0.0** remains available with the original unpacked tool layout. Freeze dataset and evaluator versions together when reporting results. / 1.1.0 仅调整文档与打包；1.0.0 保留原有展开工具目录。报告实验时应同时固定数据和评估器版本。

LICENSE.md

@@ -1,12 +1,12 @@
-# Component licenses and attribution
-
-This collection contains original and adapted material. The Hub uses `license: other` with this file as its license entry point because no single license label describes every component.
-
-| Component | Retained terms / notice |
-| --- | --- |
-| EasyFoam project code and original project material | Existing project Apache-2.0 license in `LICENSE`, subject to third-party exceptions |
-| Inherited FoamBench Basic/Advanced task content | Upstream BSD-3-Clause notice in `LICENSES/FoamBench-BSD-3-Clause.txt`; retain applicable OpenFOAM/other embedded notices |
-| OpenFOAM tutorial-derived case content and geometry | Existing GPL-3.0-or-later notices and `LICENSES/GPL-3.txt`; see `benchmarks/assets/README.md` and `manifest.json` |
-| Generated task catalogs | Projections of the corresponding task records; preserve their source attribution and applicable terms |
-
-The packaging does not relicense upstream content or override embedded notices. Scientific authorship of the evaluation/reference data and original ExtFoamBench task design is distinguished from upstream ownership in `docs/PROVENANCE.md`. No new CC-BY, CC0 or other blanket grant is introduced by this release.
+# Component licenses and attribution
+
+This collection contains original and adapted material. The Hub uses `license: other` with this file as its license entry point because no single license label describes every component.
+
+| Component | Retained terms / notice |
+| --- | --- |
+| EasyFoam project code and original project material | Existing project Apache-2.0 license in `LICENSE`, subject to third-party exceptions |
+| Inherited FoamBench Basic/Advanced task content | Upstream BSD-3-Clause notice in `LICENSES/FoamBench-BSD-3-Clause.txt`; retain applicable OpenFOAM/other embedded notices |
+| OpenFOAM tutorial-derived case content and geometry | Existing GPL-3.0-or-later notices and `LICENSES/GPL-3.txt`; see `benchmarks/assets/README.md` and `manifest.json` |
+| Generated task catalogs | Projections of the corresponding task records; preserve their source attribution and applicable terms |
+
+The packaging does not relicense upstream content or override embedded notices. Scientific authorship of the evaluation/reference data and original ExtFoamBench task design is distinguished from upstream ownership in `GUIDE.md`. No new CC-BY, CC0 or other blanket grant is introduced by this release.

README.md

@@ -1,5 +1,5 @@
 ---
-pretty_name: ExtFoamBench — CFD Tasks, Evaluation Protocols and Offline Reference Data
+pretty_name: ExtFoamBench — CFD Tasks, Geometry Assets and Evaluation Metrics
 language:
 - en
 license: other
@@ -41,130 +41,61 @@ configs:
 
 # ExtFoamBench
 
-**100 new CFD tasks, task-specific QoI acceptance rules, and offline reference data for evaluating OpenFOAM agents.**
+**English** | [中文介绍](README_zh.md)
 
-This release accompanies [EasyFoam: Skill-Oriented OpenFOAM Agents with Evidence-Driven Evolution](https://openreview.net/forum?id=GhQ5YmhU8B). It brings together three research contributions: the **ExtFoamBench task dataset**, the **execution / numerical / physical acceptance evaluation framework**, and **offline reference simulations summarized as QoIs and numerical diagnostics**.
+**100 CFD tasks · 7 geometry assets · task-specific physical evaluation**
 
-The EasyFoam Skill library is available separately on [GitHub](https://github.com/CAS-CLab/EasyFoam). Installing that library does not require downloading this dataset. This dataset includes an offline evaluator; using it does not require installing the EasyFoam agent or providing a model API key.
+ExtFoamBench is a benchmark for evaluating OpenFOAM agents, introduced in [EasyFoam](https://openreview.net/forum?id=GhQ5YmhU8B). This repository focuses on **the ExtFoamBench dataset, the geometry assets needed by its tasks, and the evaluation metrics and acceptance criteria**.
 
-## Contributions and attribution
+## Core resources
 
-| Component | Task count | Task origin | Contribution in this release |
-| --- | ---: | --- | --- |
-| **ExtFoamBench / Extended** | **100** | New task suite developed by the EasyFoam authors, using attributed CFD source cases and geometry | New tasks, task-specific evaluation rules, and offline reference data |
-| FoamBench Basic | 110 | Existing [FoamBench / CFDLLMBench](https://github.com/NLR-Theseus/cfdllmbench), adapted for OpenFOAM Foundation 13 | Evaluation rules and offline reference data developed/generated by the EasyFoam authors |
-| FoamBench Advanced | 16 | Existing FoamBench / CFDLLMBench, adapted for OpenFOAM Foundation 13 | Evaluation rules and offline reference data developed/generated by the EasyFoam authors |
+| Resource | What it provides | Files |
+| --- | --- | --- |
+| **ExtFoamBench dataset** | 100 tasks across 10 families, covering operating conditions, mesh/geometry, physics, numerical settings and multi-run workflows | [Task table](data/extended.jsonl) · [Reference case inputs](benchmarks/FoamBench_extended_openfoam13_fixed.json) |
+| **Geometry assets** | 7 ready-to-use geometry files for stirred-reactor, airfoil and vehicle cases, with source attribution and checksums | [Assets](benchmarks/assets/) · [Manifest](benchmarks/assets/manifest.json) |
+| **Evaluation metrics and criteria** | Execution, numerical and physical acceptance; per-task QoI definitions, measurement rules, reference comparisons and tolerances | [Measurement specs](benchmarks/FoamBench_extended_openfoam13_measurement_specs.json) · [QoI design](benchmarks/FoamBench_extended_openfoam13_qoi_design.json) · [Reference values and tolerances](benchmarks/FoamBench_extended_openfoam13_reference_qois.json) |
 
-**The 126 Basic/Advanced tasks are not claimed as an original EasyFoam dataset.** They are included for compatibility with the evaluation suite. The EasyFoam authors' evaluation and offline-reference contributions cover all **226** tasks. Existing geometry, OpenFOAM tutorials, and upstream benchmark materials retain their provenance and licenses.
+Each family has a baseline and nine variants: `yPlusVerification`, `risingBubble`, `supersonicCrossJet`, `nozzleCDV`, `MRF_stirredReactor`, `ERCOFTA_pump`, `compressibleBubbleCollapse`, `aerofoilNACA0012`, `drivaerFastback`, and `riemann2D`.
 
-The default Hub configuration, `extended`, shows only the 100 ExtFoamBench tasks. `basic` and `advanced` expose inherited tasks separately. `all` combines the 226 evaluation tasks. The `test` split name means benchmark evaluation tasks; it does **not** describe the historical held-out split used in the EasyFoam skill-evolution experiments.
+The tasks are developed by the EasyFoam authors. Geometry assets are redistributed from attributed OpenFOAM 13 sources; their original notices are retained.
 
-## ExtFoamBench coverage
+## Evaluation
 
-Each of the ten families contains ten tasks: a baseline and nine variants.
+A task is assessed along three dimensions: **E** (execution completes), **N** (applicable numerical checks pass), and **Q** (all mandatory physical/QoI criteria pass).
 
-| Family | Physical setting |
-| --- | --- |
-| `yPlusVerification` | Near-wall resolution and wall-law verification |
-| `risingBubble` | Buoyancy-driven two-phase bubble motion |
-| `supersonicCrossJet` | Supersonic cross-flow / jet interaction |
-| `nozzleCDV` | Compressible converging-diverging nozzle flow |
-| `MRF_stirredReactor` | Rotating stirred-reactor flow |
-| `ERCOFTA_pump` | Rotating-pump pressure and flow response |
-| `compressibleBubbleCollapse` | Compressible bubble-collapse dynamics |
-| `aerofoilNACA0012` | Airfoil aerodynamic response |
-| `drivaerFastback` | Vehicle external aerodynamics |
-| `riemann2D` | Two-dimensional compressible Riemann flow |
+- **ECR** = tasks passing E / all assigned tasks.
+- **TAR** = tasks passing E, N and Q together / all assigned tasks.
 
-Variants cover operating conditions and boundary conditions, geometry and mesh, physics and closure models, solver/numerical settings, and study/workflow requirements. Some tasks require multiple runs, comparisons, parallel execution, or restart workflows.
+QoI rules specify what to measure, spatial/time support, comparison methods and acceptance tolerances. Missing outputs remain in the denominator. Diagnostic or continuous scores do not override failed mandatory criteria.
 
-## What is downloaded?
+## Use the dataset
 
-| Location | Contents |
-| --- | --- |
-| `data/*.jsonl` | Hub-readable task catalog: identifiers, original requirements, origin, and permitted geometry identifiers |
-| `benchmarks/FoamBench_*_fixed*.json` | Reference case input dictionaries, including OpenFOAM files and any reference subcases |
-| `benchmarks/FoamBench_*_reference_qois.json` | Offline reference QoIs, principal metrics, and acceptance tolerances for each track |
-| `benchmarks/FoamBench_extended_*measurement_specs.json` | Per-task measurement definitions for ExtFoamBench |
-| `benchmarks/FoamBench_extended_*qoi_design.json` | Family/branch QoI design and principal-versus-diagnostic roles |
-| `benchmarks/FoamBench_extended_*evidence_contract.v1.json` | Evidence format and discovery contract |
-| `benchmarks/reference_statistics/` | Parsed reference residual, Courant, continuity, and related numerical diagnostics |
-| `benchmarks/assets/` | Seven geometry assets, original source locations, and SHA-256 checksums |
-| `benchmarks/evaluation/`, `schemas/` | Offline evaluation implementation and validation schemas |
-| `benchmarks/scripts/` | Reference materialization, extraction, comparison, and asset checking utilities |
-| `metadata/` | Version, family coverage, missing-data inventory, and source checksums |
-| `docs/` | Data format, evaluation, provenance, and release notes |
-
-Reference data are **simulation-derived computational references**, with the assumptions and limits of their configurations. Raw solution fields, raw reference logs, historical agent rollouts, and paper-result archives are not included in this release. No historical train/validation/test split is inferred or invented.
-
-## Quick start: inspect a task locally
-
-From the downloaded repository root, using Python 3.11 or 3.12:
-
-```bash
-python examples/inspect_task.py --track extended --case-id nozzleCDV/1
-python scripts/verify_release.py
-```
-
-Both commands use the Python standard library and do not run a model or a CFD solver. The inspection command shows the task plus the associated measurement and reference-metric summary. Its output is intended for a human or evaluator, not as an agent prompt.
-
-For the Hub task catalog, install `datasets` in a separate environment from the pinned evaluator dependencies, and use:
+Install `datasets`, then load the default Extended track:
 
 ```python
 from datasets import load_dataset
 
-tasks = load_dataset("Eurus132/ExtFoamBench", "extended", split="test")
+tasks = load_dataset("Eurus132/ExtFoamBench", "extended", split="test", revision="v1.1.0")
 print(len(tasks))  # 100
 print(tasks[0]["usr_requirement"])
 ```
 
-The task catalog excludes reference input files and reference values. Load/download the full repository if you need the evaluator and reference data; `load_dataset` loads only the selected task table. Pin the repository revision when reporting experiments.
-
-## Quick start: validate the evaluator inputs
-
-```bash
-python -m pip install -r requirements.txt
-python -m benchmarks.evaluation validate-profile --profile benchmarks/evaluation/profiles/extended.json
-python -m benchmarks.evaluation validate-profile --profile benchmarks/evaluation/profiles/basic.json
-python -m benchmarks.evaluation validate-profile --profile benchmarks/evaluation/profiles/advanced.json
-python benchmarks/scripts/validate_benchmark_assets.py --benchmark benchmarks/FoamBench_extended_openfoam13_fixed.json --manifest benchmarks/assets/manifest.json
-```
-
-These checks require no OpenFOAM installation. Materialize one **reference input case** without solving it:
+To download geometry, criteria and reference data as well:
 
 ```bash
-python benchmarks/scripts/materialize_benchmark.py --benchmark benchmarks/FoamBench_basic_openfoam13_fixed_final.json --case-id Cavity/1 --output-root outputs/reference-input
+hf download Eurus132/ExtFoamBench --repo-type dataset --revision v1.1.0 --local-dir ExtFoamBench
 ```
 
-Actual CFD simulation requires **OpenFOAM Foundation 13** and the appropriate system tools. This release does not launch an agent. The offline evaluator consumes existing run artifacts; some derived measurements require native OpenFOAM tools. See [Evaluation](docs/EVALUATION.md) before enabling preparation or mesh auditing.
-
-## Evaluation: execution, numerics, and physics
-
-The framework measures whether a task completes (**E**), satisfies applicable numerical checks (**N**), and satisfies every mandatory task-specific physical/QoI criterion (**Q**). It reports execution completion rate (**ECR**) and joint task acceptance rate (**TAR**):
-
-```text
-ECR = count(E passes) / number of assigned tasks
-TAR = count(E and N and Q all pass) / number of assigned tasks
-```
-
-A high ECR alone does not establish physically acceptable task completion. Measurements can be scalars, spatial profiles, time histories, events, or branch-dependent responses. The supplied contracts fix extraction semantics, tolerances, missing-evidence behavior, and aggregation. Optional diagnostic scores and continuous quality values are not substitutes for mandatory acceptance checks or TAR.
-
-See [Evaluation](docs/EVALUATION.md) for the implementation fields, [Data format](docs/DATA_FORMAT.md) for file relationships, and [release notes](docs/RELEASE_NOTES.md) for current protocol boundaries.
-
-## Reference visibility and intended use
-
-This is a public research dataset and evaluation resource. Give a solving agent only the selected task requirements, allowed assets, and explicitly task-visible measurement instructions. Keep reference inputs, reference values, and evaluator files outside its accessible workspace. A working-directory setting alone is not read-access isolation.
-
-The benchmark supports comparative research under its declared contracts. Passing it is not a general certification of physical validity or engineering suitability. Researchers should report software/data revisions, model and runtime settings, task membership, and any changed acceptance rules.
+The task table contains requirements and metadata. Reference case inputs and reference answers are for evaluation; keep them outside the solving agent's accessible workspace. The `test` label denotes benchmark tasks, not the historical skill-evolution held-out split.
 
-## Data completeness and versioning
+## Supporting resources
 
-All 226 tasks have reference-QoI case entries. Parsed numerical reference statistics are nonempty for **215 of 226** tasks. They are unavailable for `nozzleCDV/4` and all ten `riemann2D` tasks in the Extended track; missing statistics are recorded explicitly in [coverage.json](metadata/coverage.json), not filled with synthetic values. Case-entry presence is not a claim that every optional diagnostic or conditional QoI is available.
+For broader comparison, the repository also includes **FoamBench Basic (110)** and **Advanced (16)** from [upstream FoamBench](https://github.com/NLR-Theseus/cfdllmbench). These are inherited tasks; the EasyFoam authors contribute their **evaluation criteria and offline reference data**. Select `basic`, `advanced`, or `all` (226 tasks) to browse them.
 
-Release `1.0.0` packages the supplied data and scorer without changing their numerical contents. Embedded schema versions and the Extended contract's `provisional` tolerance status are retained. This package is not a certification that all current defaults reproduce every historical table in the manuscript. Changes to tasks, reference values, extraction, or scoring require a new release. See [release notes](docs/RELEASE_NOTES.md).
+Offline QoI references and numerical summaries support evaluation across all three tracks. The [optional evaluation tools](tools/evaluation-tools.zip) bundle the scorer, scripts and schemas; extract them only when needed. The [guide](GUIDE.md) covers usage, data coverage and protocol details. The [EasyFoam Skill library](https://github.com/CAS-CLab/EasyFoam) is distributed separately.
 
-## Attribution and licenses
+## Citation and licenses
 
-Use of ExtFoamBench tasks or the EasyFoam evaluation/reference resources should cite the [EasyFoam paper](https://openreview.net/forum?id=GhQ5YmhU8B). Use of Basic/Advanced should also credit the [upstream FoamBench work](https://github.com/NLR-Theseus/cfdllmbench). Dataset originality and reuse permissions are described separately in [Provenance](docs/PROVENANCE.md) and [component licenses](LICENSE.md).
+Cite [EasyFoam](https://openreview.net/forum?id=GhQ5YmhU8B) when using ExtFoamBench or its evaluation/reference resources, and credit [FoamBench](https://github.com/NLR-Theseus/cfdllmbench) when using Basic/Advanced. See [component licenses](LICENSE.md) for project and third-party terms.
 
-This is a mixed-origin collection. The repository does not apply a new blanket license that overrides upstream terms. Apache-2.0 project terms, the FoamBench BSD-3-Clause notice, and OpenFOAM GPL notices are retained in `LICENSE` and `LICENSES/`.
+Version **1.1.0** simplifies the presentation and adds this optional-tool layout. Scientific data, acceptance criteria and scoring code are unchanged from **1.0.0**, which remains available.

README_zh.md

@@ -0,0 +1,60 @@
+# ExtFoamBench
+
+[English](README.md) | **中文介绍**
+
+**100 个 CFD 任务 · 7 个几何资产 · 面向任务物理响应的评价体系**
+
+ExtFoamBench 是 [EasyFoam 论文](https://openreview.net/forum?id=GhQ5YmhU8B)提出的 OpenFOAM 智能体评测基准。本仓库重点提供三部分：**ExtFoamBench 数据集、任务所需的几何资产，以及评价指标与接受准则**。
+
+## 核心内容
+
+| 资源 | 内容 | 文件入口 |
+| --- | --- | --- |
+| **ExtFoamBench 数据集** | 10 个任务家族、100 个任务，覆盖工况、几何与网格、物理模型、数值设置和多次运行工作流 | [任务列表](data/extended.jsonl) · [参考算例输入](benchmarks/FoamBench_extended_openfoam13_fixed.json) |
+| **几何资产** | 适用于搅拌反应器、翼型和车辆算例的 7 个几何文件，附来源与校验值 | [几何目录](benchmarks/assets/) · [资产清单](benchmarks/assets/manifest.json) |
+| **评价指标与准则** | 执行、数值和物理三个维度的评价，以及逐任务 QoI 定义、测量方式、参考比较与容差 | [测量规范](benchmarks/FoamBench_extended_openfoam13_measurement_specs.json) · [QoI 设计](benchmarks/FoamBench_extended_openfoam13_qoi_design.json) · [参考值与容差](benchmarks/FoamBench_extended_openfoam13_reference_qois.json) |
+
+每个家族包含 1 个基准任务和 9 个变体：`yPlusVerification`、`risingBubble`、`supersonicCrossJet`、`nozzleCDV`、`MRF_stirredReactor`、`ERCOFTA_pump`、`compressibleBubbleCollapse`、`aerofoilNACA0012`、`drivaerFastback` 和 `riemann2D`。
+
+任务由 EasyFoam 作者设计。几何资产来自已注明出处的 OpenFOAM 13 资源，保留原有归属与许可说明。
+
+## 评价方式
+
+每个任务从三个维度评价：**E：执行完成；N：满足适用的数值条件；Q：所有必需的物理量／QoI 准则通过。**
+
+- **ECR（执行完成率）** = E 通过的任务数 / 全部指定任务数。
+- **TAR（任务接受率）** = E、N、Q 同时通过的任务数 / 全部指定任务数。
+
+QoI 准则规定测什么、在哪里和什么时间测、如何比较，以及允许多大误差。缺失输出仍计入任务总数；诊断分数或连续质量分数不能覆盖必需准则的失败。
+
+## 使用数据集
+
+安装 `datasets` 后，读取默认的 Extended 任务：
+
+```python
+from datasets import load_dataset
+
+tasks = load_dataset("Eurus132/ExtFoamBench", "extended", split="test", revision="v1.1.0")
+print(len(tasks))  # 100
+print(tasks[0]["usr_requirement"])
+```
+
+同时下载几何资产、评价准则和参考数据：
+
+```bash
+hf download Eurus132/ExtFoamBench --repo-type dataset --revision v1.1.0 --local-dir ExtFoamBench
+```
+
+任务表包含需求和元数据。参考算例输入和参考答案用于评价，应放在求解智能体无法读取的位置。这里的 `test` 表示基准评测任务，并非论文中技能演化实验的历史留出划分。
+
+## 配套资源
+
+为方便更广泛的比较，本仓库附带来自[上游 FoamBench](https://github.com/NLR-Theseus/cfdllmbench) 的 **Basic（110 个）**和 **Advanced（16 个）**任务。它们不是 EasyFoam 的原创任务；EasyFoam 作者为其提供了**评价准则和离线参考数据**。可选择 `basic`、`advanced` 或 `all`（226 个任务）浏览。
+
+三组任务的离线 QoI 参考值和数值统计用于支持评价。[可选评价工具包](tools/evaluation-tools.zip)集中提供评估器、脚本和格式定义，需要时再解压。[使用指南](GUIDE.md)说明工具运行方法、数据覆盖情况和评价协议细节。[EasyFoam Skill 库](https://github.com/CAS-CLab/EasyFoam)独立发布。
+
+## 引用与许可
+
+使用 ExtFoamBench 或其评价／参考资源时，请引用 [EasyFoam](https://openreview.net/forum?id=GhQ5YmhU8B)；使用 Basic/Advanced 时，同时注明 [FoamBench](https://github.com/NLR-Theseus/cfdllmbench) 的贡献。项目与第三方资源的许可见[组件许可证说明](LICENSE.md)。
+
+**1.1.0** 版本精简了页面与文件组织，并增加中英文介绍。科学数据、接受准则和评分代码与 **1.0.0** 一致，旧版仍可下载。

SHA256SUMS

@@ -1,5 +1,4 @@
 fec9848fa0a1a2a2d7f78eebc2cac8239fe830c918d5776a684ed129beb203d9  .gitignore
-b5375698c34737e22fabdf9cea774287609ce6edc3fa8c73791c3749e89c3bca  benchmarks/__init__.py
 0d9fe71467b76d42e23ad97a6878ef6f981ebbb72438bb0a96ffed0d15609f8f  benchmarks/assets/manifest.json
 0622638e6d9e2ef61d739ef2ae699ce4d5fb212abeaaa6f4583da54f3da24efe  benchmarks/assets/openfoam13/drivaerFastback/body.obj.gz
 f3e4f7f432c3e76d4f509fbba2429825acfc25ab696265df73f828504e6483b7  benchmarks/assets/openfoam13/drivaerFastback/frontWheels.obj.gz
@@ -9,49 +8,6 @@ f3e4f7f432c3e76d4f509fbba2429825acfc25ab696265df73f828504e6483b7  benchmarks/ass
 d64e176d6aa872857bb5b01791cc0441aa15ff8456440be7235f7481f658a117  benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer4.obj
 d0572aec19c41b2454ba0d7eecd1e07a7aae6aa98695f35ce781715e663ae40b  benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer6.obj
 b29238a8d12572509f8aa805dd095023c9b9759dbbd4c85e1def66ab40d5d540  benchmarks/assets/README.md
-6488b16a905c9e6ae7d33f06bd55fbf276c917df54f53984f4f4ba3504f1710d  benchmarks/evaluation/__init__.py
-b965c21513f41de952a6f983700e961845746fd1b3df1c56ab1e7a612ca8be8f  benchmarks/evaluation/__main__.py
-dc4d21e3f45bd036f5a0d23ef2e9bf4406f4e34a76437472e3b9bbb25ff5bd40  benchmarks/evaluation/adapters/__init__.py
-b8933e85b63abc1c792fdad5ddd76dedb2e0344e38ce6d2e8991ee760e7419ce  benchmarks/evaluation/adapters/chatcfd.py
-cdf7354b586bc67898bc2f3b44292aacd7fc9d7a58f0544efa9c603ac69a8f11  benchmarks/evaluation/adapters/coding_agent.py
-260f1efc5943ef598fa02b3dae130101961fc0c2ce22080abec2b4836d850d63  benchmarks/evaluation/adapters/common.py
-5ffd5d35e2431ae568b3e78b647aa85d091d01c124bcdacedcb6e68d4474339b  benchmarks/evaluation/adapters/easyfoam.py
-a33bcc116b3043c2b70a1342d0d3c71c30eac42f1ea286ca08b543f0e6496c40  benchmarks/evaluation/adapters/foamagent.py
-513e63ba562da617ef6f665c452bec8c2d308ca1e716629ac6ca360494724849  benchmarks/evaluation/aggregate.py
-1f8db418394f143b9ecb780eec4118ebde99885130cc30552f64735c5ea93307  benchmarks/evaluation/basic_advanced.py
-9d4a6bc429e0ef9a751384be2d777101f7f2d91dfee7edbdc6e3e0d771154ccd  benchmarks/evaluation/cli.py
-eb44b8d8020e5f9c22f19880884ade107afd395246b0d9ad8f78b9a6a4d30280  benchmarks/evaluation/comparison.py
-272bc7e44456c330fd7ac97685279538f8b0715d8aae3deb88366314fea1efc9  benchmarks/evaluation/evidence_contract.py
-cd2e1ff40d7dcb830b4230d86e143652d1d93a1b007019e3583384486a242604  benchmarks/evaluation/execution.py
-78cd982892e8ede31ee7e951cec87c7c595813a975bf4b111ea0d980b37633b5  benchmarks/evaluation/extbench.py
-51d8bb69224ed37ae0de073700c5f9cfd403095f53fa16d633a3eb777e1a0b13  benchmarks/evaluation/field_candidate.py
-95900ed3c04bc04846e2dd2dd6ae4f98c2fb0aba4b85978199c20b1a444f4c0e  benchmarks/evaluation/field_extractor.py
-3c6a38077eecae484f264cd46478b21687b21ca33f543f4f041d954bdfa98205  benchmarks/evaluation/foam.py
-80bd6344a529cc574693053b97b14cccb209c40a099b01a942f8654ddf24c614  benchmarks/evaluation/foam_arrays.py
-ce3a16fb9e29587eaabd816bdfda832bcdc83e3744ac233e1365b3350146ddf9  benchmarks/evaluation/foam_field.py
-a043e6a9022c30aea8fa94b8f753f1608804c526644a1f851c23453b7482727a  benchmarks/evaluation/foam_io.py
-55bd6f2c61c4e3cef677e4cf428433ae9e3fb8b778efc10bb281e814fc2c5d05  benchmarks/evaluation/frozen_recovery.py
-1cf606f832b4410908faaddeb439d0ca768cf134f4832f87f901c113a17d25da  benchmarks/evaluation/health.py
-83c7166635578af9b5ed7eaeac96c06df7b65ab0936dc39a5310e5c42a6003e4  benchmarks/evaluation/io.py
-eb16a2dbd37f6ddb112adb6a92f5b3c1b8aa6295592d8f5430d7d3a24f0ff334  benchmarks/evaluation/measurement_specs.py
-7f35b96268d62aca315d70f2c14a6bdda602bb51b70666fb1fa7667bc88a0cbf  benchmarks/evaluation/mesh.py
-75cdb75a677e47c786769d541e019085eb84a3de73b0539647143d869115d8ef  benchmarks/evaluation/models.py
-f87a0946dc0d29c656e362d56e3aa0cc68c495d6daecf5d17f429a916e6468ff  benchmarks/evaluation/numerical.py
-4921843f568f4ff06d4f02d270da87a8833d34dac2a448aae1a090caa68d2206  benchmarks/evaluation/pipeline.py
-95d54ca4f2dea32c9223cc092db6ac1e93fd045ab3a47a965c10f035b6211bd3  benchmarks/evaluation/preparation.py
-5e8791bf4840c8ea18d1f5c70ca922b100e7694a07e75f2c7fb47a9b834137a2  benchmarks/evaluation/profiles/advanced.json
-a9976b3f6d2125a9ada142614052eb7d4cbc263ac8c1781f7b3fd4f0e567e2e4  benchmarks/evaluation/profiles/basic.json
-8bbbc58e77b09da38eef2565e95b8d69c88b1db21ac696e9991b887e2394af85  benchmarks/evaluation/profiles/extended.json
-5cf9b70b1ec3ae040d2e3b478e61d5c4e1bf838106621e3d3f7c1827670841a5  benchmarks/evaluation/profiles.py
-305eba7114c1ae50521c05aa12ad95c9db35304af33665ea5e655bfd8f17c51b  benchmarks/evaluation/qoi.py
-af47ba704a5edcd8490261a7ddba07fe9204473ae4d19d3b09a7e4f7fb9f548f  benchmarks/evaluation/qoi_glue.py
-99a6af4a1f422bbb4f808602b744b2fa3660b4a7740e39ab24f3f4fcad9bda6b  benchmarks/evaluation/qoi_reference.py
-e0b13a6223ffa692f1297ba76b6817db4156bb3c3c3d2abfa96afc095d41511f  benchmarks/evaluation/README.md
-627725f472e89d9b97ff8cedf23d2ac92097a53f27f23d648f7be0bf943d33b1  benchmarks/evaluation/reference.py
-159655e9dadb4367a59a7ea1a804856c5280b3bc025c2892f06fd0535e265bae  benchmarks/evaluation/reporting.py
-0c54e9671b9f7353cbc28ecf9798d678db4bfacaa5f7c184bf4e45ebef9ec4a7  benchmarks/evaluation/retained_fields.py
-477332e61a0f668ff51db9817ec874706051d37c2dedf65b5ca43b73435c9583  benchmarks/evaluation/schema.py
-b9ba1b4c4583e9b393c699d47bab71a82aed159519408062b631147bd70d25a5  benchmarks/evaluation/stability.py
 74133664f968335b38cd17a0265d5003a4cce52230fc3f03846fcd3315599027  benchmarks/FoamBench_advanced_openfoam13_fixed_final.json
 31f46baabdbfb1482d8ef2573d25b82cd1c40f6859bf71cddae6f12e80fbba63  benchmarks/FoamBench_advanced_openfoam13_reference_qois.json
 50588c363869dd0a37befaa8e91bbc83c7bd8b14d8a23ff1eb2dc66fd77a0523  benchmarks/FoamBench_basic_openfoam13_fixed_final.json
@@ -64,39 +20,20 @@ fb1db5034a1d2688ad360c6b0810bab68c33d4c6dc1dc5bec29095e93b077393  benchmarks/Foa
 6c4a770c4b750ab0a8587cd18543517fd45cc93671014ced5fc81d668cd8a41b  benchmarks/reference_statistics/advanced.json
 3f780d1cac318eb13e43eae062b6f713d8a549b149856adc3749b06b1c916f72  benchmarks/reference_statistics/basic.json
 637e8b34e515fb439976804970eea4aa0cb651ef8aeeff59dfaa44c67844a0e9  benchmarks/reference_statistics/extended.json
-5c1f78137dc1c7032363bb0ebf96cf01f19c9f2ffb48abd7fef39cb8b54a9f82  benchmarks/scripts/__init__.py
-113840a36b914722ff422505b1ed128daf023ee20bf287ab8ebfcd1af938a786  benchmarks/scripts/build_extbench_reference.py
-827836c6f2363f0104917b6573dc86935ffc58fd3b9dcdf0ca83cd5ce874f753  benchmarks/scripts/compare_foambench_qois.py
-845727247e81e82d75abb0e05b62d1bd15f9a7d8512533b749b8a20e1631f6a5  benchmarks/scripts/extract_extbench_qois.py
-1110f0962468820146307099c463c1be8a25cbc5c3729fd7abc116d7fe06d27a  benchmarks/scripts/extract_foambench_candidate_qois.py
-cf3c18a0329ac576fc05e35ba2f70f95f0c1d6668a86fe6a65d8402de41a1abe  benchmarks/scripts/extract_foambench_qois.py
-265ac1ec1fcc347c82e9351a86305d6f7bafaf3bd8ff69075904ebaf285ed2bc  benchmarks/scripts/materialize_benchmark.py
-fc1268f130f4b0800b5a75346198e97896bd5e74b07ea3face5d0e4afa0d6d2c  benchmarks/scripts/recover_extbench_qoi.py
-ca2f885342099b4a06f425d971bee5edc24b199b596000e9997f8940b23770b4  benchmarks/scripts/validate_benchmark_assets.py
 488b6a139660cbcafd3de131c1e7e3c6758e71f609003e69cbfa1f9991afe95a  data/advanced.jsonl
 50a62e6ab16faa998dd1c284db6ecb4e8ac78ee226c8be4e0fb6cce741e7581f  data/basic.jsonl
 edfd82f84456540c89844eae84143dc4897a93599b1b28f278a945de5826981e  data/extended.jsonl
-07019bf3f590423b1b0804e6a8ac1dacf97677cb23a4842c4e5a0e601c155974  docs/DATA_FORMAT.md
-f0c1d691c071253fa66517e68349d9c2ee6c6d73f963a967c10173180693342b  docs/EVALUATION.md
-4f1353233c7d1d86da7f49d51a64f584805c435f8b052c37b37d30c84927530d  docs/PROVENANCE.md
-a3690d9a63846f36f58bd8e79e1ab974a4d46673a16943166e8ad0fd9b91faf1  docs/RELEASE_NOTES.md
-c05b1930bed5658497b9ac9de230127c23a8541b274adfd270c995943773f4d5  examples/inspect_task.py
+dfeed01d712c4915d2c2f0eccb60575de454eab740c97642ce9ed9d628346d50  GUIDE.md
 cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE
-1c8f0e5ad4fe2f145137ef723f54d62e8891a2b1b3467c90bc33c4c6680c907f  LICENSE.md
+e3ef265ef148001bef8936ecef4074605705b28d47c5be54f73e44893f2f25f1  LICENSE.md
 7e0a18d9201969787f5fc32b977318576c7d2942f2828e19fa212bde19706a22  LICENSES/FoamBench-BSD-3-Clause.txt
 8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b165a1dcd80c7c545eb65b903  LICENSES/GPL-3.txt
 770397d605802346385b7c69ab27b919c1b734d653c6ed64b255349e5ffeaef2  metadata/coverage.json
-a82a5872d4c62c7a0159ee23c684273e0eb61f4cd252f0db735e15e00364f95a  metadata/families.json
-ffc93609ac4a7d0f858696da211e1ec214409df51b8223d6833fd318b0d19f86  metadata/release.json
-74105bd146098de3bbe19c995eed3b3e5c63cad8b9480d08db34333292fec1d5  metadata/source_manifest.json
-9b912f908b65a553835273e3cfe3745b5d63f5d148ec1b719412db2471dbd0d7  metadata/validation.json
-ba391bbb79dd26d51519409f44987afff3757513aa7bf9519b053795c2f156d8  README.md
-df4bd25666834a74821035deda2154cd2922e3e0d2d00db0bd02f99ba4ad8caf  requirements.txt
-d49505bf35dffc763df91b13c8b5885e78b607af56d7aceba01e427c3fa19a6b  schemas/benchmark_evaluation.schema.json
-32a7f0865e9c851848fc775f9bde1125bd03749b4130d34fe95d5ffc62a700c0  schemas/benchmark_profile.schema.json
-88fb894b919323c0457f1cb4bf934f72320d644299185127c164579343606425  schemas/foambench_qoi_candidate.schema.json
-9204923e5b93e333459ccfc43394137deaee1bf19d6f01beaf8ada664806d7e8  schemas/foambench_qoi_comparison.schema.json
-2ef632eb4ed82ad78213de6ee4b18aa36558916a106cb258505493c95285ac68  schemas/foambench_qoi_reference.schema.json
-839a77fa504b7f13b2b6803c0ca2448df83418779cee2a2a5a5acdc18cd8760c  schemas/qoi_recovery_plan.schema.json
-73da798dd8c3ff74733a2a08a8d914d9e85c6d3184196dd0f2f8d0a45789a45a  scripts/verify_release.py
-59854984853104df5c353e2f681a15fc7924742f9a2e468c29af248dce45ce03  VERSION
+678ee25dd7207becec717dda6f981ed42dc240575452e5f18db0fd4df93ba4f3  metadata/release.json
+801975a7617517d8286bc8d91fa6e6041ad3e09433edcb1f9249750530e05902  metadata/source_manifest.json
+a308986a00db26567dc02fc6c4651667bf742bfc2f1997a8ee700f8f2faa918a  metadata/validation.json
+fd31e2cca58d84ca3581c3fa8f3e2ee5f24edddf71adff196f7bc3785d3fef19  README.md
+483b2e6058e6145e9dc4d62cadb650e7187d45d8a4c37e0f1a70dc7fd24d05a5  README_zh.md
+15d37d4b5c2293675fb977568f43a34e2eed8951a4e245407771cf9e09a4fdf5  scripts/verify_release.py
+6bf6fd0963a10c4a42e7de6529b4e75ca144e81716fa000cde8ea26d5c45a021  tools/evaluation-tools.zip
+6ca2e3356014241331fb2b399428fca23c558e3f3d428edcf4f56eb0fe907069  VERSION

VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

benchmarks/__init__.py

@@ -1 +0,0 @@
-"""FoamBench assets and evaluation utilities."""

benchmarks/evaluation/README.md

@@ -1,12 +0,0 @@
-# Standalone EasyFoam benchmark evaluator
-
-This directory contains the supplied evaluation implementation for Basic, Advanced and Extended tracks. See [Evaluation](../../docs/EVALUATION.md) for metric definitions, commands, dependencies, native-tool behavior and protocol boundaries, and the [dataset card](../../README.md) for contribution attribution.
-
-From the repository root:
-
-```bash
-python -m pip install -r requirements.txt
-python -m benchmarks.evaluation validate-profile --profile benchmarks/evaluation/profiles/extended.json
-```
-
-Agent campaign launchers and skill-evolution runtime code are distributed separately from this dataset. No model API key is needed to inspect the dataset or evaluate retained artifacts.

benchmarks/evaluation/__init__.py

@@ -1,31 +0,0 @@
-"""Dataset-independent FoamBench evaluation framework."""
-
-from pathlib import Path
-from typing import Any
-
-from .aggregate import aggregate_results
-from .models import BenchmarkProfile, CaseArtifact
-
-
-def evaluate_campaign(
-    profile: BenchmarkProfile,
-    *,
-    adapter_name: str,
-    run_root: Path,
-    output_dir: Path | None = None,
-    check_mesh: bool = False,
-    mesh_timeout: float = 120.0,
-) -> dict[str, Any]:
-    """Evaluate a campaign without importing the full pipeline at package import time."""
-    from .pipeline import evaluate_campaign as run_evaluation
-
-    return run_evaluation(
-        profile,
-        adapter_name=adapter_name,
-        run_root=run_root,
-        output_dir=output_dir,
-        check_mesh=check_mesh,
-        mesh_timeout=mesh_timeout,
-    )
-
-__all__ = ["BenchmarkProfile", "CaseArtifact", "aggregate_results", "evaluate_campaign"]

benchmarks/evaluation/__main__.py

@@ -1,10 +0,0 @@
-import json
-import sys
-
-from .cli import main
-
-try:
-    raise SystemExit(main())
-except (OSError, ValueError, RuntimeError, json.JSONDecodeError) as exc:
-    print(f"foambench-evaluate: error: {exc}", file=sys.stderr)
-    raise SystemExit(2)

benchmarks/evaluation/adapters/__init__.py

@@ -1,22 +0,0 @@
-from .easyfoam import EasyFoamAdapter
-from .foamagent import FoamAgentAdapter
-from .chatcfd import ChatCFDAdapter
-from .coding_agent import CodingAgentAdapter
-
-ADAPTERS = {
-    "easyfoam": EasyFoamAdapter,
-    "foamagent": FoamAgentAdapter,
-    "chatcfd": ChatCFDAdapter,
-    "coding-agent": CodingAgentAdapter,
-}
-
-
-def create_adapter(name: str, *args, **kwargs):
-    try:
-        adapter = ADAPTERS[name]
-    except KeyError as exc:
-        raise ValueError(f"unknown evaluation adapter: {name}") from exc
-    return adapter(*args, **kwargs)
-
-
-__all__ = ["EasyFoamAdapter", "FoamAgentAdapter", "ChatCFDAdapter", "create_adapter"]

benchmarks/evaluation/adapters/chatcfd.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..io import read_object
-from ..models import BenchmarkProfile, CaseArtifact
-from .common import duration, token_usage
-
-
-class ChatCFDAdapter:
-    """Normalize ChatCFD rollouts for the shared FoamBench scorer.
-
-    ChatCFD writes a case_run.log and keeps its model accounting in either a
-    rollout manifest or qa_logs.jsonl.  The adapter deliberately does not
-    infer case identity from generated files: a manifest is the reproducible
-    source of truth for benchmark membership.
-    """
-
-    def __init__(self, run_root: Path, profile: BenchmarkProfile):
-        self.run_root = run_root.resolve(strict=True)
-        self.profile = profile
-
-    def discover(self) -> dict[str, CaseArtifact]:
-        artifacts: dict[str, CaseArtifact] = {}
-        for manifest_path in sorted(self.run_root.rglob("rollout_manifest.json")):
-            manifest = read_object(manifest_path)
-            case_id = manifest.get("case_id")
-            if not isinstance(case_id, str) or case_id in artifacts:
-                continue
-            rollout = manifest_path.parent
-            case_ref = manifest.get("case_path", "case")
-            case_dir = Path(case_ref)
-            if not case_dir.is_absolute():
-                case_dir = rollout / case_dir
-            case_dir = case_dir.resolve()
-            family, variant = self.profile.identity(case_id)
-            logs = [p.resolve() for p in case_dir.glob("log.*") if p.is_file()]
-            logs.extend(p.resolve() for p in (case_dir / "case_run.log", case_dir / "Allrun.out", case_dir / "Allrun.err") if p.is_file())
-            normalized = dict(manifest)
-            normalized["duration_seconds"] = duration(manifest)
-            normalized["token_usage"] = token_usage(manifest)
-            if manifest.get("resource_measurement") == "request-journal-v1":
-                # Shared CSV reporting uses input/output names. Preserve the
-                # raw journal totals and completeness flags alongside aliases.
-                usage = normalized["token_usage"]
-                usage["input_tokens"] = usage["prompt_tokens"]
-                usage["output_tokens"] = usage["response_tokens"]
-            # Task selection and generation/repair have separate logs.
-            qa_logs = {p.resolve() for p in (rollout / "qa_logs.jsonl", case_dir / "qa_logs.jsonl") if p.is_file()}
-            if not normalized["token_usage"] and qa_logs:
-                totals = {"calls": 0, "prompt_tokens": 0, "response_tokens": 0, "reasoning_tokens": 0}
-                for path in sorted(qa_logs):
-                    for key, value in self._qa_usage(path).items():
-                        totals[key] += value
-                normalized["token_usage"] = totals
-            artifacts[case_id] = CaseArtifact(
-                case_id=case_id,
-                dataset=self.profile.dataset,
-                family=str(manifest.get("family") or family),
-                variant=str(manifest.get("variant") or variant),
-                replicate=int(manifest.get("replicate", 1)),
-                rollout_dir=rollout,
-                # Like Foam-Agent, ChatCFD supplies generic solver evidence,
-                # not an EasyFoam workflow workspace with formal run records.
-                workspace_dir=None,
-                case_dir=case_dir if case_dir.is_dir() else None,
-                manifest=normalized,
-                solver_logs=tuple(sorted(set(logs))),
-            )
-        return artifacts
-
-    @staticmethod
-    def _qa_usage(path: Path) -> dict[str, int]:
-        import json
-        totals = {"calls": 0, "prompt_tokens": 0, "response_tokens": 0, "reasoning_tokens": 0}
-        for line in path.read_text(encoding="utf-8").splitlines():
-            try:
-                row = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            totals["calls"] += 1
-            totals["prompt_tokens"] += int(row.get("prompt_tokens", 0) or 0)
-            totals["response_tokens"] += int(row.get("response_tokens", 0) or 0)
-            totals["reasoning_tokens"] += int(row.get("reasoning_tokens", 0) or 0)
-        return totals

benchmarks/evaluation/adapters/coding_agent.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..io import read_object
-from ..models import BenchmarkProfile, CaseArtifact
-
-
-class CodingAgentAdapter:
-    """Use externally recorded output discovery; impose no agent-side file contract."""
-
-    def __init__(self, run_root: Path, profile: BenchmarkProfile):
-        self.run_root = run_root.resolve(strict=True)
-        self.profile = profile
-
-    def discover(self) -> dict[str, CaseArtifact]:
-        result = {}
-        for path in sorted(self.run_root.glob("*/*/replicate_001/rollout_manifest.json")):
-            manifest = read_object(path)
-            if manifest.get("experiment_kind") != "requirement_only_coding_agent.v1":
-                raise ValueError(f"Unexpected experiment manifest: {path}")
-            case_id = manifest["case_id"]
-            if case_id in result:
-                raise ValueError(f"Duplicate case: {case_id}")
-            rollout = path.parent
-            workspace = rollout / "workspace"
-            ref = manifest.get("output_discovery", {}).get("case_ref")
-            case_dir = None
-            if isinstance(ref, str):
-                candidate = (workspace / ref).resolve()
-                if not candidate.is_relative_to(workspace.resolve()):
-                    raise ValueError(f"Case escapes workspace: {ref}")
-                case_dir = candidate
-            logs = []
-            for ref in manifest.get("solver_log_refs", []):
-                candidate = (rollout / ref).resolve()
-                if not candidate.is_relative_to(rollout.resolve()):
-                    raise ValueError(f"Log escapes rollout: {ref}")
-                if candidate.is_file():
-                    logs.append(candidate)
-            family, variant = self.profile.identity(case_id)
-            result[case_id] = CaseArtifact(
-                case_id=case_id, dataset=self.profile.dataset, family=family, variant=variant,
-                replicate=1, rollout_dir=rollout, workspace_dir=workspace, case_dir=case_dir,
-                manifest={**manifest, "agent_mode": "coding-only", "domain_assets_enabled": False},
-                solver_logs=tuple(logs),
-            )
-        return result

benchmarks/evaluation/adapters/common.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from ..io import read_object
-
-
-def formal_records(workspace: Path) -> tuple[Path, ...]:
-    paths: list[Path] = []
-    workflow_path = workspace / "workflow.json"
-    if workflow_path.is_file():
-        workflow = read_object(workflow_path)
-        refs = workflow.get("artifacts", {}).get("run_records", [])
-        for ref in refs if isinstance(refs, list) else []:
-            if isinstance(ref, str):
-                paths.append(workspace / ref)
-    paths.extend(workspace.glob("runs/formal-*/run_record.json"))
-    unique = {path.resolve() for path in paths if path.is_file()}
-    return tuple(sorted(unique))
-
-
-def successful_formal_records(paths: tuple[Path, ...]) -> tuple[Path, ...]:
-    successful = []
-    for path in paths:
-        record = read_object(path)
-        if record.get("mode") == "formal" and record.get("terminal_status") == "succeeded":
-            successful.append(path)
-    return tuple(successful)
-
-
-def logs_from_records(workspace: Path, records: tuple[Path, ...]) -> tuple[Path, ...]:
-    logs: list[Path] = []
-    for path in records:
-        record = read_object(path)
-        for command in record.get("commands", []) if isinstance(record.get("commands"), list) else []:
-            if not isinstance(command, dict):
-                continue
-            for key in ("stdout_ref", "stderr_ref"):
-                ref = command.get(key)
-                if isinstance(ref, str):
-                    candidate = workspace / ref
-                    if candidate.is_file():
-                        logs.append(candidate.resolve())
-    return tuple(dict.fromkeys(logs))
-
-
-def token_usage(manifest: dict[str, Any]) -> dict[str, Any]:
-    usage = manifest.get("token_usage")
-    if isinstance(usage, dict):
-        return dict(usage)
-    attempts = manifest.get("attempts")
-    if isinstance(attempts, list) and attempts and isinstance(attempts[-1], dict):
-        usage = attempts[-1].get("token_usage")
-    return dict(usage) if isinstance(usage, dict) else {}
-
-
-def duration(manifest: dict[str, Any]) -> float | None:
-    value = manifest.get("duration_seconds")
-    if isinstance(value, (int, float)):
-        return float(value)
-    process = manifest.get("process")
-    if isinstance(process, dict) and isinstance(process.get("duration_seconds"), (int, float)):
-        return float(process["duration_seconds"])
-    attempts = manifest.get("attempts")
-    values = [
-        float(item["duration_seconds"])
-        for item in attempts if isinstance(attempts, list) and isinstance(item, dict)
-        and isinstance(item.get("duration_seconds"), (int, float))
-    ] if isinstance(attempts, list) else []
-    return sum(values) if values else None

benchmarks/evaluation/adapters/easyfoam.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..foam import FATAL_RE, final_log_time, normal_end
-from ..foam_io import read_text
-from ..io import read_object
-from ..models import BenchmarkProfile, CaseArtifact
-from .common import duration, formal_records, logs_from_records, successful_formal_records, token_usage
-
-
-class EasyFoamAdapter:
-    """Normalize supported EasyFoam rollout layouts."""
-
-    def __init__(self, run_root: Path, profile: BenchmarkProfile):
-        self.run_root = run_root.resolve(strict=True)
-        self.profile = profile
-
-    def discover(self) -> dict[str, CaseArtifact]:
-        artifacts: dict[str, CaseArtifact] = {}
-        legacy = sorted(self.run_root.glob("*/*/replicate_*/rollout_manifest.json"))
-        current = sorted(self.run_root.rglob("run_manifest.json")) if not legacy else []
-        for path in [*legacy, *current]:
-            manifest = read_object(path)
-            case_id = manifest.get("case_id")
-            if not isinstance(case_id, str) or case_id in artifacts:
-                continue
-            rollout = path.parent
-            workspace = self._workspace(rollout, manifest)
-            family, variant = self.profile.identity(case_id)
-            coding_only = manifest.get("agent_mode") == "coding-only" or manifest.get("domain_assets_enabled") is False
-            case_dir = workspace / "case" if workspace else None
-            if coding_only and case_dir and case_dir.is_dir():
-                # Coding-only rollouts intentionally do not retain EasyFoam
-                # formal records. Avoid scanning their large workspaces for
-                # workflow/run-record artifacts before using generic logs.
-                records = ()
-                generic_logs = [item for item in case_dir.glob("log.*") if item.is_file()]
-                generic_logs.extend(
-                    item for item in (case_dir / "Allrun.out", case_dir / "Allrun.err") if item.is_file()
-                )
-                logs = _successful_generic_logs(generic_logs)
-            else:
-                records = formal_records(workspace) if workspace and workspace.is_dir() else ()
-                logs = logs_from_records(workspace, successful_formal_records(records)) if workspace else ()
-            normalized = dict(manifest)
-            normalized["duration_seconds"] = duration(manifest)
-            normalized["token_usage"] = token_usage(manifest)
-            artifacts[case_id] = CaseArtifact(
-                case_id=case_id,
-                dataset=self.profile.dataset,
-                family=str(manifest.get("family") or family),
-                variant=str(manifest.get("variant") or variant),
-                replicate=int(manifest.get("replicate", 1)),
-                rollout_dir=rollout,
-                workspace_dir=workspace,
-                case_dir=case_dir,
-                manifest=normalized,
-                formal_run_records=records,
-                solver_logs=logs,
-                workflow_path=workspace / "workflow.json" if workspace else None,
-                evidence_summary_path=workspace / "evidence_summary.json" if workspace else None,
-            )
-        return artifacts
-
-    def _workspace(self, rollout: Path, manifest: dict) -> Path | None:
-        direct = rollout / "workspace"
-        if direct.is_dir():
-            return direct.resolve()
-        ref = manifest.get("workspace_ref")
-        if isinstance(ref, str):
-            candidate = Path(ref)
-            if not candidate.is_absolute():
-                candidate = self.run_root / candidate
-            return candidate.resolve()
-        return None
-
-
-def _successful_generic_logs(paths: list[Path]) -> tuple[Path, ...]:
-    """Select final successful solver evidence without failed repair/postprocess logs."""
-    canonical_paths = tuple(sorted({item.resolve() for item in paths if item.name == "log.foamRun"}))
-    if canonical_paths:
-        # log.foamRun is the runner's canonical solver log.  Do not read
-        # multi-hundred-MB repair logs during artifact discovery; execution
-        # and numerical gates perform the substantive log checks later.
-        return canonical_paths
-    if paths:
-        # Avoid eagerly loading every repair/post-processing log merely to
-        # choose evidence. Prefer the newest generic log; gate parsing will
-        # validate its contents when it is actually evaluated.
-        existing = [item.resolve() for item in paths if item.is_file()]
-        if existing:
-            return (max(existing, key=lambda item: item.stat().st_mtime),)
-    evidence = []
-    for path in sorted({item.resolve() for item in paths}):
-        text = read_text(path)
-        if FATAL_RE.search(text):
-            continue
-        evidence.append((path, text, final_log_time(text)))
-    canonical = [item for item in evidence if item[0].name == "log.foamRun"]
-    if canonical:
-        return tuple(item[0] for item in canonical)
-    timed = [item for item in evidence if item[2] is not None]
-    if timed:
-        latest = max(float(item[2]) for item in timed if item[2] is not None)
-        return tuple(item[0] for item in timed if item[2] == latest)
-    ended = [item for item in evidence if normal_end(item[1])]
-    return tuple(item[0] for item in (ended or evidence))

benchmarks/evaluation/adapters/foamagent.py

@@ -1,57 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from ..io import read_object
-from ..models import BenchmarkProfile, CaseArtifact
-from .common import duration, token_usage
-
-
-class FoamAgentAdapter:
-    def __init__(self, run_root: Path, profile: BenchmarkProfile):
-        self.run_root = run_root.resolve(strict=True)
-        self.profile = profile
-
-    def discover(self) -> dict[str, CaseArtifact]:
-        artifacts: dict[str, CaseArtifact] = {}
-        for path in sorted(self.run_root.glob("*/*/replicate_*/rollout_manifest.json")):
-            manifest = read_object(path)
-            case_id = manifest.get("case_id")
-            if not isinstance(case_id, str) or case_id in artifacts:
-                continue
-            rollout = path.parent
-            case_dir = rollout / "case"
-            family, variant = self.profile.identity(case_id)
-            logs = [item for item in case_dir.glob("log.*") if item.is_file()]
-            logs.extend(item for item in (case_dir / "Allrun.out", case_dir / "Allrun.err") if item.is_file())
-            process = manifest.get("process") if isinstance(manifest.get("process"), dict) else {}
-            attempts = manifest.get("attempts") if isinstance(manifest.get("attempts"), list) else []
-            last_attempt = attempts[-1] if attempts and isinstance(attempts[-1], dict) else {}
-            normalized = dict(manifest)
-            normalized["return_code"] = process.get(
-                "return_code", last_attempt.get("return_code", manifest.get("return_code"))
-            )
-            normalized["timed_out"] = bool(process.get(
-                "timed_out", last_attempt.get("timed_out", manifest.get("timed_out", False))
-            ))
-            normalized["duration_seconds"] = duration(manifest)
-            normalized["token_usage"] = token_usage(manifest)
-            for metrics_path in (rollout / "llm_metrics.json", rollout / "attempt_001.llm_metrics.json"):
-                if metrics_path.is_file():
-                    normalized["token_usage"] = token_usage({"token_usage": read_object(metrics_path)})
-                    break
-            if isinstance(manifest.get("execution"), dict):
-                normalized["source_execution"] = manifest["execution"]
-            artifacts[case_id] = CaseArtifact(
-                case_id=case_id,
-                dataset=self.profile.dataset,
-                family=str(manifest.get("family") or family),
-                variant=str(manifest.get("variant") or variant),
-                replicate=int(manifest.get("replicate", 1)),
-                rollout_dir=rollout,
-                workspace_dir=None,
-                case_dir=case_dir,
-                manifest=normalized,
-                solver_logs=tuple(sorted({item.resolve() for item in logs})),
-            )
-        return artifacts

benchmarks/evaluation/aggregate.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-import statistics
-from collections import Counter
-from typing import Any
-
-
-def _rate(count: int, denominator: int) -> float | None:
-    return count / denominator if denominator else None
-
-
-def aggregate_results(rows: list[dict[str, Any]]) -> dict[str, Any]:
-    total = len(rows)
-    execution = sum(bool(row.get("scores", {}).get("execution_pass")) for row in rows)
-    numerical = sum(bool(row.get("scores", {}).get("numerical_pass")) for row in rows)
-    qoi = sum(
-        bool(
-            row.get("scores", {}).get(
-                "physics_grounded_qoi_pass",
-                row.get("scores", {}).get("qoi_pass"),
-            )
-        )
-        for row in rows
-    )
-    end_to_end = sum(bool(row.get("scores", {}).get("end_to_end_pass")) for row in rows)
-    ratios = [float(row.get("qoi", {}).get("effective_pass_ratio", 0.0)) for row in rows]
-    coverage = [
-        float(comparison["qoi_coverage_fraction"])
-        for row in rows
-        for comparison in [row.get("qoi", {}).get("comparison")]
-        if isinstance(comparison, dict) and isinstance(comparison.get("qoi_coverage_fraction"), (int, float))
-    ]
-    failures = Counter(
-        failure
-        for row in rows
-        for failure in row.get("failure_categories", [])
-    )
-    return {
-        "task_count": total,
-        "execution_pass_count": execution,
-        "execution_pass_rate": _rate(execution, total),
-        "numerical_pass_count": numerical,
-        "numerical_pass_rate_all_tasks": _rate(numerical, total),
-        "numerical_pass_rate_execution_pass": _rate(numerical, execution),
-        "physics_grounded_qoi_pass_count": qoi,
-        "physics_grounded_qoi_pass_rate_all_tasks": _rate(qoi, total),
-        "physics_grounded_qoi_pass_rate_execution_pass": _rate(qoi, execution),
-        "end_to_end_pass_count": end_to_end,
-        "end_to_end_pass_rate": _rate(end_to_end, total),
-        "mean_qoi_pass_ratio_all_tasks": statistics.fmean(ratios) if ratios else None,
-        "mean_qoi_coverage_evaluated": statistics.fmean(coverage) if coverage else None,
-        "failure_taxonomy": dict(sorted(failures.items())),
-    }
-
-
-def aggregate_evolution(groups: dict[str, list[dict[str, Any]]]) -> dict[str, Any]:
-    """Paired repeated-split reporting. Duplicate tasks remain group-qualified."""
-    metrics = ("execution_pass", "numerical_pass", "physics_grounded_qoi_pass", "end_to_end_pass")
-
-    def summarize(rows):
-        for row in rows:
-            for side in ("initial", "evolved"):
-                scores = row.get("reporting_scores", {}).get(side)
-                if not isinstance(scores, dict) or any(type(scores.get(key)) is not bool for key in metrics):
-                    raise ValueError("independent reporting scores are missing; reward is not a pass metric")
-                if scores["end_to_end_pass"] != all(scores[key] for key in metrics[:3]):
-                    raise ValueError("TAR is inconsistent with the three task-level checks")
-        return {metric: {
-            side: {"count": sum(row["reporting_scores"][side][metric] for row in rows),
-                   "rate": statistics.fmean(row["reporting_scores"][side][metric] for row in rows)}
-            for side in ("initial", "evolved")
-        } | {
-            "gain": statistics.fmean(int(row["reporting_scores"]["evolved"][metric]) - int(row["reporting_scores"]["initial"][metric]) for row in rows),
-            "failed_to_passed": sum(not row["reporting_scores"]["initial"][metric] and row["reporting_scores"]["evolved"][metric] for row in rows),
-            "passed_to_failed": sum(row["reporting_scores"]["initial"][metric] and not row["reporting_scores"]["evolved"][metric] for row in rows),
-        } for metric in metrics}
-
-    per_group = {}
-    all_rows = []
-    for group_id, rows in groups.items():
-        keys = {(row["dataset"], row["case_id"]) for row in rows}
-        if not rows or len(keys) != len(rows):
-            raise ValueError(f"empty or duplicate test tasks in group {group_id}")
-        per_group[group_id] = {"task_count": len(rows), "metrics": summarize(rows)}
-        all_rows.extend(dict(row, group_id=group_id) for row in rows)
-    families = {family: summarize([row for row in all_rows if row["family"] == family])
-                for family in sorted({row["family"] for row in all_rows})}
-    means = {metric: {side: {
-        "mean": statistics.fmean(group["metrics"][metric][side]["rate"] for group in per_group.values()),
-        "min": min(group["metrics"][metric][side]["rate"] for group in per_group.values()),
-        "max": max(group["metrics"][metric][side]["rate"] for group in per_group.values()),
-    } for side in ("initial", "evolved")} for metric in metrics}
-    return {"groups": per_group, "group_rates": means, "families": families,
-            "family_equal_weight_rates": {metric: {side: statistics.fmean(family[metric][side]["rate"] for family in families.values())
-                                                  for side in ("initial", "evolved")} for metric in metrics},
-            "test_records_per_condition": len(all_rows),
-            "unique_task_count": len({(row["dataset"], row["case_id"]) for row in all_rows}),
-            "test_frequency": dict(Counter(f"{row['dataset']}::{row['case_id']}" for row in all_rows)),
-            "interpretation": "Descriptive repeated splits; overlapping tasks and groups are not independent samples.",
-            "cases": all_rows}

benchmarks/evaluation/basic_advanced.py

@@ -1,807 +0,0 @@
-#!/usr/bin/env python3
-"""Structured QoIs shared by FoamBench Basic and Advanced references/candidates."""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import re
-import subprocess
-from pathlib import Path
-from typing import Any, Callable
-
-from .foam_arrays import FoamArrayError, foam_path, read_scalar_field, read_vector_field
-from .foam_io import magnitude, read_text
-from .io import utc_now, write_json
-from .schema import validate
-
-
-ADVANCED_TEMPLATE = {
-    "Cavity_LES": "Cavity", "Cavity_SA": "Cavity", "Cavity_geometry_1": "Cavity",
-    "Cylinder_LES": "Cylinder", "Cylinder_SA": "Cylinder",
-    "Diamond_Obstacle_KOMEGASST": "Obstacle", "Diamond_Obstacle_SA": "Obstacle",
-    "Double_Square_SA": "Obstacle", "Rectangular_Obstacle_KOMEGASST": "Obstacle",
-    "Rectangular_Obstacle_SA": "Obstacle", "counterFlowFlame2D_KE": "counterFlowFlame2D",
-    "counterFlowFlame2D_SA": "counterFlowFlame2D", "nozzleFlow2D_SA": "Nozzle",
-    "obliqueShock_KE": "Shock", "obliqueShock_LES": "Shock", "wedge_SA": "Shock",
-}
-
-GROUPS = {
-    "BernardCells": "thermal_state", "Cavity": "cavity_response", "Cylinder": "wake_response",
-    "counterFlowFlame2D": "flame_response", "damBreakWithObstacle": "free_surface_response",
-    "forwardStep": "shock_response", "obliqueShock": "shock_response", "wedge": "shock_response",
-    "Shock": "shock_response", "pitzDaily": "separation_response", "Obstacle": "obstacle_response",
-    "shallowWaterWithSquareBump": "surface_response", "squareBend": "bend_response",
-    "Nozzle": "nozzle_response",
-}
-
-PHYSICS_METRICS = {
-    "BernardCells": ("temperature_min", "temperature_max", "convection_mean_speed"),
-    "Cavity": ("response_speed_max", "reverse_flow_min_u"),
-    "Cylinder": ("wake_deficit_final",),
-    "counterFlowFlame2D": ("species_sum_max_error", "reaction_temperature_span"),
-    "damBreakWithObstacle": ("water_volume_relative_drift", "front_net_advance"),
-    "forwardStep": ("supersonic_volume_fraction", "shock_pressure_jump_ratio"),
-    "obliqueShock": ("supersonic_volume_fraction", "shock_pressure_jump_ratio"),
-    "wedge": ("supersonic_volume_fraction", "shock_pressure_jump_ratio"),
-    "Shock": ("supersonic_volume_fraction", "shock_pressure_jump_ratio"),
-    "pitzDaily": ("reverse_flow_volume_fraction", "streamwise_pressure_change_magnitude"),
-    "Obstacle": ("streamwise_pressure_change_magnitude",),
-    "shallowWaterWithSquareBump": ("mid_bump_height_relative_change",),
-    "squareBend": ("streamwise_pressure_change_magnitude",),
-    "Nozzle": ("flow_speed_max",),
-}
-
-# Each family already extracts one spatial response profile.  Making that
-# profile mandatory adds field-structure discrimination without introducing
-# another observable or extractor.  Scalar envelopes remain the
-# reference-independent admissibility check; profiles are the deliberately
-# stricter, reference-anchored response-shape check.
-PRINCIPAL_RESPONSE_PROFILES = {
-    "BernardCells": ("thermal_vertical_profile",),
-    "Cavity": ("centerline_velocity_profiles",),
-    "Cylinder": ("wake_velocity_profiles",),
-    "counterFlowFlame2D": ("reaction_zone_profile",),
-    "damBreakWithObstacle": ("free_surface_profile",),
-    "forwardStep": ("pressure_mach_profiles",),
-    "obliqueShock": ("pressure_mach_profiles",),
-    "wedge": ("pressure_mach_profiles",),
-    "Shock": ("pressure_mach_profiles",),
-    "pitzDaily": ("separation_profiles",),
-    "Obstacle": ("separation_profiles",),
-    "shallowWaterWithSquareBump": ("surface_profile",),
-    "squareBend": ("bend_axial_profile",),
-    "Nozzle": ("nozzle_axial_profile",),
-}
-
-
-def principal_metrics(template: str) -> tuple[str, ...]:
-    return PHYSICS_METRICS[template] + PRINCIPAL_RESPONSE_PROFILES[template]
-
-
-def numeric_times(case: Path) -> list[tuple[float, Path]]:
-    result = []
-    for child in case.iterdir():
-        if child.is_dir():
-            try:
-                result.append((float(child.name), child))
-            except ValueError:
-                pass
-    return sorted(result)
-
-
-def align(values: list[Any], count: int) -> list[Any]:
-    if len(values) == count:
-        return values
-    if len(values) == 1 and count:
-        return values * count
-    return []
-
-
-def scalars(directory: Path, name: str, count: int) -> list[float]:
-    path = foam_path(directory, name)
-    if path is None:
-        return []
-    try:
-        return align(read_scalar_field(path), count)
-    except (FoamArrayError, OSError, ValueError):
-        return []
-
-
-def vectors(directory: Path, name: str, count: int) -> list[tuple[float, float, float]]:
-    path = foam_path(directory, name)
-    if path is None:
-        return []
-    try:
-        return align(read_vector_field(path), count)
-    except (FoamArrayError, OSError, ValueError):
-        match = re.search(
-            r"internalField\s+uniform\s+\(([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\)",
-            read_text(path),
-        )
-        return [(float(match[1]), float(match[2]), float(match[3]))] * count if match else []
-
-
-def geometry(case: Path) -> tuple[list[tuple[float, float, float]], list[float], float, Path]:
-    times = numeric_times(case)
-    for time, directory in reversed(times):
-        c_path, v_path = foam_path(directory, "C"), foam_path(directory, "Vc")
-        if c_path and v_path:
-            centres = read_vector_field(c_path)
-            volumes = align(read_scalar_field(v_path), len(centres))
-            if centres and volumes:
-                return centres, volumes, time, directory
-    # C and Vc are measurement products, not required solver outputs. The
-    # independent evaluator also runs without prepare_campaign(), so recover
-    # the same geometric quantities directly from a retained static polyMesh.
-    # This uses no reference values and never writes into the frozen case.
-    if not times:
-        raise ValueError(f"no retained time directories for measurement: {case}")
-    from .retained_fields import derive_cell_geometry
-    try:
-        volumes, centres, _ = derive_cell_geometry(case)
-    except (ValueError, OSError) as exc:
-        raise ValueError(f"missing C/Vc and retained mesh geometry unavailable: {case}: {exc}") from exc
-    time, directory = times[-1]
-    count = raw_field_count(directory)
-    if count is not None and count != len(centres):
-        raise ValueError(f"retained field/mesh cell count mismatch: {case}")
-    return centres, volumes, time, directory
-
-
-def raw_field_count(directory: Path) -> int | None:
-    for name, reader in (("alpha.water", read_scalar_field), ("h", read_scalar_field),
-                         ("T", read_scalar_field), ("p", read_scalar_field), ("U", read_vector_field)):
-        path = foam_path(directory, name)
-        if path is None:
-            continue
-        try:
-            count = len(reader(path))
-        except (FoamArrayError, OSError, ValueError):
-            continue
-        if count > 1:
-            return count
-    return None
-
-
-def geometry_for_time(
-    case: Path, directory: Path, fallback_centres: list[tuple[float, float, float]], fallback_volumes: list[float],
-) -> tuple[list[tuple[float, float, float]], list[float]]:
-    expected = raw_field_count(directory)
-    if expected in {None, len(fallback_centres)}:
-        return fallback_centres, fallback_volumes
-    c_path, v_path = foam_path(directory, "C"), foam_path(directory, "Vc")
-    if not c_path or not v_path:
-        for function in ("writeCellCentres", "writeCellVolumes"):
-            completed = subprocess.run(
-                ["foamPostProcess", "-case", str(case), "-func", function, "-time", directory.name],
-                stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT, check=False,
-            )
-            if completed.returncode != 0:
-                raise ValueError(f"{case}: {function} failed at time {directory.name}")
-        c_path, v_path = foam_path(directory, "C"), foam_path(directory, "Vc")
-    if not c_path or not v_path:
-        raise ValueError(f"{case}: no time-local C/Vc at {directory.name}")
-    centres = read_vector_field(c_path)
-    volumes = align(read_scalar_field(v_path), len(centres))
-    if len(centres) != expected or not volumes:
-        raise ValueError(f"{case}: time-local geometry mismatch at {directory.name}")
-    return centres, volumes
-
-
-def bounds(centres: list[tuple[float, float, float]]) -> tuple[list[float], list[float]]:
-    return ([min(p[i] for p in centres) for i in range(3)], [max(p[i] for p in centres) for i in range(3)])
-
-
-def primary_axis(spans: list[float]) -> int:
-    """Choose x/y/z deterministically when extents differ only by roundoff."""
-    largest = max(spans)
-    return next(i for i, span in enumerate(spans) if math.isclose(span, largest, rel_tol=1e-12, abs_tol=0.0))
-
-
-def weighted(values: list[float], volumes: list[float]) -> float:
-    denominator = sum(volumes)
-    return sum(value * volume for value, volume in zip(values, volumes)) / denominator
-
-
-def bins(
-    centres: list[tuple[float, float, float]], volumes: list[float], axis: int,
-    fields: dict[str, list[float]], *, count: int = 41,
-    selector: Callable[[tuple[float, float, float]], bool] | None = None,
-) -> list[list[float]]:
-    low, high = bounds(centres)
-    span = high[axis] - low[axis]
-    groups: list[list[int]] = [[] for _ in range(count)]
-    for index, point in enumerate(centres):
-        if selector is not None and not selector(point):
-            continue
-        slot = min(count - 1, max(0, int((point[axis] - low[axis]) / max(span, 1e-30) * count)))
-        groups[slot].append(index)
-    rows = []
-    for indices in groups:
-        if not indices:
-            continue
-        weights = [volumes[i] for i in indices]
-        row = [weighted([centres[i][axis] for i in indices], weights)]
-        for values in fields.values():
-            row.append(weighted([values[i] for i in indices], weights))
-        rows.append(row)
-    return rows
-
-
-def profile(profile_id: str, coordinate: str, rows: list[list[float]], fields: list[str]) -> dict[str, Any]:
-    return {"profile_id": profile_id, "columns": [coordinate, *fields], "rows": rows}
-
-
-def named_profiles(items: list[dict[str, Any]]) -> dict[str, Any]:
-    return {"kind": "named_profiles", "profiles": items}
-
-
-def history(points: list[dict[str, float]]) -> dict[str, Any]:
-    return {"kind": "time_history", "points": points}
-
-
-def velocity_fields(directory: Path, count: int) -> tuple[list[tuple[float, float, float]], dict[str, list[float]]]:
-    velocity = vectors(directory, "U", count)
-    if not velocity:
-        return [], {}
-    return velocity, {
-        "u": [v[0] for v in velocity], "v": [v[1] for v in velocity],
-        "speed": magnitude(velocity),
-    }
-
-
-def thermo(case: Path) -> tuple[float, float]:
-    text = read_text(case / "constant" / "physicalProperties")
-    mw = re.search(r"(?m)^\s*molWeight\s+([-+0-9.eE]+)\s*;", text)
-    cp = re.search(r"(?m)^\s*Cp\s+([-+0-9.eE]+)\s*;", text)
-    if not mw or not cp:
-        return 1.4, 287.0
-    gas = 8314.46261815324 / float(mw[1])
-    heat = float(cp[1])
-    return (heat / (heat - gas) if heat > gas else 1.4), gas
-
-
-def state_fields(case: Path, directory: Path, count: int) -> dict[str, list[float]]:
-    _, fields = velocity_fields(directory, count)
-    for name in (
-        "p", "p_rgh", "rho", "T", "CH4", "O2", "CO2", "H2O", "N2", "Qdot",
-        "alpha.water", "alpha.fuel", "h",
-    ):
-        values = scalars(directory, name, count)
-        if values:
-            fields[name] = values
-    if fields.get("T") and fields.get("speed"):
-        gamma, gas = thermo(case)
-        fields["Mach"] = [u / math.sqrt(gamma * gas * t) if t > 0 else 0.0 for u, t in zip(fields["speed"], fields["T"])]
-    hu = vectors(directory, "hU", count)
-    if hu and fields.get("h"):
-        fields["Froude"] = [
-            q / h / math.sqrt(9.81 * h) if h > 1e-12 else 0.0
-            for q, h in zip(magnitude(hu), fields["h"])
-        ]
-    return fields
-
-
-def line_profile(
-    profile_id: str, centres: list[tuple[float, float, float]], volumes: list[float],
-    axis: int, fixed_axis: int, fraction: float, fields: dict[str, list[float]], names: list[str],
-) -> dict[str, Any]:
-    low, high = bounds(centres)
-    target = low[fixed_axis] + fraction * (high[fixed_axis] - low[fixed_axis])
-    target = min((point[fixed_axis] for point in centres), key=lambda value: abs(value - target))
-    bandwidth = max((high[fixed_axis] - low[fixed_axis]) / 41.0, 1e-12)
-    selected = lambda point: abs(point[fixed_axis] - target) <= bandwidth
-    usable = {name: fields[name] for name in names if name in fields}
-    return profile(profile_id, "xyz"[axis], bins(centres, volumes, axis, usable, selector=selected), list(usable))
-
-
-def section_profile(
-    profile_id: str, centres: list[tuple[float, float, float]], volumes: list[float], axis: int,
-    fields: dict[str, list[float]], names: list[str],
-) -> dict[str, Any]:
-    usable = {name: fields[name] for name in names if name in fields}
-    return profile(profile_id, "xyz"[axis], bins(centres, volumes, axis, usable), list(usable))
-
-
-def histories(
-    case: Path, centres: list[tuple[float, float, float]], volumes: list[float],
-    measure: Callable[[dict[str, list[float]], list[tuple[float, float, float]], list[float]], float | None],
-) -> dict[str, Any]:
-    points = []
-    for time, directory in numeric_times(case):
-        local_centres, local_volumes = geometry_for_time(case, directory, centres, volumes)
-        fields = state_fields(case, directory, len(local_centres))
-        value = measure(fields, local_centres, local_volumes)
-        if value is not None and math.isfinite(value):
-            points.append({"time": time, "value": float(value)})
-    return history(points)
-
-
-def shock_events(value: dict[str, Any]) -> dict[str, Any]:
-    events = []
-    for item in value.get("profiles", []):
-        columns, rows = item["columns"], item["rows"]
-        if "p" not in columns or len(rows) < 2:
-            continue
-        p_index = columns.index("p")
-        candidates = []
-        coordinate_min, coordinate_max = rows[0][0], rows[-1][0]
-        interior_low = coordinate_min + 0.05 * (coordinate_max - coordinate_min)
-        interior_high = coordinate_max - 0.05 * (coordinate_max - coordinate_min)
-        for left, right in zip(rows, rows[1:]):
-            dx = right[0] - left[0]
-            coordinate = 0.5 * (right[0] + left[0])
-            if dx > 0 and interior_low < coordinate < interior_high:
-                candidates.append((abs(right[p_index] - left[p_index]) / dx, coordinate, dx))
-        if candidates:
-            _, coordinate, cell = max(candidates)
-            events.append({"profile_id": item["profile_id"], "field": "p", "coordinate": coordinate, "local_cell_size": cell})
-    return {"kind": "profile_feature_locations", "events": events}
-
-
-def relative_drift(values: list[float]) -> float | None:
-    finite_values = [float(value) for value in values if math.isfinite(value)]
-    if len(finite_values) < 2:
-        return None
-    scale = max(abs(finite_values[0]), sum(abs(value) for value in finite_values) / len(finite_values), 1e-12)
-    return (max(finite_values) - min(finite_values)) / scale
-
-
-def pressure_change(
-    pressure: list[float], centres: list[tuple[float, float, float]], volumes: list[float], axis: int,
-) -> float | None:
-    if not pressure:
-        return None
-    cut = max(1, len(pressure) // 10)
-    ordered = sorted(zip(centres, pressure, volumes), key=lambda item: item[0][axis])
-    first, last = ordered[:cut], ordered[-cut:]
-    return weighted([p for _, p, _ in first], [w for _, _, w in first]) - weighted(
-        [p for _, p, _ in last], [w for _, _, w in last]
-    )
-
-
-def inventory_series(case: Path, field_name: str) -> list[float]:
-    centres, volumes, _, _ = geometry(case)
-    values = []
-    for _, directory in numeric_times(case):
-        local_centres, local_volumes = geometry_for_time(case, directory, centres, volumes)
-        field = scalars(directory, field_name, len(local_centres))
-        if field:
-            values.append(sum(value * volume for value, volume in zip(field, local_volumes)))
-    return values
-
-
-def shock_pressure_jump_ratio(profiles: dict[str, Any]) -> float | None:
-    ratios = []
-    for item in profiles.get("profiles", []):
-        columns, rows = item.get("columns", []), item.get("rows", [])
-        if "p" not in columns:
-            continue
-        index = columns.index("p")
-        for left, right in zip(rows, rows[1:]):
-            low, high = sorted((float(left[index]), float(right[index])))
-            if low > 0:
-                ratios.append(high / low)
-    return max(ratios) if ratios else None
-
-
-def family_qois(case: Path, template: str) -> dict[str, Any]:
-    centres, volumes, _, latest = geometry(case)
-    low, high = bounds(centres)
-    spans = [high[i] - low[i] for i in range(3)]
-    primary = primary_axis(spans)
-    secondary = 1 if primary == 0 else 0
-    fields = state_fields(case, latest, len(centres))
-    if fields.get("p"):
-        pressure_mean = weighted(fields["p"], volumes)
-        fields["p_gauge"] = [value - pressure_mean for value in fields["p"]]
-    qois: dict[str, Any] = {}
-
-    def downstream_min_u(f: dict[str, list[float]], c: list[tuple[float, float, float]], v: list[float]) -> float | None:
-        values = [u for point, u in zip(c, f.get("u", [])) if point[primary] >= low[primary] + 0.5 * spans[primary]]
-        return min(values) if values else None
-
-    def middle_section_mean(name: str, fraction: float = 0.5) -> Callable[[dict[str, list[float]], list[tuple[float, float, float]], list[float]], float | None]:
-        def measure(f: dict[str, list[float]], c: list[tuple[float, float, float]], v: list[float]) -> float | None:
-            values = f.get(name, [])
-            if not values:
-                return None
-            local_low, local_high = bounds(c)
-            target = local_low[primary] + fraction * (local_high[primary] - local_low[primary])
-            target = min((point[primary] for point in c), key=lambda value: abs(value - target))
-            width = max((local_high[primary] - local_low[primary]) / 41.0, 1e-12)
-            selected = [(value, volume) for point, value, volume in zip(c, values, v) if abs(point[primary] - target) <= width]
-            return weighted([item[0] for item in selected], [item[1] for item in selected]) if selected else None
-        return measure
-
-    def wake_deficit(f: dict[str, list[float]], c: list[tuple[float, float, float]], v: list[float]) -> float | None:
-        streamwise = f.get("u", [])
-        if not streamwise:
-            return None
-        local_low, local_high = bounds(c)
-        span = local_high[primary] - local_low[primary]
-        width = max(span / 41.0, 1e-12)
-        section_values = []
-        for fraction in (0.10, 0.65):
-            target = local_low[primary] + fraction * span
-            target = min((point[primary] for point in c), key=lambda value: abs(value - target))
-            selected = [(u, volume) for point, u, volume in zip(c, streamwise, v)
-                        if abs(point[primary] - target) <= width]
-            if not selected:
-                return None
-            section_values.append(weighted([item[0] for item in selected], [item[1] for item in selected]))
-        upstream, wake = section_values
-        return (upstream - wake) / max(abs(upstream), 1e-12)
-
-    if template == "BernardCells":
-        qois["thermal_vertical_profile"] = named_profiles([
-            line_profile("vertical_centerline", centres, volumes, 1, 0, 0.5, fields, ["T", "u", "v", "speed"])
-        ])
-        qois["circulation_strength_history"] = histories(case, centres, volumes, lambda f, c, v: weighted(f["speed"], v) if f.get("speed") else None)
-        if fields.get("T"):
-            qois["temperature_min"] = min(fields["T"])
-            qois["temperature_max"] = max(fields["T"])
-        if fields.get("speed"):
-            qois["convection_mean_speed"] = weighted(fields["speed"], volumes)
-    elif template == "Cavity":
-        qois["centerline_velocity_profiles"] = named_profiles([
-            line_profile("vertical_centerline", centres, volumes, 1, 0, 0.5, fields, ["u", "v", "speed"]),
-            line_profile("horizontal_centerline", centres, volumes, 0, 1, 0.5, fields, ["u", "v", "speed"]),
-        ])
-        qois["kinetic_energy_history"] = histories(case, centres, volumes, lambda f, c, w: 0.5 * weighted([v*v for v in f["speed"]], w) if f.get("speed") else None)
-        if fields.get("speed"):
-            qois["response_speed_max"] = max(fields["speed"])
-        if fields.get("u"):
-            qois["reverse_flow_min_u"] = min(fields["u"])
-    elif template == "Cylinder":
-        qois["wake_velocity_profiles"] = named_profiles([
-            line_profile(f"wake_x_{fraction:.2f}", centres, volumes, secondary, primary, fraction, fields, ["u", "v", "speed", "p_gauge"])
-            for fraction in (0.65, 0.80)
-        ])
-        qois["wake_deficit_history"] = histories(case, centres, volumes, wake_deficit)
-        points = qois["wake_deficit_history"].get("points", [])
-        if points:
-            qois["wake_deficit_final"] = float(points[-1]["value"])
-    elif template == "counterFlowFlame2D":
-        names = ["T", "CO2"] + (["Qdot"] if fields.get("Qdot") else [])
-        qois["reaction_zone_profile"] = named_profiles([section_profile("reaction_axis", centres, volumes, primary, fields, names)])
-        if fields.get("Qdot"):
-            qois["heat_release_history"] = histories(case, centres, volumes, lambda f, c, w: sum(v*vol for v, vol in zip(f["Qdot"], w)) if f.get("Qdot") else None)
-        else:
-            qois["peak_temperature_history"] = histories(case, centres, volumes, lambda f, c, v: max(f["T"]) if f.get("T") else None)
-        species = [fields[name] for name in ("CH4", "O2", "CO2", "H2O", "N2") if fields.get(name)]
-        if len(species) == 5:
-            qois["species_sum_max_error"] = max(abs(sum(values) - 1.0) for values in zip(*species))
-        if fields.get("T"):
-            qois["reaction_temperature_span"] = max(fields["T"]) - min(fields["T"])
-    elif template == "damBreakWithObstacle":
-        qois["front_position_history"] = histories(case, centres, volumes, lambda f, c, v: max((p[0] for p, a in zip(c, f.get("alpha.water", [])) if a >= 0.5), default=None))
-        alpha = fields.get("alpha.water", [])
-        rows = []
-        for slot in bins(centres, volumes, 0, {"alpha": alpha}):
-            x = slot[0]
-            width = spans[0] / 41
-            wet_y = [p[1] for p, a in zip(centres, alpha) if abs(p[0] - x) <= width and a >= 0.5]
-            if wet_y:
-                rows.append([x, max(wet_y)])
-        qois["free_surface_profile"] = named_profiles([profile("alpha_0.5_surface", "x", rows, ["surface_y"])])
-        drift = relative_drift(inventory_series(case, "alpha.water"))
-        if drift is not None:
-            qois["water_volume_relative_drift"] = drift
-        front_points = qois["front_position_history"].get("points", [])
-        if len(front_points) >= 2:
-            qois["front_net_advance"] = float(front_points[-1]["value"]) - float(front_points[0]["value"])
-    elif template in {"forwardStep", "obliqueShock", "wedge", "Shock"}:
-        profiles = named_profiles([
-            line_profile(f"streamline_{fraction:.2f}", centres, volumes, primary, secondary, fraction, fields, ["p", "Mach", "u", "speed"])
-            for fraction in (0.25, 0.50, 0.75)
-        ])
-        qois["pressure_mach_profiles"] = profiles
-        qois["shock_feature_locations"] = shock_events(profiles)
-        if fields.get("Mach"):
-            qois["supersonic_volume_fraction"] = sum(
-                volume for mach, volume in zip(fields["Mach"], volumes) if mach > 1.0
-            ) / sum(volumes)
-        jump = shock_pressure_jump_ratio(profiles)
-        if jump is not None:
-            qois["shock_pressure_jump_ratio"] = jump
-    elif template in {"pitzDaily", "Obstacle"}:
-        qois["separation_profiles"] = named_profiles([
-            section_profile("streamwise_sections", centres, volumes, primary, fields, ["u", "v", "speed", "p_gauge"]),
-            *[line_profile(f"wake_{fraction:.2f}", centres, volumes, secondary, primary, fraction, fields, ["u", "v", "speed", "p_gauge"]) for fraction in (0.65, 0.80)],
-        ])
-        qois["recirculation_strength_history"] = histories(case, centres, volumes, downstream_min_u)
-        downstream = [
-            (u, volume) for point, u, volume in zip(centres, fields.get("u", []), volumes)
-            if point[primary] >= low[primary] + 0.5 * spans[primary]
-        ]
-        if downstream:
-            qois["reverse_flow_volume_fraction"] = sum(
-                volume for u, volume in downstream if u < 0.0
-            ) / sum(volume for _, volume in downstream)
-        change = pressure_change(fields.get("p", []) or fields.get("p_rgh", []), centres, volumes, primary)
-        if change is not None:
-            qois["streamwise_pressure_change_magnitude"] = abs(change)
-    elif template == "shallowWaterWithSquareBump":
-        qois["surface_profile"] = named_profiles([section_profile("bump_axis", centres, volumes, primary, fields, ["h", "Froude"])])
-        qois["mid_bump_height_history"] = histories(case, centres, volumes, middle_section_mean("h"))
-        height_points = qois["mid_bump_height_history"].get("points", [])
-        if len(height_points) >= 2:
-            first, last = float(height_points[0]["value"]), float(height_points[-1]["value"])
-            qois["mid_bump_height_relative_change"] = abs(last - first) / max(abs(first), 1e-12)
-    elif template in {"squareBend", "Nozzle"}:
-        prefix = "bend" if template == "squareBend" else "nozzle"
-        qois[f"{prefix}_axial_profile"] = named_profiles([section_profile("axial_sections", centres, volumes, primary, fields, ["p", "p_rgh", "Mach", "u", "speed"])])
-        def pressure_drop(f: dict[str, list[float]], c: list[tuple[float, float, float]], v: list[float]) -> float | None:
-            return pressure_change(f.get("p") or f.get("p_rgh") or [], c, v, primary)
-        qois["pressure_drop_history"] = histories(case, centres, volumes, pressure_drop)
-        if template == "squareBend":
-            change = pressure_change(fields.get("p", []) or fields.get("p_rgh", []), centres, volumes, primary)
-            if change is not None:
-                qois["streamwise_pressure_change_magnitude"] = abs(change)
-        else:
-            drift = relative_drift(inventory_series(case, "alpha.fuel"))
-            if drift is not None:
-                qois["transported_phase_inventory_relative_drift"] = drift
-            if fields.get("speed"):
-                qois["flow_speed_max"] = max(fields["speed"])
-    else:
-        raise ValueError(f"no structured QoI family for {template}")
-    return qois
-
-
-def structured_errors(name: str, value: Any) -> list[str]:
-    if isinstance(value, (int, float)) and not isinstance(value, bool):
-        return [] if math.isfinite(float(value)) else [f"{name}: non-finite scalar"]
-    if not isinstance(value, dict):
-        return [f"{name}: not structured"]
-    if value.get("kind") == "time_history":
-        return [] if len(value.get("points", [])) >= 2 else [f"{name}: fewer than two history points"]
-    if value.get("kind") == "named_profiles":
-        profiles = value.get("profiles", [])
-        return [] if profiles and all(len(p.get("rows", [])) >= 2 and len(p.get("columns", [])) >= 2 for p in profiles) else [f"{name}: incomplete profiles"]
-    if value.get("kind") == "profile_feature_locations":
-        return [] if value.get("events") else [f"{name}: no feature events"]
-    return [f"{name}: unsupported kind"]
-
-
-def extract(
-    case: Path,
-    case_id: str,
-    requested_metrics: list[str] | None = None,
-    *,
-    required_metrics: list[str] | None = None,
-    log_paths: list[Path] | None = None,
-) -> dict[str, Any]:
-    family = case_id.split("/", 1)[0]
-    template = ADVANCED_TEMPLATE.get(case_id, family)
-    values = family_qois(case, template)
-    requested = requested_metrics or sorted(values)
-    required = required_metrics or requested
-    selected = {name: values[name] for name in requested if name in values}
-    missing = sorted(set(required) - set(selected))
-    errors = [
-        error for name, value in selected.items() if name in required
-        for error in structured_errors(name, value)
-    ]
-    _, _, latest_time, _ = geometry(case)
-    complete = not missing and not errors
-    return {
-        "schema_version": "foambench.qoi.candidate", "case_id": case_id, "family": template,
-        "latest_time": latest_time, "status": "complete" if complete else "incomplete",
-        "principal_qoi_group": GROUPS[template],
-        "principal_metrics": sorted(name for name in required if name in selected),
-        "required_metrics": required, "missing_metrics": missing, "qois": selected,
-        "health": {"status": "pass" if complete else "fail", "checks": {
-            "principal_qoi_complete": not missing, "structured_qoi_valid": not errors,
-            "measurement_geometry_available": True, "no_proxy_fallback": True,
-        }, "validation_errors": errors},
-    }
-
-
-FIELD_NORMALIZATION_FLOORS = {
-    "p": 1.0, "p_gauge": 1.0, "p_rgh": 1.0, "T": 0.1, "CO2": 1e-6, "Qdot": 1e-3,
-    "u": 1e-5, "v": 1e-5, "speed": 1e-5, "Mach": 1e-4,
-    "h": 1e-6, "Froude": 1e-4, "surface_y": 1e-6,
-}
-HISTORY_NORMALIZATION_FLOORS = {
-    "circulation_strength_history": 1e-6, "kinetic_energy_history": 1e-8,
-    "wake_deficit_history": 1e-4, "recirculation_strength_history": 1e-5,
-    "heat_release_history": 1e-3, "peak_temperature_history": 0.1,
-    "front_position_history": 1e-5, "mid_bump_height_history": 1e-6,
-    "pressure_drop_history": 1.0,
-}
-
-
-def tolerance(name: str, value: dict[str, Any], group: str) -> dict[str, Any]:
-    kind = value.get("kind")
-    if kind == "time_history":
-        return {"kind": kind, "normalized_rmse_max": 0.06 if group == "shock_response" else 0.08,
-                "normalized_linf_max": 0.15 if group == "shock_response" else 0.20,
-                "minimum_time_coverage": 1.0,
-                "normalization_floor": HISTORY_NORMALIZATION_FLOORS.get(name, 1e-8), "provisional": True}
-    if kind == "named_profiles":
-        columns = {column for item in value.get("profiles", []) for column in item.get("columns", [])[1:]}
-        return {"kind": kind, "normalized_l1_max": 0.05 if group == "shock_response" else 0.08,
-                "normalized_linf_max": 0.15 if group == "shock_response" else 0.20,
-                "normalization_floors": {column: FIELD_NORMALIZATION_FLOORS.get(column, 1e-8) for column in sorted(columns)},
-                "criterion_role": "principal_response_shape",
-                "reference_independent": False,
-                "threshold_source": "reference_anchored_spatial_response_shape",
-                "provisional": True}
-    if kind == "profile_feature_locations":
-        return {"kind": kind, "maximum_cell_offset": 2.0, "physical_floor": 1e-10, "provisional": True}
-    raise ValueError(f"unsupported structured tolerance for {kind}")
-
-
-def uniform_scalars(path: Path) -> list[float]:
-    return [
-        float(match)
-        for match in re.findall(r"\bvalue\s+uniform\s+([-+0-9.eE]+)\s*;", read_text(path))
-    ]
-
-
-def uniform_vector_magnitudes(path: Path) -> list[float]:
-    return [
-        math.sqrt(sum(float(component) ** 2 for component in match))
-        for match in re.findall(
-            r"\bvalue\s+uniform\s+\(([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\)\s*;",
-            read_text(path),
-        )
-    ]
-
-
-def physical_tolerance(template: str, name: str, case: Path) -> dict[str, Any]:
-    common: dict[str, Any] = {
-        "kind": "physics_range",
-        "criterion_role": "principal_physics",
-        "reference_independent": True,
-    }
-    if template == "BernardCells" and name in {"temperature_min", "temperature_max"}:
-        imposed = uniform_scalars(case / "0" / "T")
-        if len(imposed) < 2:
-            raise ValueError(f"{case}: cannot determine imposed temperature envelope")
-        low, high = min(imposed), max(imposed)
-        margin = max(1e-6, 0.02 * max(high - low, 1e-6))
-        bounds = (low - margin, high + margin)
-        return {**common, "low": bounds[0], "high": bounds[1],
-                "threshold_source": "imposed_temperature_boundary_envelope", "provisional": False}
-    if template == "BernardCells" and name == "convection_mean_speed":
-        return {**common, "low": 1e-12, "high": 1e6,
-                "threshold_source": "nontrivial_buoyant_response", "provisional": True}
-    if template == "Cavity":
-        imposed = uniform_vector_magnitudes(case / "0" / "U")
-        lid_speed = max(imposed, default=0.0)
-        if lid_speed <= 0:
-            raise ValueError(f"{case}: cannot determine moving-wall speed")
-        if name == "response_speed_max":
-            return {**common, "low": 0.10 * lid_speed, "high": 1.0 * lid_speed,
-                    "threshold_source": "lid_speed_response_envelope_tightened", "provisional": True}
-        if name == "reverse_flow_min_u":
-            return {**common, "low": -1.0 * lid_speed, "high": -0.05 * lid_speed,
-                    "threshold_source": "main_vortex_reverse_flow_envelope_tightened", "provisional": True}
-    if template == "shallowWaterWithSquareBump" and name == "mid_bump_height_relative_change":
-        initial_depths = uniform_scalars(case / "0" / "h")
-        initial_depth = sum(initial_depths) / len(initial_depths) if initial_depths else 0.0
-        # The shallow-water family changes regime with its prompt-specified
-        # initial depth. A single non-zero floor would accept a numerically
-        # stagnant response for the deeper cases.
-        low = 2e-4 if initial_depth <= 0.012 else 0.1
-        return {**common, "low": low, "high": 1.0,
-                "threshold_source": "initial_depth_conditioned_bump_response", "provisional": True}
-    fixed = {
-        # These are first-stage family envelopes: they reject merely non-zero
-        # signatures while retaining the checked-in reference regimes. They
-        # are intentionally absolute and reference-independent; later runs can
-        # replace them with law-based relations or repeatability envelopes.
-        ("Cylinder", "wake_deficit_final"): (0.03, 0.15, "bounded_dimensionless_wake_deficit"),
-        ("counterFlowFlame2D", "species_sum_max_error"): (0.0, 5e-5, "species_mass_fraction_closure_tightened"),
-        ("counterFlowFlame2D", "reaction_temperature_span"): (500.0, 3000.0, "bounded_thermal_reaction_zone"),
-        ("damBreakWithObstacle", "water_volume_relative_drift"): (0.0, 5e-3, "closed_phase_volume_conservation_tightened"),
-        ("damBreakWithObstacle", "front_net_advance"): (0.03, 0.25, "bounded_downstream_free_surface_advance"),
-        ("forwardStep", "supersonic_volume_fraction"): (0.40, 1.0, "supersonic_regime_coverage_tightened"),
-        ("obliqueShock", "supersonic_volume_fraction"): (0.85, 1.0, "supersonic_regime_coverage_tightened"),
-        ("wedge", "supersonic_volume_fraction"): (0.85, 1.0, "supersonic_regime_coverage_tightened"),
-        ("Shock", "supersonic_volume_fraction"): (0.85, 1.0, "supersonic_regime_coverage_tightened"),
-        ("forwardStep", "shock_pressure_jump_ratio"): (1.50, 20.0, "bounded_compressive_pressure_feature"),
-        ("obliqueShock", "shock_pressure_jump_ratio"): (1.10, 2.20, "bounded_compressive_pressure_feature"),
-        ("wedge", "shock_pressure_jump_ratio"): (2.00, 6.50, "bounded_compressive_pressure_feature"),
-        ("Shock", "shock_pressure_jump_ratio"): (1.10, 2.20, "bounded_compressive_pressure_feature"),
-        ("pitzDaily", "reverse_flow_volume_fraction"): (1e-3, 0.08, "bounded_separated_reverse_flow_signature"),
-        ("pitzDaily", "streamwise_pressure_change_magnitude"): (8.0, 140.0, "bounded_streamwise_pressure_response"),
-        ("Obstacle", "streamwise_pressure_change_magnitude"): (0.005, 10.0, "bounded_obstacle_pressure_response"),
-        ("squareBend", "streamwise_pressure_change_magnitude"): (3e4, 1.2e5, "bounded_bend_pressure_response"),
-        ("Nozzle", "flow_speed_max"): (100.0, 1000.0, "bounded_nozzle_flow_response"),
-    }
-    if (template, name) not in fixed:
-        raise ValueError(f"no physics tolerance for {template}/{name}")
-    low, high, source = fixed[(template, name)]
-    exact_sources = {"species_mass_fraction_closure", "closed_phase_volume_conservation"}
-    return {**common, "low": low, "high": high, "threshold_source": source,
-            "provisional": source not in exact_sources}
-
-
-def diagnostic_scalar_tolerance(value: float) -> dict[str, Any]:
-    scale = max(abs(float(value)), 1e-12)
-    return {
-        "low": float(value) - 0.2 * scale,
-        "high": float(value) + 0.2 * scale,
-        "kind": "diagnostic_scalar_reference",
-        "provisional": True,
-        "threshold_source": "reference_diagnostic_relative_band",
-    }
-
-
-def build_references(run_root: Path) -> tuple[dict[str, Any], dict[str, Any]]:
-    documents: dict[str, dict[str, Any]] = {}
-    for track in ("basic", "advanced"):
-        records = {}
-        for wrapper in sorted((run_root / "materialized" / track).iterdir()):
-            case = wrapper / "case"
-            if not case.is_dir():
-                continue
-            case_id = wrapper.name.replace("__", "/", 1) if track == "basic" else wrapper.name
-            candidate = extract(case, case_id)
-            if candidate["status"] != "complete":
-                raise ValueError(f"{case_id}: {candidate['health'].get('validation_errors') or candidate['missing_metrics']}")
-            group, qois = candidate["principal_qoi_group"], candidate["qois"]
-            principal = list(principal_metrics(candidate["family"]))
-            missing_principal = sorted(set(principal) - set(qois))
-            if missing_principal:
-                raise ValueError(f"{case_id}: missing physics metrics {missing_principal}")
-            roles = {name: "principal" if name in principal else "diagnostic" for name in qois}
-            tolerances = {
-                name: tolerance(name, value, group)
-                if isinstance(value, dict) and name in principal else (
-                    physical_tolerance(candidate["family"], name, case)
-                    if name in principal else (
-                    diagnostic_scalar_tolerance(value)
-                    if isinstance(value, (int, float)) and not isinstance(value, bool)
-                    else tolerance(name, value, group)
-                    )
-                )
-                for name, value in qois.items()
-            }
-            records[case_id] = {
-                "track": track, "family": candidate["family"], "source_case_id": case_id,
-                "latest_time": candidate["latest_time"], "principal_qoi_group": group,
-                "principal_metrics": sorted(principal), "qois": qois,
-                "metric_roles": roles, "tolerances": tolerances,
-                "health": candidate["health"], "extraction": {
-                    "producer": "benchmarks/evaluation/basic_advanced.py",
-                    "geometry": "field-derived physics metrics plus physical-coordinate reference diagnostics",
-                    "reference_run": str(run_root),
-                },
-            }
-        documents[track] = {
-            "schema_version": "foambench.reference_qois.v2", "generated_at": utc_now(),
-            "openfoam_version": "Foundation v13", "producer": "benchmarks/evaluation/basic_advanced.py",
-            "design": "guide/foambench_basic_advanced_qoi_design.md",
-            "tolerance_policy": "physics_grounded_scalar_and_response_shape_joint_gate.v2",
-            "summary": {"tracks": [track], "case_count": len(records), "health_pass_count": len(records), "health_fail_count": 0},
-            "notes": ["Principal scalar QoIs are reference-independent family physics criteria extracted from retained fields.",
-                      "One existing spatial response profile per family is also principal and must jointly pass its reference-anchored shape tolerance.",
-                      "Other histories, profiles, and feature locations remain diagnostic and do not decide Physics-grounded pass.",
-                      "Provisional physical-signature and response-shape limits require future valid-alternative calibration."],
-            "cases": records,
-        }
-        validate(documents[track], "foambench_qoi_reference.schema.json")
-    return documents["basic"], documents["advanced"]
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--run-root", required=True, type=Path)
-    parser.add_argument("--basic-output", required=True, type=Path)
-    parser.add_argument("--advanced-output", required=True, type=Path)
-    args = parser.parse_args()
-    basic, advanced = build_references(args.run_root.resolve(strict=True))
-    write_json(args.basic_output, basic)
-    write_json(args.advanced_output, advanced)
-    print(json.dumps({"basic": len(basic["cases"]), "advanced": len(advanced["cases"])}, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

benchmarks/evaluation/cli.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-from .io import read_object
-from .models import BenchmarkProfile
-from .pipeline import evaluate_campaign
-from .preparation import prepare_campaign
-from .profiles import load_assets
-from .reporting import summary_table
-from .schema import validate
-
-
-def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(description="Evaluate FoamBench rollouts with a dataset-independent scorer.")
-    subparsers = parser.add_subparsers(dest="command", required=True)
-    validate = subparsers.add_parser("validate-profile", help="validate benchmark profile assets")
-    validate.add_argument("--profile", type=Path, required=True)
-    evaluate = subparsers.add_parser("evaluate", help="evaluate one rollout campaign")
-    evaluate.add_argument("--profile", type=Path, required=True)
-    evaluate.add_argument("--adapter", choices=("easyfoam", "foamagent", "chatcfd", "coding-agent"), required=True)
-    evaluate.add_argument("--run-root", type=Path, required=True)
-    evaluate.add_argument("--output", type=Path, required=True)
-    evaluate.add_argument(
-        "--prepare", action="store_true",
-        help="generate measurement-only C, Vc, and vorticity fields before evaluation",
-    )
-    evaluate.add_argument("--prepare-jobs", type=int, default=1)
-    evaluate.add_argument(
-        "--check-mesh", action="store_true",
-        help="run read-only checkMesh when no retained mesh log is available",
-    )
-    evaluate.add_argument("--mesh-timeout", type=float, default=120.0)
-    return parser
-
-
-def main(argv: list[str] | None = None) -> int:
-    args = build_parser().parse_args(argv)
-    validate(read_object(args.profile), "benchmark_profile.schema.json")
-    profile = BenchmarkProfile.load(args.profile)
-    if args.command == "validate-profile":
-        benchmark, references = load_assets(profile)
-        print(json.dumps({
-            "profile_id": profile.profile_id,
-            "dataset": profile.dataset,
-            "benchmark_case_count": len(benchmark),
-            "reference_case_count": len(references),
-            "status": "pass",
-        }, indent=2, sort_keys=True))
-        return 0
-    if args.prepare:
-        prepare_campaign(
-            profile,
-            adapter_name=args.adapter,
-            run_root=args.run_root,
-            output_root=args.output.resolve() / "preparation",
-            jobs=args.prepare_jobs,
-        )
-    report = evaluate_campaign(
-        profile,
-        adapter_name=args.adapter,
-        run_root=args.run_root,
-        output_dir=args.output,
-        check_mesh=args.check_mesh,
-        mesh_timeout=args.mesh_timeout,
-    )
-    print(summary_table(report["overall"]))
-    return 0
-
-
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main())
-    except (OSError, ValueError, RuntimeError) as exc:
-        print(f"foambench-evaluate: error: {exc}", file=sys.stderr)
-        raise SystemExit(2)

benchmarks/evaluation/comparison.py

@@ -1,750 +0,0 @@
-#!/usr/bin/env python3
-"""Compare candidate FoamBench QoIs with checked-in reference contracts.
-
-Coverage and numerical agreement are reported separately. Related field
-statistics are scored as equal-weight QoI groups; ranges and runtime metrics
-remain available as diagnostics but do not determine the group score. A
-missing QoI means that the benchmark cannot assess that part of the result; it
-is not relabelled as an out-of-tolerance value.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import re
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-
-def finite(value: Any) -> float | None:
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        return None
-    result = float(value)
-    return result if math.isfinite(result) else None
-
-
-def scalar_observation(value: Any) -> float | None:
-    direct = finite(value)
-    if direct is not None:
-        return direct
-    if isinstance(value, dict) and value.get("kind") in {"scalar_ratio", "window_regression"}:
-        return finite(value.get("value"))
-    return None
-
-
-def interpolate(points: list[dict[str, Any]], time: float) -> float | None:
-    rows = [(finite(item.get("time")), finite(item.get("value"))) for item in points if isinstance(item, dict)]
-    rows = sorted((t, v) for t, v in rows if t is not None and v is not None)
-    if not rows or time < rows[0][0] or time > rows[-1][0]:
-        return None
-    for index, (left_t, left_v) in enumerate(rows):
-        if abs(time - left_t) <= 1e-12 * max(1.0, abs(time)):
-            return left_v
-        if index + 1 < len(rows) and left_t < time < rows[index + 1][0]:
-            right_t, right_v = rows[index + 1]
-            weight = (time - left_t) / (right_t - left_t)
-            return left_v + weight * (right_v - left_v)
-    return None
-
-
-def compare_history(reference: dict[str, Any], candidate: dict[str, Any], tolerance: dict[str, Any]) -> dict[str, Any]:
-    reference_points = reference.get("points", [])
-    candidate_points = candidate.get("points", [])
-    pairs = []
-    for point in reference_points if isinstance(reference_points, list) else []:
-        time, reference_value = finite(point.get("time")), finite(point.get("value")) if isinstance(point, dict) else (None, None)
-        if time is None or reference_value is None:
-            continue
-        candidate_value = interpolate(candidate_points if isinstance(candidate_points, list) else [], time)
-        if candidate_value is not None:
-            pairs.append((reference_value, candidate_value))
-    required_coverage = finite(tolerance.get("minimum_time_coverage")) or 1.0
-    coverage = len(pairs) / len(reference_points) if reference_points else 0.0
-    if not pairs:
-        return {"status": "missing", "coverage_fraction": coverage}
-    floor = finite(tolerance.get("normalization_floor")) or 1e-12
-    norm = max(math.sqrt(sum(ref * ref for ref, _ in pairs) / len(pairs)), floor)
-    errors = [cand - ref for ref, cand in pairs]
-    nrmse = math.sqrt(sum(error * error for error in errors) / len(errors)) / norm
-    nlinf = max(abs(error) for error in errors) / norm
-    rmse_limit = finite(tolerance.get("normalized_rmse_max"))
-    linf_limit = finite(tolerance.get("normalized_linf_max"))
-    valid = rmse_limit is not None and linf_limit is not None
-    passed = valid and coverage >= required_coverage and nrmse <= rmse_limit and nlinf <= linf_limit
-    return {"status": "within_tolerance" if passed else "invalid_contract" if not valid else "out_of_tolerance",
-            "coverage_fraction": coverage, "aligned_point_count": len(pairs),
-            "normalized_rmse": nrmse, "normalized_linf": nlinf,
-            "normalized_rmse_max": rmse_limit, "normalized_linf_max": linf_limit}
-
-
-def profile_key(profile: dict[str, Any]) -> str:
-    """Normalize centerline aliases by the coordinate direction they sample."""
-    name = Path(str(profile.get("profile_id", ""))).name.lower()
-    stem = Path(name).stem
-    if stem in {"centreline_y0", "centerline_y0", "centerliney", "horizontal", "horizontalcenterline", "horizontalcentreline"}:
-        return "horizontal.xy"
-    if stem in {"centreline_x0", "centerline_x0", "centerlinex", "vertical", "verticalcenterline", "verticalcentreline"}:
-        return "vertical.xy"
-    return name
-
-
-def compare_profiles(reference: dict[str, Any], candidate: dict[str, Any], tolerance: dict[str, Any]) -> dict[str, Any]:
-    references = {profile_key(item): item for item in reference.get("profiles", []) if isinstance(item, dict)}
-    candidates = {profile_key(item): item for item in candidate.get("profiles", []) if isinstance(item, dict)}
-    l1_limit, linf_limit = finite(tolerance.get("normalized_l1_max")), finite(tolerance.get("normalized_linf_max"))
-    if l1_limit is None or linf_limit is None:
-        return {"status": "invalid_contract"}
-    fields: list[dict[str, Any]] = []
-    expected_fields = sum(max(0, len(item.get("columns", [])) - 1) for item in references.values())
-    for key, ref_profile in references.items():
-        cand_profile = candidates.get(key)
-        if cand_profile is None:
-            continue
-        ref_columns, cand_columns = ref_profile.get("columns", []), cand_profile.get("columns", [])
-        ref_rows, cand_rows = ref_profile.get("rows", []), cand_profile.get("rows", [])
-        if len(ref_columns) < 2 or ref_columns[0] not in cand_columns:
-            continue
-        cand_x = cand_columns.index(ref_columns[0])
-        for field in ref_columns[1:]:
-            if field not in cand_columns:
-                continue
-            ref_i, cand_i = ref_columns.index(field), cand_columns.index(field)
-            cand_points = [{"time": row[cand_x], "value": row[cand_i]} for row in cand_rows]
-            pairs = [(row[ref_i], interpolate(cand_points, row[0])) for row in ref_rows]
-            pairs = [(ref, cand) for ref, cand in pairs if finite(ref) is not None and cand is not None]
-            if not pairs:
-                continue
-            declared_floors = tolerance.get("normalization_floors", {})
-            field_floor = finite(declared_floors.get(field)) if isinstance(declared_floors, dict) else None
-            norm = max(sum(abs(ref) for ref, _ in pairs) / len(pairs), field_floor or finite(tolerance.get("normalization_floor")) or 1e-12)
-            errors = [abs(cand - ref) for ref, cand in pairs]
-            fields.append({"profile": key, "field": field, "normalized_l1": sum(errors) / len(errors) / norm,
-                           "normalized_linf": max(errors) / norm})
-    coverage = len(fields) / expected_fields if expected_fields else 0.0
-    passed = bool(fields) and coverage == 1.0 and all(item["normalized_l1"] <= l1_limit and item["normalized_linf"] <= linf_limit for item in fields)
-    return {"status": "within_tolerance" if passed else "missing" if not fields else "out_of_tolerance",
-            "coverage_fraction": coverage, "observed_field_count": len(fields),
-            "expected_field_count": expected_fields, "fields": fields,
-            "normalized_l1_max": l1_limit, "normalized_linf_max": linf_limit}
-
-
-def compare_events(reference: dict[str, Any], candidate: dict[str, Any], tolerance: dict[str, Any]) -> dict[str, Any]:
-    def groups(value: dict[str, Any]) -> dict[tuple[str, str], list[dict[str, Any]]]:
-        result: dict[tuple[str, str], list[dict[str, Any]]] = {}
-        for event in value.get("events", []):
-            if isinstance(event, dict):
-                result.setdefault((profile_key({"profile_id": event.get("profile_id", "")}), str(event.get("field"))), []).append(event)
-        return result
-    refs, cands = groups(reference), groups(candidate)
-    cell_limit = finite(tolerance.get("maximum_cell_offset"))
-    if cell_limit is None:
-        return {"status": "invalid_contract"}
-    offsets = []
-    for key, ref_events in refs.items():
-        cand_events = cands.get(key, [])
-        available = list(cand_events)
-        for event in ref_events:
-            coordinate = finite(event.get("coordinate"))
-            if coordinate is None or not available:
-                continue
-            match = min(
-                available,
-                key=lambda item: abs(value - coordinate) if (value := finite(item.get("coordinate"))) is not None else math.inf,
-            )
-            available.remove(match)
-            matched_coordinate = finite(match.get("coordinate"))
-            if matched_coordinate is None:
-                continue
-            cell = max(finite(event.get("local_cell_size")) or 0.0, finite(match.get("local_cell_size")) or 0.0,
-                       finite(tolerance.get("physical_floor")) or 1e-12)
-            offsets.append(abs(matched_coordinate - coordinate) / cell)
-    expected = sum(len(items) for items in refs.values())
-    coverage = len(offsets) / expected if expected else 0.0
-    passed = expected > 0 and coverage == 1.0 and max(offsets, default=math.inf) <= cell_limit
-    return {"status": "within_tolerance" if passed else "missing" if not offsets else "out_of_tolerance",
-            "coverage_fraction": coverage, "maximum_cell_offset": max(offsets, default=None), "allowed_cell_offset": cell_limit}
-
-
-def compare_structured(reference: dict[str, Any], candidate: Any, tolerance: dict[str, Any]) -> dict[str, Any]:
-    if not isinstance(candidate, dict) or candidate.get("kind") != reference.get("kind"):
-        return {"status": "missing"}
-    kind = reference.get("kind")
-    if kind == "time_history":
-        return compare_history(reference, candidate, tolerance)
-    if kind == "branched_time_histories":
-        ref_branches, cand_branches = reference.get("branches", {}), candidate.get("branches", {})
-        results = {name: compare_history(value, cand_branches.get(name, {}), tolerance)
-                   for name, value in ref_branches.items()}
-        passed = bool(results) and all(item["status"] == "within_tolerance" for item in results.values())
-        return {"status": "within_tolerance" if passed else "out_of_tolerance", "branches": results,
-                "coverage_fraction": sum(item.get("coverage_fraction", 0.0) for item in results.values()) / len(results) if results else 0.0}
-    if kind == "named_profiles":
-        return compare_profiles(reference, candidate, tolerance)
-    if kind == "profile_feature_locations":
-        return compare_events(reference, candidate, tolerance)
-    if kind == "component_trajectory":
-        refs = {str(item.get("component_id")): item for item in reference.get("series", [])}
-        cands = {str(item.get("component_id")): item for item in candidate.get("series", [])}
-        results = {key: compare_history({"points": item.get("points", [])}, {"points": cands.get(key, {}).get("points", [])}, tolerance)
-                   for key, item in refs.items()}
-        passed = bool(results) and all(item["status"] == "within_tolerance" for item in results.values())
-        return {"status": "within_tolerance" if passed else "out_of_tolerance", "components": results}
-    if kind == "component_scalars":
-        refs = {str(item.get("component_id")): finite(item.get("value")) for item in reference.get("components", [])}
-        cands = {str(item.get("component_id")): finite(item.get("value")) for item in candidate.get("components", [])}
-        relative, floor = finite(tolerance.get("relative_max")), finite(tolerance.get("absolute_floor")) or 1e-12
-        if relative is None:
-            return {"status": "invalid_contract"}
-        errors = {key: abs(cands[key] - ref) / max(abs(ref), floor) for key, ref in refs.items() if ref is not None and cands.get(key) is not None}
-        physical_low, physical_high = finite(tolerance.get("physical_low")), finite(tolerance.get("physical_high"))
-        observed = [value for value in cands.values() if value is not None]
-        physically_valid = all(
-            (physical_low is None or value >= physical_low)
-            and (physical_high is None or value <= physical_high)
-            for value in observed
-        )
-        passed = len(errors) == len(refs) and physically_valid and all(error <= relative for error in errors.values())
-        return {"status": "within_tolerance" if passed else "missing" if not errors else "out_of_tolerance",
-                "relative_errors": errors, "physical_bounds_pass": physically_valid,
-                "physical_low": physical_low, "physical_high": physical_high}
-    if kind == "branch_scalars":
-        ref_branches, cand_branches = reference.get("branches", {}), candidate.get("branches", {})
-        relative, floor = finite(tolerance.get("relative_max")), finite(tolerance.get("absolute_floor")) or 1e-12
-        if relative is None:
-            return {"status": "invalid_contract"}
-        errors: dict[str, Any] = {}
-        for branch, ref_metrics in ref_branches.items():
-            cand_metrics = cand_branches.get(branch, {})
-            errors[branch] = {
-                name: abs(float(cand_metrics[name]) - float(ref)) / max(abs(float(ref)), floor)
-                for name, ref in ref_metrics.items()
-                if name in cand_metrics and finite(ref) is not None and finite(cand_metrics[name]) is not None
-            }
-        complete = set(errors) == set(ref_branches) and all(set(errors[b]) == set(ref_branches[b]) for b in ref_branches)
-        physical_low, physical_high = finite(tolerance.get("physical_low")), finite(tolerance.get("physical_high"))
-        observed = [value for branch in cand_branches.values() if isinstance(branch, dict) for value in branch.values()
-                    if finite(value) is not None]
-        physically_valid = all(
-            (physical_low is None or float(value) >= physical_low)
-            and (physical_high is None or float(value) <= physical_high)
-            for value in observed
-        )
-        passed = complete and physically_valid and all(error <= relative for branch in errors.values() for error in branch.values())
-        return {"status": "within_tolerance" if passed else "missing" if not complete else "out_of_tolerance",
-                "relative_errors": errors, "relative_max": relative,
-                "physical_bounds_pass": physically_valid, "physical_low": physical_low,
-                "physical_high": physical_high}
-    scalar_ref, scalar_cand = scalar_observation(reference), scalar_observation(candidate)
-    if scalar_ref is not None and scalar_cand is not None:
-        relative, floor = finite(tolerance.get("relative_max")), finite(tolerance.get("absolute_floor")) or 1e-12
-        if relative is None:
-            return {"status": "invalid_contract"}
-        error = abs(scalar_cand - scalar_ref) / max(abs(scalar_ref), floor)
-        physical_low, physical_high = finite(tolerance.get("physical_low")), finite(tolerance.get("physical_high"))
-        physically_valid = (
-            (physical_low is None or scalar_cand >= physical_low)
-            and (physical_high is None or scalar_cand <= physical_high)
-        )
-        passed = error <= relative and physically_valid
-        return {"status": "within_tolerance" if passed else "out_of_tolerance",
-                "relative_error": error, "relative_max": relative, "physical_bounds_pass": physically_valid,
-                "physical_low": physical_low, "physical_high": physical_high}
-    return {"status": "invalid_contract", "reason": f"unsupported structured kind {kind!r}"}
-
-
-def comparison_quality(result: dict[str, Any]) -> float:
-    """Map comparison distance to [0, 1] without changing strict status."""
-    status = result.get("status")
-    if status == "within_tolerance":
-        return 1.0
-    if status in {"missing", "invalid_contract"}:
-        return 0.0
-    distances: list[float] = []
-    for key in ("relative_error", "normalized_rmse", "normalized_l1", "maximum_cell_offset"):
-        value = finite(result.get(key))
-        limit = finite(result.get({
-            "relative_error": "relative_max",
-            "normalized_rmse": "normalized_rmse_max",
-            "normalized_l1": "normalized_l1_max",
-            "maximum_cell_offset": "allowed_cell_offset",
-        }[key]))
-        if value is not None and limit is not None and limit > 0:
-            distances.append(value / limit)
-    for value in result.get("fields", []) if isinstance(result.get("fields"), list) else []:
-        if isinstance(value, dict):
-            q = comparison_quality({
-                "status": "within_tolerance" if value.get("normalized_l1", math.inf) <= (result.get("normalized_l1_max") or 0.0) else "out_of_tolerance",
-                "normalized_l1": value.get("normalized_l1"),
-                "normalized_l1_max": result.get("normalized_l1_max"),
-            })
-            distances.append(1.0 - q)
-    for value in result.get("branches", {}).values() if isinstance(result.get("branches"), dict) else []:
-        if isinstance(value, dict):
-            distances.append(1.0 - comparison_quality(value))
-    ratio = sum(distances) / len(distances) if distances else 1.0
-    return max(0.0, min(1.0, 1.0 / (1.0 + ratio)))
-
-
-def load_cases(path: Path) -> dict[str, Any]:
-    data = json.loads(path.read_text(encoding="utf-8"))
-    cases = data.get("cases") if isinstance(data, dict) else None
-    if not isinstance(cases, dict):
-        raise ValueError(f"JSON has no cases object: {path}")
-    return cases
-
-
-def write_json(path: Path, value: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-    temporary.replace(path)
-
-
-STAT_SUFFIX_RE = re.compile(r"_(?:min|max|mean|range)$")
-SCORING_POLICY = "grouped_qois"
-EXPLICIT_SCORING_POLICY = "explicit_principal_qoi_group"
-
-
-def case_scoring_policy(reference: dict[str, Any]) -> str:
-    return EXPLICIT_SCORING_POLICY if isinstance(reference.get("metric_roles"), dict) else SCORING_POLICY
-
-
-def metric_role(name: str, explicit_roles: dict[str, Any] | None = None) -> str:
-    """Classify metrics without changing the extracted raw values.
-
-    Residual and Courant values remain useful diagnostics, while ``range`` is
-    a deterministic derivative of min/max.  All other legacy measurements are
-    scored, but related statistics are aggregated as one QoI group below.
-    """
-    explicit = explicit_roles.get(name) if explicit_roles else None
-    if explicit in {"principal", "scored"}:
-        return "scored"
-    if explicit in {"diagnostic", "redundant"}:
-        return explicit
-    if "residual" in name or "courant" in name:
-        return "diagnostic"
-    if name.endswith("_range"):
-        return "redundant"
-    return "scored"
-
-
-def metric_group(name: str, principal_group: str | None = None,
-                 explicit_roles: dict[str, Any] | None = None) -> str:
-    if principal_group and explicit_roles and explicit_roles.get(name) in {"principal", "scored"}:
-        return principal_group
-    if name in {"center_u", "center_v", "center_w", "center_speed"}:
-        return "center_velocity"
-    return STAT_SUFFIX_RE.sub("", name)
-
-
-def comparison_outcome(*, missing: list[str], out_of_tolerance: list[str],
-                       invalid_contract: list[str], accepted: bool) -> str:
-    if invalid_contract:
-        return "invalid_contract"
-    if accepted:
-        return "pass"
-    if missing and out_of_tolerance:
-        return "incomplete_and_out_of_tolerance"
-    if missing:
-        return "incomplete"
-    return "out_of_tolerance"
-
-
-def rollout_status(comparison: dict[str, Any]) -> str:
-    """Map a QoI result to a rollout status after execution has passed."""
-    return {
-        "pass": "scientifically_validated",
-        "incomplete": "execution_passed_qoi_incomplete",
-        "out_of_tolerance": "execution_passed_qoi_out_of_tolerance",
-        "incomplete_and_out_of_tolerance": "execution_passed_qoi_incomplete_and_out_of_tolerance",
-        "invalid_contract": "execution_passed_qoi_evaluation_error",
-        "error": "execution_passed_qoi_evaluation_error",
-    }.get(str(comparison.get("status")), "execution_passed_qoi_evaluation_error")
-
-
-def compare_case(reference: dict[str, Any], candidate: dict[str, Any], required_fraction: float) -> dict[str, Any]:
-    references = reference.get("qois") if isinstance(reference.get("qois"), dict) else {}
-    tolerances = reference.get("tolerances") if isinstance(reference.get("tolerances"), dict) else {}
-    candidates = candidate.get("qois") if isinstance(candidate.get("qois"), dict) else {}
-    explicit_roles = reference.get("metric_roles") if isinstance(reference.get("metric_roles"), dict) else None
-    principal_group = reference.get("principal_qoi_group") if isinstance(reference.get("principal_qoi_group"), str) else None
-    role_for = lambda name: metric_role(name, explicit_roles)
-    metrics: dict[str, Any] = {}
-    passed = 0
-    out_of_tolerance: list[str] = []
-    missing: list[str] = []
-    invalid_contract: list[str] = []
-    diagnostic_out_of_tolerance: list[str] = []
-    diagnostic_missing: list[str] = []
-    redundant_metric_count = 0
-    groups: dict[str, dict[str, Any]] = {}
-    for name, reference_value in sorted(references.items()):
-        role = role_for(name)
-        group = metric_group(name, principal_group, explicit_roles)
-        if role == "redundant":
-            redundant_metric_count += 1
-            value = finite(candidates.get(name))
-            metrics[name] = {
-                "status": "available" if value is not None else "missing",
-                "role": role,
-                "group": group,
-                "reference_value": reference_value,
-                "candidate_value": value,
-            }
-            continue
-        group_record = groups.setdefault(group, {
-            "role": "scored" if role == "scored" else role,
-            "metrics": [],
-            "passed_metric_count": 0,
-            "observed_metric_count": 0,
-            "invalid_metric_count": 0,
-            "quality_sum": 0.0,
-            "coverage_fraction": 1.0,
-        })
-        group_record["metrics"].append(name)
-        tolerance = tolerances.get(name) if isinstance(tolerances.get(name), dict) else {}
-        if isinstance(reference_value, dict):
-            result = compare_structured(reference_value, candidates.get(name), tolerance)
-            result["quality"] = comparison_quality(result)
-            status = result.get("status")
-            is_missing = status == "missing"
-            is_invalid = status == "invalid_contract"
-            is_pass = status == "within_tolerance"
-            structured_coverage = finite(result.get("coverage_fraction"))
-            if structured_coverage is not None:
-                group_record["coverage_fraction"] = min(
-                    group_record["coverage_fraction"], structured_coverage
-                )
-            elif is_missing:
-                group_record["coverage_fraction"] = 0.0
-            if is_missing:
-                missing.append(name)
-                if role == "diagnostic":
-                    diagnostic_missing.append(name)
-            elif is_invalid and role == "scored":
-                invalid_contract.append(name)
-                group_record["invalid_metric_count"] += 1
-            else:
-                group_record["observed_metric_count"] += int(role == "scored")
-                if role == "scored":
-                    passed += int(is_pass)
-                    group_record["passed_metric_count"] += int(is_pass)
-                    group_record["quality_sum"] += float(result["quality"])
-                    if not is_pass:
-                        out_of_tolerance.append(name)
-                elif role == "diagnostic" and not is_pass:
-                    diagnostic_out_of_tolerance.append(name)
-            metrics[name] = {"role": role, "group": group, "reference_value": reference_value,
-                             "candidate_value": candidates.get(name), **result}
-            continue
-        value = finite(candidates.get(name))
-        low, high = finite(tolerance.get("low")), finite(tolerance.get("high"))
-        if value is None:
-            missing.append(name)
-            group_record["coverage_fraction"] = 0.0
-            if role == "diagnostic":
-                diagnostic_missing.append(name)
-            metrics[name] = {
-                "status": "missing",
-                "role": role,
-                "group": group,
-                "reference_value": reference_value,
-                "quality": 0.0,
-            }
-            continue
-        if low is None or high is None:
-            group_record["coverage_fraction"] = 0.0
-            if role == "scored":
-                invalid_contract.append(name)
-                group_record["invalid_metric_count"] += 1
-            metrics[name] = {
-                "status": "invalid_contract" if role == "scored" else "available_without_tolerance",
-                "role": role,
-                "group": group,
-                "reference_value": reference_value,
-                "candidate_value": value,
-                "quality": 0.0,
-            }
-            continue
-        physical_low, physical_high = finite(tolerance.get("physical_low")), finite(tolerance.get("physical_high"))
-        physical_pass = (
-            (physical_low is None or value >= physical_low)
-            and (physical_high is None or value <= physical_high)
-        )
-        is_pass = low <= value <= high and physical_pass
-        tolerance_span = max(high - low, 1e-12)
-        distance = 0.0 if is_pass else min(abs(value - min(max(value, low), high)) / tolerance_span, 1.0)
-        quality = 1.0 if is_pass else max(0.0, 1.0 - distance)
-        if role == "scored":
-            passed += int(is_pass)
-            group_record["observed_metric_count"] += 1
-            group_record["passed_metric_count"] += int(is_pass)
-            group_record["quality_sum"] += quality
-            if not is_pass:
-                out_of_tolerance.append(name)
-        elif role == "diagnostic" and not is_pass:
-            diagnostic_out_of_tolerance.append(name)
-        metrics[name] = {
-            "status": "within_tolerance" if is_pass else "out_of_tolerance",
-            "role": role,
-            "group": group,
-            "reference_value": reference_value,
-            "candidate_value": value,
-            "low": low,
-            "high": high,
-            "absolute_error": abs(value - float(reference_value)),
-            "criterion_role": tolerance.get("criterion_role"),
-            "threshold_source": tolerance.get("threshold_source"),
-            "reference_independent": tolerance.get("reference_independent", False),
-            "provisional": tolerance.get("provisional"),
-            "physical_bounds_pass": physical_pass,
-            "physical_low": physical_low,
-            "physical_high": physical_high,
-            "physical_threshold_source": tolerance.get("physical_threshold_source"),
-            "quality": quality,
-        }
-    scored_groups = {
-        name: record for name, record in groups.items() if record["role"] == "scored"
-    }
-    scored_metrics = [name for name in references if role_for(name) == "scored"]
-    scored_missing = [name for name in missing if role_for(name) == "scored"]
-    scored_count = len(scored_metrics)
-    extracted_count = sum(record["observed_metric_count"] for record in scored_groups.values())
-    evaluated_count = extracted_count
-    coverage = extracted_count / scored_count if scored_count else 0.0
-    metric_value_pass_fraction = passed / evaluated_count if evaluated_count else None
-    metric_joint_pass_fraction = passed / scored_count if scored_count else 0.0
-    group_scores: dict[str, dict[str, Any]] = {}
-    for group_name, record in sorted(scored_groups.items()):
-        member_count = len(record["metrics"])
-        group_score = record["quality_sum"] / member_count if member_count else 0.0
-        group_coverage = (
-            min(record["observed_metric_count"] / member_count, record["coverage_fraction"])
-            if member_count else 0.0
-        )
-        group_scores[group_name] = {
-            "score": group_score,
-            "coverage_fraction": group_coverage,
-            "metric_count": member_count,
-            "observed_metric_count": record["observed_metric_count"],
-            "passed_metric_count": record["passed_metric_count"],
-            "metrics": record["metrics"],
-        }
-    qoi_pass_ratio = (
-        sum(item["score"] for item in group_scores.values()) / len(group_scores)
-        if group_scores else 0.0
-    )
-    qoi_coverage_fraction = (
-        sum(item["coverage_fraction"] for item in group_scores.values()) / len(group_scores)
-        if group_scores else 0.0
-    )
-    # Continuous quality is intentionally separate from the strict scientific
-    # acceptance bit.  It exposes partial QoI agreement to Evolution without
-    # weakening the all-groups physics-grounded contract.
-    qoi_quality = qoi_pass_ratio * qoi_coverage_fraction
-    physics_grounded_accepted = bool(
-        scored_groups
-        and not scored_missing
-        and not invalid_contract
-        and not out_of_tolerance
-        and passed == scored_count
-        and all(
-            item["coverage_fraction"] == 1.0
-            for item in group_scores.values()
-        )
-    )
-    threshold_pass = bool(
-        scored_groups
-        and qoi_coverage_fraction == 1.0
-        and qoi_pass_ratio >= required_fraction
-    )
-    outcome = comparison_outcome(
-        missing=scored_missing,
-        out_of_tolerance=out_of_tolerance,
-        invalid_contract=invalid_contract,
-        accepted=physics_grounded_accepted,
-    )
-    diagnostic_names = [name for name in references if role_for(name) == "diagnostic"]
-    diagnostic_observed = [
-        name for name in diagnostic_names
-        if metrics.get(name, {}).get("status") not in {None, "missing", "invalid_contract"}
-    ]
-    diagnostic_passed = [
-        name for name in diagnostic_names if metrics.get(name, {}).get("status") == "within_tolerance"
-    ]
-    return {
-        "schema_version": "foambench.qoi.case_comparison.v3",
-        "scoring_policy": case_scoring_policy(reference),
-        "status": outcome,
-        "coverage_status": "complete" if scored_count and not scored_missing else "incomplete",
-        "value_status": (
-            "not_assessed" if not scored_count
-            else "within_tolerance" if metric_value_pass_fraction is not None and metric_value_pass_fraction >= required_fraction
-            else "out_of_tolerance"
-        ),
-        "required_metric_count": scored_count,
-        "extracted_metric_count": extracted_count,
-        "evaluated_metric_count": evaluated_count,
-        "passed_metric_count": passed,
-        "coverage_fraction": coverage,
-        "value_pass_fraction": metric_value_pass_fraction,
-        "joint_pass_fraction": metric_joint_pass_fraction,
-        "qoi_pass_ratio": qoi_pass_ratio,
-        "qoi_quality": qoi_quality,
-        "qoi_coverage_fraction": qoi_coverage_fraction,
-        "group_count": len(group_scores),
-        "group_scores": group_scores,
-        "physics_grounded_qoi_pass": physics_grounded_accepted,
-        "threshold_pass": threshold_pass,
-        "diagnostic_metric_count": sum(len(record["metrics"]) for record in groups.values() if record["role"] == "diagnostic"),
-        "diagnostic_observed_metric_count": len(diagnostic_observed),
-        "diagnostic_passed_metric_count": len(diagnostic_passed),
-        "diagnostic_reference_coverage_fraction": (
-            len(diagnostic_observed) / len(diagnostic_names) if diagnostic_names else None
-        ),
-        "diagnostic_reference_pass_fraction": (
-            len(diagnostic_passed) / len(diagnostic_observed) if diagnostic_observed else None
-        ),
-        "redundant_metric_count": redundant_metric_count,
-        # Raw metric fractions remain available above; the canonical case-level
-        # quality score is qoi_pass_ratio.
-        "pass_fraction": metric_joint_pass_fraction,
-        "required_fraction": required_fraction,
-        "missing_metrics": missing,
-        "scored_missing_metrics": scored_missing,
-        "diagnostic_missing_metrics": diagnostic_missing,
-        "out_of_tolerance_metrics": out_of_tolerance,
-        "diagnostic_out_of_tolerance_metrics": diagnostic_out_of_tolerance,
-        "invalid_contract_metrics": invalid_contract,
-        "metrics": metrics,
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--reference-qois", required=True, type=Path)
-    parser.add_argument("--candidate-qois", required=True, type=Path)
-    parser.add_argument("--case-id", action="append")
-    parser.add_argument(
-        "--required-fraction",
-        type=float,
-        default=1.0,
-        help="Optional observed-value/QoI-ratio threshold; physics_grounded_qoi_pass always requires every scored group.",
-    )
-    parser.add_argument("--output", type=Path)
-    parser.add_argument("--json", action="store_true")
-    args = parser.parse_args()
-    if not 0 < args.required_fraction <= 1:
-        parser.error("--required-fraction must be in (0, 1]")
-
-    references = load_cases(args.reference_qois.resolve(strict=True))
-    candidates = load_cases(args.candidate_qois.resolve(strict=True))
-    selected = args.case_id or sorted(references)
-    unknown = sorted(set(selected) - set(references))
-    if unknown:
-        raise ValueError("unknown reference case IDs: " + ", ".join(unknown))
-
-    results: dict[str, Any] = {}
-    missing_cases: list[str] = []
-    for case_id in selected:
-        candidate = candidates.get(case_id)
-        if not isinstance(candidate, dict):
-            missing_cases.append(case_id)
-            missing_metrics = sorted(references[case_id].get("qois", {}))
-            results[case_id] = {
-                "scoring_policy": case_scoring_policy(references[case_id]),
-                "status": "missing_candidate_case",
-                "coverage_status": "incomplete",
-                "value_status": "not_assessed",
-                "required_metric_count": len(missing_metrics),
-                "extracted_metric_count": 0,
-                "evaluated_metric_count": 0,
-                "passed_metric_count": 0,
-                "coverage_fraction": 0.0,
-                "value_pass_fraction": None,
-                "joint_pass_fraction": 0.0,
-                "qoi_pass_ratio": 0.0,
-                "qoi_coverage_fraction": 0.0,
-                "group_count": 0,
-                "pass_fraction": 0.0,
-                "missing_metrics": missing_metrics,
-                "out_of_tolerance_metrics": [],
-                "invalid_contract_metrics": [],
-            }
-        else:
-            results[case_id] = compare_case(references[case_id], candidate, args.required_fraction)
-
-    family_rows: dict[str, list[dict[str, Any]]] = {}
-    for case_id, result in results.items():
-        if "pass_fraction" in result:
-            reference_family = references.get(case_id, {}).get("family")
-            family = reference_family if isinstance(reference_family, str) and reference_family else case_id.split("/", 1)[0]
-            family_rows.setdefault(family, []).append(result)
-    def summarize(rows: list[dict[str, Any]]) -> dict[str, Any]:
-        assessed = [row["value_pass_fraction"] for row in rows if row.get("value_pass_fraction") is not None]
-        qoi_ratios = [row["qoi_pass_ratio"] for row in rows if row.get("qoi_pass_ratio") is not None]
-        return {
-            "case_count": len(rows),
-            "passed_case_count": sum(row["status"] == "pass" for row in rows),
-            "incomplete_case_count": sum(bool(row.get("missing_metrics")) for row in rows),
-            "out_of_tolerance_case_count": sum(bool(row.get("out_of_tolerance_metrics")) for row in rows),
-            "macro_coverage_fraction": sum(row["coverage_fraction"] for row in rows) / len(rows),
-            "macro_value_pass_fraction": sum(assessed) / len(assessed) if assessed else None,
-            "macro_joint_pass_fraction": sum(row["joint_pass_fraction"] for row in rows) / len(rows),
-            "macro_qoi_pass_ratio": sum(qoi_ratios) / len(qoi_ratios) if qoi_ratios else 0.0,
-            "macro_qoi_coverage_fraction": sum(row.get("qoi_coverage_fraction", 0.0) for row in rows) / len(rows),
-        }
-
-    families = {family: summarize(rows) for family, rows in sorted(family_rows.items())}
-    passed_cases = sum(result.get("status") == "pass" for result in results.values())
-    aggregate = summarize(list(results.values())) if results else {
-        "incomplete_case_count": 0,
-        "out_of_tolerance_case_count": 0,
-        "macro_coverage_fraction": 0.0,
-        "macro_value_pass_fraction": None,
-        "macro_joint_pass_fraction": 0.0,
-        "macro_qoi_pass_ratio": 0.0,
-        "macro_qoi_coverage_fraction": 0.0,
-    }
-    policies = {result.get("scoring_policy", SCORING_POLICY) for result in results.values()}
-    report = {
-        "schema_version": "foambench.qoi.comparison.v3",
-        "scoring_policy": policies.pop() if len(policies) == 1 else "mixed",
-        "generated_at": datetime.now(timezone.utc).isoformat(),
-        "status": "pass" if passed_cases == len(selected) and not missing_cases else "fail",
-        "case_count": len(selected),
-        "passed_case_count": passed_cases,
-        "case_pass_fraction": passed_cases / len(selected) if selected else 0.0,
-        "incomplete_case_count": aggregate["incomplete_case_count"],
-        "out_of_tolerance_case_count": aggregate["out_of_tolerance_case_count"],
-        "macro_coverage_fraction": aggregate["macro_coverage_fraction"],
-        "macro_value_pass_fraction": aggregate["macro_value_pass_fraction"],
-        "macro_joint_pass_fraction": aggregate["macro_joint_pass_fraction"],
-        "macro_qoi_pass_ratio": aggregate["macro_qoi_pass_ratio"],
-        "macro_qoi_coverage_fraction": aggregate["macro_qoi_coverage_fraction"],
-        "missing_cases": missing_cases,
-        "families": families,
-        "cases": results,
-    }
-    if args.output:
-        write_json(args.output.resolve(), report)
-    if args.json or not args.output:
-        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
-    else:
-        print(
-            f"comparison: {args.output.resolve()} "
-            f"(physics_grounded={passed_cases}/{len(selected)}, "
-            f"qoi_pass_ratio={report['macro_qoi_pass_ratio']:.4f})"
-        )
-    return 0 if report["status"] == "pass" else 1
-
-
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main())
-    except (OSError, ValueError, json.JSONDecodeError) as exc:
-        print(f"compare_foambench_qois.py: error: {exc}", file=sys.stderr)
-        raise SystemExit(2)

benchmarks/evaluation/evidence_contract.py

@@ -1,119 +0,0 @@
-"""Canonical evidence discovery for the Extended FoamBench contract.
-
-The resolver deliberately separates *where/how an agent writes a file* from
-the physical quantity represented by its contents.  Callers still validate
-headers, units, time semantics, and dimensions before using a file as QoI
-evidence; this module only provides deterministic semantic routing.
-"""
-from __future__ import annotations
-
-import re
-import json
-from pathlib import Path
-from typing import Any
-
-
-CANONICAL_ALIASES: dict[str, tuple[str, ...]] = {
-    "force_coefficients": ("forcecoeffs", "forcecoefficients", "forcecoefficient", "aerodynamicloads", "aeroloads", "loads"),
-    "patch_flux": ("patchflowrate", "patchflow", "massflow", "massflux", "rhophi", "fluxhistory"),
-    "patch_pressure": ("patchaverage", "patchintegrate", "pressurerise", "pressuredifference", "patchpressure"),
-    "wall_law_profile": ("spaldingcomparison", "uplusyplus", "walllawprofile", "velocityprofile", "wallprofile"),
-    "centerline_profile": ("centerline", "centreline", "horizontal", "vertical", "px0", "py0", "rhox0", "rhoy0"),
-    "bubble_geometry": ("bubblegeometry", "bubblemetrics", "interfacegeometry"),
-}
-
-CONTRACT_VERSION = "foambench.evidence.contract.v1"
-CONTRACT_FILE = Path(__file__).resolve().parents[1] / "FoamBench_extended_openfoam13_evidence_contract.v1.json"
-
-# A manifest may use the QoI name instead of the routing kind.  This mapping
-# keeps that interface stable while allowing metric extractors to retain their
-# own physical validation rules.
-METRIC_KINDS = {
-    "Cd": "force_coefficients", "Cl": "force_coefficients", "Cm": "force_coefficients",
-    "Cd_mean": "force_coefficients", "Cd_rms": "force_coefficients",
-    "Cl_mean": "force_coefficients", "Cl_rms": "force_coefficients",
-    "first_cell_yplus": "wall_law_profile", "spalding_log_rmse": "wall_law_profile",
-    "centerline_profiles": "centerline_profile", "event_locations": "centerline_profile",
-    "mass_flow_rate": "patch_flux", "volumetric_flow_rate": "patch_flux",
-    "pressure_rise": "patch_pressure", "pressure_rise_history": "patch_pressure",
-}
-
-
-def compact_name(value: str) -> str:
-    return re.sub(r"[^a-z0-9]", "", value.lower())
-
-
-def evidence_roots(case: Path) -> tuple[Path, ...]:
-    parent = case.parent
-    roots = (
-        case / "postProcessing", case / "postprocessing", case / "results", case / "outputs",
-        parent / "postProcessing", parent / "postprocessing", parent / "results", parent / "outputs",
-        parent / "evidence", parent / "reports",
-    )
-    return tuple(dict.fromkeys(root for root in roots if root.is_dir()))
-
-
-def _manifest_paths(case: Path) -> tuple[Path, ...]:
-    """Locate the optional agent-emitted manifest without trusting its paths."""
-    return tuple(dict.fromkeys((case / "evidence/qoi_manifest.v1.json", case.parent / "evidence/qoi_manifest.v1.json")))
-
-
-def declared_evidence(case: Path, kind: str) -> list[Path]:
-    """Return manifest-declared files for *kind* after path containment checks."""
-    paths: list[Path] = []
-    accepted_metrics = {kind, *[metric for metric, mapped in METRIC_KINDS.items() if mapped == kind]}
-    for manifest_path in _manifest_paths(case):
-        try:
-            payload = json.loads(manifest_path.read_text(encoding="utf-8"))
-        except (OSError, ValueError, TypeError):
-            continue
-        entries = payload.get("entries", []) if isinstance(payload, dict) else []
-        if not isinstance(entries, list):
-            continue
-        for entry in entries:
-            if not isinstance(entry, dict) or entry.get("metric") not in accepted_metrics and entry.get("kind") != kind:
-                continue
-            raw = entry.get("path")
-            if not isinstance(raw, str) or not raw:
-                continue
-            candidate = (manifest_path.parent.parent / raw).resolve()
-            allowed = tuple(root.resolve() for root in evidence_roots(case))
-            if candidate.is_file() and any(candidate == root or root in candidate.parents for root in allowed):
-                paths.append(candidate)
-    return sorted(set(paths))
-
-
-def resolve_evidence(case: Path, kind: str, *, suffixes: tuple[str, ...] = ()) -> list[Path]:
-    """Return files whose path semantically addresses canonical evidence kind.
-
-    This function never parses or promotes a file.  The metric-specific
-    extractor remains responsible for schema/header/unit validation.
-    """
-    aliases = CANONICAL_ALIASES.get(kind, (kind,))
-    paths: set[Path] = set(declared_evidence(case, kind))
-    for root in evidence_roots(case):
-        for path in root.rglob("*"):
-            if not path.is_file():
-                continue
-            if suffixes and path.suffix.lower() not in suffixes:
-                continue
-            compact = compact_name(str(path))
-            if any(compact_name(alias) in compact for alias in aliases):
-                paths.add(path)
-    return sorted(paths)
-
-
-def canonical_evidence_manifest() -> dict[str, object]:
-    """Machine-readable resolver contract for reports and future agents."""
-    fallback = {
-        "schema_version": CONTRACT_VERSION,
-        "normalization": "lowercase_ascii_alphanumeric_path_matching",
-        "kinds": {key: list(value) for key, value in CANONICAL_ALIASES.items()},
-        "content_validation": "required_by_metric_extractor",
-        "proxy_policy": "semantic routing never authorizes a proxy metric",
-    }
-    try:
-        payload = json.loads(CONTRACT_FILE.read_text(encoding="utf-8"))
-    except (OSError, ValueError, TypeError):
-        return fallback
-    return payload if isinstance(payload, dict) else fallback

benchmarks/evaluation/execution.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .adapters.common import successful_formal_records
-from .foam import FATAL_RE, converged_early, final_log_time, latest_time_dir, normal_end, read_logs
-from .models import CaseArtifact
-
-
-def evaluate_execution(artifact: CaseArtifact, expected_time: float | None) -> dict[str, Any]:
-    case_dir = artifact.case_dir
-    latest, _ = latest_time_dir(case_dir)
-    logs = artifact.solver_logs
-    text = read_logs(logs)
-    log_time = final_log_time(text)
-    successful = successful_formal_records(artifact.formal_run_records)
-    requires_formal_record = (
-        artifact.workspace_dir is not None
-        and artifact.manifest.get("agent_mode") != "coding-only"
-        and artifact.manifest.get("domain_assets_enabled") is not False
-    )
-    manifest_status = str(artifact.manifest.get("status", ""))
-    timed_out = bool(artifact.manifest.get("timed_out")) or manifest_status == "timed_out"
-    process_ok = artifact.manifest.get("return_code") in {None, 0}
-    observed_time = max(value for value in (latest, log_time) if value is not None) if any(
-        value is not None for value in (latest, log_time)
-    ) else None
-    reached = observed_time is not None and (
-        expected_time is None
-        or observed_time >= expected_time - max(1e-12, abs(expected_time) * 1e-9)
-        or converged_early(text)
-    )
-    checks = {
-        "case_directory_exists": bool(case_dir and case_dir.is_dir()),
-        "control_dict_exists": bool(case_dir and (case_dir / "system" / "controlDict").is_file()),
-        "agent_not_timed_out": not timed_out,
-        "agent_process_succeeded": process_ok,
-        "formal_run_succeeded": bool(successful) if requires_formal_record else True,
-        "solver_log_exists": bool(logs),
-        "no_fatal_log_marker": FATAL_RE.search(text) is None,
-        "latest_time_exists": latest is not None,
-        "stop_condition_reached": reached,
-    }
-    # Some retained run records omit the literal OpenFOAM "End" line from the
-    # selected stdout ref. Keep it as evidence rather than a hard requirement.
-    evidence = {
-        "normal_end_marker": normal_end(text),
-        "converged_early_marker": converged_early(text),
-        "formal_run_records": [str(path) for path in successful],
-        "solver_logs": [str(path) for path in logs],
-    }
-    failed = [name for name, passed in checks.items() if not passed]
-    return {
-        "schema_version": "foambench.execution.v2",
-        "status": "pass" if not failed else "fail",
-        "expected_latest_time": expected_time,
-        "candidate_latest_time": latest,
-        "candidate_final_log_time": log_time,
-        "checks": checks,
-        "failed_checks": failed,
-        "evidence": evidence,
-    }

benchmarks/evaluation/extbench.py

@@ -1,1572 +0,0 @@
-#!/usr/bin/env python3
-"""Extract and audit Extended FoamBench QoIs without fallback proxies."""
-from __future__ import annotations
-
-import argparse
-import csv
-import json
-import math
-import re
-import statistics
-from pathlib import Path
-from typing import Any
-
-from .evidence_contract import canonical_evidence_manifest, evidence_roots, resolve_evidence
-from .foam_arrays import foam_path, read_label_list, read_scalar_field, read_vector_field, read_vector_list
-from .io import utc_now, write_json
-from .retained_fields import derive_cell_geometry, pump_measurements, static_mesh
-from .measurement_specs import load_measurement_spec
-
-ROOT = Path(__file__).resolve().parents[2]
-DEFAULT_DESIGN = ROOT / "benchmarks/FoamBench_extended_openfoam13_qoi_design.json"
-NUMERIC = re.compile(r"^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$")
-
-
-def named_numeric_rows(path: Path) -> tuple[list[str], list[list[float]]]:
-    """Read a whitespace/CSV table using the last compatible header."""
-    headers: list[list[str]] = []
-    rows: list[list[float]] = []
-    try:
-        for line in path.read_text(errors="ignore").splitlines():
-            stripped = line.strip()
-            if not stripped:
-                continue
-            if stripped.startswith("#"):
-                names = stripped[1:].strip().replace(",", " ").split()
-                if names:
-                    headers.append(names)
-                continue
-            parts = stripped.replace("(", " ").replace(")", " ").replace(",", " ").split()
-            if parts and all(NUMERIC.match(value) for value in parts):
-                rows.append([float(value) for value in parts])
-            elif (not rows and ("," in stripped or "\t" in stripped)
-                  and any(re.search(r"[A-Za-z_]", value) and not NUMERIC.fullmatch(value) for value in parts)):
-                names = [item.strip() for item in stripped.split(",")] if "," in stripped else stripped.split("\t")
-                if names:
-                    headers.append(names)
-    except OSError:
-        return [], []
-    if not rows:
-        return [], []
-    width = len(rows[0])
-    header = next((names for names in reversed(headers) if len(names) == width), [])
-    return header, [row for row in rows if len(row) == width]
-
-
-def matching_files(case: Path, needles: tuple[str, ...], suffixes: tuple[str, ...] = ()) -> list[Path]:
-    """Find explicit post-processing evidence in the case or its workspace."""
-    parent = case.parent
-    roots = [case / "postProcessing", case / "results", parent / "postProcessing", parent / "postprocessing", parent / "results"]
-    paths: list[Path] = []
-    for root in roots:
-        if not root.is_dir():
-            continue
-        paths.extend(path for path in root.rglob("*") if path.is_file()
-                     and (not suffixes or path.suffix.lower() in suffixes)
-                     and any(needle.lower() in str(path).lower() for needle in needles))
-    return sorted(set(paths))
-
-
-def evidence_path(case: Path, path: Path) -> str:
-    """Serialize evidence paths for both native case and sibling workspace outputs."""
-    try:
-        return str(path.relative_to(case))
-    except ValueError:
-        return "../" + str(path.relative_to(case.parent))
-
-
-def design_case_contract(case_id: str, design: dict[str, Any]) -> tuple[str | None, list[str]]:
-    """Return the branch and principal metrics for one family/variant."""
-    if "/" not in case_id:
-        raise ValueError(f"case id must be family/variant: {case_id}")
-    family_name, variant = case_id.split("/", 1)
-    family = next((item for item in design.get("families", []) if item.get("family") == family_name), None)
-    if family is None:
-        raise ValueError(f"design has no family for {case_id}")
-    return required_metrics(family, variant)
-
-
-def design_case_conditionals(case_id: str, design: dict[str, Any]) -> list[str]:
-    if "/" not in case_id:
-        raise ValueError(f"case id must be family/variant: {case_id}")
-    family_name, variant = case_id.split("/", 1)
-    family = next((item for item in design.get("families", []) if item.get("family") == family_name), None)
-    if family is None:
-        raise ValueError(f"design has no family for {case_id}")
-    for branch in family.get("branches", []):
-        if variant in branch.get("cases", []):
-            return [item["name"] for item in branch.get("conditional_qois", [])]
-    return []
-
-
-def extract_contract_case(case: Path, case_id: str, design: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Extract one candidate using only the design contract."""
-    selected_design = design or json.loads(DEFAULT_DESIGN.read_text(encoding="utf-8"))
-    branch_id, metrics = design_case_contract(case_id, selected_design)
-    measurement_spec = load_measurement_spec(case_id)
-    if measurement_spec is not None:
-        declared = [item.get("metric") for item in measurement_spec.get("principal_measurements", [])]
-        if declared != metrics:
-            raise ValueError(f"measurement contract drift for {case_id}: {declared!r} != {metrics!r}")
-    conditionals = design_case_conditionals(case_id, selected_design)
-    result = extract_case(
-        case, case_id.split("/", 1)[0], case_id.split("/", 1)[1], metrics,
-        conditional_metrics=conditionals,
-    )
-    result["branch_id"] = branch_id
-    result["conditional_metrics"] = conditionals
-    result["contract_version"] = selected_design.get("schema_version")
-    if measurement_spec is not None:
-        result["measurement_contract"] = measurement_spec
-    return result
-
-
-def locate_case(run_root: Path, family: str, variant: str) -> Path | None:
-    candidates = (
-        run_root / f"{family}__{variant}" / "full_run_case",
-        run_root / f"{family}__{variant}" / "case",
-        run_root / family / variant / "full_run_case",
-        run_root / family / variant / "case",
-        run_root / family / variant,
-    )
-    return next((path for path in candidates if path.is_dir()), None)
-
-
-def required_metrics(family: dict[str, Any], variant: str) -> tuple[str | None, list[str]]:
-    for branch in family.get("branches", []):
-        if variant in branch.get("cases", []):
-            metrics = [item["name"] for item in branch.get("principal_qois", [])]
-            return branch.get("id"), metrics
-    return None, []
-
-
-def final_fraction(values: list[float], fraction: float = 0.2, minimum: int = 5) -> list[float]:
-    if not values:
-        return []
-    count = min(len(values), max(minimum, math.ceil(len(values) * fraction)))
-    return values[-count:]
-
-
-def force_coefficients(case: Path) -> tuple[dict[str, list[float]], list[str]]:
-    files = matching_files(case, ("forcecoeffs.dat",), (".dat", ".csv", ".raw"))
-    files.extend(resolve_evidence(case, "force_coefficients", suffixes=(".dat", ".csv", ".raw")))
-    # Content-addressed fallback: a different agent may call this table
-    # loads.csv or aero_coefficients.dat.  The header is the physical contract.
-    candidates = [path for root in evidence_roots(case) for path in root.rglob("*")
-                  if path.is_file() and path.suffix.lower() in {".dat", ".csv", ".raw"}]
-    for path in candidates:
-        if path in files:
-            continue
-        header, _ = named_numeric_rows(path)
-        if "Time" in header and any(name in header for name in ("Cd", "Cl", "Cm")):
-            files.append(path)
-    files = sorted(set(files))
-    columns: dict[str, list[float]] = {}
-    evidence: list[str] = []
-    for path in files:
-        header, rows = named_numeric_rows(path)
-        if not header or "Time" not in header:
-            continue
-        for name in ("Cd", "Cl", "Cm"):
-            if name not in header:
-                continue
-            index = header.index(name)
-            columns.setdefault(name, []).extend(
-                row[index] for row in rows if math.isfinite(row[index])
-            )
-        evidence.append(evidence_path(case, path))
-    return columns, evidence
-
-
-def extract_force_metric(case: Path, metric: str) -> tuple[float | None, list[str], str]:
-    columns, evidence = force_coefficients(case)
-    base = metric.removesuffix("_mean").removesuffix("_rms")
-    values = final_fraction(columns.get(base, []))
-    if not values:
-        return None, [], "header_addressed_force_coefficients.v1"
-    if metric.endswith("_rms"):
-        mean = statistics.fmean(values)
-        value = math.sqrt(statistics.fmean((item - mean) ** 2 for item in values))
-    else:
-        value = statistics.fmean(values)
-    return value, evidence, "header_addressed_force_coefficients.v1"
-
-
-def spalding_metrics_from_files(files: list[Path], relative_to: Path) -> tuple[dict[str, float], list[str]]:
-    log_errors: list[float] = []
-    first_yplus: list[float] = []
-    evidence: list[str] = []
-    for path in files:
-        header, rows = named_numeric_rows(path)
-        normalized = {
-            re.sub(r"[^a-z0-9]", "", name.lower().replace("+", "plus")): index
-            for index, name in enumerate(header)
-        }
-        y_index = next(
-            (normalized[name] for name in ("yplus", "firstcellyplus", "yplusmin", "firstcellyplusmin") if name in normalized),
-            None,
-        )
-        predicted_index = next(
-            (normalized[name] for name in ("spaldingyplus", "yplusspaldingup", "yplusspaldinguplus", "yplusspalding") if name in normalized),
-            None,
-        )
-        if y_index is None:
-            continue
-        # Zero is a valid observed wall resolution.  Missing evidence is an
-        # absent row, not a non-positive value.
-        y_values = [row[y_index] for row in rows if len(row) > y_index and math.isfinite(row[y_index]) and row[y_index] >= 0]
-        if y_values:
-            first_yplus.append(min(y_values))
-        if predicted_index is None:
-            # A first-cell summary is valid endpoint evidence, but it cannot
-            # be relabelled as a profile residual.
-            evidence.append(evidence_path(relative_to, path))
-            continue
-        valid = [
-            (row[y_index], row[predicted_index]) for row in rows
-            if len(row) > max(y_index, predicted_index)
-            and math.isfinite(row[y_index]) and math.isfinite(row[predicted_index])
-            and row[y_index] >= 0 and row[predicted_index] >= 0
-        ]
-        if not valid:
-            continue
-        log_errors.extend(
-            math.log1p(yplus) - math.log1p(predicted)
-            for yplus, predicted in valid
-        )
-        evidence.append(evidence_path(relative_to, path))
-    result: dict[str, float] = {}
-    if log_errors:
-        result["spalding_log_rmse"] = math.sqrt(statistics.fmean(value * value for value in log_errors))
-    if first_yplus:
-        result["first_cell_yplus"] = statistics.fmean(first_yplus)
-    return result, evidence
-
-
-def standard_yplus_metrics(files: list[Path], relative_to: Path) -> tuple[dict[str, float], list[str]]:
-    """Read OpenFOAM's standard ``yPlus.dat`` patch summary.
-
-    The standard table has the schema ``Time patch min max average``.  It is
-    therefore intentionally parsed separately from ``named_numeric_rows``,
-    which rejects the non-numeric patch column.  A zero average remains a
-    valid observation.
-    """
-    rows: list[tuple[float, str, float, float, float]] = []
-    evidence: list[str] = []
-    for path in files:
-        if path.name.lower() != "yplus.dat":
-            continue
-        try:
-            for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
-                parts = line.split()
-                if len(parts) < 5 or parts[0].startswith("#"):
-                    continue
-                try:
-                    time = float(parts[0])
-                    minimum, maximum, average = float(parts[2]), float(parts[3]), float(parts[4])
-                except ValueError:
-                    continue
-                if all(math.isfinite(value) for value in (time, minimum, maximum, average)):
-                    rows.append((time, parts[1], minimum, maximum, average))
-        except OSError:
-            continue
-        if rows:
-            evidence.append(evidence_path(relative_to, path))
-    if not rows:
-        return {}, []
-    final_time = max(row[0] for row in rows)
-    final_rows = [row for row in rows if abs(row[0] - final_time) <= 1e-12 * max(1.0, abs(final_time))]
-    # Symmetric wall patches are one declared response; average their final
-    # values while retaining the source file as auditable evidence.
-    return {"first_cell_yplus": statistics.fmean(row[4] for row in final_rows)}, sorted(set(evidence))
-
-
-def spalding_metrics(case: Path) -> tuple[dict[str, float], list[str]]:
-    files = matching_files(case, ("spalding_comparison", "uplus_yplus", "wall_law_profile"), (".raw", ".xy", ".dat", ".csv"))
-    # OpenFOAM's standard yPlus function object writes ``yPlus.dat`` with a
-    # non-numeric patch-name column (``Time patch min max average``).  It is
-    # intentionally handled by ``standard_yplus_metrics`` below, so discover
-    # it by basename instead of sending it through ``named_numeric_rows``.
-    for root in evidence_roots(case):
-        files.extend(
-            path for path in root.rglob("*")
-            if path.is_file() and path.name.lower() == "yplus.dat"
-        )
-    # The rollout measurement writer emits an explicit wall table instead of
-    # a Spalding profile.  yPlus_min is valid endpoint evidence; it is not
-    # treated as a profile residual.
-    files.extend(matching_files(case, ("yplus_wall.csv",), (".csv",)))
-    # Accept semantically equivalent wall tables even when the file name is
-    # agent-specific, provided the table contains a y+ column.
-    for root in evidence_roots(case):
-        for path in root.rglob("*"):
-            if not path.is_file() or path.suffix.lower() not in {".csv", ".dat", ".raw", ".xy"}:
-                continue
-            header, _ = named_numeric_rows(path)
-            normalized = {re.sub(r"[^a-z0-9]", "", name.lower().replace("+", "plus")) for name in header}
-            if "yplus" in normalized or "firstcellyplus" in normalized:
-                files.append(path)
-    files = sorted(set(files))
-    standard_values, standard_evidence = standard_yplus_metrics(files, case)
-    wall_files = [path for path in files if path.name.lower() == "yplus_wall.csv"]
-    wall_values: list[float] = []
-    wall_evidence: list[str] = []
-    for path in wall_files:
-        try:
-            with path.open(newline="", encoding="utf-8", errors="ignore") as handle:
-                for row in csv.DictReader(handle):
-                    raw = row.get("yPlus_min") or row.get("yplus_min") or row.get("first_cell_yplus")
-                    if raw is not None:
-                        value = float(raw)
-                        if math.isfinite(value) and value >= 0:
-                            wall_values.append(value)
-                if wall_values:
-                    wall_evidence.append(evidence_path(case, path))
-        except (OSError, ValueError):
-            continue
-    # Branch-labelled evidence is handled separately for the multi-Re case.
-    files = [path for path in files if "branches" not in tuple(evidence_path(case, path).split("/"))]
-    values, evidence = spalding_metrics_from_files([path for path in files if path not in wall_files], case)
-    if "first_cell_yplus" not in values:
-        # CSV profile variants use a header with a literal ``y+`` token or a
-        # yplus column and do not necessarily contain a yPlus_min summary.
-        for path in files:
-            if path in wall_files:
-                continue
-            header, rows = named_numeric_rows(path)
-            normalized = {re.sub(r"[^a-z0-9]", "", name.lower().replace("+", "plus")): i for i, name in enumerate(header)}
-            index = next((normalized[name] for name in ("yplus", "firstcellyplus") if name in normalized), None)
-            if index is not None:
-                vals = [row[index] for row in rows if len(row) > index and math.isfinite(row[index]) and row[index] >= 0]
-                if vals:
-                    values["first_cell_yplus"] = vals[0]
-                    evidence.append(evidence_path(case, path))
-                    break
-    if wall_values:
-        # The final row is the retained endpoint; using the mean would mix
-        # initialization transients with the declared final wall resolution.
-        values["first_cell_yplus"] = wall_values[-1]
-        evidence.extend(wall_evidence)
-    if "first_cell_yplus" not in values and standard_values:
-        values.update(standard_values)
-        evidence.extend(standard_evidence)
-    return values, sorted(set(evidence))
-
-
-def branchwise_spalding_metrics(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    branches: dict[str, Any] = {}
-    evidence: list[str] = []
-    files = matching_files(case, ("spalding_comparison", "uplus_yplus", "wall_law_profile"), (".raw", ".xy", ".dat", ".csv"))
-    by_branch: dict[str, list[Path]] = {}
-    for path in files:
-        match = re.search(r"Re_tau_(180|395|590)", str(path))
-        if match:
-            by_branch.setdefault(f"Re_tau_{match.group(1)}", []).append(path)
-    for branch, branch_files in sorted(by_branch.items()):
-        values, refs = spalding_metrics_from_files(sorted(branch_files), case)
-        if {"spalding_log_rmse", "first_cell_yplus"} <= set(values):
-            branches[branch] = values
-            evidence.extend(refs)
-    expected = {"Re_tau_180", "Re_tau_395", "Re_tau_590"}
-    if set(branches) != expected:
-        return None, sorted(set(evidence))
-    return {"kind": "branch_scalars", "branches": branches}, sorted(set(evidence))
-
-
-def stirrer_power_history(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    files = matching_files(case, ("surfaceFieldValue.dat",), (".dat",))
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    for path in files:
-        header, rows = named_numeric_rows(path)
-        fields = [name for name in header if name != "Time" and "stressUSf" in name]
-        if "Time" not in header or not fields:
-            continue
-        time_index, power_index = header.index("Time"), header.index(fields[0])
-        points.extend({"time": row[time_index], "value": row[power_index]} for row in rows if math.isfinite(row[power_index]))
-        evidence.append(evidence_path(case, path))
-    if not points:
-        return None, []
-    points.sort(key=lambda item: item["time"])
-    return {"kind": "time_history", "quantity": "surface_integrated_stressUSf_power", "points": points}, evidence
-
-
-def named_sample_profiles(case: Path, names: tuple[str, ...]) -> tuple[dict[str, Any] | None, list[str]]:
-    profiles: list[dict[str, Any]] = []
-    evidence: list[str] = []
-    roots = [case, *evidence_roots(case)]
-    candidates: list[Path] = []
-    for root in roots:
-        candidates.extend(item for item in root.rglob("*") if item.is_file() and (
-            item.name in names or (item.suffix.lower() == ".csv" and item.parent.name.lower() == "profiles")
-        ))
-    for path in sorted(set(candidates)):
-        header, rows = named_numeric_rows(path)
-        if len(header) < 2 or not rows or not profile_has_physical_columns(header):
-            continue
-        profiles.append({
-            "profile_id": evidence_path(case, path),
-            "columns": header,
-            "rows": rows,
-        })
-        evidence.append(evidence_path(case, path))
-    if not profiles:
-        return None, []
-    return {"kind": "named_profiles", "profiles": profiles}, evidence
-
-
-def result_profile_tables(case: Path, tokens: tuple[str, ...]) -> tuple[dict[str, Any] | None, list[str]]:
-    """Read explicit profile tables from workspace/results when named output
-    files use a family-specific filename instead of horizontal.xy/vertical.xy.
-    """
-    profiles: list[dict[str, Any]] = []
-    evidence: list[str] = []
-    roots = list(evidence_roots(case))
-    resolved = resolve_evidence(case, "centerline_profile", suffixes=(".csv", ".dat", ".raw", ".xy"))
-    for root in roots:
-        if not root.is_dir():
-            continue
-        for path in sorted(root.rglob("*")):
-            if not path.is_file() or path.suffix.lower() not in {".csv", ".dat", ".raw", ".xy"}:
-                continue
-            if path not in resolved and not any(token.lower() in path.name.lower() for token in tokens):
-                continue
-            header, rows = named_numeric_rows(path)
-            if len(header) < 2 or not rows or not profile_has_physical_columns(header):
-                continue
-            profiles.append({"profile_id": evidence_path(case, path), "columns": header, "rows": rows})
-            evidence.append(evidence_path(case, path))
-    if not profiles:
-        return None, []
-    return {"kind": "named_profiles", "profiles": profiles}, sorted(set(evidence))
-
-
-def profile_has_physical_columns(header: list[str]) -> bool:
-    """Require a coordinate and at least one sampled physical field."""
-    normalized = [re.sub(r"[^a-z0-9]", "", name.lower()) for name in header]
-    has_coordinate = any(name in {"x", "y", "z", "coordinate", "position", "arc"} or name.startswith(("x", "y", "z")) for name in normalized)
-    has_field = any(
-        name in {"p", "rho", "u", "ux", "uy", "uz"}
-        or name.startswith(("px", "py", "pz", "rhox", "rhoy", "rhoz"))
-        for name in normalized
-    )
-    return has_coordinate and has_field
-
-
-def named_profiles_containing(case: Path, tokens: tuple[str, ...], required_columns: tuple[str, ...] = ()) -> tuple[dict[str, Any] | None, list[str]]:
-    """Read explicitly named sample tables; never infer a physical metric from field extrema."""
-    profiles: list[dict[str, Any]] = []
-    evidence: list[str] = []
-    for root in (case, *evidence_roots(case)):
-        for path in sorted(item for item in root.rglob("*") if item.is_file() and path_like_sample(item, tokens)):
-            header, rows = named_numeric_rows(path)
-            if len(header) < 2 or not rows or any(column not in header for column in required_columns):
-                continue
-            profiles.append({"profile_id": evidence_path(case, path), "columns": header, "rows": rows})
-            evidence.append(evidence_path(case, path))
-    return ({"kind": "named_profiles", "profiles": profiles}, evidence) if profiles else (None, [])
-
-
-def path_like_sample(path: Path, tokens: tuple[str, ...]) -> bool:
-    name = path.name.lower()
-    return path.suffix.lower() in {".xy", ".raw", ".dat", ".csv"} and any(token.lower() in name for token in tokens)
-
-
-def field_dimensions(case: Path, field: str) -> str | None:
-    for path in sorted(case.rglob(field), reverse=True):
-        if not path.is_file() or not path.parent.name.replace(".", "", 1).isdigit():
-            continue
-        header = path.read_bytes()[:4096].decode("ascii", errors="ignore")
-        match = re.search(r"dimensions\s*\[([^]]+)\]", header)
-        if match:
-            return " ".join(match.group(1).split())
-    return None
-
-
-def evidence_branch(case: Path, path: Path) -> str:
-    try:
-        parts = path.relative_to(case).parts
-    except ValueError:
-        parts = path.relative_to(case.parent).parts
-    try:
-        index = parts.index("postProcessing")
-    except ValueError:
-        return "root"
-    return "/".join(parts[:index]) or "root"
-
-
-def explicit_mass_flow_history(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    branch_points: dict[str, list[dict[str, float]]] = {}
-    evidence: list[str] = []
-    candidates = matching_files(case, ("surfaceFieldValue", "massFlow", "massFlux", "rhoPhi"), (".dat", ".raw", ".csv"))
-    # Some benchmark variants materialize several nested operating-point cases;
-    # accept their postProcessing evidence without flattening those branches.
-    if not candidates:
-        candidates = sorted(path for path in case.rglob("*") if path.is_file()
-                            and path.suffix.lower() in {".dat", ".raw", ".csv"}
-                            and any(token.lower() in str(path).lower()
-                                    for token in ("surfaceFieldValue", "massFlow", "massFlux", "rhoPhi")))
-    for path in candidates:
-        patch_match = re.search(r"patch=([^)/]+)", str(path))
-        if patch_match is not None and patch_match.group(1).lower() not in {"inlet", "inlet1", "main", "mainstream"}:
-            # The principal pump/nozzle response is the declared inlet flow;
-            # do not concatenate inlet and outlet fluxes into one history.
-            continue
-        header, rows = named_numeric_rows(path)
-        mass_columns = [column for column in header if any(token in column.lower() for token in ("rhophi", "massflow", "massflux", "sum(phi)"))]
-        if "Time" not in header or not mass_columns:
-            continue
-        t_index, value_index = header.index("Time"), header.index(mass_columns[0])
-        branch = evidence_branch(case, path)
-        branch_points.setdefault(branch, []).extend(
-            {"time": row[t_index], "value": row[value_index]}
-            for row in rows if math.isfinite(row[value_index])
-        )
-        evidence.append(evidence_path(case, path))
-    if not branch_points:
-        return None, []
-    dimensions = field_dimensions(case, "phi")
-    quantity = {
-        "1 0 -1 0 0 0 0": "explicit_mass_flow",
-        "0 3 -1 0 0 0 0": "explicit_volumetric_flow",
-    }.get(dimensions, "explicit_flux_unknown_dimensions")
-    branches = {
-        branch: {"kind": "time_history", "quantity": quantity,
-                 "points": sorted(points, key=lambda item: item["time"])}
-        for branch, points in sorted(branch_points.items())
-    }
-    if set(branches) == {"root"}:
-        result = branches["root"]
-    else:
-        result = {"kind": "branched_time_histories", "quantity": quantity, "branches": branches}
-    result["field_dimensions"] = dimensions
-    return result, sorted(set(evidence))
-
-
-def explicit_patch_pressure(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    histories: dict[str, list[dict[str, float]]] = {}
-    evidence: list[str] = []
-    for path in matching_files(case, ("patchAverage", "patchIntegrate", "pressureRise", "pressure_rise"), (".dat", ".raw", ".csv")):
-        header, rows = named_numeric_rows(path)
-        pressure_columns = [column for column in header if column != "Time" and any(token in column.lower() for token in ("p", "pressure"))]
-        match = re.search(r"patch=([^)/]+)", str(path))
-        if "Time" not in header or not pressure_columns or not match:
-            continue
-        patch_name = match.group(1)
-        t_index, value_index = header.index("Time"), header.index(pressure_columns[0])
-        histories.setdefault(patch_name, []).extend({"time": row[t_index], "value": row[value_index]} for row in rows if math.isfinite(row[value_index]))
-        evidence.append(evidence_path(case, path))
-    inlet_name = next((name for name in histories if "inlet" in name.lower()), None)
-    outlet_name = next((name for name in histories if "outlet" in name.lower()), None)
-    if inlet_name is None or outlet_name is None:
-        return None, []
-    inlet = {round(point["time"], 12): point["value"] for point in histories[inlet_name]}
-    outlet = {round(point["time"], 12): point["value"] for point in histories[outlet_name]}
-    points = [
-        {"time": time, "value": outlet[time] - inlet[time]}
-        for time in sorted(set(inlet) & set(outlet))
-    ]
-    if not points:
-        return None, []
-    return {
-        "kind": "time_history",
-        "quantity": "pressure_rise",
-        "definition": "outlet_minus_inlet_patch_average",
-        "source_patches": {"inlet": inlet_name, "outlet": outlet_name},
-        "points": points,
-    }, sorted(set(evidence))
-
-
-def crossjet_inlet_mass_flux_ratio(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    fluxes: dict[str, list[tuple[float, float]]] = {}
-    evidence: list[str] = []
-    for path in resolve_evidence(case, "patch_flux", suffixes=(".dat", ".raw", ".csv")):
-        match = re.search(r"patch=([^)/]+)", str(path))
-        if match is None:
-            match = re.search(r"(?m)^\s*#\s*Selection\s*:\s*patch\(([^)]+)\)", path.read_text(errors="ignore"))
-        if match is None:
-            continue
-        patch = match.group(1).lower()
-        canonical = (
-            "inlet1" if patch in {"inlet1", "inlet", "main", "mainstream", "maininlet", "mainflowinlet"}
-            else "inlet2" if patch in {"inlet2", "jet", "injection", "jetinlet"}
-            else None
-        )
-        if canonical is None:
-            continue
-        header, rows = named_numeric_rows(path)
-        columns = [column for column in header if column != "Time" and "sum(phi)" in column]
-        if "Time" not in header or not columns:
-            continue
-        ti, vi = header.index("Time"), header.index(columns[0])
-        fluxes.setdefault(canonical, []).extend((row[ti], row[vi]) for row in rows)
-        evidence.append(evidence_path(case, path))
-    if not all(fluxes.get(patch) for patch in ("inlet1", "inlet2")):
-        return None, []
-    main = sorted(fluxes["inlet1"])[-1]
-    jet = sorted(fluxes["inlet2"])[-1]
-    if main[1] == 0:
-        return None, []
-    return {
-        "kind": "scalar_ratio",
-        "quantity": "jet_to_mainstream_mass_flux_ratio",
-        "value": abs(jet[1] / main[1]),
-        "mainstream_flux": main[1],
-        "jet_flux": jet[1],
-        "time": min(main[0], jet[0]),
-        "patch_aliases": {"mainstream": "inlet1", "jet": "inlet2"},
-    }, sorted(set(evidence))
-
-
-def phase_volume_history(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    for time, directory in numeric_time_dirs(case):
-        alpha_path = foam_path(directory, "alpha.water")
-        volume_path = foam_path(directory, "Vc")
-        if alpha_path is None or volume_path is None:
-            continue
-        try:
-            alpha = read_scalar_field(alpha_path)
-            volumes = read_scalar_field(volume_path)
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(alpha) != len(volumes) or not volumes:
-            continue
-        total = sum(volumes)
-        if total <= 0:
-            continue
-        points.append({"time": time, "value": sum(a * v for a, v in zip(alpha, volumes)) / total})
-        evidence.extend((evidence_path(case, alpha_path), evidence_path(case, volume_path)))
-    if not points:
-        return None, []
-    return {"kind": "time_history", "quantity": "volume_weighted_alpha_water", "points": points}, sorted(set(evidence))
-
-
-def volume_average_speed_history(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    for time, directory in numeric_time_dirs(case):
-        velocity_path = foam_path(directory, "U")
-        volume_path = foam_path(directory, "Vc")
-        if velocity_path is None or volume_path is None:
-            continue
-        try:
-            velocity = read_vector_field(velocity_path)
-            volumes = read_scalar_field(volume_path)
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(velocity) != len(volumes) or not volumes:
-            continue
-        total = sum(volumes)
-        if total <= 0:
-            continue
-        value = sum(math.sqrt(u * u + v * v + w * w) * volume
-                    for (u, v, w), volume in zip(velocity, volumes)) / total
-        if not math.isfinite(value):
-            continue
-        points.append({"time": time, "value": value})
-        evidence.extend((evidence_path(case, velocity_path), evidence_path(case, volume_path)))
-    if not points:
-        return None, []
-    return {"kind": "time_history", "quantity": "volume_average_speed", "points": points}, sorted(set(evidence))
-
-
-def volume_speed_rms_history(case: Path) -> tuple[dict[str, Any] | None, list[str]]:
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    for time, directory in numeric_time_dirs(case):
-        velocity_path, volume_path = foam_path(directory, "U"), foam_path(directory, "Vc")
-        if velocity_path is None or volume_path is None:
-            continue
-        try:
-            velocity, volumes = read_vector_field(velocity_path), read_scalar_field(volume_path)
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(velocity) != len(volumes) or not volumes or sum(volumes) <= 0:
-            continue
-        speeds = [math.sqrt(u * u + v * v + w * w) for u, v, w in velocity]
-        total = sum(volumes)
-        mean = sum(speed * volume for speed, volume in zip(speeds, volumes)) / total
-        rms = math.sqrt(sum((speed - mean) ** 2 * volume for speed, volume in zip(speeds, volumes)) / total)
-        if math.isfinite(rms):
-            points.append({"time": time, "value": rms})
-            evidence.extend((evidence_path(case, velocity_path), evidence_path(case, volume_path)))
-    if not points:
-        return None, []
-    return {"kind": "time_history", "quantity": "volume_speed_spatial_rms", "points": points}, sorted(set(evidence))
-
-
-def volume_average_speed_final(case: Path) -> tuple[float | None, list[str]]:
-    """Extract a final-state mixing response from retained U and cell volumes."""
-    for _, directory in reversed(numeric_time_dirs(case)):
-        velocity_path, volume_path = foam_path(directory, "U"), foam_path(directory, "Vc")
-        if velocity_path is None:
-            continue
-        try:
-            # Retained agent fields can contain a uniform internal U while Vc
-            # still has one volume per cell.  Decode the concrete array first
-            # so the uniform vector is expanded using an observed cell count.
-            if volume_path is not None:
-                volumes = read_scalar_field(volume_path)
-                geometry_evidence = [volume_path]
-            else:
-                from .retained_fields import derive_cell_geometry
-                volumes, _, geometry_evidence = derive_cell_geometry(case)
-            try:
-                velocity = read_vector_field(velocity_path)
-            except (ValueError, RuntimeError):
-                velocity = read_vector_field_allow_uniform(velocity_path, len(volumes))
-            if volume_path is not None and len(volumes) == 1 and len(velocity) > 1:
-                volumes = volumes * len(velocity)
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(velocity) != len(volumes) or not volumes or sum(volumes) <= 0:
-            continue
-        total = sum(volumes)
-        value = sum(math.sqrt(u * u + v * v + w * w) * volume
-                    for (u, v, w), volume in zip(velocity, volumes)) / total
-        if math.isfinite(value):
-            return value, [evidence_path(case, path) for path in [velocity_path, *geometry_evidence]]
-    return None, []
-
-
-def read_vector_field_allow_uniform(path: Path, count: int) -> list[tuple[float, float, float]]:
-    try:
-        return read_vector_field(path)
-    except (ValueError, RuntimeError):
-        text = path.read_text(encoding="ascii", errors="ignore")
-        match = re.search(r"internalField\s+uniform\s+\(([^)]+)\)", text)
-        if match is None:
-            raise
-        values = [float(item) for item in match.group(1).split()]
-        if len(values) != 3:
-            raise ValueError(f"invalid uniform vector field: {path}")
-        return [(values[0], values[1], values[2])] * count
-
-
-def read_scalar_field_allow_uniform(path: Path, count: int) -> list[float]:
-    """Read a scalar field while preserving the semantics of a uniform field."""
-    try:
-        values = read_scalar_field(path)
-    except (ValueError, RuntimeError):
-        text = path.read_text(encoding="ascii", errors="ignore")
-        match = re.search(r"internalField\s+uniform\s+([^;]+);", text)
-        if match is None:
-            raise
-        return [float(match.group(1).strip())] * count
-    if len(values) == 1 and count > 1:
-        # OpenFOAM permits a uniform field to be serialized as one value.
-        return values * count
-    return values
-
-
-def crossjet_interior_pressure_span(case: Path) -> tuple[float | None, list[str]]:
-    """Return the pressure response in the declared internal CrossJet window.
-
-    The span is deliberately computed from the retained pressure field rather
-    than from ``grad(p)``.  This remains extractable for references that store
-    ``p`` as a uniform field and avoids treating a missing/zero post-processing
-    gradient as a shock observable.
-    """
-    for _, directory in reversed(numeric_time_dirs(case)):
-        centre_path, pressure_path = foam_path(directory, "C"), foam_path(directory, "p")
-        if pressure_path is None:
-            continue
-        try:
-            if centre_path is not None:
-                centres = read_vector_field(centre_path)
-                geometry_evidence = [centre_path]
-            else:
-                from .retained_fields import derive_cell_geometry
-                _, centres, geometry_evidence = derive_cell_geometry(case)
-            pressure = read_scalar_field_allow_uniform(pressure_path, len(centres))
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(pressure) != len(centres):
-            continue
-        values = [value for (x, y, _), value in zip(centres, pressure)
-                  if -1.0 <= x <= 1.0 and 0.1 <= y <= 0.95]
-        if values:
-            return max(values) - min(values), [evidence_path(case, path) for path in [*geometry_evidence, pressure_path]]
-    return None, []
-
-
-def crossjet_interior_pressure_gradient_max(case: Path) -> tuple[float | None, list[str]]:
-    """Return the maximum interior pressure span."""
-    return crossjet_interior_pressure_span(case)
-
-
-def profile_event_locations(profiles: dict[str, Any]) -> dict[str, Any] | None:
-    events: list[dict[str, Any]] = []
-    for profile in profiles.get("profiles", []):
-        columns = profile.get("columns", [])
-        rows = profile.get("rows", [])
-        if len(columns) < 2 or len(rows) < 5:
-            continue
-        coordinate_index = 0
-        for field in ("p", "rho"):
-            field_index = next((index for index, name in enumerate(columns)
-                                if name.lower() == field or name.lower().startswith(field + "_")), None)
-            if field_index is None:
-                continue
-            gradients: list[tuple[int, float, float]] = []
-            for index in range(len(rows) - 1):
-                spacing = abs(rows[index + 1][coordinate_index] - rows[index][coordinate_index])
-                if spacing <= 0:
-                    continue
-                gradient = abs(rows[index + 1][field_index] - rows[index][field_index]) / spacing
-                coordinate = (rows[index + 1][coordinate_index] + rows[index][coordinate_index]) / 2
-                gradients.append((index, coordinate, gradient))
-            if not gradients:
-                continue
-            peak = max(value for _, _, value in gradients)
-            threshold = 0.05 * peak
-            candidates = [
-                item for position, item in enumerate(gradients)
-                if item[2] >= threshold
-                and (position == 0 or item[2] >= gradients[position - 1][2])
-                and (position == len(gradients) - 1 or item[2] > gradients[position + 1][2])
-            ]
-            selected: list[tuple[int, float, float]] = []
-            for candidate in sorted(candidates, key=lambda item: item[2], reverse=True):
-                if all(abs(candidate[0] - item[0]) >= 4 for item in selected):
-                    selected.append(candidate)
-                if len(selected) == 12:
-                    break
-            for index, coordinate, magnitude in sorted(selected, key=lambda item: item[1]):
-                local_spacing = abs(rows[index + 1][coordinate_index] - rows[index][coordinate_index])
-                events.append({
-                    "profile_id": profile["profile_id"],
-                    "field": field,
-                    "coordinate": coordinate,
-                    "gradient_magnitude": magnitude,
-                    "local_cell_size": local_spacing,
-                })
-    if not events:
-        return None
-    return {
-        "kind": "profile_feature_locations",
-        "detector": "local_abs_gradient_peaks.v1",
-        "relative_prominence": 0.05,
-        "minimum_separation_samples": 4,
-        "maximum_features_per_field_profile": 12,
-        "events": events,
-    }
-
-
-def final_riemann_profiles(profiles: dict[str, Any]) -> dict[str, Any]:
-    """Select each centerline's latest saved time and use its physical axis.
-
-    OpenFOAM raw sets may prefix x/y/z with arc distance. Preserve the sampled
-    values, but put x (horizontal) or y (vertical) first for event detection.
-    """
-    from .comparison import profile_key
-    selected: dict[str, tuple[float, dict[str, Any]]] = {}
-    for profile in profiles.get("profiles", []):
-        key = profile_key(profile)
-        axis = {"horizontal.xy": "x", "vertical.xy": "y"}.get(key)
-        columns = profile.get("columns", [])
-        if axis is None or axis not in columns:
-            continue
-        try:
-            time = float(Path(profile["profile_id"]).parent.name)
-        except ValueError:
-            time = -math.inf
-        if key in selected and time < selected[key][0]:
-            continue
-        order = [columns.index(axis)] + [i for i, name in enumerate(columns) if name != axis]
-        normalized = {**profile, "columns": [columns[i] for i in order],
-                      "rows": [[row[i] for i in order] for row in profile["rows"]]}
-        selected[key] = (time, normalized)
-    return {"kind": "named_profiles", "profiles": [item[1] for item in selected.values()]}
-
-
-def numeric_time_dirs(case: Path) -> list[tuple[float, Path]]:
-    result: list[tuple[float, Path]] = []
-    for path in case.iterdir():
-        if not path.is_dir():
-            continue
-        try:
-            result.append((float(path.name), path))
-        except ValueError:
-            pass
-    return sorted(result)
-
-
-def mesh_dir(case: Path, time_dir: Path) -> Path:
-    local = time_dir / "polyMesh"
-    return local if local.is_dir() else case / "constant/polyMesh"
-
-
-def connected_components(active: set[int], owner: list[int], neighbour: list[int]) -> list[list[int]]:
-    adjacency: dict[int, list[int]] = {cell: [] for cell in active}
-    for left, right in zip(owner, neighbour):
-        if left in active and right in active:
-            adjacency[left].append(right)
-            adjacency[right].append(left)
-    components: list[list[int]] = []
-    unseen = set(active)
-    while unseen:
-        seed = unseen.pop()
-        stack = [seed]
-        component = [seed]
-        while stack:
-            for cell in adjacency[stack.pop()]:
-                if cell in unseen:
-                    unseen.remove(cell)
-                    stack.append(cell)
-                    component.append(cell)
-        components.append(component)
-    return components
-
-
-def component_geometry(
-    cells: list[int], gas: list[float], volumes: list[float], centres: list[tuple[float, float, float]], volume_factor: float
-) -> dict[str, float]:
-    weights = [max(0.0, min(1.0, gas[cell])) * volumes[cell] for cell in cells]
-    volume = sum(weights)
-    if volume <= 0:
-        return {}
-    centroid = [sum(weight * centres[cell][axis] for weight, cell in zip(weights, cells)) / volume for axis in range(3)]
-    xx = sum(weight * (centres[cell][0] - centroid[0]) ** 2 for weight, cell in zip(weights, cells)) / volume
-    yy = sum(weight * (centres[cell][1] - centroid[1]) ** 2 for weight, cell in zip(weights, cells)) / volume
-    xy = sum(weight * (centres[cell][0] - centroid[0]) * (centres[cell][1] - centroid[1]) for weight, cell in zip(weights, cells)) / volume
-    root = math.sqrt(max(0.0, (xx - yy) ** 2 + 4 * xy * xy))
-    major = max(0.0, (xx + yy + root) / 2)
-    minor = max(0.0, (xx + yy - root) / 2)
-    aspect = math.sqrt(major / minor) if minor > 0 else None
-    return {
-        "volume": volume,
-        "centroid_x": centroid[0],
-        "centroid_y": centroid[1],
-        "centroid_z": centroid[2],
-        "aspect_ratio": aspect,
-        "equivalent_radius_3d": (3 * volume * volume_factor / (4 * math.pi)) ** (1 / 3),
-    }
-
-
-def axisymmetric_volume_factor(case: Path) -> float:
-    boundary = case / "constant/polyMesh/boundary"
-    if not boundary.is_file() or "wedge" not in boundary.read_text(encoding="utf-8", errors="ignore"):
-        return 1.0
-    points_path = foam_path(case / "constant/polyMesh", "points")
-    if points_path is None:
-        return 1.0
-    angles = [math.atan2(y, x) for x, y, _ in read_vector_list(points_path) if x > 0]
-    if not angles:
-        return 1.0
-    wedge_angle = max(angles) - min(angles)
-    return 2 * math.pi / wedge_angle if wedge_angle > 0 else 1.0
-
-
-def bubble_history(case: Path) -> tuple[list[dict[str, Any]], list[str], list[str]]:
-    history: list[dict[str, Any]] = []
-    evidence: list[str] = []
-    errors: list[str] = []
-    dynamic = not static_mesh(case)
-    volume_factor = axisymmetric_volume_factor(case)
-    cached_geometry: tuple[list[float], list[tuple[float, float, float]]] | None = None
-    cached_topology: tuple[list[int], list[int]] | None = None
-    time_dirs = numeric_time_dirs(case)
-    if not dynamic:
-        for _, directory in reversed(time_dirs):
-            volume_path = foam_path(directory, "Vc")
-            centre_path = foam_path(directory, "C")
-            if volume_path and centre_path:
-                cached_geometry = (read_scalar_field(volume_path), read_vector_field(centre_path))
-                break
-        topology_dir = case / "constant/polyMesh"
-        owner_path = foam_path(topology_dir, "owner")
-        neighbour_path = foam_path(topology_dir, "neighbour")
-        if owner_path and neighbour_path:
-            cached_topology = (read_label_list(owner_path), read_label_list(neighbour_path))
-        if cached_geometry is None:
-            try:
-                volumes, centres, mesh_paths = derive_cell_geometry(case)
-                cached_geometry = (volumes, centres)
-                evidence.extend(evidence_path(case, path) for path in mesh_paths)
-                boundary_path = foam_path(topology_dir, "boundary")
-                if boundary_path:
-                    evidence.append(evidence_path(case, boundary_path))
-            except (OSError, ValueError, RuntimeError) as exc:
-                errors.append(f"retained mesh geometry: {exc}")
-    previous_tracks: dict[int, tuple[float, float, float]] = {}
-    next_track = 1
-    for time, directory in time_dirs:
-        alpha_path = foam_path(directory, "alpha.water")
-        if alpha_path is None:
-            continue
-        volume_path = foam_path(directory, "Vc")
-        centre_path = foam_path(directory, "C")
-        try:
-            if cached_geometry is not None and not dynamic:
-                geometry = cached_geometry
-            elif volume_path and centre_path:
-                geometry = (read_scalar_field(volume_path), read_vector_field(centre_path))
-                if not dynamic:
-                    cached_geometry = geometry
-            else:
-                errors.append(f"{directory.name}: missing C/Vc measurement fields")
-                continue
-            topology_dir = mesh_dir(case, directory)
-            owner_path = foam_path(topology_dir, "owner")
-            neighbour_path = foam_path(topology_dir, "neighbour")
-            if (owner_path is None or neighbour_path is None) and dynamic:
-                # Dynamic solvers may not retain a polyMesh in every output
-                # directory.  Reuse the immutable mesh topology only when it
-                # is present and the field length remains compatible.
-                owner_path = foam_path(case / "constant/polyMesh", "owner")
-                neighbour_path = foam_path(case / "constant/polyMesh", "neighbour")
-            if cached_topology is not None and not dynamic:
-                topology = cached_topology
-            elif owner_path and neighbour_path:
-                topology = (read_label_list(owner_path), read_label_list(neighbour_path))
-                if not dynamic:
-                    cached_topology = topology
-            else:
-                errors.append(f"{directory.name}: missing owner/neighbour topology")
-                continue
-            volumes, centres = geometry
-            alpha = read_scalar_field_allow_uniform(alpha_path, len(volumes))
-            if not (len(alpha) == len(volumes) == len(centres)):
-                errors.append(f"{directory.name}: alpha/C/Vc length mismatch")
-                continue
-            gas = [1.0 - value for value in alpha]
-            active = {index for index, value in enumerate(gas) if value >= 0.5}
-            components = connected_components(active, *topology)
-            geometries = [component_geometry(item, gas, volumes, centres, volume_factor) for item in components]
-            geometries = sorted((item for item in geometries if item), key=lambda item: item["volume"], reverse=True)
-            if geometries:
-                cutoff = geometries[0]["volume"] * 1e-4
-                geometries = [item for item in geometries if item["volume"] >= cutoff]
-            available = set(previous_tracks)
-            for item in geometries:
-                point = (item["centroid_x"], item["centroid_y"], item["centroid_z"])
-                if available:
-                    track = min(available, key=lambda key: sum((a - b) ** 2 for a, b in zip(point, previous_tracks[key])))
-                    available.remove(track)
-                else:
-                    track = next_track
-                    next_track += 1
-                item["track_id"] = track
-            previous_tracks = {
-                item["track_id"]: (item["centroid_x"], item["centroid_y"], item["centroid_z"])
-                for item in geometries
-            }
-            history.append({"time": time, "components": geometries})
-            evidence.extend(evidence_path(case, path) for path in (alpha_path, volume_path, centre_path) if path)
-        except (OSError, ValueError, RuntimeError) as exc:
-            errors.append(f"{directory.name}: {exc}")
-    # A dynamic case may intentionally retain geometry/topology only at the
-    # endpoint.  Earlier missing derived fields make the optional trajectory
-    # incomplete, but must not invalidate endpoint principal QoIs when the
-    # final saved state was successfully measured.
-    if history and history[-1].get("time") == (time_dirs[-1][0] if time_dirs else None):
-        errors = []
-    return history, sorted(set(evidence)), errors
-
-
-def component_trajectory(history: list[dict[str, Any]], field: str, all_components: bool = False) -> dict[str, Any] | None:
-    rows = [item for item in history if item["components"]]
-    if not rows:
-        return None
-    tracks = sorted({component["track_id"] for item in rows for component in item["components"]}) if all_components else [rows[0]["components"][0]["track_id"]]
-    series = []
-    for track in tracks:
-        points = []
-        omitted_invalid = 0
-        for item in rows:
-            component = next((part for part in item["components"] if part["track_id"] == track), None)
-            if component is not None:
-                value = component[field]
-                if value is None:
-                    omitted_invalid += 1
-                    continue
-                points.append({"time": item["time"], "value": value})
-        series.append({
-            "component_id": track,
-            "points": points,
-            "omitted_invalid_sample_count": omitted_invalid,
-            "quality_note": "degenerate_component_geometry_samples_omitted" if omitted_invalid else None,
-        })
-    return {"kind": "component_trajectory", "component_identity": "nearest_centroid_continuation", "series": series}
-
-
-def collapse_events(radius: dict[str, Any]) -> dict[str, Any]:
-    events = []
-    for series in radius["series"]:
-        points = series["points"]
-        index = next((i for i in range(1, len(points) - 1) if points[i]["value"] <= points[i - 1]["value"] and points[i]["value"] < points[i + 1]["value"]), None)
-        censored = index is None
-        if points:
-            index = min(range(len(points)), key=lambda i: points[i]["value"]) if index is None else index
-            events.append({"component_id": series["component_id"], "time": points[index]["time"], "radius": points[index]["value"], "censored_at_time_boundary": censored})
-    status = "complete" if events and all(not event["censored_at_time_boundary"] for event in events) else "censored"
-    return {"kind": "component_events", "status": status, "detector": "first_strict_rebound_minimum_else_global_minimum", "events": events}
-
-
-def rise_velocity(centroid: dict[str, Any]) -> dict[str, Any] | None:
-    points = centroid["series"][0]["points"]
-    if len(points) < 3:
-        return None
-    end = points[-1]["time"]
-    selected = [point for point in points if 0.3 * end <= point["time"] <= 0.7 * end]
-    if len(selected) < 2:
-        return None
-    times = [point["time"] for point in selected]
-    values = [point["value"] for point in selected]
-    mt, my = statistics.fmean(times), statistics.fmean(values)
-    denominator = sum((time - mt) ** 2 for time in times)
-    if denominator == 0:
-        return None
-    slope = sum((time - mt) * (value - my) for time, value in zip(times, values)) / denominator
-    return {"kind": "window_regression", "value": slope, "window": [times[0], times[-1]], "normalized_window": [0.3, 0.7], "sample_count": len(times)}
-
-
-def bubble_metrics(case: Path, family: str) -> tuple[dict[str, Any], list[str], list[str]]:
-    history, evidence, errors = bubble_history(case)
-    if family == "risingBubble":
-        centroid = component_trajectory(history, "centroid_y")
-        aspect = component_trajectory(history, "aspect_ratio")
-        values: dict[str, Any] = {}
-        if centroid:
-            values["bubble_centroid_y_history"] = centroid
-            values["bubble_centroid_y_final"] = final_component_scalar(centroid, "bubble_centroid_y_final")
-            velocity = rise_velocity(centroid)
-            if velocity:
-                values["rise_velocity"] = velocity
-        if aspect:
-            values["shape_aspect_ratio_history"] = aspect
-            values["shape_aspect_ratio_final"] = final_component_scalar(aspect, "shape_aspect_ratio_final")
-        radius = component_trajectory(history, "equivalent_radius_3d")
-        if radius:
-            values["equivalent_radius_final"] = final_component_scalar(radius, "equivalent_radius_final")
-        return values, evidence, errors
-    radius = component_trajectory(history, "equivalent_radius_3d", all_components=True)
-    if not radius:
-        return {}, evidence, errors
-    event = collapse_events(radius)
-    values = {
-        "equivalent_radius_history": radius,
-        "equivalent_radius_final": final_component_scalar(radius, "equivalent_radius_final", all_components=True),
-        "final_component_count": len(radius.get("series", [])),
-        "collapse_time_censored_diagnostic": event,
-    }
-    minima = []
-    for series in radius.get("series", []):
-        observed = [point for point in series.get("points", [])
-                    if isinstance(point.get("value"), (int, float)) and math.isfinite(point["value"])]
-        if observed:
-            point = min(observed, key=lambda item: item["value"])
-            minima.append({"component_id": series.get("component_id"), "time": point["time"], "value": point["value"]})
-    if minima:
-        values["minimum_observed_equivalent_radius"] = {
-            "kind": "component_scalars", "quantity": "minimum_observed_equivalent_radius", "components": minima
-        }
-    if event["status"] == "complete":
-        values["collapse_time"] = event
-    return values, evidence, errors
-
-
-def final_component_scalar(
-    trajectory: dict[str, Any], quantity: str, *, all_components: bool = False
-) -> dict[str, Any]:
-    """Return the last valid connected-component observation.
-
-    The full trajectory remains available as a diagnostic, while this endpoint
-    response can be recovered when only the final field was retained.
-    """
-    series = trajectory.get("series", []) if isinstance(trajectory, dict) else []
-    components = []
-    selected = series if all_components else series[:1]
-    for item in selected:
-        points = [point for point in item.get("points", [])
-                  if isinstance(point, dict) and isinstance(point.get("value"), (int, float))
-                  and math.isfinite(float(point["value"]))]
-        if points:
-            point = points[-1]
-            components.append({"component_id": item.get("component_id"), "time": point["time"], "value": point["value"]})
-    return {"kind": "component_scalars", "quantity": quantity, "components": components}
-
-
-def structured_qoi_errors(name: str, value: Any) -> list[str]:
-    errors: list[str] = []
-    if isinstance(value, (int, float)):
-        return [] if not isinstance(value, bool) and math.isfinite(float(value)) else [f"{name}: non-finite scalar"]
-    if not isinstance(value, dict):
-        return [f"{name}: unsupported QoI value"]
-    kind = value.get("kind")
-    if kind in {"time_history", "window_regression", "scalar_ratio"}:
-        if kind == "time_history":
-            points = value.get("points")
-            if not isinstance(points, list) or not points:
-                return [f"{name}: empty time history"]
-            for point in points:
-                if not isinstance(point, dict) or not all(
-                    isinstance(point.get(key), (int, float)) and math.isfinite(float(point[key]))
-                    for key in ("time", "value")
-                ):
-                    errors.append(f"{name}: invalid time-history point")
-                    break
-        elif not isinstance(value.get("value"), (int, float)) or not math.isfinite(float(value["value"])):
-            errors.append(f"{name}: invalid scalar object")
-    elif kind == "branched_time_histories":
-        branches = value.get("branches")
-        if not isinstance(branches, dict) or not branches:
-            errors.append(f"{name}: no branches")
-        else:
-            for branch, history in branches.items():
-                errors.extend(structured_qoi_errors(f"{name}/{branch}", history))
-    elif kind == "branch_scalars":
-        branches = value.get("branches")
-        if not isinstance(branches, dict) or not branches:
-            errors.append(f"{name}: no scalar branches")
-        else:
-            for branch, metrics in branches.items():
-                if not isinstance(metrics, dict) or not metrics or any(
-                    not isinstance(item, (int, float)) or isinstance(item, bool) or not math.isfinite(float(item))
-                    for item in metrics.values()
-                ):
-                    errors.append(f"{name}/{branch}: invalid branch scalar")
-    elif kind == "component_scalars":
-        components = value.get("components")
-        if not isinstance(components, list) or not components:
-            errors.append(f"{name}: no component scalars")
-        elif any(not isinstance(item.get("value"), (int, float)) or not math.isfinite(float(item["value"]))
-                 for item in components if isinstance(item, dict)):
-            errors.append(f"{name}: invalid component scalar")
-    elif kind == "component_trajectory":
-        series = value.get("series")
-        if not isinstance(series, list) or not series:
-            errors.append(f"{name}: no component trajectories")
-        else:
-            for item in series:
-                points = item.get("points", []) if isinstance(item, dict) else []
-                valid = [point for point in points if isinstance(point, dict)
-                         and isinstance(point.get("value"), (int, float))
-                         and math.isfinite(float(point["value"]))]
-                if len(valid) < 2:
-                    errors.append(f"{name}: component has fewer than two valid points")
-    elif kind == "named_profiles":
-        profiles = value.get("profiles")
-        if not isinstance(profiles, list) or not profiles:
-            errors.append(f"{name}: no named profiles")
-        elif any(not profile.get("rows") or len(profile.get("columns", [])) < 2 for profile in profiles):
-            errors.append(f"{name}: empty or unlabelled profile")
-    elif kind in {"profile_events", "profile_feature_locations"}:
-        if not isinstance(value.get("events"), list):
-            errors.append(f"{name}: invalid event collection")
-    else:
-        errors.append(f"{name}: unknown structured kind {kind!r}")
-    return errors
-
-
-def extract_case(
-    case: Path,
-    family: str,
-    variant: str,
-    metrics: list[str],
-    *,
-    conditional_metrics: list[str] | None = None,
-) -> dict[str, Any]:
-    values: dict[str, Any] = {}
-    evidence: dict[str, list[str]] = {}
-    methods: dict[str, str] = {}
-    spalding, spalding_evidence = spalding_metrics(case) if family == "yPlusVerification" else ({}, [])
-    branchwise_spalding, branchwise_spalding_evidence = branchwise_spalding_metrics(case) if family == "yPlusVerification" else (None, [])
-    bubbles, bubble_evidence, bubble_errors = bubble_metrics(case, family) if family in {"risingBubble", "compressibleBubbleCollapse"} else ({}, [], [])
-    stirrer_power, stirrer_evidence = stirrer_power_history(case) if family == "MRF_stirredReactor" else (None, [])
-    riemann_profiles, riemann_evidence = named_sample_profiles(case, ("horizontal.xy", "vertical.xy")) if family == "riemann2D" else (None, [])
-    if family == "riemann2D" and riemann_profiles is None:
-        riemann_profiles, riemann_evidence = result_profile_tables(case, ("centreline", "centerline", "p_x", "p_y", "rho_x", "rho_y"))
-    if riemann_profiles is not None:
-        riemann_profiles = final_riemann_profiles(riemann_profiles)
-    riemann_events = profile_event_locations(riemann_profiles) if riemann_profiles is not None else None
-    nozzle_profiles, nozzle_evidence = named_profiles_containing(case, ("centerline",), ("p",)) if family == "nozzleCDV" else (None, [])
-    crossjet_profiles, crossjet_evidence = named_profiles_containing(case, ("trajectory", "centerline", "section"), ()) if family == "supersonicCrossJet" else (None, [])
-    mass_flow, mass_flow_evidence = explicit_mass_flow_history(case) if family in {"ERCOFTA_pump", "nozzleCDV"} else (None, [])
-    patch_pressure, patch_pressure_evidence = explicit_patch_pressure(case) if family == "ERCOFTA_pump" else (None, [])
-    retained_values, retained_evidence, retained_errors = {}, {}, []
-    if family == "ERCOFTA_pump":
-        retained_values, retained_evidence, retained_errors = pump_measurements(case)
-    crossjet_flux_ratio, crossjet_flux_evidence = crossjet_inlet_mass_flux_ratio(case) if family == "supersonicCrossJet" else (None, [])
-    phase_volume, phase_volume_evidence = phase_volume_history(case) if family == "MRF_stirredReactor" else (None, [])
-    average_speed, average_speed_evidence = volume_average_speed_history(case) if family == "MRF_stirredReactor" else (None, [])
-    speed_rms, speed_rms_evidence = volume_speed_rms_history(case) if family == "MRF_stirredReactor" else (None, [])
-    speed_final, speed_final_evidence = volume_average_speed_final(case) if family == "MRF_stirredReactor" else (None, [])
-    pressure_span, pressure_span_evidence = crossjet_interior_pressure_span(case) if family == "supersonicCrossJet" else (None, [])
-    conditional_metrics = conditional_metrics or []
-    requested_metrics = list(dict.fromkeys([*metrics, *conditional_metrics]))
-    for metric in requested_metrics:
-        if metric in {"Cd", "Cl", "Cm", "Cd_mean", "Cd_rms", "Cl_mean", "Cl_rms"}:
-            value, refs, method = extract_force_metric(case, metric)
-        elif metric in spalding:
-            value, refs, method = spalding[metric], spalding_evidence, "spalding_named_profile_or_endpoint.v1"
-        elif metric == "branchwise_wall_law_metrics" and branchwise_spalding is not None:
-            value, refs, method = branchwise_spalding, branchwise_spalding_evidence, "branchwise_spalding_metrics.v1"
-        elif metric in bubbles:
-            value, refs, method = bubbles[metric], bubble_evidence, "connected_gas_component_history.v1"
-        elif metric == "stirrer_power_history" and stirrer_power is not None:
-            value, refs, method = stirrer_power, stirrer_evidence, "named_stirrer_power_history.v1"
-        elif metric == "phase_volume_fraction_history" and phase_volume is not None:
-            value, refs, method = phase_volume, phase_volume_evidence, "volume_weighted_phase_fraction.v1"
-        elif metric == "volume_average_speed_history" and average_speed is not None:
-            value, refs, method = average_speed, average_speed_evidence, "volume_weighted_speed.v1"
-        elif metric == "volume_speed_rms_history" and speed_rms is not None:
-            value, refs, method = speed_rms, speed_rms_evidence, "volume_weighted_speed_rms.v1"
-        elif metric == "volume_average_speed_final" and speed_final is not None:
-            value, refs, method = speed_final, speed_final_evidence, "volume_weighted_final_speed.v1"
-        elif metric == "centerline_profiles" and riemann_profiles is not None:
-            value, refs, method = riemann_profiles, riemann_evidence, "named_centerline_profiles.v1"
-        elif metric == "event_locations" and riemann_events is not None:
-            value, refs, method = riemann_events, riemann_evidence, "local_abs_gradient_peaks.v1"
-        elif metric == "centerline_pressure_profile" and nozzle_profiles is not None:
-            value, refs, method = nozzle_profiles, nozzle_evidence, "named_centerline_pressure_profile.v1"
-        elif metric in retained_values:
-            # The retained-field measurement is the canonical path.  Agent
-            # emitted tables remain useful evidence, but a one-point table or
-            # a table with a different time grid must not mask a complete
-            # history available in the original fields.
-            value, refs, method = retained_values[metric], retained_evidence[metric], "retained_boundary_field_measurement.v1"
-        elif metric == "mass_flow_rate" and mass_flow is not None:
-            value, refs, method = mass_flow, mass_flow_evidence, "explicit_mass_flux_history.v1"
-        elif metric == "volumetric_flow_rate" and mass_flow is not None:
-            value, refs, method = mass_flow, mass_flow_evidence, "explicit_volumetric_flux_history.v1"
-        elif metric == "pressure_rise" and patch_pressure is not None:
-            value, refs, method = patch_pressure, patch_pressure_evidence, "named_patch_pressure_history.v1"
-        elif metric == "pressure_rise_history" and patch_pressure is not None:
-            value, refs, method = patch_pressure, patch_pressure_evidence, "named_patch_pressure_history.v1"
-        elif metric == "jet_centerline_trajectory" and crossjet_profiles is not None:
-            value, refs, method = crossjet_profiles, crossjet_evidence, "declared_jet_trajectory_profile.v1"
-        elif metric == "jet_to_mainstream_mass_flux_ratio" and crossjet_flux_ratio is not None:
-            value, refs, method = crossjet_flux_ratio, crossjet_flux_evidence, "named_inlet_mass_flux_ratio.v1"
-        elif metric == "interior_pressure_span" and pressure_span is not None:
-            value, refs, method = pressure_span, pressure_span_evidence, "internal_pressure_span_from_p_field.v1"
-        else:
-            value, refs, method = None, [], "not_implemented_without_declared_v3_evidence"
-        if value is not None and (not isinstance(value, float) or math.isfinite(value)):
-            values[metric] = value
-            evidence[metric] = refs
-            methods[metric] = method
-    extraction_errors = list(bubble_errors)
-    if "stirrer_power_history" in metrics and stirrer_power is None:
-        extraction_errors.append("stirrer_power_history: no named stirrer power evidence")
-    missing = sorted(set(metrics) - set(values))
-    principal_values = {name: values[name] for name in metrics if name in values}
-    conditional_values = {name: values[name] for name in conditional_metrics if name in values}
-    validation_errors = [
-        error for name, value in principal_values.items()
-        for error in structured_qoi_errors(name, value)
-    ]
-    diagnostic_qois = {name: value for name, value in bubbles.items() if name not in metrics}
-    if family == "yPlusVerification":
-        for name, value in spalding.items():
-            if name not in metrics:
-                diagnostic_qois[name] = value
-        if branchwise_spalding is not None and "branchwise_wall_law_metrics" not in metrics:
-            diagnostic_qois["branchwise_wall_law_metrics"] = branchwise_spalding
-    if stirrer_power is not None and "stirrer_power_history" not in metrics:
-        diagnostic_qois["stirrer_power_history"] = stirrer_power
-    if phase_volume is not None and "phase_volume_fraction_history" not in metrics:
-        diagnostic_qois["phase_volume_fraction_history"] = phase_volume
-    if nozzle_profiles is not None and "centerline_pressure_profile" not in metrics:
-        diagnostic_qois["centerline_pressure_profile"] = nozzle_profiles
-    if crossjet_profiles is not None and "jet_centerline_trajectory" not in metrics:
-        diagnostic_qois["jet_centerline_trajectory"] = crossjet_profiles
-    complete = not missing and not validation_errors and not extraction_errors
-    resolver = {
-        metric: {
-            "status": "selected" if metric in evidence else "unresolved",
-            "selected_evidence": sorted(set(evidence.get(metric, []))),
-            "method": methods.get(metric),
-            "physical_validation": "metric_extractor_contract.v1",
-        }
-        for metric in requested_metrics
-    }
-    return {
-        "schema_version": "foambench.qoi.candidate",
-        "case_id": f"{family}/{variant}",
-        "family": family,
-        "required_metrics": metrics,
-        "missing_metrics": missing,
-        "qois": principal_values,
-        "conditional_qois": conditional_values,
-        "conditional_status": {
-            name: "available" if name in conditional_values else "not_assessed_missing_evidence"
-            for name in conditional_metrics
-        },
-        "diagnostic_qois": diagnostic_qois,
-        "evidence": evidence,
-        "metric_methods": methods,
-        "evidence_contract": canonical_evidence_manifest(),
-        "resolver_report": resolver,
-        "extraction_errors": extraction_errors,
-        "retained_field_diagnostics": retained_errors,
-        "status": "complete" if complete else "incomplete",
-        "health": {
-            "status": "pass" if complete else "incomplete",
-            "checks": {
-                "principal_qoi_complete": not missing,
-                "structured_qoi_valid": not validation_errors,
-                "principal_extraction_error_free": not extraction_errors,
-                "no_proxy_fallback": True,
-            },
-            "validation_errors": [*validation_errors, *extraction_errors],
-        },
-    }
-
-
-def metric_anomalies(cases: dict[str, dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
-    grouped: dict[tuple[str, str, str], list[tuple[str, float]]] = {}
-    anomalies: list[dict[str, Any]] = []
-    review: list[dict[str, Any]] = []
-    for case_id, record in cases.items():
-        for metric, value in record.get("qois", {}).items():
-            if isinstance(value, (int, float)):
-                grouped.setdefault((record["family"], str(record.get("branch_id")), metric), []).append((case_id, float(value)))
-            elif isinstance(value, dict) and value.get("kind") == "component_trajectory":
-                expected_components = 2 if case_id == "compressibleBubbleCollapse/10" else 1
-                if len(value.get("series", [])) != expected_components:
-                    review.append({
-                        "type": "unexpected_component_count",
-                        "case_id": case_id,
-                        "family": record["family"],
-                        "metric": metric,
-                        "expected": expected_components,
-                        "observed": len(value.get("series", [])),
-                        "interpretation": "review physical breakup versus threshold or mesh-induced disconnection",
-                    })
-                for series in value.get("series", []):
-                    for point in series.get("points", []):
-                        sample = point.get("value")
-                        if not isinstance(sample, (int, float)) or not math.isfinite(sample):
-                            anomalies.append({
-                                "type": "invalid_trajectory_point",
-                                "case_id": case_id,
-                                "family": record["family"],
-                                "branch_id": record.get("branch_id"),
-                                "metric": metric,
-                                "component_id": series.get("component_id"),
-                                "time": point.get("time"),
-                                "value": sample,
-                                "quality_flag": point.get("quality_flag"),
-                            })
-    for (family, branch, metric), rows in sorted(grouped.items()):
-        values = [value for _, value in rows]
-        if any(not math.isfinite(value) for value in values):
-            anomalies.append({"type": "nonfinite", "family": family, "branch_id": branch, "metric": metric})
-            continue
-        if values and all(value == 0 for value in values):
-            anomalies.append({"type": "all_zero", "family": family, "branch_id": branch, "metric": metric, "case_count": len(values)})
-        if len(values) >= 2 and max(values) == min(values):
-            anomalies.append({"type": "constant_metric", "family": family, "branch_id": branch, "metric": metric, "value": values[0]})
-        nonzero = [abs(value) for value in values if value != 0]
-        if len(nonzero) >= 2 and max(nonzero) / min(nonzero) > 1e6:
-            review.append({"type": "dynamic_range_gt_1e6", "family": family, "branch_id": branch, "metric": metric, "minimum_abs": min(nonzero), "maximum_abs": max(nonzero), "interpretation": "review against declared variant relation; not automatically invalid"})
-        if len(values) >= 5:
-            median = statistics.median(values)
-            deviations = [abs(value - median) for value in values]
-            mad = statistics.median(deviations)
-            if mad > 0:
-                for case_id, value in rows:
-                    score = abs(value - median) / mad
-                    if score > 8:
-                        review.append({"type": "robust_outlier", "family": family, "branch_id": branch, "metric": metric, "case_id": case_id, "value": value, "median": median, "mad_score": score, "interpretation": "review against declared variant relation; not automatically invalid"})
-            elif any(value != median for value in values):
-                for case_id, value in rows:
-                    if value != median:
-                        review.append({"type": "robust_outlier", "family": family, "branch_id": branch, "metric": metric, "case_id": case_id, "value": value, "median": median, "mad_score": None, "interpretation": "review against declared variant relation; not automatically invalid"})
-    return anomalies, review
-
-
-def extract_campaign(run_roots: Path | list[Path], design: dict[str, Any]) -> dict[str, Any]:
-    roots = [run_roots] if isinstance(run_roots, Path) else list(run_roots)
-    cases: dict[str, dict[str, Any]] = {}
-    missing_case_dirs: list[str] = []
-    for family in design.get("families", []):
-        family_name = family["family"]
-        variants = sorted({variant for branch in family.get("branches", []) for variant in branch.get("cases", [])}, key=int)
-        for variant in variants:
-            branch, metrics = required_metrics(family, variant)
-            conditionals = [
-                item["name"] for item in next(
-                    item for item in family.get("branches", []) if variant in item.get("cases", [])
-                ).get("conditional_qois", [])
-            ]
-            case_id = f"{family_name}/{variant}"
-            case_dir = None
-            for root in roots:
-                case_dir = locate_case(root, family_name, variant)
-                if case_dir is not None:
-                    break
-            if case_dir is None:
-                missing_case_dirs.append(case_id)
-                continue
-            record = extract_case(
-                case_dir, family_name, variant, metrics, conditional_metrics=conditionals
-            )
-            record["branch_id"] = branch
-            record["case_dir"] = str(case_dir)
-            cases[case_id] = record
-    complete = sum(record["status"] == "complete" for record in cases.values())
-    anomalies, review = metric_anomalies(cases)
-    design_findings = [
-        {
-            "type": "reference_configuration_mismatch",
-            "case_id": "compressibleBubbleCollapse/2",
-            "severity": "resolved_by_contract_scope",
-            "finding": "The materialized reference contains a single 50 um sphere. The QoI branch is restricted to that observed single-bubble response and makes no unsupported radius-scaling claim.",
-            "evidence": "compressibleBubbleCollapse__2/full_run_case/system/setFieldsDict",
-            "action": "Retain the materialized_single_bubble_response branch unless separate radius subcases are generated.",
-        },
-        {
-            "type": "axisymmetric_geometry_mismatch",
-            "case_id": "compressibleBubbleCollapse/10",
-            "severity": "resolved_by_contract_scope",
-            "finding": "The off-axis gas region in the 5 degree wedge is evaluated under an explicit axisymmetric connected-region convention, not described as an ordinary second 3D sphere.",
-            "evidence": "compressibleBubbleCollapse__10/full_run_case/system/setFieldsDict and constant/polyMesh/boundary",
-            "action": "Retain the axisymmetric_ring_interaction branch unless a genuinely 3D two-bubble case is materialized.",
-        },
-        {
-            "type": "reference_coverage_gap",
-            "severity": "blocking",
-            "finding": "The 90-case main materialized run has no riemann2D directories. A separate riemann2d_parallel run exists, but it has not yet been merged into the unified reference audit and its diagnostics are not yet mapped to the profile/event contract.",
-            "evidence": "anonymous-reference/extended/riemann2D",
-            "action": "validate and import the ten separate Riemann runs into the unified current audit; do not synthesize profiles",
-        },
-    ]
-    if any(root.name == "materialized" and root.parent.name.startswith("riemann2d_parallel") for root in roots):
-        design_findings[-1]["severity"] = "resolved_for_current_audit"
-        design_findings[-1]["finding"] = "The separate ten-case Riemann run is included in this audit; profile and feature evidence is now extracted, while reference uncertainty remains a comparison-layer concern."
-    return {
-        "schema_version": "foambench.qoi_extraction_audit.v1",
-        "generated_at": utc_now(),
-        "run_roots": [str(root) for root in roots],
-        "case_count": len(cases),
-        "complete_case_count": complete,
-        "coverage_fraction": complete / len(cases) if cases else 0.0,
-        "missing_case_dirs": missing_case_dirs,
-        "structural_anomalies": anomalies,
-        "review_candidates": review,
-        "design_findings": design_findings,
-        "cases": cases,
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--run-root", type=Path, action="append", required=True, help="reference run root; repeat to merge independent materialized campaigns")
-    parser.add_argument("--design", type=Path, default=DEFAULT_DESIGN)
-    parser.add_argument("--output", type=Path, required=True)
-    args = parser.parse_args()
-    design = json.loads(args.design.read_text(encoding="utf-8"))
-    roots = [root.resolve(strict=True) for root in args.run_root]
-    report = extract_campaign(roots, design)
-    write_json(args.output.resolve(), report)
-    print(json.dumps({key: report[key] for key in ("case_count", "complete_case_count", "coverage_fraction", "missing_case_dirs", "structural_anomalies", "review_candidates")}, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

benchmarks/evaluation/field_candidate.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from .basic_advanced import extract
-
-
-def extract_field_candidate(
-    case_dir: Path,
-    case_id: str,
-    requested_metrics: list[str],
-    *,
-    required_metrics: list[str] | None = None,
-    log_paths: list[Path] | None = None,
-) -> dict[str, Any]:
-    return extract(
-        case_dir,
-        case_id,
-        requested_metrics,
-        required_metrics=required_metrics,
-        log_paths=log_paths,
-    )

benchmarks/evaluation/field_extractor.py

@@ -1,421 +0,0 @@
-#!/usr/bin/env python3
-"""Extract the numeric signatures used by the FoamBench v13 QoI contracts.
-
-The definitions in this module intentionally preserve the extractor that
-produced the checked-in reference JSON files.  Candidate runs must use this
-same implementation so reference and candidate values have identical field,
-ordering, and proxy definitions.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import re
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-ROOT = Path(__file__).resolve().parents[2]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-from benchmarks.evaluation.foam_io import field_path, magnitude, read_text
-
-
-NUMBER_RE = re.compile(r"[-+]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][-+]?\d+)?")
-VECTOR_RE = re.compile(r"\(\s*([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\s*\)")
-RESIDUAL_RE = re.compile(
-    r"Solving for (?P<field>[^,]+), Initial residual = (?P<initial>[-+0-9.eE]+), "
-    r"Final residual = (?P<final>[-+0-9.eE]+), No Iterations (?P<iterations>\d+)"
-)
-COURANT_RE = re.compile(r"Courant Number mean:\s*(?P<mean>[-+0-9.eE]+)\s+max:\s*(?P<max>[-+0-9.eE]+)")
-FATAL_RE = re.compile(
-    r"FOAM FATAL (?:ERROR|IO ERROR)|(?m:^\s*(?:Floating point exception|Segmentation fault)(?:\s|$))",
-    re.I,
-)
-
-FAMILY_PROBLEM_TYPES = {
-    "BernardCells": "buoyant_thermal_convection",
-    "Cavity": "lid_driven_cavity",
-    "Cylinder": "cylinder_wake",
-    "counterFlowFlame2D": "counterflow_flame",
-    "damBreakWithObstacle": "free_surface_vof",
-    "forwardStep": "compressible_shock",
-    "obliqueShock": "compressible_shock",
-    "pitzDaily": "separated_internal_flow",
-    "shallowWaterWithSquareBump": "shallow_water_bump",
-    "squareBend": "compressible_bend",
-    "wedge": "compressible_shock",
-}
-FAMILY_ALIASES = {name.lower(): name for name in FAMILY_PROBLEM_TYPES}
-
-
-class ExtractionError(RuntimeError):
-    """Raised when a field exists but cannot be interpreted safely."""
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def write_json(path: Path, data: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    temporary.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-    temporary.replace(path)
-
-
-def strip_comments(text: str) -> str:
-    return re.sub(r"//.*", "", re.sub(r"/\*.*?\*/", "", text, flags=re.S))
-
-
-def foam_entry(text: str, key: str) -> str | None:
-    match = re.search(rf"^\s*{re.escape(key)}\s+([^;\s]+)\s*;", strip_comments(text), re.M)
-    return match.group(1) if match else None
-
-
-def latest_time_dir(case_dir: Path) -> tuple[float | None, Path | None]:
-    choices: list[tuple[float, Path]] = []
-    if not case_dir.is_dir():
-        return None, None
-    for child in case_dir.iterdir():
-        if not child.is_dir():
-            continue
-        try:
-            choices.append((float(child.name), child))
-        except ValueError:
-            continue
-    return max(choices, key=lambda item: item[0]) if choices else (None, None)
-
-
-def clean_internal_field_text(text: str) -> str:
-    marker = text.find("internalField")
-    if marker < 0:
-        return ""
-    text = text[marker:]
-    boundary = text.find("boundaryField")
-    return text[:boundary] if boundary >= 0 else text
-
-
-def ensure_ascii_field(path: Path, text: str) -> None:
-    header = text[: min(len(text), 4096)]
-    if re.search(r"\bformat\s+binary\s*;", header):
-        raise ExtractionError(
-            f"binary OpenFOAM field is not supported directly: {path}; "
-            "convert the latest time to ASCII with foamFormatConvert before evaluation"
-        )
-
-
-def parse_scalar_field(path: Path) -> list[float]:
-    raw = read_text(path)
-    ensure_ascii_field(path, raw)
-    text = clean_internal_field_text(raw)
-    if not text:
-        return []
-    uniform = re.search(r"internalField\s+uniform\s+([-+0-9.eE]+)", text)
-    if uniform:
-        return [float(uniform.group(1))]
-    start, end = text.find("("), text.rfind(")")
-    body = text[start + 1 : end] if start >= 0 and end > start else text
-    return [float(token) for token in NUMBER_RE.findall(body)]
-
-
-def parse_vector_field(path: Path) -> list[tuple[float, float, float]]:
-    raw = read_text(path)
-    ensure_ascii_field(path, raw)
-    text = clean_internal_field_text(raw)
-    if not text:
-        return []
-    uniform = re.search(
-        r"internalField\s+uniform\s+\(([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\)", text
-    )
-    if uniform:
-        return [(float(uniform.group(1)), float(uniform.group(2)), float(uniform.group(3)))]
-    return [(float(m.group(1)), float(m.group(2)), float(m.group(3))) for m in VECTOR_RE.finditer(text)]
-
-
-def scalar(latest: Path | None, name: str) -> list[float]:
-    path = field_path(latest, name)
-    return parse_scalar_field(path) if path else []
-
-
-def vector(latest: Path | None, name: str) -> list[tuple[float, float, float]]:
-    path = field_path(latest, name)
-    return parse_vector_field(path) if path else []
-
-
-def finite_values(values: list[float]) -> list[float]:
-    return [value for value in values if math.isfinite(value)]
-
-
-def stats(values: list[float]) -> dict[str, float]:
-    values = finite_values(values)
-    if not values:
-        return {}
-    low, high = min(values), max(values)
-    return {"min": low, "max": high, "mean": sum(values) / len(values), "range": high - low}
-
-
-def add_stats(qois: dict[str, float], prefix: str, values: list[float]) -> None:
-    qois.update({f"{prefix}_{suffix}": value for suffix, value in stats(values).items()})
-
-
-def add_common_field_qois(qois: dict[str, float], latest: Path | None) -> None:
-    velocities = vector(latest, "U")
-    if velocities:
-        add_stats(qois, "velocity_magnitude", magnitude(velocities))
-        x, y, z = velocities[len(velocities) // 2]
-        qois.update({"center_u": x, "center_v": y, "center_w": z, "center_speed": math.sqrt(x*x + y*y + z*z)})
-    for name in ("p", "p_rgh", "T", "rho", "nut", "k", "epsilon", "omega", "nuTilda"):
-        values = scalar(latest, name)
-        if values:
-            add_stats(qois, name.replace(".", "_"), values)
-    vorticity = vector(latest, "vorticity")
-    if vorticity:
-        add_stats(qois, "vorticity_magnitude", magnitude(vorticity))
-
-
-def add_compressible_qois(qois: dict[str, float], latest: Path | None) -> None:
-    temperatures = scalar(latest, "T")
-    speeds = magnitude(vector(latest, "U"))
-    if temperatures and speeds:
-        mach = [
-            speed / math.sqrt(1.4 * 0.7143 * temperature)
-            for speed, temperature in zip(speeds, temperatures)
-            if temperature > 0
-        ]
-        add_stats(qois, "mach", mach)
-    pressures = scalar(latest, "p")
-    if pressures:
-        summary = stats(pressures)
-        mean, low, high = summary.get("mean"), summary.get("min"), summary.get("max")
-        if mean is not None and low is not None and high is not None and abs(mean) > 1e-12:
-            qois["pressure_ratio_max_over_mean"] = high / mean
-            qois["pressure_ratio_max_over_min"] = high / max(abs(low), 1e-12)
-        if len(pressures) > 1:
-            qois["shock_strength_proxy_max_dp_index"] = max(abs(b - a) for a, b in zip(pressures, pressures[1:]))
-
-
-def add_flame_qois(qois: dict[str, float], latest: Path | None) -> None:
-    qdot = scalar(latest, "Qdot")
-    if qdot:
-        add_stats(qois, "Qdot", qdot)
-        qois["integrated_Qdot_proxy"] = sum(finite_values(qdot))
-    for species in ("CH4", "O2", "CO2", "H2O", "N2", "Ydefault"):
-        values = scalar(latest, species)
-        if values:
-            add_stats(qois, species, values)
-
-
-def add_vof_qois(qois: dict[str, float], latest: Path | None) -> None:
-    alpha = scalar(latest, "alpha.water")
-    if not alpha:
-        return
-    clipped = [min(1.0, max(0.0, value)) for value in alpha if math.isfinite(value)]
-    add_stats(qois, "alpha_water", clipped)
-    if clipped:
-        qois["alpha_water_volume_proxy"] = sum(clipped)
-        qois["alpha_water_wet_fraction"] = sum(value > 0.5 for value in clipped) / len(clipped)
-        last_wet = max((index for index, value in enumerate(clipped) if value > 0.5), default=0)
-        qois["alpha_water_front_index_fraction"] = last_wet / max(len(clipped) - 1, 1)
-
-
-def add_shallow_water_qois(qois: dict[str, float], latest: Path | None) -> None:
-    heights, total_heights, fluxes = scalar(latest, "h"), scalar(latest, "hTotal"), vector(latest, "hU")
-    if heights:
-        add_stats(qois, "h", heights)
-    if total_heights:
-        add_stats(qois, "hTotal", total_heights)
-    velocities: list[float] = []
-    froude: list[float] = []
-    for height, flux in zip(heights, fluxes):
-        if abs(height) <= 1e-12:
-            continue
-        speed = math.sqrt(sum(component * component for component in flux)) / abs(height)
-        velocities.append(speed)
-        if height > 0:
-            froude.append(speed / math.sqrt(9.81 * height))
-    add_stats(qois, "shallow_velocity", velocities)
-    add_stats(qois, "froude", froude)
-
-
-def infer_family(case_id: str) -> str:
-    first = case_id.split("/", 1)[0]
-    return FAMILY_ALIASES.get(first.lower(), first)
-
-
-def infer_problem_type(family: str, latest: Path | None) -> str:
-    if family in FAMILY_PROBLEM_TYPES:
-        return FAMILY_PROBLEM_TYPES[family]
-    names = {path.name.removesuffix(".gz") for path in latest.iterdir() if path.is_file()} if latest else set()
-    if "alpha.water" in names:
-        return "free_surface_vof"
-    if {"h", "hU"} & names:
-        return "shallow_water_bump"
-    if "Qdot" in names or {"CH4", "O2"} & names:
-        return "counterflow_flame"
-    if {"p", "T", "U"} <= names:
-        return "compressible_flow"
-    return "generic_cfd"
-
-
-def parse_log_metrics(case_dir: Path, log_paths: list[Path] | None = None) -> tuple[dict[str, float], list[str]]:
-    """Extract residual/Courant metrics from case logs and optional run logs.
-
-    FoamAgent writes solver output into ``case/log.*``. EasyFoam keeps the
-    same output under ``workspace/runs/formal-*/`` and records the paths in
-    ``run_record.json``. ``log_paths`` lets an offline evaluator consume that
-    evidence without copying or modifying the generated case.
-    """
-    candidates = sorted(
-        {path for pattern in ("log.foamRun*", "log.*") for path in case_dir.glob(pattern) if path.is_file()},
-        key=lambda path: (path.name != "log.foamRun", path.name),
-    )
-    if log_paths:
-        candidates.extend(path for path in log_paths if path.is_file() and path not in candidates)
-    texts = [(path, read_text(path)) for path in candidates]
-    residuals: list[float] = []
-    courants: list[float] = []
-    fatal_logs: list[str] = []
-    for path, text in texts:
-        if FATAL_RE.search(text):
-            fatal_logs.append(path.name)
-        residuals.extend(float(match.group("final")) for match in RESIDUAL_RE.finditer(text))
-        courants.extend(float(match.group("max")) for match in COURANT_RE.finditer(text))
-    qois: dict[str, float] = {}
-    if residuals:
-        qois.update({"max_final_residual": max(residuals), "last_final_residual": residuals[-1]})
-    if courants:
-        qois.update({"max_courant": max(courants), "last_courant": courants[-1]})
-    return qois, fatal_logs
-
-
-def required_metrics(reference_path: Path | None, case_id: str) -> tuple[list[str] | None, dict[str, Any] | None]:
-    if reference_path is None:
-        return None, None
-    data = json.loads(reference_path.read_text(encoding="utf-8"))
-    cases = data.get("cases") if isinstance(data, dict) else None
-    if not isinstance(cases, dict) or not isinstance(cases.get(case_id), dict):
-        raise ValueError(f"case {case_id!r} is absent from reference contract {reference_path}")
-    record = cases[case_id]
-    qois = record.get("qois")
-    if not isinstance(qois, dict):
-        raise ValueError(f"case {case_id!r} has no qois object in {reference_path}")
-    return sorted(qois), record
-
-
-def extract_case_qois(
-    case_dir: Path,
-    case_id: str,
-    reference_path: Path | None = None,
-    log_paths: list[Path] | None = None,
-) -> dict[str, Any]:
-    case_dir = case_dir.resolve(strict=True)
-    latest_time, latest = latest_time_dir(case_dir)
-    family = infer_family(case_id)
-    problem_type = infer_problem_type(family, latest)
-    required, reference = required_metrics(reference_path, case_id)
-    if reference and isinstance(reference.get("problem_type"), str):
-        problem_type = reference["problem_type"]
-
-    qois, fatal_logs = parse_log_metrics(case_dir, log_paths=log_paths)
-    add_common_field_qois(qois, latest)
-    if problem_type in {"compressible_shock", "compressible_flow", "compressible_bend"}:
-        add_compressible_qois(qois, latest)
-    if problem_type == "counterflow_flame":
-        add_flame_qois(qois, latest)
-    if problem_type == "free_surface_vof":
-        add_vof_qois(qois, latest)
-    if problem_type == "shallow_water_bump":
-        add_shallow_water_qois(qois, latest)
-    qois = {name: value for name, value in sorted(qois.items()) if math.isfinite(float(value))}
-    missing = sorted(set(required or []) - set(qois))
-    unexpected = sorted(set(qois) - set(required or [])) if required is not None else []
-    control = read_text(case_dir / "system" / "controlDict")
-    return {
-        "schema_version": "foambench.qoi.candidate.v1",
-        "generated_at": utc_now(),
-        "producer": "benchmarks/evaluation/qoi_reference.py",
-        "case_id": case_id,
-        "family": family,
-        "problem_type": problem_type,
-        "application": foam_entry(control, "application"),
-        "solver": foam_entry(control, "solver"),
-        "latest_time": latest_time,
-        "qois": qois,
-        "coverage": {
-            "required_count": len(required) if required is not None else None,
-            "extracted_required_count": len(required) - len(missing) if required is not None else None,
-            "fraction": (len(required) - len(missing)) / len(required) if required else None,
-            "missing_metrics": missing,
-            "unexpected_metrics": unexpected,
-        },
-        "fatal_logs": fatal_logs,
-        "status": "complete" if latest and not missing and not fatal_logs else "incomplete",
-    }
-
-
-def find_case_dirs(root: Path) -> list[Path]:
-    return sorted({control.parents[1] for control in root.rglob("system/controlDict")})
-
-
-def infer_case_id(case_dir: Path, root: Path) -> str:
-    relative = case_dir.resolve().relative_to(root.resolve())
-    parts = list(relative.parts)
-    if parts and parts[-1] in {"case", "workspace"}:
-        parts.pop()
-    if len(parts) >= 2 and parts[-1].startswith("replicate_"):
-        parts.pop()
-    return "/".join(parts[-2:]) if len(parts) >= 2 else (parts[0] if parts else case_dir.name)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--case", type=Path, action="append", default=[])
-    parser.add_argument("--case-id", action="append", default=[])
-    parser.add_argument("--root", type=Path)
-    parser.add_argument("--reference-qois", type=Path)
-    parser.add_argument("--output", type=Path)
-    parser.add_argument("--require-complete", action="store_true")
-    parser.add_argument("--json", action="store_true")
-    args = parser.parse_args()
-
-    explicit_cases = [path.resolve(strict=True) for path in args.case]
-    if args.case_id and len(args.case_id) != len(explicit_cases):
-        parser.error("--case-id count must match --case count")
-    selected = [(path, args.case_id[index]) for index, path in enumerate(explicit_cases)]
-    if args.root:
-        root = args.root.resolve(strict=True)
-        selected.extend((path, infer_case_id(path, root)) for path in find_case_dirs(root) if path not in explicit_cases)
-    if not selected:
-        parser.error("provide --case or --root")
-
-    records: dict[str, Any] = {}
-    for case_dir, case_id in selected:
-        records[case_id] = extract_case_qois(case_dir, case_id, args.reference_qois)
-    incomplete = sorted(case_id for case_id, record in records.items() if record["status"] != "complete")
-    report = {
-        "schema_version": "foambench.qoi.candidates.v1",
-        "generated_at": utc_now(),
-        "case_count": len(records),
-        "complete_count": len(records) - len(incomplete),
-        "incomplete_cases": incomplete,
-        "cases": records,
-    }
-    if args.output:
-        write_json(args.output.resolve(), report)
-    if args.json or not args.output:
-        print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
-    else:
-        print(f"qoi_report: {args.output.resolve()} ({report['complete_count']}/{len(records)} complete)")
-    return 1 if args.require_complete and incomplete else 0
-
-
-if __name__ == "__main__":
-    try:
-        raise SystemExit(main())
-    except (OSError, ValueError, ExtractionError, json.JSONDecodeError) as exc:
-        print(f"extract_foambench_qois.py: error: {exc}", file=sys.stderr)
-        raise SystemExit(2)

benchmarks/evaluation/foam.py

@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-from .foam_io import read_text
-
-NUMBER = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?"
-TIME_RE = re.compile(rf"(?m)^\s*Time\s*=\s*({NUMBER})\s*s?\s*$")
-FATAL_RE = re.compile(
-    r"FOAM FATAL (?:ERROR|IO ERROR)|(?m:^\s*(?:Floating point exception|Segmentation fault)(?:\s|$))",
-    re.I,
-)
-NONFINITE_RE = re.compile(r"(?<![A-Za-z])[-+]?(?:nan|inf(?:inity)?)(?![A-Za-z])", re.I)
-
-
-def final_time_dirs(case_dir: Path | None) -> tuple[float | None, list[Path], str]:
-    if case_dir is None or not case_dir.is_dir():
-        return None, [], "missing"
-    values: list[tuple[float, Path]] = []
-    for path in case_dir.iterdir():
-        if not path.is_dir():
-            continue
-        try:
-            value = float(path.name)
-        except ValueError:
-            continue
-        if value > 0:
-            values.append((value, path))
-    if values:
-        latest = max(value for value, _ in values)
-        return latest, [path for value, path in values if value == latest], "reconstructed"
-    processors = sorted(
-        (path for path in case_dir.iterdir() if path.is_dir() and re.fullmatch(r"processor\d+", path.name)),
-        key=lambda path: int(path.name[9:]),
-    )
-    processor_times = []
-    for processor in processors:
-        found = []
-        for path in processor.iterdir():
-            if not path.is_dir():
-                continue
-            try:
-                value = float(path.name)
-            except ValueError:
-                continue
-            if value > 0:
-                found.append((value, path))
-        processor_times.append(sorted(found))
-    if processors and all(processor_times):
-        common = set(value for value, _ in processor_times[0])
-        for values in processor_times[1:]:
-            common.intersection_update(value for value, _ in values)
-        if not common:
-            return None, [], "missing"
-        latest = max(common)
-        selected = [
-            next(path for value, path in values if value == latest)
-            for values in processor_times
-        ]
-        return latest, selected, "decomposed"
-    return None, [], "missing"
-
-
-def latest_time_dir(case_dir: Path | None) -> tuple[float | None, Path | None]:
-    latest, directories, _ = final_time_dirs(case_dir)
-    return latest, directories[0] if directories else None
-
-
-def read_logs(paths: tuple[Path, ...] | list[Path]) -> str:
-    return "\n".join(read_text(path) for path in paths if path.is_file())
-
-
-def normal_end(log_text: str) -> bool:
-    return re.search(r"(?m)^\s*End\s*$", log_text) is not None
-
-
-def converged_early(log_text: str) -> bool:
-    return re.search(r"solution converged|convergence criterion satisfied", log_text, re.I) is not None
-
-
-def final_log_time(log_text: str) -> float | None:
-    values = [float(match.group(1)) for match in TIME_RE.finditer(log_text)]
-    return values[-1] if values else None

benchmarks/evaluation/foam_arrays.py

@@ -1,129 +0,0 @@
-#!/usr/bin/env python3
-"""Read complete OpenFOAM primitive arrays for v3 scientific QoIs."""
-from __future__ import annotations
-
-import gzip
-import re
-import struct
-from pathlib import Path
-from typing import Literal
-
-
-NUMBER = rb"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?"
-
-
-class FoamArrayError(RuntimeError):
-    """Raised when a primitive array cannot be decoded unambiguously."""
-
-
-def _bytes(path: Path) -> bytes:
-    return gzip.decompress(path.read_bytes()) if path.suffix == ".gz" else path.read_bytes()
-
-
-def _header(data: bytes) -> bytes:
-    end = data.find(b"// * * *")
-    return data[: end if end >= 0 else min(len(data), 4096)]
-
-
-def _format(data: bytes) -> Literal["ascii", "binary"]:
-    match = re.search(rb"\bformat\s+(ascii|binary)\s*;", _header(data))
-    if not match:
-        raise FoamArrayError("OpenFOAM header has no format entry")
-    return match.group(1).decode("ascii")  # type: ignore[return-value]
-
-
-def _arch(data: bytes) -> tuple[str, int, int]:
-    match = re.search(rb'\barch\s+"([^\"]+)"\s*;', _header(data))
-    arch = match.group(1).decode("ascii") if match else "LSB;label=32;scalar=64"
-    endian = ">" if arch.startswith("MSB") else "<"
-    label = int(re.search(r"label=(32|64)", arch).group(1)) if "label=" in arch else 32
-    scalar = int(re.search(r"scalar=(32|64)", arch).group(1)) if "scalar=" in arch else 64
-    return endian, label, scalar
-
-
-def _list_payload(data: bytes, marker: bytes | None = None) -> tuple[int, bytes]:
-    if marker is None:
-        header_end = data.find(b"// * * *")
-        search = data[header_end if header_end >= 0 else 0 :]
-        match = re.search(rb"\b(\d+)\s*\(", search)
-        offset = (header_end if header_end >= 0 else 0) + (match.end() if match else 0)
-    else:
-        match = re.search(marker + rb"\s+(\d+)\s*\(", data)
-        offset = match.end() if match else 0
-    if not match:
-        raise FoamArrayError("OpenFOAM nonuniform list header was not found")
-    while offset < len(data) and data[offset : offset + 1] in (b"\n", b"\r"):
-        offset += 1
-    return int(match.group(1)), data[offset:]
-
-
-def _ascii_body(payload: bytes) -> bytes:
-    end = payload.rfind(b")")
-    return payload[:end] if end >= 0 else payload
-
-
-def read_scalar_field(path: Path) -> list[float]:
-    data = _bytes(path)
-    uniform = re.search(rb"internalField\s+uniform\s+(" + NUMBER + rb")", data)
-    if uniform:
-        return [float(uniform.group(1))]
-    count, payload = _list_payload(data, rb"internalField\s+nonuniform\s+List<scalar>")
-    if _format(data) == "ascii":
-        values = [float(token) for token in re.findall(NUMBER, _ascii_body(payload))[:count]]
-    else:
-        endian, _, scalar_bits = _arch(data)
-        code = "f" if scalar_bits == 32 else "d"
-        size = scalar_bits // 8
-        values = list(struct.unpack(f"{endian}{count}{code}", payload[: count * size]))
-    if len(values) != count:
-        raise FoamArrayError(f"{path}: declared {count} scalars but decoded {len(values)}")
-    return values
-
-
-def read_vector_field(path: Path) -> list[tuple[float, float, float]]:
-    data = _bytes(path)
-    count, payload = _list_payload(data, rb"internalField\s+nonuniform\s+List<vector>")
-    return _decode_vectors(path, data, count, payload)
-
-
-def read_vector_list(path: Path) -> list[tuple[float, float, float]]:
-    data = _bytes(path)
-    count, payload = _list_payload(data)
-    return _decode_vectors(path, data, count, payload)
-
-
-def _decode_vectors(path: Path, data: bytes, count: int, payload: bytes) -> list[tuple[float, float, float]]:
-    if _format(data) == "ascii":
-        rows = re.findall(rb"\(\s*(" + NUMBER + rb")\s+(" + NUMBER + rb")\s+(" + NUMBER + rb")\s*\)", _ascii_body(payload))
-        values = [(float(x), float(y), float(z)) for x, y, z in rows[:count]]
-    else:
-        endian, _, scalar_bits = _arch(data)
-        code = "f" if scalar_bits == 32 else "d"
-        size = scalar_bits // 8
-        flat = struct.unpack(f"{endian}{count * 3}{code}", payload[: count * 3 * size])
-        values = list(zip(flat[0::3], flat[1::3], flat[2::3]))
-    if len(values) != count:
-        raise FoamArrayError(f"{path}: declared {count} vectors but decoded {len(values)}")
-    return values
-
-
-def read_label_list(path: Path) -> list[int]:
-    data = _bytes(path)
-    count, payload = _list_payload(data)
-    if _format(data) == "ascii":
-        values = [int(token) for token in re.findall(rb"[-+]?\d+", _ascii_body(payload))[:count]]
-    else:
-        endian, label_bits, _ = _arch(data)
-        code = "i" if label_bits == 32 else "q"
-        size = label_bits // 8
-        values = list(struct.unpack(f"{endian}{count}{code}", payload[: count * size]))
-    if len(values) != count:
-        raise FoamArrayError(f"{path}: declared {count} labels but decoded {len(values)}")
-    return values
-
-
-def foam_path(directory: Path, name: str) -> Path | None:
-    for candidate in (directory / name, directory / f"{name}.gz"):
-        if candidate.is_file():
-            return candidate
-    return None

benchmarks/evaluation/foam_field.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-import gzip
-import math
-import mmap
-import re
-import struct
-from pathlib import Path
-from typing import Any, Iterable
-
-NUMBER = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?"
-NONFINITE_RE = re.compile(r"(?<![A-Za-z])[-+]?(?:nan|inf(?:inity)?)(?![A-Za-z])", re.I)
-FIELD_CLASS_RE = re.compile(
-    r"\bclass\s+(?P<class>(?:vol|surface|point)(?:Scalar|Vector|SphericalTensor|SymmTensor|Tensor)Field)\s*;"
-)
-FORMAT_RE = re.compile(r"\bformat\s+(?P<format>ascii|binary)\s*;")
-OBJECT_RE = re.compile(r"\bobject\s+(?P<object>[^;\s]+)\s*;")
-LIST_RE = re.compile(
-    rb"nonuniform\s+(?:List<)?(?P<type>scalar|vector|sphericalTensor|symmTensor|tensor|label)>?"
-    rb"\s+(?P<count>\d+)\s*\("
-)
-COMPONENTS = {"scalar": 1, "vector": 3, "sphericalTensor": 1, "symmTensor": 6, "tensor": 9, "label": 1}
-
-
-def _stats(values: Iterable[float]) -> dict[str, Any]:
-    low, high, count, nonfinite = math.inf, -math.inf, 0, 0
-    for value in values:
-        count += 1
-        if math.isfinite(value):
-            low, high = min(low, value), max(high, value)
-        else:
-            nonfinite += 1
-    return {
-        "count": count,
-        "finite": nonfinite == 0,
-        "nonfinite_count": nonfinite,
-        "min": None if low == math.inf else low,
-        "max": None if high == -math.inf else high,
-    }
-
-
-def _binary_list_stats(
-    data: bytes | mmap.mmap,
-    match: re.Match[bytes],
-    width: int,
-    byte_order: str,
-) -> dict[str, Any]:
-    kind = match.group("type").decode("ascii")
-    count = int(match.group("count"))
-    item_count = count * COMPONENTS[kind]
-    start, end = match.end(), match.end() + item_count * width
-    if end > len(data) or not bytes(data[end : min(len(data), end + 16)]).lstrip().startswith(b")"):
-        raise ValueError("binary field list does not match its declaration")
-    unpacked = struct.iter_unpack(byte_order + ("d" if width == 8 else "f"), memoryview(data)[start:end])
-    result = _stats(item[0] for item in unpacked)
-    result.update({"value_type": kind, "element_count": count, "components": COMPONENTS[kind]})
-    return result
-
-
-def _binary_internal_data(
-    data: bytes | mmap.mmap,
-    header: str,
-) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
-    width_match = re.search(r"scalar=(32|64)", header)
-    preferred = int(width_match.group(1)) // 8 if width_match else 8
-    byte_order = ">" if "MSB" in header else "<"
-    records = []
-    for match in LIST_RE.finditer(data):
-        for width in (preferred, 4 if preferred == 8 else 8):
-            try:
-                record = _binary_list_stats(data, match, width, byte_order)
-                record["offset"] = match.start()
-                records.append(record)
-                break
-            except ValueError:
-                continue
-    internal_marker, boundary_marker = data.find(b"internalField"), data.find(b"boundaryField")
-    internal = next(
-        (record for record in records if record["offset"] > internal_marker and (boundary_marker < 0 or record["offset"] < boundary_marker)),
-        None,
-    )
-    if internal is None and internal_marker >= 0:
-        stop = boundary_marker if boundary_marker > internal_marker else min(len(data), internal_marker + 1024)
-        section = bytes(data[internal_marker:stop]).decode("ascii", errors="ignore")
-        uniform = re.search(rf"internalField\s+uniform\s+(\([^;]+\)|{NUMBER})\s*;", section)
-        if uniform:
-            internal = _stats(float(token) for token in re.findall(NUMBER, uniform.group(1)))
-    return records, internal
-
-
-def _binary_internal(path: Path, header: str) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
-    if path.suffix == ".gz":
-        with gzip.open(path, "rb") as stream:
-            return _binary_internal_data(stream.read(), header)
-    with path.open("rb") as stream, mmap.mmap(stream.fileno(), 0, access=mmap.ACCESS_READ) as data:
-        return _binary_internal_data(data, header)
-
-
-def _ascii_internal(raw: bytes) -> tuple[list[dict[str, Any]], dict[str, Any] | None, bool]:
-    text = raw.decode("utf-8", errors="replace")
-    marker = text.find("internalField")
-    boundary = text.find("boundaryField", marker + 1) if marker >= 0 else -1
-    section = text[marker : boundary if boundary >= 0 else len(text)] if marker >= 0 else ""
-    uniform = re.search(rf"internalField\s+uniform\s+(\([^;]+\)|{NUMBER})\s*;", section)
-    if uniform:
-        internal = _stats(float(token) for token in re.findall(NUMBER, uniform.group(1)))
-        return [internal], internal, NONFINITE_RE.search(section) is not None
-    listed = re.search(
-        rf"internalField\s+nonuniform\s+(?:List<)?(?P<type>scalar|vector|sphericalTensor|symmTensor|tensor)>?"
-        rf"\s+(?P<count>\d+)\s*\((?P<body>.*?)\)\s*;",
-        section,
-        re.S,
-    )
-    if not listed:
-        return [], None, NONFINITE_RE.search(section) is not None
-    values = [float(token) for token in re.findall(NUMBER, listed.group("body"))]
-    internal = _stats(values)
-    kind, count = listed.group("type"), int(listed.group("count"))
-    internal["count_matches_declaration"] = len(values) == count * COMPONENTS[kind]
-    return [internal], internal, NONFINITE_RE.search(section) is not None
-
-
-def scan_field(path: Path, base: Path | None = None) -> dict[str, Any]:
-    base = base or path.parent
-    try:
-        if path.suffix == ".gz":
-            with gzip.open(path, "rb") as stream:
-                header_bytes = stream.read(4096)
-        else:
-            header_bytes = path.read_bytes()[:4096]
-        header = header_bytes.decode("ascii", errors="ignore")
-        field_class, field_format = FIELD_CLASS_RE.search(header), FORMAT_RE.search(header)
-        if not field_class or not field_format:
-            return {"status": "skip", "reason": "not_a_supported_field", "parse_ok": False}
-        if field_format.group("format") == "binary":
-            records, internal = _binary_internal(path, header)
-            nonfinite = any(not record["finite"] for record in records)
-        else:
-            raw = gzip.open(path, "rb").read() if path.suffix == ".gz" else path.read_bytes()
-            records, internal, marker = _ascii_internal(raw)
-            nonfinite = marker or any(not record["finite"] for record in records)
-        parse_ok = internal is not None and all(record.get("count_matches_declaration", True) for record in records)
-        object_match = OBJECT_RE.search(header)
-        return {
-            "path": str(path.relative_to(base)) if path.is_relative_to(base) else str(path),
-            "status": "pass" if parse_ok and not nonfinite else "fail",
-            "class": field_class.group("class"),
-            "format": field_format.group("format"),
-            "field": object_match.group("object") if object_match else path.name.removesuffix(".gz"),
-            "internal": internal,
-            "finite": not nonfinite,
-            "parse_ok": parse_ok,
-        }
-    except (OSError, ValueError, struct.error) as exc:
-        return {"status": "fail", "finite": False, "parse_ok": False, "error": str(exc)}

benchmarks/evaluation/foam_io.py

@@ -1,29 +0,0 @@
-"""Small shared OpenFOAM file helpers used by evaluators and CLI extractors."""
-from __future__ import annotations
-
-import gzip
-import math
-from pathlib import Path
-
-
-def read_text(path: Path) -> str:
-    try:
-        if path.suffix == ".gz":
-            with gzip.open(path, "rt", encoding="utf-8", errors="ignore") as stream:
-                return stream.read()
-        return path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return ""
-
-
-def field_path(time_dir: Path | None, name: str) -> Path | None:
-    if time_dir is None:
-        return None
-    for candidate in (time_dir / name, time_dir / f"{name}.gz"):
-        if candidate.is_file():
-            return candidate
-    return None
-
-
-def magnitude(values: list[tuple[float, float, float]]) -> list[float]:
-    return [math.sqrt(x * x + y * y + z * z) for x, y, z in values]

benchmarks/evaluation/frozen_recovery.py

@@ -1,713 +0,0 @@
-#!/usr/bin/env python3
-"""Deterministic QoI recovery for already-finished Extended FoamBench runs.
-
-This module deliberately has no solver or OpenFOAM command dependency.  It
-reads only the retained case files named by an existing campaign artifact and
-returns a new candidate document in memory.  The command-line driver writes
-the audit products to a separate directory; neither the frozen run nor its
-original QoI document is modified.
-"""
-from __future__ import annotations
-
-import copy
-import gzip
-import hashlib
-import json
-import math
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Iterable
-
-from .comparison import compare_case
-from .extbench import (
-    extract_contract_case,
-    evidence_path,
-    field_dimensions,
-    numeric_time_dirs,
-    profile_event_locations,
-    read_scalar_field_allow_uniform,
-    read_vector_field_allow_uniform,
-    structured_qoi_errors,
-)
-from .foam_arrays import foam_path, read_label_list, read_scalar_field, read_vector_list
-
-
-RECOVERY_VERSION = "foambench.frozen_qoi_recovery.v1"
-
-
-@dataclass
-class RecoveryEvidence:
-    """Values and audit information produced by one recovery branch."""
-
-    values: dict[str, Any] = field(default_factory=dict)
-    evidence: dict[str, list[str]] = field(default_factory=dict)
-    methods: dict[str, str] = field(default_factory=dict)
-    source_times: list[float] = field(default_factory=list)
-    preflight: dict[str, Any] = field(default_factory=dict)
-    reasons: list[str] = field(default_factory=list)
-
-
-def sha256_file(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as stream:
-        for block in iter(lambda: stream.read(1024 * 1024), b""):
-            digest.update(block)
-    return digest.hexdigest()
-
-
-def _raw_bytes(path: Path) -> bytes:
-    return gzip.decompress(path.read_bytes()) if path.suffix == ".gz" else path.read_bytes()
-
-
-def _text(path: Path) -> str:
-    return _raw_bytes(path).decode("utf-8", errors="ignore")
-
-
-def _named_block(text: str, name: str, start: int = 0) -> str | None:
-    match = re.search(r"(?m)^\s*" + re.escape(name) + r"\s*\{", text[start:])
-    if match is None:
-        return None
-    left = start + match.end()
-    depth, index = 1, left
-    while index < len(text) and depth:
-        char = text[index]
-        if char == "{":
-            depth += 1
-        elif char == "}":
-            depth -= 1
-        index += 1
-    return text[left : index - 1] if depth == 0 else None
-
-
-def _boundary_block(case: Path, patch: str) -> str | None:
-    path = foam_path(case / "constant/polyMesh", "boundary")
-    if path is None:
-        return None
-    text = _text(path)
-    anchor = text.find("object      boundary")
-    return _named_block(text, patch, max(anchor, 0))
-
-
-def _boundary_specs(case: Path) -> dict[str, dict[str, Any]]:
-    path = foam_path(case / "constant/polyMesh", "boundary")
-    if path is None:
-        return {}
-    text = _text(path)
-    anchor = max(text.find("object      boundary"), 0)
-    result: dict[str, dict[str, Any]] = {}
-    names = re.finditer(r"(?m)^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\{", text[anchor:])
-    for match in names:
-        name = match.group(1)
-        block = _named_block(text, name, anchor + match.start())
-        if block is None:
-            continue
-        start_match = re.search(r"\bstartFace\s+([0-9]+)\s*;", block)
-        count_match = re.search(r"\bnFaces\s+([0-9]+)\s*;", block)
-        if start_match and count_match:
-            result[name] = {
-                "start_face": int(start_match.group(1)),
-                "n_faces": int(count_match.group(1)),
-                "type": (re.search(r"\btype\s+([^;\s]+)\s*;", block) or [None, ""])[1],
-            }
-    return result
-
-
-def _face_list(case: Path) -> list[list[int]]:
-    path = foam_path(case / "constant/polyMesh", "faces")
-    if path is None:
-        return []
-    text = _text(path)
-    marker = re.search(r"\bobject\s+faces\s*;.*?\n\s*[0-9]+\s*\(\s*\n", text, re.S)
-    if marker is None:
-        return []
-    body = text[marker.end() :]
-    return [
-        [int(value) for value in match.group(1).split()]
-        for match in re.finditer(r"[0-9]+\(\s*([0-9\s]+)\)", body)
-    ]
-
-
-def _polygon_area(points: list[tuple[float, float, float]], indices: list[int]) -> float:
-    if len(indices) < 3:
-        return 0.0
-    origin = points[indices[0]]
-    area = 0.0
-    for left, right in zip(indices[1:-1], indices[2:]):
-        a = tuple(points[left][axis] - origin[axis] for axis in range(3))
-        b = tuple(points[right][axis] - origin[axis] for axis in range(3))
-        cross = (
-            a[1] * b[2] - a[2] * b[1],
-            a[2] * b[0] - a[0] * b[2],
-            a[0] * b[1] - a[1] * b[0],
-        )
-        area += 0.5 * math.sqrt(sum(value * value for value in cross))
-    return area
-
-
-def _patch_geometry(case: Path, patch: str) -> tuple[list[float], list[int]]:
-    specs = _boundary_specs(case)
-    spec = specs.get(patch)
-    mesh = case / "constant/polyMesh"
-    points_path = foam_path(mesh, "points")
-    owner_path = foam_path(mesh, "owner")
-    if spec is None or points_path is None or owner_path is None:
-        return [], []
-    faces = _face_list(case)
-    points = read_vector_list(points_path)
-    owners = read_label_list(owner_path)
-    start, count = spec["start_face"], spec["n_faces"]
-    if start + count > len(faces) or start + count > len(owners):
-        return [], []
-    areas = [_polygon_area(points, faces[index]) for index in range(start, start + count)]
-    return areas, owners[start : start + count]
-
-
-def _scalar_boundary_values(path: Path, patch: str) -> list[float] | None:
-    """Read one scalar patch's ``value`` entry without trusting field names."""
-    text = _text(path)
-    anchor = text.find("boundaryField")
-    block = _named_block(text, patch, max(anchor, 0))
-    if block is None:
-        return None
-    uniform = re.search(r"\bvalue\s+uniform\s+([-+0-9.eE]+)\s*;", block)
-    if uniform:
-        spec = _boundary_specs(path.parents[2] if len(path.parents) > 2 else path.parent)
-        count = spec.get(patch, {}).get("n_faces", 1)
-        return [float(uniform.group(1))] * int(count or 1)
-    listed = re.search(
-        r"\bvalue\s+nonuniform\s+(?:List<)?scalar>?\s+([0-9]+)\s*\((.*?)\)\s*;",
-        block,
-        re.S,
-    )
-    if listed is None:
-        return None
-    count = int(listed.group(1))
-    values = [float(item) for item in re.findall(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?", listed.group(2))]
-    return values[:count] if len(values) >= count else None
-
-
-def _field_boundary_scalar(path: Path, patch: str, face_count: int) -> list[float] | None:
-    """Boundary scalar reader with an explicit face count from the mesh."""
-    text = _text(path)
-    anchor = text.find("boundaryField")
-    block = _named_block(text, patch, max(anchor, 0))
-    if block is None:
-        return None
-    uniform = re.search(r"\bvalue\s+uniform\s+([-+0-9.eE]+)\s*;", block)
-    if uniform:
-        return [float(uniform.group(1))] * face_count
-    listed = re.search(
-        r"\bvalue\s+nonuniform\s+(?:List<)?scalar>?\s+([0-9]+)\s*\((.*?)\)\s*;",
-        block,
-        re.S,
-    )
-    if listed is None:
-        return None
-    count = int(listed.group(1))
-    values = [float(item) for item in re.findall(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?", listed.group(2))]
-    return values[:count] if len(values) >= count else None
-
-
-def _patch_sum_history(case: Path, field: str, patch: str, targets: Iterable[float]) -> tuple[list[dict[str, float]], list[str], list[float], str | None]:
-    specs = _boundary_specs(case)
-    face_count = int(specs.get(patch, {}).get("n_faces", 0))
-    if face_count <= 0:
-        return [], [], [], "patch is absent from boundary contract"
-    target_values = sorted({float(value) for value in targets})
-    dirs = numeric_time_dirs(case)
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    source_times: list[float] = []
-    for target in target_values:
-        nearest = min(dirs, key=lambda item: abs(item[0] - target), default=None)
-        if nearest is None or abs(nearest[0] - target) > 1e-8 * max(1.0, abs(target)):
-            continue
-        actual_time, directory = nearest
-        path = foam_path(directory, field)
-        if path is None:
-            continue
-        values = _field_boundary_scalar(path, patch, face_count)
-        if not values or any(not math.isfinite(value) for value in values):
-            continue
-        points.append({"time": actual_time, "value": float(sum(values))})
-        evidence.append(evidence_path(case, path))
-        source_times.append(actual_time)
-    return points, sorted(set(evidence)), sorted(set(source_times)), None
-
-
-def _patch_average_history(case: Path, field: str, patch: str, targets: Iterable[float]) -> tuple[list[dict[str, float]], list[str], list[float], str | None]:
-    areas, owners = _patch_geometry(case, patch)
-    if not areas or not owners or sum(areas) <= 0:
-        return [], [], [], "patch geometry could not be reconstructed"
-    target_values = sorted({float(value) for value in targets})
-    dirs = numeric_time_dirs(case)
-    points: list[dict[str, float]] = []
-    evidence: list[str] = []
-    source_times: list[float] = []
-    for target in target_values:
-        nearest = min(dirs, key=lambda item: abs(item[0] - target), default=None)
-        if nearest is None or abs(nearest[0] - target) > 1e-8 * max(1.0, abs(target)):
-            continue
-        actual_time, directory = nearest
-        path = foam_path(directory, field)
-        if path is None:
-            continue
-        try:
-            values = read_scalar_field_allow_uniform(path, max(owners) + 1)
-        except (OSError, ValueError, RuntimeError):
-            continue
-        if len(values) <= max(owners):
-            continue
-        total_area = sum(areas)
-        average = sum(area * values[owner] for area, owner in zip(areas, owners)) / total_area
-        if not math.isfinite(average):
-            continue
-        points.append({"time": actual_time, "value": float(average)})
-        evidence.append(evidence_path(case, path))
-        source_times.append(actual_time)
-    return points, sorted(set(evidence)), sorted(set(source_times)), None
-
-
-def _reference_times(reference: dict[str, Any], metric_names: Iterable[str]) -> list[float]:
-    times: set[float] = set()
-    for metric in metric_names:
-        value = reference.get("qois", {}).get(metric)
-        if not isinstance(value, dict):
-            continue
-        if value.get("kind") == "time_history":
-            for point in value.get("points", []):
-                if isinstance(point, dict) and isinstance(point.get("time"), (int, float)):
-                    times.add(float(point["time"]))
-        elif value.get("kind") == "branched_time_histories":
-            for branch in value.get("branches", {}).values():
-                if isinstance(branch, dict):
-                    for point in branch.get("points", []):
-                        if isinstance(point, dict) and isinstance(point.get("time"), (int, float)):
-                            times.add(float(point["time"]))
-    return sorted(times)
-
-
-def _history(quantity: str, points: list[dict[str, float]], dimensions: str | None = None) -> dict[str, Any]:
-    value: dict[str, Any] = {"kind": "time_history", "quantity": quantity, "points": sorted(points, key=lambda item: item["time"])}
-    if dimensions:
-        value["field_dimensions"] = dimensions
-    return value
-
-
-def recover_ercofta(case: Path, reference: dict[str, Any], variant: str) -> RecoveryEvidence:
-    result = RecoveryEvidence()
-    reference_times = _reference_times(reference, ("mass_flow_rate", "pressure_rise"))
-    available_times = [time for time, _ in numeric_time_dirs(case)]
-    expected_latest = max(reference_times, default=None)
-    observed_latest = max(available_times, default=None)
-    result.preflight.update({
-        "reference_latest_time": expected_latest,
-        "retained_latest_time": observed_latest,
-        "time_semantics": "numeric_directory_name_exact_match",
-    })
-    if variant != "1" and expected_latest is not None and (observed_latest is None or observed_latest < expected_latest - 1e-10 * max(1.0, expected_latest)):
-        result.reasons.append(
-            f"retained result ends at {observed_latest!r}, before reference time {expected_latest!r}; no time rescaling is permitted"
-        )
-        result.preflight["status"] = "fail"
-        return result
-    mass_points, mass_refs, mass_times, mass_error = _patch_sum_history(case, "phi", "inlet", reference_times)
-    pressure_points_in, pressure_refs_in, pressure_times_in, pressure_error_in = _patch_average_history(case, "p", "inlet", reference_times)
-    pressure_points_out, pressure_refs_out, pressure_times_out, pressure_error_out = _patch_average_history(case, "p", "outlet", reference_times)
-    result.preflight.update({
-        "status": "pass" if mass_points or pressure_points_in else "fail",
-        "mass_point_count": len(mass_points),
-        "pressure_inlet_point_count": len(pressure_points_in),
-        "pressure_outlet_point_count": len(pressure_points_out),
-    })
-    if mass_points:
-        result.values["mass_flow_rate"] = _history("explicit_mass_flow", mass_points, field_dimensions(case, "phi"))
-        result.evidence["mass_flow_rate"] = mass_refs
-        result.methods["mass_flow_rate"] = "retained_phi_boundary_sum.v1"
-        result.source_times.extend(mass_times)
-    if pressure_points_in and pressure_points_out:
-        inlet = {round(point["time"], 12): point["value"] for point in pressure_points_in}
-        outlet = {round(point["time"], 12): point["value"] for point in pressure_points_out}
-        points = [{"time": time, "value": outlet[time] - inlet[time]} for time in sorted(set(inlet) & set(outlet))]
-        if points:
-            result.values["pressure_rise"] = {
-                "kind": "time_history",
-                "quantity": "pressure_rise",
-                "definition": "outlet_minus_inlet_patch_owner_cell_area_average",
-                "source_patches": {"inlet": "inlet", "outlet": "outlet"},
-                "points": points,
-            }
-            result.evidence["pressure_rise"] = sorted(set(pressure_refs_in + pressure_refs_out))
-            result.methods["pressure_rise"] = "retained_p_owner_cell_patch_area_average.v1"
-            result.source_times.extend(pressure_times_in + pressure_times_out)
-    for error in (mass_error, pressure_error_in, pressure_error_out):
-        if error:
-            result.reasons.append(error)
-    if expected_latest is not None and not mass_points and not pressure_points_in:
-        result.reasons.append(
-            "no retained time directory matches the reference time grid; time units or scale are not inferred"
-        )
-    result.source_times = sorted(set(result.source_times))
-    return result
-
-
-def _case_branch_dirs(case: Path) -> dict[str, Path]:
-    parent = case.parent
-    result = {"pBack_101325": case}
-    for path in parent.glob("case_pBack_*"):
-        match = re.fullmatch(r"case_pBack_([0-9]+)", path.name)
-        if match and path.is_dir():
-            result[f"pBack_{match.group(1)}"] = path
-    return result
-
-
-def recover_nozzle(case: Path, reference: dict[str, Any], adapter: str, variant: str) -> RecoveryEvidence:
-    result = RecoveryEvidence()
-    reference_value = reference.get("qois", {}).get("mass_flow_rate", {})
-    if variant == "4" and adapter == "easyfoam" and reference_value.get("kind") == "branched_time_histories":
-        branches: dict[str, Any] = {}
-        evidence: list[str] = []
-        sources: dict[str, float] = {}
-        for branch, history in reference_value.get("branches", {}).items():
-            branch_case = _case_branch_dirs(case).get(branch)
-            points = history.get("points", []) if isinstance(history, dict) else []
-            target = [point.get("time") for point in points if isinstance(point, dict) and isinstance(point.get("time"), (int, float))]
-            if branch_case is None or not target:
-                result.reasons.append(f"missing retained branch directory or target time for {branch}")
-                continue
-            branch_points, refs, times, error = _patch_sum_history(branch_case, "phi", "inlet", target)
-            if branch_points:
-                branches[branch] = _history("explicit_mass_flow", branch_points, field_dimensions(branch_case, "phi"))
-                # ``evidence_path`` is relative to each branch case.  Add the
-                # sibling directory explicitly so three otherwise identical
-                # ``0.005/phi`` paths cannot be confused in the manifest.
-                if branch_case != case:
-                    evidence.extend(f"../{branch_case.name}/{ref}" for ref in refs)
-                else:
-                    evidence.extend(refs)
-                if times:
-                    sources[branch] = max(times)
-            elif error:
-                result.reasons.append(f"{branch}: {error}")
-        if branches:
-            result.values["mass_flow_rate"] = {
-                "kind": "branched_time_histories",
-                "quantity": "explicit_mass_flow",
-                "field_dimensions": field_dimensions(case, "phi"),
-                "branches": branches,
-            }
-            result.evidence["mass_flow_rate"] = sorted(set(evidence))
-            result.methods["mass_flow_rate"] = "retained_branch_phi_boundary_sum.v1"
-            result.preflight.update({"status": "pass", "branches": sorted(branches), "source_times": sources})
-            result.source_times.extend(sources.values())
-        else:
-            result.preflight["status"] = "fail"
-        return result
-    if variant == "2" and adapter == "foamagent" and reference_value.get("kind") == "time_history":
-        targets = [point.get("time") for point in reference_value.get("points", []) if isinstance(point, dict) and isinstance(point.get("time"), (int, float))]
-        points, refs, times, error = _patch_sum_history(case, "phi", "inlet", targets)
-        if points:
-            result.values["mass_flow_rate"] = _history("explicit_mass_flow", points, field_dimensions(case, "phi"))
-            result.evidence["mass_flow_rate"] = refs
-            result.methods["mass_flow_rate"] = "retained_phi_boundary_sum.v1"
-            result.source_times.extend(times)
-            result.preflight.update({"status": "pass", "point_count": len(points), "source_times": times})
-        else:
-            result.preflight["status"] = "fail"
-            if error:
-                result.reasons.append(error)
-        return result
-    result.preflight["status"] = "not_applicable"
-    return result
-
-
-def _final_fields(case: Path) -> tuple[float, Path] | None:
-    for time, directory in reversed(numeric_time_dirs(case)):
-        if all(foam_path(directory, name) is not None for name in ("C", "U", "rho", "p", "T")):
-            return time, directory
-    return None
-
-
-def recover_riemann(case: Path) -> RecoveryEvidence:
-    result = RecoveryEvidence()
-    final = _final_fields(case)
-    if final is None:
-        result.preflight = {"status": "fail", "reason": "final C/U/rho/p/T fields are not all retained"}
-        return result
-    time, directory = final
-    try:
-        centres = read_vector_list(foam_path(directory, "C"))  # type: ignore[arg-type]
-        velocity = read_vector_field_allow_uniform(foam_path(directory, "U"), len(centres))  # type: ignore[arg-type]
-        rho = read_scalar_field_allow_uniform(foam_path(directory, "rho"), len(centres))  # type: ignore[arg-type]
-        pressure = read_scalar_field_allow_uniform(foam_path(directory, "p"), len(centres))  # type: ignore[arg-type]
-        temperature = read_scalar_field_allow_uniform(foam_path(directory, "T"), len(centres))  # type: ignore[arg-type]
-    except (OSError, ValueError, RuntimeError) as exc:
-        result.preflight = {"status": "fail", "reason": f"field decoding failed: {exc}"}
-        return result
-    if not all(len(values) == len(centres) for values in (velocity, rho, pressure, temperature)):
-        result.preflight = {"status": "fail", "reason": "final fields have inconsistent cell counts"}
-        return result
-    x_target = min((point[0] for point in centres), key=lambda value: abs(value))
-    y_target = min((point[1] for point in centres), key=lambda value: abs(value))
-    horizontal_indices = [index for index, point in enumerate(centres) if abs(point[1] - y_target) <= 1e-10 * max(1.0, abs(y_target))]
-    vertical_indices = [index for index, point in enumerate(centres) if abs(point[0] - x_target) <= 1e-10 * max(1.0, abs(x_target))]
-    horizontal_indices.sort(key=lambda index: centres[index][0])
-    vertical_indices.sort(key=lambda index: centres[index][1])
-    columns_h = ["x", "rho", "U_x", "U_y", "U_z", "p", "T"]
-    columns_v = ["y", "rho", "U_x", "U_y", "U_z", "p", "T"]
-    rows_h = [[centres[i][0], rho[i], *velocity[i], pressure[i], temperature[i]] for i in horizontal_indices]
-    rows_v = [[centres[i][1], rho[i], *velocity[i], pressure[i], temperature[i]] for i in vertical_indices]
-    if len(rows_h) < 5 or len(rows_v) < 5:
-        result.preflight = {"status": "fail", "reason": "centerline preflight retained fewer than five cells", "horizontal_count": len(rows_h), "vertical_count": len(rows_v)}
-        return result
-    root = evidence_path(case, directory / "C")
-    refs = sorted({root, evidence_path(case, directory / "U"), evidence_path(case, directory / "rho"), evidence_path(case, directory / "p"), evidence_path(case, directory / "T")})
-    profiles = {
-        "kind": "named_profiles",
-        "profiles": [
-            {"profile_id": f"recovery/{time:g}/horizontal.xy", "columns": columns_h, "rows": rows_h},
-            {"profile_id": f"recovery/{time:g}/vertical.xy", "columns": columns_v, "rows": rows_v},
-        ],
-    }
-    result.values["centerline_profiles"] = profiles
-    result.values["event_locations"] = profile_event_locations(profiles)
-    result.evidence["centerline_profiles"] = refs
-    result.evidence["event_locations"] = refs
-    result.methods["centerline_profiles"] = "retained_final_cell_centerline_sampling.v1"
-    result.methods["event_locations"] = "retained_final_cell_centerline_sampling_gradient_peaks.v1"
-    result.source_times = [time]
-    result.preflight = {
-        "status": "pass",
-        "source_time": time,
-        "horizontal_cell_count": len(rows_h),
-        "vertical_cell_count": len(rows_v),
-        "selected_coordinates": {"x": x_target, "y": y_target},
-    }
-    if result.values["event_locations"] is None:
-        result.values.pop("event_locations", None)
-        result.evidence.pop("event_locations", None)
-        result.methods.pop("event_locations", None)
-        result.reasons.append("centerline profiles were available but no local pressure/rho gradient event was detected")
-    return result
-
-
-def _nu_value(case: Path) -> tuple[float | None, str | None]:
-    for path in (case / "constant/physicalProperties", case / "constant/transportProperties", case / "constant/thermophysicalProperties"):
-        if not path.is_file():
-            continue
-        match = re.search(r"(?m)^\s*nu\s+(?:\[[^]]+\]\s*)?([-+0-9.eE]+)\s*;", _text(path))
-        if match:
-            return float(match.group(1)), evidence_path(case, path)
-    return None, None
-
-
-def _vector_boundary_uniform(path: Path, patch: str) -> tuple[float, float, float] | None:
-    text = _text(path)
-    anchor = text.find("boundaryField")
-    block = _named_block(text, patch, max(anchor, 0))
-    if block is None:
-        return None
-    match = re.search(r"\bvalue\s+uniform\s*\(\s*([-+0-9.eE]+)\s+([-+0-9.eE]+)\s+([-+0-9.eE]+)\s*\)\s*;", block)
-    return tuple(float(match.group(index)) for index in range(1, 4)) if match else None
-
-
-def _first_cell_distance(case: Path) -> tuple[float | None, str | None]:
-    candidates = sorted(case.glob("postProcessing/wallLawSets/*/yLine.csv"))
-    for path in reversed(candidates):
-        rows = []
-        try:
-            for line in path.read_text(encoding="utf-8", errors="ignore").splitlines()[1:]:
-                parts = [float(item) for item in line.split(",")]
-                if len(parts) >= 2:
-                    rows.append(abs(parts[1]))
-        except (OSError, ValueError):
-            continue
-        positive = [value for value in rows if value > 0 and math.isfinite(value)]
-        if positive:
-            return min(positive), evidence_path(case, path)
-    return None, None
-
-
-def recover_yplus(case: Path) -> RecoveryEvidence:
-    result = RecoveryEvidence()
-    final = next(((time, directory) for time, directory in reversed(numeric_time_dirs(case)) if foam_path(directory, "wallShearStress")), None)
-    nu, nu_ref = _nu_value(case)
-    distance, distance_ref = _first_cell_distance(case)
-    if final is None or nu is None or distance is None:
-        result.preflight = {"status": "fail", "final_wall_shear": bool(final), "nu": nu, "first_cell_distance": distance}
-        result.reasons.append("wall shear, kinematic viscosity, or first-cell distance is absent")
-        return result
-    time, directory = final
-    wall_patches = [name for name, spec in _boundary_specs(case).items() if str(spec.get("type")) == "wall"]
-    values: list[float] = []
-    shear_path = foam_path(directory, "wallShearStress")
-    for patch in wall_patches:
-        vector = _vector_boundary_uniform(shear_path, patch) if shear_path else None
-        if vector is not None:
-            values.append(math.sqrt(sum(component * component for component in vector)))
-    if not values:
-        result.preflight = {"status": "fail", "reason": "wallShearStress has no parseable wall patch value"}
-        return result
-    tau = statistics_mean(values)
-    yplus = math.sqrt(max(tau, 0.0)) * distance / nu
-    if not math.isfinite(yplus):
-        result.preflight = {"status": "fail", "reason": "derived y+ is non-finite"}
-        return result
-    refs = [evidence_path(case, shear_path)] if shear_path else []
-    refs.extend(item for item in (nu_ref, distance_ref) if item)
-    result.values["first_cell_yplus"] = float(yplus)
-    result.evidence["first_cell_yplus"] = sorted(set(refs))
-    result.methods["first_cell_yplus"] = "retained_wall_shear_first_cell_distance.v1"
-    result.source_times = [time]
-    result.preflight = {"status": "pass", "source_time": time, "wall_patch_count": len(values), "tau_magnitude": tau, "nu": nu, "first_cell_distance": distance}
-    result.reasons.append("derived endpoint is an auditable wall-shear estimate, not a substituted Spalding profile")
-    return result
-
-
-def statistics_mean(values: list[float]) -> float:
-    return sum(values) / len(values) if values else math.nan
-
-
-def _merge_candidate(candidate: dict[str, Any], recovery: RecoveryEvidence) -> dict[str, Any]:
-    result = copy.deepcopy(candidate)
-    qois = result.setdefault("qois", {})
-    evidence = result.setdefault("evidence", {})
-    methods = result.setdefault("metric_methods", {})
-    resolver = result.setdefault("resolver_report", {})
-    for metric, value in recovery.values.items():
-        qois[metric] = value
-        evidence[metric] = sorted(set(recovery.evidence.get(metric, [])))
-        methods[metric] = recovery.methods.get(metric, "frozen_recovery.v1")
-        resolver[metric] = {
-            "status": "selected",
-            "selected_evidence": evidence[metric],
-            "method": methods[metric],
-            "physical_validation": "metric_extractor_contract.v1",
-        }
-    required = list(result.get("required_metrics", []))
-    missing = sorted(set(required) - set(qois))
-    result["missing_metrics"] = missing
-    result["status"] = "complete" if not missing and not result.get("extraction_errors") else "incomplete"
-    health = result.setdefault("health", {})
-    checks = health.setdefault("checks", {})
-    checks["principal_qoi_complete"] = not missing
-    checks["principal_extraction_error_free"] = not result.get("extraction_errors")
-    validation_errors = [
-        error for name, value in qois.items() if name in required for error in structured_qoi_errors(name, value)
-    ]
-    checks["structured_qoi_valid"] = not validation_errors
-    health["status"] = "pass" if not missing and not validation_errors and not result.get("extraction_errors") else "incomplete"
-    health["validation_errors"] = validation_errors + list(result.get("extraction_errors", []))
-    return result
-
-
-def recover_case(
-    case_id: str,
-    case: Path,
-    reference: dict[str, Any],
-    *,
-    adapter: str,
-    design: dict[str, Any],
-) -> dict[str, Any]:
-    """Re-extract and, where justified, recover one selected incomplete case."""
-    original = extract_contract_case(case, case_id, design)
-    original_comparison = compare_case(reference, original, 1.0)
-    family, variant = case_id.split("/", 1)
-    recovery = RecoveryEvidence(preflight={"status": "not_applicable"})
-    if family == "ERCOFTA_pump":
-        recovery = recover_ercofta(case, reference, variant)
-    elif family == "nozzleCDV":
-        recovery = recover_nozzle(case, reference, adapter, variant)
-    elif family == "riemann2D":
-        recovery = recover_riemann(case)
-    elif family == "yPlusVerification" and variant == "1" and adapter == "easyfoam":
-        recovery = recover_yplus(case)
-    elif family == "supersonicCrossJet" and variant == "1":
-        recovery.reasons.append("declared interior pressure window contains no valid retained cell; global extrema are not an allowed proxy")
-        recovery.preflight = {"status": "fail", "check": "declared_internal_window_nonempty", "observed_cell_count": 0}
-    merged = _merge_candidate(original, recovery)
-    comparison = compare_case(reference, merged, 1.0)
-    if "incomplete" in str(comparison.get("status")):
-        recovery_status = "irrecoverable_incomplete"
-    elif comparison.get("status") == "out_of_tolerance":
-        recovery_status = "recovered_out_of_tolerance"
-    elif comparison.get("status") == "pass":
-        recovery_status = "recovered_complete"
-    else:
-        recovery_status = "recovery_evaluation_error"
-    return {
-        "case_id": case_id,
-        "family": family,
-        "variant": variant,
-        "case_dir": str(case.resolve()),
-        "original": {
-            "reextract_status": original_comparison.get("status"),
-            "reextract_missing_metrics": original_comparison.get("missing_metrics", []),
-            "reextract_out_of_tolerance_metrics": original_comparison.get("out_of_tolerance_metrics", []),
-            "reextract_candidate_missing_metrics": original.get("missing_metrics", []),
-        },
-        "recovery": {
-            "status": recovery_status,
-            "version": RECOVERY_VERSION,
-            "methods": recovery.methods,
-            "source_evidence": recovery.evidence,
-            "source_times": recovery.source_times,
-            "preflight": recovery.preflight,
-            "reasons": recovery.reasons,
-        },
-        "candidate": merged,
-        "comparison": comparison,
-    }
-
-
-def recovery_score_record(source: dict[str, Any], recovered: dict[str, Any]) -> dict[str, Any]:
-    """Build a compact campaign-compatible record without rerunning checks."""
-    original = source
-    comparison = recovered["comparison"]
-    execution = copy.deepcopy(original.get("execution", {}))
-    numerical = copy.deepcopy(original.get("numerical", {}))
-    execution_pass = execution.get("status") == "pass"
-    numerical_pass = numerical.get("status") == "pass" or bool(numerical.get("pass"))
-    qoi_pass = bool(comparison.get("physics_grounded_qoi_pass"))
-    failure_categories: list[str] = []
-    if not execution_pass:
-        failure_categories.append("execution_failure")
-    elif "incomplete" in str(comparison.get("status", "")):
-        failure_categories.append("qoi_incomplete")
-    elif comparison.get("status") == "out_of_tolerance":
-        failure_categories.append("qoi_out_of_tolerance")
-    return {
-        "schema_version": "foambench.frozen_case_recovery.v1",
-        "case_id": recovered["case_id"],
-        "dataset": original.get("dataset", "extended"),
-        "family": recovered["family"],
-        "variant": recovered["variant"],
-        "replicate": original.get("replicate", 1),
-        "artifact": {
-            "case_dir": recovered["case_dir"],
-            "rollout_dir": original.get("artifact", {}).get("rollout_dir"),
-            "workspace_dir": original.get("artifact", {}).get("workspace_dir"),
-        },
-        "execution": execution,
-        "numerical": numerical,
-        "qoi": {
-            "status": "pass" if qoi_pass else comparison.get("status", "evaluation_error"),
-            "physics_grounded_qoi_pass": qoi_pass,
-            "effective_pass_ratio": float(comparison.get("qoi_pass_ratio", 0.0) or 0.0),
-            "candidate": recovered["candidate"],
-            "comparison": comparison,
-        },
-        "scores": {
-            "execution_pass": execution_pass,
-            "numerical_pass": numerical_pass,
-            "physics_grounded_qoi_pass": qoi_pass,
-            "end_to_end_pass": execution_pass and numerical_pass and qoi_pass,
-        },
-        "failure_categories": failure_categories,
-        "recovery": recovered["recovery"],
-    }
-
-
-def document_checksum(path: Path) -> dict[str, Any]:
-    return {"path": str(path.resolve()), "sha256": sha256_file(path), "size_bytes": path.stat().st_size}

benchmarks/evaluation/health.py

@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from .foam import final_time_dirs
-from .foam_field import scan_field
-from .foam_io import field_path
-
-SCALAR_FIELDS = (
-    "p", "p_rgh", "T", "rho", "nut", "k", "epsilon", "omega", "nuTilda",
-    "Qdot", "CH4", "O2", "CO2", "H2O", "N2", "alpha.water", "alpha.air",
-    "h", "hTotal",
-)
-POSITIVE_FIELDS = {"T", "rho", "k", "epsilon", "omega", "nuTilda", "h", "hTotal"}
-
-
-def final_field_health(case_dir: Path | None) -> dict[str, Any]:
-    latest, time_dirs, layout = final_time_dirs(case_dir)
-    if not time_dirs:
-        return {
-            "status": "unavailable",
-            "latest_time": latest,
-            "checks": {},
-            "reason": "no_final_time_directory",
-        }
-    parsed: list[str] = []
-    nonfinite: list[str] = []
-    bound_failures: list[str] = []
-    parse_errors: dict[str, str] = {}
-    bounds: dict[str, dict[str, float]] = {}
-    for name in SCALAR_FIELDS:
-        paths = [path for time_dir in time_dirs for path in [field_path(time_dir, name)] if path is not None]
-        if not paths:
-            continue
-        records = [scan_field(path, case_dir) for path in paths]
-        invalid = [record for record in records if not record.get("parse_ok")]
-        if invalid:
-            parse_errors[name] = str(invalid[0].get("error") or invalid[0].get("reason") or "internalField is not parseable")
-            continue
-        if any(not record.get("finite") for record in records):
-            nonfinite.append(name)
-        extrema = [record.get("internal") for record in records]
-        lows = [float(item["min"]) for item in extrema if isinstance(item, dict) and isinstance(item.get("min"), (int, float))]
-        highs = [float(item["max"]) for item in extrema if isinstance(item, dict) and isinstance(item.get("max"), (int, float))]
-        if not lows or not highs:
-            continue
-        parsed.append(name)
-        low, high = min(lows), max(highs)
-        bounds[name] = {"min": low, "max": high}
-        if name in POSITIVE_FIELDS and low < -1e-12:
-            bound_failures.append(name)
-        if name.startswith("alpha.") and (low < -1e-3 or high > 1.0 + 1e-3):
-            bound_failures.append(f"{name}_bounds")
-    checks = {
-        "parsed_fields_finite": not nonfinite and not parse_errors,
-        "applicable_field_bounds_valid": not bound_failures,
-    }
-    return {
-        "status": "pass" if all(checks.values()) else "fail",
-        "latest_time": latest,
-        "layout": layout,
-        "checks": checks,
-        "parsed_fields": sorted(parsed),
-        "nonfinite_fields": sorted(nonfinite),
-        "field_bound_failures": sorted(bound_failures),
-        "parse_errors": parse_errors,
-        "bounds": bounds,
-    }

benchmarks/evaluation/io.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import json
-import math
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def read_json(path: Path) -> Any:
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def read_object(path: Path) -> dict[str, Any]:
-    value = read_json(path)
-    if not isinstance(value, dict):
-        raise ValueError(f"expected JSON object: {path}")
-    return value
-
-
-def write_json(path: Path, value: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    temporary.write_text(
-        json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
-        encoding="utf-8",
-    )
-    temporary.replace(path)
-
-
-def finite(value: Any) -> float | None:
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        return None
-    number = float(value)
-    return number if math.isfinite(number) else None

benchmarks/evaluation/measurement_specs.py

@@ -1,45 +0,0 @@
-"""Load the visible, reference-free Extended measurement contract."""
-from __future__ import annotations
-
-import hashlib
-import json
-from pathlib import Path
-from typing import Any
-
-ROOT = Path(__file__).resolve().parents[2]
-PATH = ROOT / "benchmarks/FoamBench_extended_openfoam13_measurement_specs.json"
-SCHEMA = "easyfoam.extbench.measurement.v1"
-
-
-def _sha(text: str) -> str:
-    return hashlib.sha256(text.encode()).hexdigest()
-
-
-def load_measurement_spec(case_id: str, requirement: str | None = None) -> dict[str, Any] | None:
-    """Return one case contract; reference values and tolerances are absent by construction."""
-    if not PATH.is_file() or "/" not in case_id:
-        return None
-    document = json.loads(PATH.read_text(encoding="utf-8"))
-    if document.get("schema_version") != "easyfoam.extbench.measurement_specs.v1":
-        raise ValueError("unsupported measurement contract")
-    spec = document.get("cases", {}).get(case_id)
-    if not isinstance(spec, dict):
-        return None
-    if spec.get("measurement_schema") != SCHEMA:
-        raise ValueError(f"invalid measurement schema for {case_id}")
-    if requirement is not None:
-        spec = dict(spec)
-        spec["requirement_sha256"] = _sha(requirement)
-    return spec
-
-
-def prompt_measurement_spec(case_id: str, requirement: str) -> str:
-    spec = load_measurement_spec(case_id, requirement)
-    if spec is None:
-        return ""
-    return (
-        "Measurement contract for this ExtBench task (visible task definition; it contains no reference answer or tolerance):\n"
-        + json.dumps(spec, ensure_ascii=False, indent=2)
-        + "\nUse this contract to plan what fields, patches, probes, meshes, and saved times must be retained. "
-        "Do not invent a proxy when a principal measurement is unavailable; report the missing evidence.\n\n"
-    )

benchmarks/evaluation/mesh.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import re
-import subprocess
-from pathlib import Path
-from typing import Any
-
-from .foam import FATAL_RE, NUMBER, read_text
-
-
-def parse_mesh_log(text: str, *, source: str) -> dict[str, Any]:
-    failed_values = [int(value) for value in re.findall(r"Failed\s+(\d+)\s+mesh checks", text, re.I)]
-    min_volumes = [float(value) for value in re.findall(rf"Min volume\s*=\s*({NUMBER})", text)]
-    markers = {
-        "fatal": FATAL_RE.search(text) is not None,
-        "non_positive_cell_volume": min(min_volumes, default=float("inf")) <= 0,
-        "negative_or_zero_volume": re.search(r"(?:negative|zero)\s+(?:cell\s+)?volumes?", text, re.I) is not None,
-        "illegal_face": re.search(r"illegal\s+faces?", text, re.I) is not None,
-        "open_cell": re.search(r"open\s+cells?", text, re.I) is not None,
-        "non_manifold": re.search(r"non[- ]manifold", text, re.I) is not None,
-    }
-    available = "Mesh OK." in text or bool(failed_values) or bool(min_volumes)
-    hard_failure = any(markers.values()) or max(failed_values, default=0) > 0
-    return {
-        "status": "unavailable" if not available else "fail" if hard_failure else "pass",
-        "source": source,
-        "failed_mesh_checks": max(failed_values, default=0),
-        "min_volume": min(min_volumes) if min_volumes else None,
-        "critical_markers": markers,
-    }
-
-
-def mesh_evidence(log_paths: tuple[Path, ...]) -> dict[str, Any]:
-    selected = [
-        path for path in log_paths
-        if "checkmesh" in path.name.lower() or "checkMesh" in read_text(path)[:4096]
-    ]
-    text = "\n".join(read_text(path) for path in selected)
-    return parse_mesh_log(text, source=",".join(str(path) for path in selected))
-
-
-def run_check_mesh(case_dir: Path | None, timeout: float = 120.0) -> dict[str, Any]:
-    if case_dir is None:
-        return {"status": "unavailable", "source": "read_only_replay", "reason": "case_directory_missing"}
-    command = ["checkMesh", "-case", str(case_dir), "-allTopology", "-allGeometry", "-noFunctionObjects"]
-    try:
-        completed = subprocess.run(command, capture_output=True, text=True, check=False, timeout=timeout)
-    except (OSError, subprocess.TimeoutExpired) as exc:
-        return {"status": "fail", "source": "read_only_replay", "command": command, "error": str(exc)}
-    result = parse_mesh_log(completed.stdout + "\n" + completed.stderr, source="read_only_replay")
-    result.update({"command": command, "return_code": completed.returncode})
-    if completed.returncode != 0:
-        result["status"] = "fail"
-    return result

benchmarks/evaluation/models.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-from .io import read_object
-
-
-@dataclass(frozen=True)
-class BenchmarkProfile:
-    profile_id: str
-    dataset: str
-    benchmark_path: Path
-    reference_qois_path: Path
-    expected_case_count: int
-    case_id_style: str = "family_variant"
-    extractor: str = "field"
-    required_qoi_fraction: float = 1.0
-    reference_run_root: Path | None = None
-    numerical_contract: dict[str, Any] = field(default_factory=dict)
-
-    @classmethod
-    def load(cls, path: Path, *, repository_root: Path | None = None) -> "BenchmarkProfile":
-        path = path.resolve(strict=True)
-        data = read_object(path)
-        if repository_root:
-            root = repository_root.resolve()
-        else:
-            root = next(
-                (parent for parent in path.parents if (parent / "benchmarks").is_dir() and (parent / "schemas").is_dir()),
-                path.parent,
-            )
-
-        def resolve(value: str | None) -> Path | None:
-            if value is None:
-                return None
-            candidate = Path(value)
-            return candidate.resolve() if candidate.is_absolute() else (root / candidate).resolve()
-
-        membership = data.get("membership", {})
-        qoi = data.get("qoi", {})
-        return cls(
-            profile_id=str(data["profile_id"]),
-            dataset=str(data["dataset"]),
-            benchmark_path=resolve(str(data["benchmark_path"])),  # type: ignore[arg-type]
-            reference_qois_path=resolve(str(data["reference_qois_path"])),  # type: ignore[arg-type]
-            expected_case_count=int(membership["expected_case_count"]),
-            case_id_style=str(membership.get("case_id_style", "family_variant")),
-            extractor=str(qoi.get("extractor", "field")),
-            required_qoi_fraction=float(qoi.get("required_fraction", 1.0)),
-            reference_run_root=resolve(data.get("reference_run_root")),
-            numerical_contract=dict(data.get("numerical", {})),
-        )
-
-    def identity(self, case_id: str) -> tuple[str, str]:
-        if "/" in case_id:
-            return tuple(case_id.split("/", 1))  # type: ignore[return-value]
-        return case_id, "1"
-
-
-@dataclass(frozen=True)
-class CaseArtifact:
-    case_id: str
-    dataset: str
-    family: str
-    variant: str
-    replicate: int
-    rollout_dir: Path
-    case_dir: Path | None
-    workspace_dir: Path | None = None
-    manifest: dict[str, Any] = field(default_factory=dict)
-    formal_run_records: tuple[Path, ...] = ()
-    solver_logs: tuple[Path, ...] = ()
-    workflow_path: Path | None = None
-    evidence_summary_path: Path | None = None
-
-    @property
-    def duration_seconds(self) -> float | None:
-        value = self.manifest.get("duration_seconds")
-        return float(value) if isinstance(value, (int, float)) else None
-
-    @property
-    def token_usage(self) -> dict[str, Any]:
-        value = self.manifest.get("token_usage")
-        return dict(value) if isinstance(value, dict) else {}

benchmarks/evaluation/numerical.py

@@ -1,253 +0,0 @@
-from __future__ import annotations
-
-import math
-import re
-from pathlib import Path
-from typing import Any
-
-from .foam import FATAL_RE, NONFINITE_RE, NUMBER, final_time_dirs, read_logs
-from .health import final_field_health
-from .mesh import mesh_evidence, run_check_mesh
-from .models import CaseArtifact
-from .stability import numerical_scheme, steady_plateau
-
-RESIDUAL_RE = re.compile(
-    rf"Solving for (?P<field>[^,\r\n]+),\s*Initial residual = (?P<initial>{NUMBER}),\s*Final residual = (?P<final>{NUMBER})"
-)
-COURANT_RE = re.compile(rf"Courant Number mean:\s*(?P<mean>{NUMBER})\s+max:\s*(?P<max>{NUMBER})")
-CONTINUITY_RE = re.compile(
-    rf"(?:time step )?continuity errors\s*:\s*sum local = (?P<local>{NUMBER}),\s*global = (?P<global>{NUMBER}),\s*cumulative = (?P<cumulative>{NUMBER})",
-    re.I,
-)
-
-DEFAULT_CONTRACT = {
-    "final_window_fraction": 0.2,
-    "minimum_final_window_samples": 5,
-    "final_linear_residual": {"reference_factor": 10.0, "absolute_floor": 1e-3},
-    "initial_residual": {"reference_factor": 10.0, "absolute_floor": 1e-3},
-    "courant_final_p95": {"reference_factor": 3.0, "absolute_floor": 1.0},
-    "courant_peak": {"reference_factor": 3.0, "absolute_floor": 2.0},
-    "continuity_global_p95": {"reference_factor": 10.0, "absolute_floor": 1e-5},
-    "continuity_cumulative_final": {"reference_factor": 10.0, "absolute_floor": 1e-3},
-}
-
-
-def percentile(values: list[float], fraction: float) -> float | None:
-    if not values:
-        return None
-    ordered = sorted(values)
-    position = (len(ordered) - 1) * fraction
-    low, high = math.floor(position), math.ceil(position)
-    if low == high:
-        return ordered[low]
-    return ordered[low] + (ordered[high] - ordered[low]) * (position - low)
-
-
-def final_window(values: list[float], contract: dict[str, Any] = DEFAULT_CONTRACT) -> list[float]:
-    count = max(
-        int(contract["minimum_final_window_samples"]),
-        math.ceil(len(values) * float(contract["final_window_fraction"])),
-    )
-    return values[-min(len(values), count):]
-
-
-def parse_logs(paths: list[Path] | tuple[Path, ...], contract: dict[str, Any] = DEFAULT_CONTRACT) -> dict[str, Any]:
-    text = read_logs(paths)
-    residuals: dict[str, dict[str, list[float]]] = {}
-    courants: list[float] = []
-    continuity_global: list[float] = []
-    continuity_cumulative: list[float] = []
-    for match in RESIDUAL_RE.finditer(text):
-        field = match.group("field").strip()
-        values = residuals.setdefault(field, {"initial": [], "final": []})
-        values["initial"].append(float(match.group("initial")))
-        values["final"].append(float(match.group("final")))
-    courants.extend(float(match.group("max")) for match in COURANT_RE.finditer(text))
-    for match in CONTINUITY_RE.finditer(text):
-        continuity_global.append(abs(float(match.group("global"))))
-        continuity_cumulative.append(abs(float(match.group("cumulative"))))
-    residual_summary = {
-        field: {
-            "sample_count": len(values["initial"]),
-            "initial_final_window_p95": percentile(final_window(values["initial"], contract), 0.95),
-            "final_final_window_p95": percentile(final_window(values["final"], contract), 0.95),
-        }
-        for field, values in sorted(residuals.items())
-    }
-    return {
-        "log_paths": [str(path) for path in paths if path.is_file()],
-        "fatal_marker": FATAL_RE.search(text) is not None,
-        "nonfinite_marker": NONFINITE_RE.search(text) is not None,
-        "residual_field_count": len(residuals),
-        "residual_record_count": sum(len(values["initial"]) for values in residuals.values()),
-        "residuals": residual_summary,
-        "initial_residual_final_window_p95": max(
-            (record["initial_final_window_p95"] for record in residual_summary.values()
-             if record["initial_final_window_p95"] is not None),
-            default=None,
-        ),
-        "final_residual_final_window_p95": max(
-            (record["final_final_window_p95"] for record in residual_summary.values()
-             if record["final_final_window_p95"] is not None),
-            default=None,
-        ),
-        "courant_count": len(courants),
-        "courant_peak": max(courants) if courants else None,
-        "courant_final_window_p95": percentile(final_window(courants, contract), 0.95),
-        "continuity_count": len(continuity_global),
-        "continuity_global_final_window_p95": percentile(final_window(continuity_global, contract), 0.95),
-        "continuity_cumulative_final": continuity_cumulative[-1] if continuity_cumulative else None,
-    }
-
-
-def threshold(reference: float, key: str, contract: dict[str, Any] = DEFAULT_CONTRACT) -> float:
-    policy = contract[key]
-    return max(abs(reference) * float(policy["reference_factor"]), float(policy["absolute_floor"]))
-
-
-def compatible(
-    candidate: float | None,
-    reference: float | None,
-    key: str,
-    contract: dict[str, Any] = DEFAULT_CONTRACT,
-) -> tuple[bool | None, float | None]:
-    if reference is None:
-        return None, None
-    limit = threshold(reference, key, contract)
-    return candidate is not None and math.isfinite(candidate) and candidate <= limit, limit
-
-
-def _field_health(candidate: dict[str, Any], case_dir: Path | None) -> tuple[bool | None, bool | None, dict[str, Any]]:
-    health = candidate.get("health")
-    if not isinstance(health, dict):
-        health = final_field_health(case_dir)
-        checks = health.get("checks", {})
-        return checks.get("parsed_fields_finite"), checks.get("applicable_field_bounds_valid"), health
-    checks = health.get("checks") if isinstance(health.get("checks"), dict) else {}
-    finite = checks.get("all_parsed_fields_finite")
-    bounds = checks.get("applicable_field_bounds_valid")
-    if not isinstance(finite, bool) or not isinstance(bounds, bool):
-        fallback = final_field_health(case_dir)
-        fallback_checks = fallback.get("checks", {})
-        finite = finite if isinstance(finite, bool) else fallback_checks.get("parsed_fields_finite")
-        bounds = bounds if isinstance(bounds, bool) else fallback_checks.get("applicable_field_bounds_valid")
-        health = {"candidate_health": health, "independent_field_health": fallback}
-    return finite if isinstance(finite, bool) else None, bounds if isinstance(bounds, bool) else None, health
-
-
-def evaluate_numerical(
-    artifact: CaseArtifact,
-    *,
-    execution_pass: bool,
-    qoi_candidate: dict[str, Any],
-    reference_logs: list[Path] | tuple[Path, ...] = (),
-    reference_case_dir: Path | None = None,
-    reference_qois: dict[str, Any] | None = None,
-    reference_statistics: dict[str, Any] | None = None,
-    steady_plateau_enabled: bool = False,
-    check_mesh: bool = False,
-    mesh_timeout: float = 120.0,
-    contract: dict[str, Any] = DEFAULT_CONTRACT,
-) -> dict[str, Any]:
-    if not execution_pass:
-        return {
-            "schema_version": "foambench.numerical_validity.v2",
-            "status": "not_evaluated_execution_failure",
-            "pass": False,
-            "checks": {},
-            "failed_checks": [],
-        }
-    candidate = parse_logs(artifact.solver_logs, contract)
-    reference = (dict(reference_statistics) if reference_statistics is not None
-                 else parse_logs(reference_logs, contract) if reference_logs else {})
-    finite_fields, bounded_fields, health = _field_health(qoi_candidate, artifact.case_dir)
-    mesh = mesh_evidence(artifact.solver_logs)
-    if check_mesh and mesh["status"] == "unavailable":
-        mesh = run_check_mesh(artifact.case_dir, mesh_timeout)
-    latest, latest_dirs, layout = final_time_dirs(artifact.case_dir)
-    scheme = numerical_scheme(artifact.case_dir) if artifact.case_dir else "unknown"
-    plateau: dict[str, Any] = {"status": "not_applicable", "applicable": False}
-    reference_plateau: dict[str, Any] = {"status": "not_applicable", "applicable": False}
-    if steady_plateau_enabled and scheme == "steadyState" and reference_qois:
-        reference_plateau = steady_plateau(reference_qois)
-        baseline = {
-            name: float(metric["relative_span"])
-            for name, metric in reference_plateau.get("metrics", {}).items()
-            if isinstance(metric, dict) and isinstance(metric.get("relative_span"), (int, float))
-        }
-        plateau = steady_plateau(qoi_candidate.get("qois", {}), baseline)
-
-    relative = {
-        "final_linear_residual_reference_compatible": compatible(
-            candidate["final_residual_final_window_p95"], reference.get("final_residual_final_window_p95"),
-            "final_linear_residual", contract,
-        ),
-        "initial_residual_reference_compatible": compatible(
-            candidate["initial_residual_final_window_p95"], reference.get("initial_residual_final_window_p95"),
-            "initial_residual", contract,
-        ),
-        "courant_final_reference_compatible": compatible(
-            candidate["courant_final_window_p95"], reference.get("courant_final_window_p95"),
-            "courant_final_p95", contract,
-        ),
-        "courant_peak_reference_compatible": compatible(
-            candidate["courant_peak"], reference.get("courant_peak"), "courant_peak", contract,
-        ),
-        "continuity_reference_compatible": compatible(
-            candidate["continuity_global_final_window_p95"], reference.get("continuity_global_final_window_p95"),
-            "continuity_global_p95", contract,
-        ),
-        "continuity_cumulative_reference_compatible": compatible(
-            candidate["continuity_cumulative_final"], reference.get("continuity_cumulative_final"),
-            "continuity_cumulative_final", contract,
-        ),
-    }
-    checks: dict[str, dict[str, Any]] = {
-        "solver_log_present": {"status": "pass" if candidate["log_paths"] else "fail", "required": True},
-        "no_fatal_marker": {"status": "fail" if candidate["fatal_marker"] else "pass", "required": True},
-        "no_nonfinite_log_marker": {"status": "fail" if candidate["nonfinite_marker"] else "pass", "required": True},
-        "residual_evidence_present": {
-            "status": "pass" if candidate["residual_record_count"] else "fail",
-            "required": True,
-        },
-        "final_fields_present": {"status": "pass" if latest_dirs else "fail", "required": True},
-        "mesh_core_valid": {
-            "status": mesh["status"],
-            "required": mesh["status"] != "unavailable",
-        },
-        "steady_principal_qoi_plateau": {
-            "status": plateau["status"],
-            "required": bool(plateau.get("applicable")),
-        },
-        "all_parsed_final_fields_finite": {
-            "status": "not_applicable" if finite_fields is None else "pass" if finite_fields else "fail",
-            "required": finite_fields is not None,
-        },
-        "applicable_field_bounds_valid": {
-            "status": "not_applicable" if bounded_fields is None else "pass" if bounded_fields else "fail",
-            "required": bounded_fields is not None,
-        },
-    }
-    for name, (passed, limit) in relative.items():
-        checks[name] = {
-            "status": "not_applicable" if passed is None else "pass" if passed else "fail",
-            "required": passed is not None,
-            "limit": limit,
-        }
-    failed = [name for name, value in checks.items() if value["required"] and value["status"] == "fail"]
-    return {
-        "schema_version": "foambench.numerical_validity.v2",
-        "status": "pass" if not failed else "fail",
-        "pass": not failed,
-        "checks": checks,
-        "failed_checks": failed,
-        "candidate_logs": candidate,
-        "reference_logs": reference or None,
-        "candidate_latest_time": latest,
-        "final_field_layout": layout,
-        "field_health": health,
-        "mesh": mesh,
-        "time_scheme": scheme,
-        "steady_plateau": plateau,
-        "reference_steady_plateau": reference_plateau,
-    }

benchmarks/evaluation/pipeline.py

@@ -1,166 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from .adapters import create_adapter
-from .aggregate import aggregate_results
-from .execution import evaluate_execution
-from .io import utc_now, write_json
-from .models import BenchmarkProfile, CaseArtifact
-from .numerical import evaluate_numerical
-from .profiles import expected_completion_time, load_assets
-from .qoi import evaluate_qoi
-from .reference import reference_case_dir, reference_log_paths, reference_statistics
-from .reporting import write_case_csv, write_summary_csv
-from .schema import validate
-
-
-def missing_artifact(case_id: str, profile: BenchmarkProfile, run_root: Path) -> CaseArtifact:
-    family, variant = profile.identity(case_id)
-    return CaseArtifact(
-        case_id=case_id,
-        dataset=profile.dataset,
-        family=family,
-        variant=variant,
-        replicate=1,
-        rollout_dir=run_root / family / variant / "replicate_001",
-        case_dir=None,
-        manifest={"status": "missing_rollout"},
-    )
-
-
-def failure_categories(result: dict[str, Any]) -> list[str]:
-    categories = []
-    if not result["scores"]["execution_pass"]:
-        categories.append("execution_failure")
-    elif not result["scores"]["numerical_pass"]:
-        categories.append("numerical_failure")
-    if result["scores"]["execution_pass"] and not result["scores"]["physics_grounded_qoi_pass"]:
-        qoi_status = result["qoi"].get("status")
-        if qoi_status == "evaluation_error":
-            categories.append("qoi_evaluation_error")
-        else:
-            categories.append("qoi_incomplete" if "incomplete" in str(qoi_status) else "qoi_out_of_tolerance")
-    return categories
-
-
-def evaluate_case(
-    artifact: CaseArtifact,
-    profile: BenchmarkProfile,
-    benchmark_case: dict[str, Any],
-    reference: dict[str, Any],
-    *,
-    check_mesh: bool = False,
-    mesh_timeout: float = 120.0,
-) -> dict[str, Any]:
-    execution = evaluate_execution(artifact, expected_completion_time(benchmark_case, reference))
-    execution_pass = execution["status"] == "pass"
-    qoi = evaluate_qoi(artifact, profile, reference, execution_pass=execution_pass)
-    numerical = evaluate_numerical(
-        artifact,
-        execution_pass=execution_pass,
-        qoi_candidate=qoi["candidate"],
-        reference_logs=reference_log_paths(profile, artifact.case_id),
-        reference_statistics=reference_statistics(profile, artifact.case_id),
-        reference_case_dir=reference_case_dir(profile, artifact.case_id),
-        # Numerical plateau is a stability check over available histories. It is
-        # deliberately separate from the principal Physics-grounded QoI roles.
-        reference_qois=dict(reference.get("qois", {})),
-        steady_plateau_enabled=bool(profile.numerical_contract.get("steady_qoi_plateau")),
-        check_mesh=check_mesh,
-        mesh_timeout=mesh_timeout,
-    )
-    numerical_pass = bool(numerical.get("pass"))
-    physics_grounded_qoi_pass = bool(qoi.get("physics_grounded_qoi_pass"))
-    result = {
-        "schema_version": "foambench.case_evaluation.v1",
-        "case_id": artifact.case_id,
-        "dataset": artifact.dataset,
-        "family": artifact.family,
-        "variant": artifact.variant,
-        "replicate": artifact.replicate,
-        "execution": execution,
-        "numerical": numerical,
-        "qoi": qoi,
-        "scores": {
-            "execution_pass": execution_pass,
-            "numerical_pass": numerical_pass,
-            "physics_grounded_qoi_pass": physics_grounded_qoi_pass,
-            "end_to_end_pass": execution_pass and numerical_pass and physics_grounded_qoi_pass,
-        },
-        "resources": {
-            "duration_seconds": artifact.duration_seconds,
-            "token_usage": artifact.token_usage,
-        },
-        "artifact": {
-            "rollout_dir": str(artifact.rollout_dir),
-            "workspace_dir": str(artifact.workspace_dir) if artifact.workspace_dir else None,
-            "case_dir": str(artifact.case_dir) if artifact.case_dir else None,
-        },
-    }
-    result["failure_categories"] = failure_categories(result)
-    return result
-
-
-def evaluate_campaign(
-    profile: BenchmarkProfile,
-    *,
-    adapter_name: str,
-    run_root: Path,
-    output_dir: Path | None = None,
-    check_mesh: bool = False,
-    mesh_timeout: float = 120.0,
-) -> dict[str, Any]:
-    benchmark, references = load_assets(profile)
-    adapter = create_adapter(adapter_name, run_root, profile)
-    discovered = adapter.discover()
-    unknown = sorted(set(discovered) - set(references))
-    if unknown:
-        raise ValueError("run contains cases outside the benchmark profile: " + ", ".join(unknown))
-    results = []
-    for case_id in sorted(references):
-        artifact = discovered.get(case_id) or missing_artifact(case_id, profile, run_root)
-        results.append(evaluate_case(
-            artifact, profile, benchmark[case_id], references[case_id],
-            check_mesh=check_mesh, mesh_timeout=mesh_timeout,
-        ))
-    overall = aggregate_results(results)
-    families = {
-        family: aggregate_results([row for row in results if row["family"] == family])
-        for family in sorted({row["family"] for row in results})
-    }
-    report = {
-        "schema_version": "foambench.campaign_evaluation.v1",
-        "generated_at": utc_now(),
-        "profile_id": profile.profile_id,
-        "dataset": profile.dataset,
-        "adapter": adapter_name,
-        "run_root": str(run_root.resolve()),
-        "reference_qois": str(profile.reference_qois_path),
-        "definitions": {
-            "execution_pass": "independent execution contract passed",
-            "numerical_pass": "execution passed and independent numerical contract passed",
-            "physics_grounded_qoi_pass": "execution passed and every principal Physics-grounded QoI passed its physical contract",
-            "end_to_end_pass": "execution_pass AND numerical_pass AND physics_grounded_qoi_pass",
-        },
-        "overall": overall,
-        "families": families,
-        "cases": {row["case_id"]: row for row in results},
-    }
-    validate(report, "benchmark_evaluation.schema.json")
-    if output_dir is not None:
-        output_dir = output_dir.resolve()
-        write_json(output_dir / "campaign_evaluation.json", report)
-        write_json(output_dir / "summary.json", {
-            key: report[key] for key in (
-                "schema_version", "generated_at", "profile_id", "dataset", "adapter",
-                "run_root", "definitions", "overall", "families",
-            )
-        })
-        case_root = output_dir / "cases"
-        for row in results:
-            write_json(case_root / row["family"] / f"{row['variant']}.json", row)
-        write_case_csv(output_dir / "cases.csv", results)
-        write_summary_csv(output_dir / "summary.csv", overall, families)
-    return report

benchmarks/evaluation/preparation.py

@@ -1,172 +0,0 @@
-from __future__ import annotations
-
-import re
-import subprocess
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from pathlib import Path
-from typing import Any
-
-from .foam import read_text
-from .adapters import create_adapter
-from .execution import evaluate_execution
-from .io import write_json
-from .models import BenchmarkProfile, CaseArtifact
-from .profiles import expected_completion_time, load_assets
-
-
-WRITE_FORMAT_RE = re.compile(r"(?m)^\s*writeFormat\s+(ascii|binary)\s*;")
-
-
-def _patch_names(case_dir: Path) -> set[str]:
-    boundary = case_dir / "constant" / "polyMesh" / "boundary"
-    if not boundary.is_file():
-        return set()
-    text = boundary.read_text(encoding="utf-8", errors="ignore")
-    return set(re.findall(r"(?m)^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\n\s*\{", text))
-
-
-def _run(command: list[str], log: Any, timeout: int) -> dict[str, Any]:
-    try:
-        completed = subprocess.run(
-            command,
-            stdout=log,
-            stderr=subprocess.STDOUT,
-            check=False,
-            text=True,
-            timeout=timeout,
-        )
-        return {"command": command, "return_code": completed.returncode, "timed_out": False}
-    except subprocess.TimeoutExpired:
-        return {"command": command, "return_code": None, "timed_out": True}
-    except OSError as exc:
-        return {"command": command, "return_code": 127, "timed_out": False, "error": str(exc)}
-
-
-def prepare_case(artifact: CaseArtifact, output_root: Path) -> dict[str, Any]:
-    case_dir = artifact.case_dir
-    if case_dir is None:
-        return {"case_id": artifact.case_id, "status": "skipped", "reason": "case_directory_missing"}
-    case_output = output_root / artifact.family / artifact.variant
-    case_output.mkdir(parents=True, exist_ok=True)
-    log_path = case_output / "preparation.log"
-    records: list[dict[str, Any]] = []
-    control_path = case_dir / "system" / "controlDict"
-    original_format_match = WRITE_FORMAT_RE.search(read_text(control_path))
-    original_format = original_format_match.group(1) if original_format_match else None
-    functions = ["writeCellCentres", "writeCellVolumes", "vorticity"]
-    # Sampling is measurement-only and deterministic when the candidate has
-    # explicitly declared the benchmark's system/sample dictionary.  Do not
-    # invent sample coordinates for cases that did not provide this contract.
-    if (case_dir / "system" / "sample").is_file():
-        functions.append("sample")
-    patches = _patch_names(case_dir)
-    if artifact.family == "supersonicCrossJet":
-        # Patch names vary between the fixed reference (inlet1/inlet2) and
-        # agent cases (inlet/jet).  Resolve only semantically named patches.
-        selected = sorted(name for name in patches if any(token in name.lower() for token in ("inlet", "jet")))
-        functions.extend(f"patchFlowRate(phi,patch={name})" for name in selected)
-    elif artifact.family in {"ERCOFTA_pump", "nozzleCDV"}:
-        selected = sorted(name for name in patches if any(token in name.lower() for token in ("inlet", "outlet")))
-        functions.extend(f"patchFlowRate(phi,patch={name})" for name in selected)
-        functions.extend(f"patchAverage(p,patch={name})" for name in selected)
-    with log_path.open("w", encoding="utf-8") as log:
-        for function_name in functions:
-            command = ["foamPostProcess", "-case", str(case_dir), "-func", function_name]
-            # Preparation is intentionally endpoint-only.  A single retained
-            # endpoint cannot support a transient-history claim, so histories
-            # remain diagnostic unless the candidate already saved them.
-            command.append("-latestTime")
-            record = _run(command, log, 300)
-            record["required"] = function_name != "sample"
-            records.append(record)
-        if original_format == "binary":
-            set_ascii = [
-                "foamDictionary", "-case", str(case_dir), "system/controlDict",
-                "-entry", "writeFormat", "-set", "ascii",
-            ]
-            restore = [
-                "foamDictionary", "-case", str(case_dir), "system/controlDict",
-                "-entry", "writeFormat", "-set", "binary",
-            ]
-            record = _run(set_ascii, log, 60)
-            record["required"] = True
-            records.append(record)
-            try:
-                record = _run([
-                    "foamFormatConvert", "-case", str(case_dir), "-latestTime",
-                ], log, 300)
-                record["required"] = True
-                records.append(record)
-            finally:
-                record = _run(restore, log, 60)
-                record["required"] = True
-                records.append(record)
-    failed = [
-        record for record in records
-        if record.get("required", True) and record.get("return_code") != 0
-    ]
-    optional_failures = [
-        record for record in records
-        if not record.get("required", True) and record.get("return_code") != 0
-    ]
-    result = {
-        "case_id": artifact.case_id,
-        "case_dir": str(case_dir),
-        "status": "pass" if not failed else "fail",
-        "role": "measurement_only",
-        "original_write_format": original_format,
-        "log": str(log_path),
-        "commands": records,
-        "optional_failures": optional_failures,
-    }
-    write_json(case_output / "preparation.json", result)
-    return result
-
-
-def prepare_cases(artifacts: list[CaseArtifact], output_root: Path, jobs: int) -> dict[str, Any]:
-    output_root.mkdir(parents=True, exist_ok=True)
-    records = []
-    with ThreadPoolExecutor(max_workers=max(1, jobs)) as executor:
-        futures = {executor.submit(prepare_case, artifact, output_root): artifact for artifact in artifacts}
-        for future in as_completed(futures):
-            artifact = futures[future]
-            try:
-                records.append(future.result())
-            except Exception as exc:
-                records.append({"case_id": artifact.case_id, "status": "error", "error": str(exc)})
-    records.sort(key=lambda record: record["case_id"])
-    report = {
-        "role": "measurement_only",
-        "case_count": len(records),
-        "pass_count": sum(record["status"] == "pass" for record in records),
-        "fail_count": sum(record["status"] != "pass" for record in records),
-        "cases": records,
-    }
-    write_json(output_root / "preparation_summary.json", report)
-    return report
-
-
-def prepare_campaign(
-    profile: BenchmarkProfile,
-    *,
-    adapter_name: str,
-    run_root: Path,
-    output_root: Path,
-    jobs: int = 1,
-) -> dict[str, Any]:
-    """Prepare derived field QoIs for execution-complete field campaigns."""
-    if profile.extractor not in {"field", "extended"}:
-        raise ValueError("preparation is only applicable to field and Extended QoI profiles")
-    benchmark, references = load_assets(profile)
-    artifacts = create_adapter(adapter_name, run_root, profile).discover()
-    eligible = []
-    for case_id, artifact in artifacts.items():
-        reference = references.get(case_id)
-        if reference is None:
-            continue
-        execution = evaluate_execution(
-            artifact, expected_completion_time(benchmark[case_id], reference)
-        )
-        if execution["status"] == "pass":
-            eligible.append(artifact)
-    return prepare_cases(eligible, output_root, jobs)

benchmarks/evaluation/profiles.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from .io import read_object
-from .models import BenchmarkProfile
-from .schema import validate
-
-
-def load_assets(profile: BenchmarkProfile) -> tuple[dict[str, Any], dict[str, Any]]:
-    benchmark = read_object(profile.benchmark_path)
-    reference_document = read_object(profile.reference_qois_path)
-    validate(reference_document, "foambench_qoi_reference.schema.json")
-    references = reference_document.get("cases")
-    if not isinstance(references, dict):
-        raise ValueError(f"reference QoI file has no cases object: {profile.reference_qois_path}")
-    if len(references) != profile.expected_case_count:
-        raise ValueError(
-            f"profile membership mismatch: expected {profile.expected_case_count}, got {len(references)}"
-        )
-    current_design = (
-        read_object(profile.benchmark_path.parent / "FoamBench_extended_openfoam13_qoi_design.json")
-        if profile.extractor == "extended" else None
-    )
-    for case_id, reference in references.items():
-        principal = reference.get("principal_metrics", [])
-        qois = reference.get("qois", {})
-        tolerances = reference.get("tolerances", {})
-        missing_values = sorted(set(principal) - set(qois))
-        missing_tolerances = sorted(set(principal) - set(tolerances))
-        if missing_values or missing_tolerances:
-            raise ValueError(
-                f"reference QoI contract incomplete for {case_id}: "
-                f"missing_values={missing_values}, missing_tolerances={missing_tolerances}"
-            )
-        if profile.extractor == "extended":
-            from .extbench import design_case_contract
-
-            expected_branch, expected_principal = design_case_contract(case_id, current_design or {})
-            if reference.get("branch_id") != expected_branch:
-                raise ValueError(
-                    f"ExtBench branch drift for {case_id}: "
-                    f"reference={reference.get('branch_id')!r}, design={expected_branch!r}"
-                )
-            if set(principal) != set(expected_principal):
-                raise ValueError(
-                    f"ExtBench principal-metric drift for {case_id}: "
-                    f"reference={sorted(principal)}, design={sorted(expected_principal)}"
-                )
-    benchmark_cases = benchmark.get("cases") if isinstance(benchmark.get("cases"), dict) else benchmark
-    if not isinstance(benchmark_cases, dict):
-        raise ValueError(f"benchmark has no case mapping: {profile.benchmark_path}")
-    missing = sorted(set(references) - set(benchmark_cases))
-    if missing:
-        raise ValueError("benchmark is missing reference cases: " + ", ".join(missing))
-    return benchmark_cases, references
-
-
-def expected_end_time(case: dict[str, Any]) -> float | None:
-    text = case.get("system/controlDict")
-    if not isinstance(text, str):
-        return None
-    import re
-
-    match = re.search(r"(?m)^\s*endTime\s+([-+0-9.eE]+)\s*;", text)
-    return float(match.group(1)) if match else None
-
-
-def expected_completion_time(case: dict[str, Any], reference: dict[str, Any]) -> float | None:
-    latest = reference.get("latest_time")
-    if isinstance(latest, (int, float)):
-        return float(latest)
-    return expected_end_time(case)

benchmarks/evaluation/profiles/advanced.json

@@ -1,19 +0,0 @@
-{
-  "profile_id": "foambench.advanced.v1",
-  "dataset": "advanced",
-  "benchmark_path": "benchmarks/FoamBench_advanced_openfoam13_fixed_final.json",
-  "reference_qois_path": "benchmarks/FoamBench_advanced_openfoam13_reference_qois.json",
-  "membership": {
-    "expected_case_count": 16,
-    "case_id_style": "case_name"
-  },
-  "qoi": {
-    "extractor": "field",
-    "required_fraction": 1.0
-  },
-  "numerical": {
-    "contract": "physics_grounded_qoi.v1",
-    "steady_qoi_plateau": true,
-    "reference_statistics_path": "benchmarks/reference_statistics/advanced.json"
-  }
-}

benchmarks/evaluation/profiles/basic.json

@@ -1,19 +0,0 @@
-{
-  "profile_id": "foambench.basic.v1",
-  "dataset": "basic",
-  "benchmark_path": "benchmarks/FoamBench_basic_openfoam13_fixed_final.json",
-  "reference_qois_path": "benchmarks/FoamBench_basic_openfoam13_reference_qois.json",
-  "membership": {
-    "expected_case_count": 110,
-    "case_id_style": "family_variant"
-  },
-  "qoi": {
-    "extractor": "field",
-    "required_fraction": 1.0
-  },
-  "numerical": {
-    "contract": "physics_grounded_qoi.v1",
-    "steady_qoi_plateau": true,
-    "reference_statistics_path": "benchmarks/reference_statistics/basic.json"
-  }
-}

benchmarks/evaluation/profiles/extended.json

@@ -1,19 +0,0 @@
-{
-  "profile_id": "foambench.extended",
-  "dataset": "extended",
-  "benchmark_path": "benchmarks/FoamBench_extended_openfoam13_fixed.json",
-  "reference_qois_path": "benchmarks/FoamBench_extended_openfoam13_reference_qois.json",
-  "membership": {
-    "expected_case_count": 100,
-    "case_id_style": "family_variant"
-  },
-  "qoi": {
-    "extractor": "extended",
-    "required_fraction": 1.0
-  },
-  "numerical": {
-    "contract": "foambench.qoi.design",
-    "tolerances": "joint_physical_admissibility_and_reference_response_provisional",
-    "reference_statistics_path": "benchmarks/reference_statistics/extended.json"
-  }
-}

benchmarks/evaluation/qoi.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from .comparison import compare_case
-from .extbench import extract_contract_case
-
-from .field_candidate import extract_field_candidate
-from .models import BenchmarkProfile, CaseArtifact
-from .schema import validate
-
-
-def empty_candidate(case_id: str, status: str, reason: str) -> dict[str, Any]:
-    return {
-        "schema_version": "foambench.qoi.candidate",
-        "case_id": case_id,
-        "status": status,
-        "qois": {},
-        "health": {"status": "not_assessed", "reason": reason},
-    }
-
-
-def evaluate_qoi(
-    artifact: CaseArtifact,
-    profile: BenchmarkProfile,
-    reference: dict[str, Any],
-    *,
-    execution_pass: bool,
-) -> dict[str, Any]:
-    if not execution_pass or artifact.case_dir is None:
-        return {
-            "status": "not_evaluated_execution_failure",
-            "physics_grounded_qoi_pass": False,
-            "effective_pass_ratio": 0.0,
-            "candidate": empty_candidate(
-                artifact.case_id, "not_evaluated_execution_failure", "execution_not_passed"
-            ),
-            "comparison": None,
-        }
-    try:
-        if profile.extractor == "extended":
-            candidate = extract_contract_case(artifact.case_dir, artifact.case_id)
-            required = candidate.get("required_metrics", [])
-        elif profile.extractor == "field":
-            required = reference.get("principal_metrics")
-            if not isinstance(required, list):
-                required = list(reference.get("qois", {}))
-            requested = list(reference.get("qois", {}))
-            candidate = extract_field_candidate(
-                artifact.case_dir,
-                artifact.case_id,
-                requested,
-                required_metrics=required,
-                log_paths=list(artifact.solver_logs),
-            )
-        else:
-            raise ValueError(f"unknown QoI extractor: {profile.extractor}")
-        validate(candidate, "foambench_qoi_candidate.schema.json")
-        comparison = compare_case(reference, candidate, profile.required_qoi_fraction)
-        validate(comparison, "foambench_qoi_comparison.schema.json")
-        health = candidate.get("health")
-        health_pass = not isinstance(health, dict) or health.get("status") in {None, "pass"}
-        physics_grounded_qoi = bool(comparison.get("physics_grounded_qoi_pass") and health_pass)
-        return {
-            "status": "pass" if physics_grounded_qoi else str(comparison.get("status", "fail")),
-            "physics_grounded_qoi_pass": physics_grounded_qoi,
-            "effective_pass_ratio": float(comparison.get("qoi_pass_ratio", 0.0)) if health_pass else 0.0,
-            "candidate": candidate,
-            "comparison": comparison,
-        }
-    except Exception as exc:
-        return {
-            "status": "evaluation_error",
-            "physics_grounded_qoi_pass": False,
-            "effective_pass_ratio": 0.0,
-            "candidate": empty_candidate(artifact.case_id, "error", str(exc)),
-            "comparison": None,
-            "error": str(exc),
-        }

benchmarks/evaluation/qoi_glue.py

@@ -1,493 +0,0 @@
-#!/usr/bin/env python3
-"""Conservative LLM-assisted recovery for incomplete Extended QoI evidence.
-
-The model is an evidence router only.  It selects an existing file/column and
-an allow-listed deterministic operation; this module computes the observation
-and validates the source locally.  Reference QoI values are never included in
-the model packet.
-"""
-from __future__ import annotations
-
-import copy
-import csv
-import hashlib
-import json
-import math
-import os
-import re
-import subprocess
-from pathlib import Path
-from typing import Any
-
-
-ROOT = Path(__file__).resolve().parents[2]
-GLUE_VERSION = "foambench.qoi_glue.v1"
-PLAN_SCHEMA = ROOT / "schemas/qoi_recovery_plan.schema.json"
-TABLE_SUFFIXES = {".csv", ".dat", ".raw", ".xy"}
-TIME_COLUMN = "Time"
-MASS_COLUMNS = {
-    "rhophi",
-    "massflow",
-    "massflux",
-    "sumphi",
-    "areaintegratephi",
-}
-EXPECTED_BRANCHES = {"Re_tau_180", "Re_tau_395", "Re_tau_590"}
-
-
-def _enabled() -> bool:
-    return os.environ.get("EVOLUTION_QOI_GLUE", "off").strip().lower() in {
-        "1", "true", "on", "yes",
-    }
-
-
-def _model() -> str:
-    return (
-        os.environ.get("evolution_QOI_GLUE_MODEL")
-        or os.environ.get("evolution_EVALUATION_MODEL")
-        or "gpt-5.6-terra"
-    )
-
-
-def _reasoning() -> str | None:
-    return (
-        os.environ.get("evolution_QOI_GLUE_REASONING_EFFORT")
-        or os.environ.get("evolution_EVALUATION_REASONING_EFFORT")
-        or os.environ.get("evolution_REASONING_EFFORT")
-    )
-
-
-def _timeout() -> float:
-    raw = os.environ.get("EVOLUTION_QOI_GLUE_TIMEOUT", "180")
-    try:
-        return max(5.0, float(raw))
-    except ValueError:
-        return 180.0
-
-
-def _normalise(value: str) -> str:
-    return re.sub(r"[^a-z0-9]", "", value.lower().replace("+", "plus"))
-
-
-def _finite(value: Any) -> float | None:
-    if isinstance(value, bool) or not isinstance(value, (int, float)):
-        return None
-    result = float(value)
-    return result if math.isfinite(result) else None
-
-
-def _safe_source(case_dir: Path, raw: Any) -> Path:
-    if not isinstance(raw, str) or not raw or Path(raw).is_absolute():
-        raise ValueError("source must be a relative case path")
-    source = (case_dir / raw).resolve(strict=True)
-    if not source.is_relative_to(case_dir.resolve(strict=True)):
-        raise ValueError("source escapes the case directory")
-    if not source.is_file():
-        raise ValueError("source is not a file")
-    return source
-
-
-def _evidence_path(case_dir: Path, source: Path) -> str:
-    return source.relative_to(case_dir.resolve(strict=True)).as_posix()
-
-
-def _field_dimensions(case_dir: Path, field: str) -> str | None:
-    for path in sorted(case_dir.rglob(field), reverse=True):
-        if not path.is_file() or not path.parent.name.replace(".", "", 1).isdigit():
-            continue
-        text = path.read_bytes()[:4096].decode("ascii", errors="ignore")
-        match = re.search(r"dimensions\s*\[([^]]+)\]", text)
-        if match:
-            return " ".join(match.group(1).split())
-    return None
-
-
-def _named_numeric_rows(path: Path) -> tuple[list[str], list[list[float]]]:
-    """Read a compatible numeric table without accepting arbitrary prose."""
-    headers: list[list[str]] = []
-    rows: list[list[float]] = []
-    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
-        stripped = line.strip()
-        if not stripped:
-            continue
-        if stripped.startswith("#"):
-            names = stripped[1:].strip().replace(",", " ").replace("\t", " ").split()
-            if names:
-                headers.append(names)
-            continue
-        parts = stripped.replace("(", " ").replace(")", " ").replace(",", " ").split()
-        if parts and all(re.fullmatch(r"[-+0-9.eE]+", item) for item in parts):
-            rows.append([float(item) for item in parts])
-        elif not rows and ("," in stripped or "\t" in stripped):
-            names = [item.strip() for item in stripped.split(",")] if "," in stripped else stripped.split("\t")
-            if names:
-                headers.append(names)
-    if not rows:
-        return [], []
-    width = len(rows[0])
-    header = next((names for names in reversed(headers) if len(names) == width), [])
-    return header, [row for row in rows if len(row) == width]
-
-
-def _case_fingerprint(case_dir: Path) -> str:
-    digest = hashlib.sha256()
-    for path in sorted(item for item in case_dir.rglob("*") if item.is_file()):
-        relative = path.relative_to(case_dir).as_posix().encode("utf-8")
-        digest.update(len(relative).to_bytes(8, "big"))
-        digest.update(relative)
-        digest.update(path.stat().st_size.to_bytes(8, "big"))
-        with path.open("rb") as stream:
-            for block in iter(lambda: stream.read(1024 * 1024), b""):
-                digest.update(block)
-    return digest.hexdigest()
-
-
-def _inventory(case_dir: Path) -> list[dict[str, Any]]:
-    entries: list[dict[str, Any]] = []
-    candidates = [item for item in case_dir.rglob("*") if item.is_file()]
-    candidates.sort(key=lambda item: (item.suffix.lower() not in TABLE_SUFFIXES, str(item)))
-    for path in candidates[:180]:
-        relative = path.relative_to(case_dir).as_posix()
-        item: dict[str, Any] = {"path": relative, "bytes": path.stat().st_size}
-        if path.suffix.lower() in TABLE_SUFFIXES and path.stat().st_size <= 512 * 1024:
-            sample = path.read_text(encoding="utf-8", errors="ignore")[:1600]
-            item["sample"] = sample
-        elif path.name in {"phi", "C", "U", "Vc", "p", "alpha.water"}:
-            sample = path.read_bytes()[:4096].decode("ascii", errors="ignore")
-            match = re.search(r"dimensions\s*\[([^]]+)\]", sample)
-            if match:
-                item["dimensions"] = " ".join(match.group(1).split())
-        entries.append(item)
-    return entries
-
-
-def build_packet(
-    case_dir: Path,
-    case_id: str,
-    candidate: dict[str, Any],
-    comparison: dict[str, Any],
-) -> dict[str, Any]:
-    """Create the small, reference-free packet supplied to the model."""
-    return {
-        "schema_version": GLUE_VERSION,
-        "case_id": case_id,
-        "family": case_id.split("/", 1)[0] if "/" in case_id else case_id,
-        "required_metrics": list(candidate.get("required_metrics", [])),
-        "missing_metrics": list(candidate.get("missing_metrics", [])),
-        "extraction_errors": list(candidate.get("extraction_errors", [])),
-        "comparison_status": comparison.get("status"),
-        "allowed_operations": {
-            "table_time_history": "Read an explicit Time plus one flux column; preserve signed values and phi dimensions.",
-            "branch_spalding_table": "Split one labelled table by branch and compute branch wall-law scalars only when yPlus and spaldingYPlus columns exist.",
-        },
-        "files": _inventory(case_dir),
-    }
-
-
-def _prompt(packet: dict[str, Any]) -> str:
-    return (
-        "You are a conservative CFD measurement-evidence router.\n"
-        "Reference QoI values are unavailable and must not be requested or inferred.\n"
-        "Do not calculate or emit QoI numbers. Return only JSON matching the supplied schema.\n"
-        "Select an existing file and columns only when they are physically equivalent to a declared principal metric.\n"
-        "Use status=unrecoverable when evidence is absent, ambiguous, a proxy, or has the wrong physical quantity.\n"
-        "Allowed operations are exactly table_time_history and branch_spalding_table.\n\n"
-        "Evidence packet:\n" + json.dumps(packet, ensure_ascii=False, indent=2)
-    )
-
-
-def _cache_path(campaign_root: Path, case_dir: Path, case_id: str, missing: list[str], model: str) -> Path:
-    identity = {
-        "version": GLUE_VERSION,
-        "case_id": case_id,
-        "missing": sorted(missing),
-        "model": model,
-        "fingerprint": _case_fingerprint(case_dir),
-    }
-    key = hashlib.sha256(json.dumps(identity, sort_keys=True).encode("utf-8")).hexdigest()
-    return campaign_root / "cache" / "qoi_glue" / f"{key}.json"
-
-
-def _write_json(path: Path, value: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    temporary.replace(path)
-
-
-def _load_cached(path: Path) -> dict[str, Any] | None:
-    if not path.is_file():
-        return None
-    try:
-        value = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    return value if isinstance(value, dict) else None
-
-
-def _run_model(
-    case_dir: Path,
-    packet: dict[str, Any],
-    artifact: Path,
-) -> dict[str, Any]:
-    from scripts.evolution_adapter_common import codex_exec_command
-
-    model = _model()
-    artifact.parent.mkdir(parents=True, exist_ok=True)
-    final_message = artifact.with_suffix(".last_message.json")
-    trajectory = artifact.with_suffix(".trajectory.jsonl")
-    command = codex_exec_command(
-        case_dir,
-        final_message,
-        model,
-        output_schema=PLAN_SCHEMA if PLAN_SCHEMA.is_file() else None,
-        reasoning_effort=_reasoning(),
-        sandbox="read-only",
-    )
-    try:
-        completed = subprocess.run(
-            command,
-            input=_prompt(packet),
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            cwd=case_dir,
-            timeout=_timeout(),
-            check=False,
-        )
-    except (OSError, subprocess.TimeoutExpired) as exc:
-        return {
-            "status": "unavailable",
-            "model": model,
-            "error": str(exc),
-            "command": command,
-        }
-    trajectory.write_text(completed.stdout, encoding="utf-8")
-    if completed.returncode != 0:
-        return {
-            "status": "unavailable",
-            "model": model,
-            "return_code": completed.returncode,
-            "stderr_tail": completed.stderr[-2000:],
-            "command": command,
-        }
-    try:
-        plan = json.loads(final_message.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError) as exc:
-        return {
-            "status": "invalid_response",
-            "model": model,
-            "error": str(exc),
-            "stderr_tail": completed.stderr[-2000:],
-        }
-    if not isinstance(plan, dict):
-        return {"status": "invalid_response", "model": model, "error": "plan is not an object"}
-    return {
-        "status": "received",
-        "model": model,
-        "return_code": completed.returncode,
-        "plan": plan,
-        "stderr_tail": completed.stderr[-2000:],
-    }
-
-
-def _validate_mapping(mapping: dict[str, Any], required: set[str]) -> None:
-    metric = mapping.get("metric")
-    if not isinstance(metric, str) or metric not in required:
-        raise ValueError("mapping metric is not a missing principal metric")
-    operation = mapping.get("operation")
-    if operation not in {"table_time_history", "branch_spalding_table"}:
-        raise ValueError("operation is not allow-listed")
-    if operation == "table_time_history":
-        column = mapping.get("column")
-        if not isinstance(column, str) or not column:
-            raise ValueError("table_time_history requires a column")
-    if operation == "branch_spalding_table":
-        if metric != "branchwise_wall_law_metrics":
-            raise ValueError("branch_spalding_table has one supported metric")
-        if mapping.get("branch_column") != "branch":
-            raise ValueError("branch_spalding_table requires a branch column")
-
-
-def _execute_time_history(case_dir: Path, mapping: dict[str, Any]) -> tuple[dict[str, Any], list[str]]:
-    source = _safe_source(case_dir, mapping.get("source"))
-    header, rows = _named_numeric_rows(source)
-    if TIME_COLUMN not in header:
-        raise ValueError("table has no Time column")
-    column = str(mapping["column"])
-    if column not in header or _normalise(column) not in MASS_COLUMNS:
-        raise ValueError("column is not an allow-listed explicit flux column")
-    if "inlet" not in str(source).lower() and str(mapping.get("patch", "")).lower() not in {"inlet", "inlet1", "main"}:
-        raise ValueError("mass-flow source is not identified as an inlet")
-    dimensions = _field_dimensions(case_dir, "phi")
-    quantity = {
-        "1 0 -1 0 0 0 0": "explicit_mass_flow",
-        "0 3 -1 0 0 0 0": "explicit_volumetric_flow",
-    }.get(dimensions)
-    if quantity is None:
-        raise ValueError("phi dimensions are absent or unsupported")
-    time_index, value_index = header.index(TIME_COLUMN), header.index(column)
-    points = [
-        {"time": row[time_index], "value": row[value_index]}
-        for row in rows
-        if math.isfinite(row[time_index]) and math.isfinite(row[value_index])
-    ]
-    if not points:
-        raise ValueError("table has no finite history points")
-    branch = "root"
-    parent = source.relative_to(case_dir).parts
-    if "postProcessing" in parent:
-        branch = "/".join(parent[: parent.index("postProcessing")]) or "root"
-    history: dict[str, Any] = {
-        "kind": "time_history",
-        "quantity": quantity,
-        "field_dimensions": dimensions,
-        "points": sorted(points, key=lambda item: item["time"]),
-    }
-    if branch != "root":
-        history = {
-            "kind": "branched_time_histories",
-            "quantity": quantity,
-            "field_dimensions": dimensions,
-            "branches": {branch: history},
-        }
-    return history, [_evidence_path(case_dir, source)]
-
-
-def _csv_rows(path: Path) -> tuple[list[str], list[dict[str, str]]]:
-    with path.open(newline="", encoding="utf-8", errors="ignore") as stream:
-        reader = csv.DictReader(stream)
-        rows = [dict(row) for row in reader if row]
-        return list(reader.fieldnames or []), rows
-
-
-def _execute_branch_spalding(case_dir: Path, mapping: dict[str, Any]) -> tuple[dict[str, Any], list[str]]:
-    source = _safe_source(case_dir, mapping.get("source"))
-    columns, rows = _csv_rows(source)
-    normalised = {_normalise(column): column for column in columns}
-    branch_name = normalised.get("branch")
-    y_name = normalised.get("yplus")
-    predicted_name = normalised.get("spaldingyplus")
-    if not branch_name or not y_name or not predicted_name:
-        raise ValueError("branch table requires branch, yPlus, and spaldingYPlus columns")
-    branches: dict[str, Any] = {}
-    for branch in EXPECTED_BRANCHES:
-        selected = [row for row in rows if row.get(branch_name) == branch]
-        if not selected:
-            raise ValueError(f"branch table is missing {branch}")
-        errors: list[float] = []
-        y_values: list[float] = []
-        for row in selected:
-            yplus = _finite(float(row[y_name])) if row.get(y_name) else None
-            predicted = _finite(float(row[predicted_name])) if row.get(predicted_name) else None
-            if yplus is None or predicted is None or yplus < 0 or predicted < 0:
-                continue
-            y_values.append(yplus)
-            errors.append(math.log1p(yplus) - math.log1p(predicted))
-        if not errors or not y_values:
-            raise ValueError(f"branch {branch} has no finite wall-law rows")
-        branches[branch] = {
-            "first_cell_yplus": min(y_values),
-            "spalding_log_rmse": math.sqrt(sum(item * item for item in errors) / len(errors)),
-        }
-    return {"kind": "branch_scalars", "branches": branches}, [_evidence_path(case_dir, source)]
-
-
-def apply_plan(
-    case_dir: Path,
-    candidate: dict[str, Any],
-    plan: dict[str, Any],
-) -> tuple[dict[str, Any], dict[str, Any]]:
-    """Apply a validated plan; any ambiguity leaves the candidate unchanged."""
-    if plan.get("status") != "recoverable":
-        return copy.deepcopy(candidate), {"status": str(plan.get("status", "unrecoverable")), "reason": plan.get("reason")}
-    mappings = plan.get("mappings")
-    required = set(candidate.get("missing_metrics", []))
-    if not isinstance(mappings, list) or not mappings:
-        return copy.deepcopy(candidate), {"status": "invalid_plan", "reason": "recoverable plan has no mappings"}
-    result = copy.deepcopy(candidate)
-    selected: dict[str, Any] = {}
-    try:
-        for mapping in mappings:
-            if not isinstance(mapping, dict):
-                raise ValueError("mapping is not an object")
-            _validate_mapping(mapping, required)
-            metric = str(mapping["metric"])
-            if metric in selected:
-                raise ValueError(f"duplicate mapping for {metric}")
-            if mapping["operation"] == "table_time_history":
-                value, evidence = _execute_time_history(case_dir, mapping)
-                method = "qoi_glue.table_time_history.v1"
-            else:
-                value, evidence = _execute_branch_spalding(case_dir, mapping)
-                method = "qoi_glue.branch_spalding_table.v1"
-            selected[metric] = {"value": value, "evidence": evidence, "method": method}
-    except (OSError, ValueError, TypeError, KeyError) as exc:
-        return copy.deepcopy(candidate), {"status": "rejected", "reason": str(exc), "plan": plan}
-    qois = result.setdefault("qois", {})
-    evidence = result.setdefault("evidence", {})
-    methods = result.setdefault("metric_methods", {})
-    resolver = result.setdefault("resolver_report", {})
-    for metric, item in selected.items():
-        qois[metric] = item["value"]
-        evidence[metric] = item["evidence"]
-        methods[metric] = item["method"]
-        resolver[metric] = {
-            "status": "selected",
-            "selected_evidence": item["evidence"],
-            "method": item["method"],
-            "physical_validation": "qoi_glue.allowlisted_operation.v1",
-        }
-    required_metrics = list(result.get("required_metrics", []))
-    missing = sorted(set(required_metrics) - set(qois))
-    result["missing_metrics"] = missing
-    extraction_errors = list(result.get("extraction_errors", []))
-    result["status"] = "complete" if not missing and not extraction_errors else "incomplete"
-    health = result.setdefault("health", {})
-    health["status"] = "pass" if not missing and not extraction_errors else "incomplete"
-    checks = health.setdefault("checks", {})
-    checks["principal_qoi_complete"] = not missing
-    checks["principal_extraction_error_free"] = not extraction_errors
-    return result, {
-        "status": "recovered_complete" if not missing and not extraction_errors else "recovered_partial",
-        "metrics": sorted(selected),
-        "evidence": {metric: item["evidence"] for metric, item in selected.items()},
-        "methods": {metric: item["method"] for metric, item in selected.items()},
-        "plan": plan,
-    }
-
-
-def recover_with_llm(
-    case_dir: Path,
-    case_id: str,
-    candidate: dict[str, Any],
-    comparison: dict[str, Any],
-    campaign_root: Path,
-) -> tuple[dict[str, Any], dict[str, Any]]:
-    """Recover one incomplete candidate, with one cached model call at most."""
-    if not _enabled():
-        return copy.deepcopy(candidate), {"status": "disabled", "version": GLUE_VERSION}
-    missing = list(candidate.get("missing_metrics", []))
-    if not missing:
-        return copy.deepcopy(candidate), {"status": "not_needed", "version": GLUE_VERSION}
-    model = _model()
-    artifact = _cache_path(campaign_root, case_dir, case_id, missing, model)
-    cached = _load_cached(artifact)
-    if cached is None:
-        packet = build_packet(case_dir, case_id, candidate, comparison)
-        cached = _run_model(case_dir, packet, artifact)
-        cached["version"] = GLUE_VERSION
-        cached["case_id"] = case_id
-        cached["missing_metrics"] = sorted(missing)
-        _write_json(artifact, cached)
-    plan = cached.get("plan") if isinstance(cached.get("plan"), dict) else {"status": cached.get("status", "unavailable")}
-    recovered, detail = apply_plan(case_dir, candidate, plan)
-    detail.update({
-        "version": GLUE_VERSION,
-        "artifact": str(artifact),
-        "model": cached.get("model", model),
-        "execution_status": cached.get("status"),
-    })
-    return recovered, detail

benchmarks/evaluation/qoi_reference.py

@@ -1,566 +0,0 @@
-#!/usr/bin/env python3
-"""Build canonical FoamBench QoI reference datasets from completed runs.
-
-The extractor uses family-level principal result groups, volume-weighted
-generic diagnostics, and geometry-aware normalized probes. It never edits the
-benchmark source JSON.
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import math
-import os
-import re
-import subprocess
-import sys
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Callable
-
-ROOT = Path(__file__).resolve().parents[2]
-if str(ROOT) not in sys.path:
-    sys.path.insert(0, str(ROOT))
-
-from benchmarks.evaluation.foam_io import field_path
-from benchmarks.evaluation.schema import validate
-
-try:
-    from benchmarks.evaluation.field_extractor import (
-        ExtractionError, FATAL_RE, extract_case_qois, latest_time_dir, magnitude,
-        parse_log_metrics, parse_scalar_field, parse_vector_field, read_text,
-    )
-except ImportError:  # Direct script execution keeps the historical CLI working.
-    from field_extractor import (
-        ExtractionError, FATAL_RE, extract_case_qois, latest_time_dir, magnitude,
-        parse_log_metrics, parse_scalar_field, parse_vector_field, read_text,
-    )
-
-
-SCHEMA_VERSION = "foambench.reference_qois.v2"
-TOLERANCE_POLICY = "principal_relative_15pct_abs_floor_1e-8.v1"
-COMMON_SCALAR_FIELDS = (
-    "p", "p_rgh", "T", "rho", "nut", "k", "epsilon", "omega",
-    "nuTilda", "Qdot", "CH4", "O2", "CO2", "H2O", "N2",
-    "alpha.water", "h", "hTotal",
-)
-POSITIVE_FIELDS = {"T", "rho", "k", "epsilon", "omega", "nuTilda", "h", "hTotal"}
-ADVANCED_TEMPLATE = {
-    "Cavity_LES": "Cavity",
-    "Cavity_SA": "Cavity",
-    "Cavity_geometry_1": "Cavity",
-    "Cylinder_LES": "Cylinder",
-    "Cylinder_SA": "Cylinder",
-    "Diamond_Obstacle_KOMEGASST": "Obstacle",
-    "Diamond_Obstacle_SA": "Obstacle",
-    "Double_Square_SA": "Obstacle",
-    "Rectangular_Obstacle_KOMEGASST": "Obstacle",
-    "Rectangular_Obstacle_SA": "Obstacle",
-    "counterFlowFlame2D_KE": "counterFlowFlame2D",
-    "counterFlowFlame2D_SA": "counterFlowFlame2D",
-    "nozzleFlow2D_SA": "Nozzle",
-    "obliqueShock_KE": "Shock",
-    "obliqueShock_LES": "Shock",
-    "wedge_SA": "Shock",
-}
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def write_json(path: Path, value: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-    temporary.replace(path)
-
-
-def scalar_field(time_dir: Path, name: str) -> list[float]:
-    path = field_path(time_dir, name)
-    return parse_scalar_field(path) if path else []
-
-
-def vector_field(time_dir: Path, name: str) -> list[tuple[float, float, float]]:
-    path = field_path(time_dir, name)
-    return parse_vector_field(path) if path else []
-
-
-def align(values: list[Any], count: int) -> list[Any]:
-    if len(values) == count:
-        return values
-    if len(values) == 1 and count:
-        return values * count
-    return []
-
-
-def weighted_mean(values: list[float], weights: list[float]) -> float | None:
-    if not values or len(values) != len(weights):
-        return None
-    denominator = sum(weights)
-    return sum(value * weight for value, weight in zip(values, weights)) / denominator if denominator else None
-
-
-def weighted_stats(values: list[float], weights: list[float]) -> dict[str, float]:
-    pairs = [(value, weight) for value, weight in zip(values, weights) if math.isfinite(value) and math.isfinite(weight)]
-    if not pairs:
-        return {}
-    clean_values = [value for value, _ in pairs]
-    clean_weights = [weight for _, weight in pairs]
-    mean = weighted_mean(clean_values, clean_weights)
-    return {
-        "min": min(clean_values),
-        "max": max(clean_values),
-        "volume_mean": float(mean),
-    } if mean is not None else {}
-
-
-def bounds(centres: list[tuple[float, float, float]]) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
-    return (
-        tuple(min(point[axis] for point in centres) for axis in range(3)),
-        tuple(max(point[axis] for point in centres) for axis in range(3)),
-    )
-
-
-def normalized_point(centres: list[tuple[float, float, float]], fraction: tuple[float, float, float]) -> tuple[float, float, float]:
-    low, high = bounds(centres)
-    return tuple(low[axis] + fraction[axis] * (high[axis] - low[axis]) for axis in range(3))
-
-
-def nearest_index(centres: list[tuple[float, float, float]], fraction: tuple[float, float, float]) -> int:
-    target = normalized_point(centres, fraction)
-    low, high = bounds(centres)
-    scale = [max(high[axis] - low[axis], 1e-12) for axis in range(3)]
-    return min(
-        range(len(centres)),
-        key=lambda index: sum(((centres[index][axis] - target[axis]) / scale[axis]) ** 2 for axis in range(3)),
-    )
-
-
-def scalar_probe(values: list[float], centres: list[tuple[float, float, float]], fraction: tuple[float, float, float]) -> float | None:
-    return values[nearest_index(centres, fraction)] if len(values) == len(centres) else None
-
-
-def speed_probe(velocities: list[tuple[float, float, float]], centres: list[tuple[float, float, float]], fraction: tuple[float, float, float]) -> float | None:
-    if len(velocities) != len(centres):
-        return None
-    x, y, z = velocities[nearest_index(centres, fraction)]
-    return math.sqrt(x * x + y * y + z * z)
-
-
-def probe_drop(values: list[float], centres: list[tuple[float, float, float]]) -> float | None:
-    upstream = scalar_probe(values, centres, (0.2, 0.5, 0.5))
-    downstream = scalar_probe(values, centres, (0.8, 0.5, 0.5))
-    return upstream - downstream if upstream is not None and downstream is not None else None
-
-
-def pressure_ratio(pressures: list[float]) -> float | None:
-    positive = [value for value in pressures if math.isfinite(value) and value > 1e-12]
-    return max(positive) / min(positive) if positive else None
-
-
-def thermo_parameters(case_dir: Path) -> tuple[float, float]:
-    text = read_text(case_dir / "constant" / "physicalProperties")
-    mol_weight_match = re.search(r"(?m)^\s*molWeight\s+([-+0-9.eE]+)\s*;", text)
-    cp_match = re.search(r"(?m)^\s*Cp\s+([-+0-9.eE]+)\s*;", text)
-    if not mol_weight_match or not cp_match:
-        return 1.4, 0.7143
-    mol_weight = float(mol_weight_match.group(1))
-    cp = float(cp_match.group(1))
-    gas_constant = 8314.46261815324 / mol_weight if mol_weight > 0 else 0.0
-    gamma = cp / (cp - gas_constant) if cp > gas_constant else 1.4
-    return gamma, gas_constant if gas_constant > 0 else 0.7143
-
-
-def mach_values(
-    velocities: list[tuple[float, float, float]],
-    temperatures: list[float],
-    gamma: float,
-    gas_constant: float,
-) -> list[float]:
-    if len(temperatures) == 1 and velocities:
-        temperatures = temperatures * len(velocities)
-    if len(velocities) != len(temperatures):
-        return []
-    return [
-        speed / math.sqrt(gamma * gas_constant * temperature)
-        for speed, temperature in zip(magnitude(velocities), temperatures)
-        if temperature > 0 and math.isfinite(temperature)
-    ]
-
-
-def shock_location(pressures: list[float], centres: list[tuple[float, float, float]]) -> float | None:
-    if len(pressures) != len(centres) or len(pressures) < 2:
-        return None
-    low, high = bounds(centres)
-    y_span = max(high[1] - low[1], 1e-12)
-    z_span = max(high[2] - low[2], 1e-12)
-    y_mid = 0.5 * (low[1] + high[1])
-    z_mid = 0.5 * (low[2] + high[2])
-    selected = [
-        (point[0], value)
-        for point, value in zip(centres, pressures)
-        if abs(point[1] - y_mid) <= 0.08 * y_span and abs(point[2] - z_mid) <= 0.51 * z_span
-    ]
-    selected.sort()
-    if len(selected) < 2:
-        return None
-    best_x, best_gradient = None, -1.0
-    for (x0, p0), (x1, p1) in zip(selected, selected[1:]):
-        dx = x1 - x0
-        if dx <= 1e-12:
-            continue
-        gradient = abs(p1 - p0) / dx
-        if gradient > best_gradient:
-            best_x, best_gradient = 0.5 * (x0 + x1), gradient
-    return best_x
-
-
-def phase_front(alpha: list[float], centres: list[tuple[float, float, float]]) -> float | None:
-    wet = [point[0] for value, point in zip(alpha, centres) if value >= 0.5]
-    return max(wet) if wet else None
-
-
-def add_metric(target: dict[str, float], name: str, value: float | None) -> None:
-    if value is not None and math.isfinite(value):
-        target[name] = float(value)
-
-
-def family_metrics(
-    case_dir: Path,
-    template: str,
-    scalars: dict[str, list[float]],
-    velocities: list[tuple[float, float, float]],
-    vorticity: list[tuple[float, float, float]],
-    centres: list[tuple[float, float, float]],
-    volumes: list[float],
-) -> tuple[str, dict[str, float]]:
-    metrics: dict[str, float] = {}
-    speed = magnitude(velocities)
-    vort_mag = magnitude(vorticity)
-    pressures = scalars.get("p", [])
-    temperatures = scalars.get("T", [])
-    gamma, gas_constant = thermo_parameters(case_dir)
-    mach = mach_values(velocities, temperatures, gamma, gas_constant)
-
-    if template == "BernardCells":
-        group = "thermal_state"
-        stats = weighted_stats(temperatures, volumes)
-        add_metric(metrics, "T_volume_mean", stats.get("volume_mean"))
-        add_metric(metrics, "T_max", stats.get("max"))
-    elif template == "Cavity":
-        group = "cavity_response"
-        add_metric(metrics, "U_center_probe", speed_probe(velocities, centres, (0.5, 0.5, 0.5)))
-        add_metric(metrics, "vorticity_volume_mean", weighted_mean(vort_mag, volumes))
-    elif template == "Cylinder":
-        group = "wake_response"
-        add_metric(metrics, "U_wake_probe", speed_probe(velocities, centres, (0.75, 0.5, 0.5)))
-        add_metric(metrics, "vorticity_volume_mean", weighted_mean(vort_mag, volumes))
-    elif template == "counterFlowFlame2D":
-        group = "flame_response"
-        add_metric(metrics, "T_max", max(temperatures) if temperatures else None)
-        add_metric(metrics, "CO2_volume_mean", weighted_mean(scalars.get("CO2", []), volumes))
-    elif template == "damBreakWithObstacle":
-        group = "free_surface_response"
-        alpha = scalars.get("alpha.water", [])
-        add_metric(metrics, "front_position", phase_front(alpha, centres))
-        add_metric(metrics, "water_volume", sum(value * volume for value, volume in zip(alpha, volumes)))
-    elif template == "forwardStep":
-        group = "shock_response"
-        add_metric(metrics, "shock_location", shock_location(pressures, centres))
-        add_metric(metrics, "pressure_ratio", pressure_ratio(pressures))
-    elif template in {"obliqueShock", "wedge", "Shock"}:
-        group = "shock_response"
-        add_metric(metrics, "pressure_ratio", pressure_ratio(pressures))
-        add_metric(metrics, "Mach_volume_mean", weighted_mean(mach, volumes))
-    elif template == "pitzDaily":
-        group = "separation_response"
-        add_metric(metrics, "pressure_probe_drop", probe_drop(pressures, centres))
-        add_metric(metrics, "U_downstream_probe", speed_probe(velocities, centres, (0.8, 0.5, 0.5)))
-    elif template == "shallowWaterWithSquareBump":
-        group = "surface_response"
-        heights = scalars.get("h", [])
-        fluxes = scalars.get("_hU_magnitude", [])
-        froude = [flux / abs(height) / math.sqrt(9.81 * height) if height > 0 else 0.0 for flux, height in zip(fluxes, heights)]
-        add_metric(metrics, "h_volume_mean", weighted_mean(heights, volumes))
-        add_metric(metrics, "Froude_volume_mean", weighted_mean(froude, volumes))
-    elif template == "squareBend":
-        group = "bend_response"
-        add_metric(metrics, "pressure_probe_drop", probe_drop(pressures, centres))
-        add_metric(metrics, "Mach_volume_mean", weighted_mean(mach, volumes))
-    elif template == "Obstacle":
-        group = "obstacle_response"
-        add_metric(metrics, "pressure_probe_drop", probe_drop(pressures, centres))
-        add_metric(metrics, "U_wake_probe", speed_probe(velocities, centres, (0.8, 0.5, 0.5)))
-    elif template == "Nozzle":
-        group = "nozzle_response"
-        add_metric(metrics, "pressure_probe_drop", probe_drop(pressures, centres))
-        add_metric(metrics, "U_outlet_probe", speed_probe(velocities, centres, (0.9, 0.5, 0.5)))
-    else:
-        raise ValueError(f"no QoI family template for {template}")
-    return group, metrics
-
-
-def tolerance(value: float) -> dict[str, float]:
-    margin = max(abs(value) * 0.15, 1e-8)
-    return {
-        "reference_value": value,
-        "low": value - margin,
-        "high": value + margin,
-        "relative_tolerance": 0.15,
-        "absolute_floor": 1e-8,
-    }
-
-
-def prepare_case(case_dir: Path) -> dict[str, Any]:
-    commands = (
-        ("writeCellCentres",),
-        ("writeCellVolumes",),
-        ("vorticity",),
-    )
-    records = []
-    log_path = case_dir / "qoi_postprocess.log"
-    with log_path.open("w", encoding="utf-8") as log:
-        for function_name, in commands:
-            completed = subprocess.run(
-                ["foamPostProcess", "-case", str(case_dir), "-func", function_name, "-latestTime"],
-                stdout=log,
-                stderr=subprocess.STDOUT,
-                check=False,
-                text=True,
-                timeout=300,
-            )
-            records.append({"function": function_name, "return_code": completed.returncode})
-        control_path = case_dir / "system" / "controlDict"
-        control = read_text(control_path)
-        if re.search(r"(?m)^\s*writeFormat\s+binary\s*;", control):
-            set_ascii = subprocess.run(
-                ["foamDictionary", "-case", str(case_dir), "system/controlDict", "-entry", "writeFormat", "-set", "ascii"],
-                stdout=log, stderr=subprocess.STDOUT, check=False, text=True, timeout=60,
-            )
-            converted = subprocess.run(
-                ["foamFormatConvert", "-case", str(case_dir), "-latestTime"],
-                stdout=log, stderr=subprocess.STDOUT, check=False, text=True, timeout=300,
-            )
-            restored = subprocess.run(
-                ["foamDictionary", "-case", str(case_dir), "system/controlDict", "-entry", "writeFormat", "-set", "binary"],
-                stdout=log, stderr=subprocess.STDOUT, check=False, text=True, timeout=60,
-            )
-            records.append({
-                "function": "convertLatestTimeToAscii",
-                "return_code": converted.returncode,
-                "set_ascii_return_code": set_ascii.returncode,
-                "restore_binary_return_code": restored.returncode,
-            })
-    return {"case_dir": str(case_dir), "commands": records}
-
-
-def prepare_all(case_dirs: list[Path], jobs: int) -> list[dict[str, Any]]:
-    records = []
-    with ThreadPoolExecutor(max_workers=jobs) as executor:
-        futures = {executor.submit(prepare_case, case_dir): case_dir for case_dir in case_dirs}
-        for future in as_completed(futures):
-            case_dir = futures[future]
-            try:
-                records.append(future.result())
-            except Exception as exc:  # keep the other reference cases extractable
-                records.append({"case_dir": str(case_dir), "error": str(exc)})
-    return sorted(records, key=lambda record: record["case_dir"])
-
-
-def case_id_from_dir(track: str, case_dir: Path) -> str:
-    safe = case_dir.parent.name
-    return safe.replace("__", "/", 1) if track == "basic" else safe
-
-
-def extract_case(track: str, case_dir: Path, execution: dict[tuple[str, str], dict[str, str]]) -> tuple[str, dict[str, Any]]:
-    case_id = case_id_from_dir(track, case_dir)
-    template = case_id.split("/", 1)[0] if track == "basic" else ADVANCED_TEMPLATE[case_id]
-    latest_time, latest = latest_time_dir(case_dir)
-    if latest is None:
-        raise ValueError(f"no numeric time directory: {case_dir}")
-    centres = vector_field(latest, "C")
-    volumes = scalar_field(latest, "Vc")
-    if not centres or not volumes:
-        raise ValueError(f"missing C/Vc post-processing fields: {case_dir}")
-    volumes = align(volumes, len(centres))
-    if not volumes:
-        raise ValueError(f"C/Vc field length mismatch: {case_dir}")
-
-    scalars: dict[str, list[float]] = {}
-    raw_nonfinite_fields: list[str] = []
-    for name in COMMON_SCALAR_FIELDS:
-        path = field_path(latest, name)
-        if not path:
-            continue
-        raw = read_text(path)
-        if re.search(r"(?i)(?<![A-Za-z])(?:nan|[-+]?inf)(?![A-Za-z])", raw):
-            raw_nonfinite_fields.append(name)
-        values = align(parse_scalar_field(path), len(centres))
-        if values:
-            scalars[name] = values
-    velocities = align(vector_field(latest, "U"), len(centres))
-    vorticity = align(vector_field(latest, "vorticity"), len(centres))
-    h_u = align(vector_field(latest, "hU"), len(centres))
-    if h_u:
-        scalars["_hU_magnitude"] = magnitude(h_u)
-
-    principal_group, principal = family_metrics(case_dir, template, scalars, velocities, vorticity, centres, volumes)
-    if not principal:
-        raise ValueError(f"no principal QoI extracted for {case_id}")
-
-    diagnostics, fatal_logs = parse_log_metrics(case_dir)
-    if velocities:
-        for suffix, value in weighted_stats(magnitude(velocities), volumes).items():
-            diagnostics[f"velocity_magnitude_{suffix}"] = value
-    if vorticity:
-        for suffix, value in weighted_stats(magnitude(vorticity), volumes).items():
-            diagnostics[f"vorticity_magnitude_{suffix}"] = value
-    field_bounds: dict[str, dict[str, float]] = {}
-    for name, values in sorted(scalars.items()):
-        if name.startswith("_"):
-            continue
-        stats = weighted_stats(values, volumes)
-        if stats:
-            field_bounds[name] = stats
-    positivity_failures = [
-        name for name in POSITIVE_FIELDS
-        if name in field_bounds and field_bounds[name]["min"] < -1e-12
-    ]
-    if "alpha.water" in field_bounds:
-        alpha = field_bounds["alpha.water"]
-        if alpha["min"] < -1e-3 or alpha["max"] > 1 + 1e-3:
-            positivity_failures.append("alpha.water_bounds")
-    full_log = read_text(case_dir / "full_run.log")
-    execution_record = execution.get((track, case_dir.parent.name), {})
-    health_checks = {
-        "execution_exit_zero": execution_record.get("exit_code") == "0",
-        "no_fatal_marker": not fatal_logs and FATAL_RE.search(full_log) is None,
-        "required_geometry_fields_available": bool(centres and volumes),
-        "principal_qoi_complete": len(principal) == 2,
-        "all_parsed_fields_finite": not raw_nonfinite_fields,
-        "applicable_field_bounds_valid": not positivity_failures,
-    }
-    health_pass = all(health_checks.values())
-    qois = {**principal, **diagnostics}
-    roles = {name: "principal" for name in principal}
-    roles.update({name: "diagnostic" for name in diagnostics})
-    return case_id, {
-        "track": track,
-        "family": case_id.split("/", 1)[0] if track == "basic" else template,
-        "source_case_id": case_id,
-        "latest_time": latest_time,
-        "principal_qoi_group": principal_group,
-        "principal_metrics": sorted(principal),
-        "qois": dict(sorted(qois.items())),
-        "metric_roles": dict(sorted(roles.items())),
-        "tolerances": {name: tolerance(value) for name, value in sorted(principal.items())},
-        "field_diagnostics": field_bounds,
-        "health": {
-            "status": "pass" if health_pass else "fail",
-            "checks": health_checks,
-            "nonfinite_fields": raw_nonfinite_fields,
-            "field_bound_failures": sorted(positivity_failures),
-            "fatal_logs": fatal_logs,
-        },
-        "extraction": {
-            "geometry": "cellCentres-normalized probes",
-            "averaging": "cell-volume-weighted",
-            "reference_run": "anonymous-reference/basic_advanced",
-        },
-    }
-
-
-def load_execution_summary(path: Path) -> dict[tuple[str, str], dict[str, str]]:
-    lines = path.read_text(encoding="utf-8").splitlines()
-    header = lines[0].split("\t")
-    records = {}
-    for line in lines[1:]:
-        values = line.split("\t")
-        record = dict(zip(header, values))
-        records[(record["track"], record["case_id"])] = record
-    return records
-
-
-def dataset(cases: dict[str, Any], tracks: list[str], run_manifest: dict[str, Any]) -> dict[str, Any]:
-    selected = {case_id: record for case_id, record in cases.items() if record["track"] in tracks}
-    family_counts: dict[str, int] = {}
-    health_pass_count = 0
-    for record in selected.values():
-        family_counts[record["family"]] = family_counts.get(record["family"], 0) + 1
-        health_pass_count += record["health"]["status"] == "pass"
-    result = {
-        "schema_version": SCHEMA_VERSION,
-        "generated_at": utc_now(),
-        "openfoam_version": "Foundation v13",
-        "producer": "benchmarks/evaluation/qoi_reference.py",
-        "design": "guide/foambench_basic_advanced_qoi_design.md",
-        "tolerance_policy": TOLERANCE_POLICY,
-        "source_run_manifest": run_manifest,
-        "summary": {
-            "tracks": tracks,
-            "case_count": len(selected),
-            "health_pass_count": health_pass_count,
-            "health_fail_count": len(selected) - health_pass_count,
-            "family_counts": dict(sorted(family_counts.items())),
-        },
-        "notes": [
-            "Reference values come from the completed fixed-final OpenFOAM Foundation v13 run.",
-            "Principal QoIs are family-defined; reference values and tolerances are case-specific.",
-            "Generic field and solver statistics are diagnostics and do not receive principal-QoI weight.",
-            "The 15% intervals are initial benchmark-consistency tolerances and should be refined with repeatability evidence.",
-        ],
-        "cases": dict(sorted(selected.items())),
-    }
-    validate(result, "foambench_qoi_reference.schema.json")
-    return result
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--run-root", type=Path, required=True)
-    parser.add_argument("--output", type=Path, required=True)
-    parser.add_argument("--basic-output", type=Path)
-    parser.add_argument("--advanced-output", type=Path)
-    parser.add_argument("--prepare-fields", action="store_true")
-    parser.add_argument("--jobs", type=int, default=min(16, os.cpu_count() or 1))
-    args = parser.parse_args()
-
-    run_root = args.run_root.resolve(strict=True)
-    materialized = run_root / "materialized"
-    case_dirs = [
-        path for track in ("basic", "advanced")
-        for path in sorted((materialized / track).glob("*/case"))
-    ]
-    if len(case_dirs) != 126:
-        raise ValueError(f"expected 126 materialized cases, found {len(case_dirs)}")
-    if args.prepare_fields:
-        preparation = prepare_all(case_dirs, max(1, args.jobs))
-        write_json(run_root / "qoi_postprocess_summary.json", preparation)
-
-    from benchmarks.evaluation.basic_advanced import build_references
-
-    basic, advanced = build_references(run_root)
-    combined = {
-        **{key: value for key, value in basic.items() if key not in {"cases", "summary"}},
-        "summary": {
-            "tracks": ["basic", "advanced"],
-            "case_count": len(basic["cases"]) + len(advanced["cases"]),
-            "health_pass_count": len(basic["cases"]) + len(advanced["cases"]),
-            "health_fail_count": 0,
-        },
-        "cases": {**basic["cases"], **advanced["cases"]},
-    }
-    validate(combined, "foambench_qoi_reference.schema.json")
-    write_json(args.output, combined)
-    if args.basic_output:
-        write_json(args.basic_output, basic)
-    if args.advanced_output:
-        write_json(args.advanced_output, advanced)
-    print(json.dumps(combined["summary"], ensure_ascii=False, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

benchmarks/evaluation/reference.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from .models import BenchmarkProfile
-
-
-def reference_case_dir(profile: BenchmarkProfile, case_id: str) -> Path | None:
-    root = profile.reference_run_root
-    if root is None or not root.is_dir():
-        return None
-    safe = case_id.replace("/", "__")
-    if profile.dataset in {"basic", "advanced"}:
-        candidate = root / profile.dataset / safe / "case"
-        return candidate if candidate.is_dir() else None
-    parent = root / safe
-    for name in ("full_run_case", "case"):
-        candidate = parent / name
-        if candidate.is_dir():
-            return candidate
-    return None
-
-
-def reference_log_paths(profile: BenchmarkProfile, case_id: str) -> tuple[Path, ...]:
-    case = reference_case_dir(profile, case_id)
-    return tuple(sorted(path for path in case.glob("log.*") if path.is_file())) if case else ()
-
-
-def reference_statistics(profile: BenchmarkProfile, case_id: str) -> dict | None:
-    """Load compact reference diagnostics without a historical simulation tree."""
-    import json
-    from .numerical import DEFAULT_CONTRACT
-    name = profile.numerical_contract.get("reference_statistics_path")
-    if not name:
-        return None
-    path = Path(name)
-    if not path.is_absolute():
-        path = profile.benchmark_path.parent.parent / path
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if data.get("parser_contract") != DEFAULT_CONTRACT:
-        raise ValueError("Reference statistics parser contract differs from evaluator")
-    if case_id not in data["cases"]:
-        raise ValueError(f"Missing reference statistics for {case_id}")
-    return data["cases"][case_id]

benchmarks/evaluation/reporting.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-import csv
-from pathlib import Path
-from typing import Any
-
-
-CASE_COLUMNS = (
-    "case_id", "dataset", "family", "variant", "replicate",
-    "execution_pass", "numerical_pass", "physics_grounded_qoi_pass", "end_to_end_pass",
-    "qoi_status", "qoi_pass_ratio", "failure_categories",
-    "duration_seconds", "input_tokens", "output_tokens",
-)
-
-
-def _token(usage: dict[str, Any], *names: str) -> Any:
-    for name in names:
-        if isinstance(usage.get(name), (int, float)):
-            return usage[name]
-    return ""
-
-
-def case_csv_row(result: dict[str, Any]) -> dict[str, Any]:
-    scores = result["scores"]
-    qoi = result["qoi"]
-    resources = result.get("resources", {})
-    usage = resources.get("token_usage") if isinstance(resources.get("token_usage"), dict) else {}
-    return {
-        "case_id": result["case_id"],
-        "dataset": result["dataset"],
-        "family": result["family"],
-        "variant": result["variant"],
-        "replicate": result["replicate"],
-        "execution_pass": scores["execution_pass"],
-        "numerical_pass": scores["numerical_pass"],
-        "physics_grounded_qoi_pass": scores["physics_grounded_qoi_pass"],
-        "end_to_end_pass": scores["end_to_end_pass"],
-        "qoi_status": qoi.get("status", ""),
-        "qoi_pass_ratio": qoi.get("effective_pass_ratio", ""),
-        "failure_categories": ";".join(result.get("failure_categories", [])),
-        "duration_seconds": resources.get("duration_seconds") or "",
-        "input_tokens": _token(usage, "input_tokens", "prompt_tokens"),
-        "output_tokens": _token(usage, "output_tokens", "completion_tokens"),
-    }
-
-
-def write_case_csv(path: Path, results: list[dict[str, Any]]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    with temporary.open("w", encoding="utf-8", newline="") as stream:
-        writer = csv.DictWriter(stream, fieldnames=CASE_COLUMNS)
-        writer.writeheader()
-        writer.writerows(case_csv_row(result) for result in results)
-    temporary.replace(path)
-
-
-SUMMARY_COLUMNS = (
-    "scope", "task_count", "execution_pass_count", "execution_pass_rate",
-    "numerical_pass_count", "numerical_pass_rate_all_tasks",
-    "physics_grounded_qoi_pass_count", "physics_grounded_qoi_pass_rate_all_tasks",
-    "end_to_end_pass_count", "end_to_end_pass_rate",
-)
-
-
-def write_summary_csv(path: Path, overall: dict[str, Any], families: dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    temporary = path.with_name(path.name + ".tmp")
-    with temporary.open("w", encoding="utf-8", newline="") as stream:
-        writer = csv.DictWriter(stream, fieldnames=SUMMARY_COLUMNS)
-        writer.writeheader()
-        for scope, summary in [("overall", overall), *sorted(families.items())]:
-            writer.writerow({"scope": scope, **{key: summary.get(key) for key in SUMMARY_COLUMNS[1:]}})
-    temporary.replace(path)
-
-
-def summary_table(summary: dict[str, Any]) -> str:
-    total = int(summary["task_count"])
-    rows = (
-        ("Execution", "execution_pass_count", "execution_pass_rate"),
-        ("Numerical", "numerical_pass_count", "numerical_pass_rate_all_tasks"),
-        ("QoI", "physics_grounded_qoi_pass_count", "physics_grounded_qoi_pass_rate_all_tasks"),
-        ("End-to-end", "end_to_end_pass_count", "end_to_end_pass_rate"),
-    )
-    lines = ["Metric       Passed       Rate", "-----------  -----------  --------"]
-    for label, count_key, rate_key in rows:
-        rate = summary.get(rate_key)
-        rendered = "n/a" if rate is None else f"{float(rate) * 100:.2f}%"
-        lines.append(f"{label:<11}  {int(summary[count_key]):>4}/{total:<6}  {rendered:>8}")
-    return "\n".join(lines)

benchmarks/evaluation/retained_fields.py

@@ -1,304 +0,0 @@
-"""Reference-free measurements from retained OpenFOAM fields and static meshes.
-
-No subprocesses, field writes, fitted constants, or reference values. Unsupported
-encodings/BCs/meshes fail closed instead of substituting a different observable.
-"""
-from __future__ import annotations
-
-import math
-import re
-import struct
-from pathlib import Path
-
-import numpy as np
-
-from .foam_arrays import _bytes, _format, _arch, foam_path, read_label_list, read_vector_list, read_scalar_field
-
-
-def _body(data: bytes) -> bytes:
-    marker = data.find(b"// * * *")
-    if marker < 0:
-        raise ValueError("mesh header separator absent")
-    return data[data.index(b"\n", marker) + 1:]
-
-
-def _binary_list(data: bytes, code: str, endian: str) -> tuple[list, bytes]:
-    match = re.match(rb"\s*(\d+)\s*\(", data)
-    if not match:
-        raise ValueError("binary list header absent")
-    count = int(match[1])
-    start = match.end()  # Do not strip bytes: 0x0a/0x20 can be data.
-    end = start + count * struct.calcsize(endian + code)
-    tail = data[end:]
-    if not tail.startswith(b")"):
-        raise ValueError("truncated binary list or invalid terminator")
-    return list(struct.unpack(f"{endian}{count}{code}", data[start:end])), tail[1:]
-
-
-def read_faces(path: Path) -> list[list[int]]:
-    data = _bytes(path)
-    body = _body(data)
-    if _format(data) == "binary":
-        if not re.search(rb"class\s+faceCompactList\s*;", data[:data.find(b"// * * *")]):
-            raise ValueError("only faceCompactList binary faces are supported")
-        endian, labels, _ = _arch(data)
-        code = "i" if labels == 32 else "q"
-        offsets, tail = _binary_list(body, code, endian)
-        indices, _ = _binary_list(tail, code, endian)
-        if not offsets or offsets[0] != 0 or offsets[-1] != len(indices):
-            raise ValueError("invalid compact face offsets")
-        if any(b - a < 3 for a, b in zip(offsets, offsets[1:])):
-            raise ValueError("invalid face size")
-        return [indices[a:b] for a, b in zip(offsets, offsets[1:])]
-    match = re.match(rb"\s*(\d+)\s*\(", body)
-    if not match:
-        raise ValueError("face list header absent")
-    faces = []
-    position = match.end()
-    face_pattern = re.compile(rb"\s*(\d+)\s*\(([^()]*)\)")
-    for _ in range(int(match[1])):
-        row = face_pattern.match(body, position)
-        if not row:
-            raise ValueError("invalid ASCII face")
-        face = [int(x) for x in row[2].split()]
-        if len(face) != int(row[1]) or len(face) < 3:
-            raise ValueError("face length mismatch")
-        faces.append(face)
-        position = row.end()
-    if not body[position:].lstrip().startswith(b")"):
-        raise ValueError("face count mismatch")
-    return faces
-
-
-def static_mesh(case: Path) -> bool:
-    if (case / "constant/dynamicMeshDict").exists():
-        return False
-    # OpenFOAM 13 can configure motion/topology changes in constant/polyMesh.
-    if any((case / "constant/polyMesh" / name).exists() for name in ("mover", "topoChanger", "distributor")):
-        return False
-    return not any(path.is_dir() and (path / "polyMesh").exists()
-                   for path in case.iterdir() if _is_time(path.name))
-
-
-def _is_time(value: str) -> bool:
-    try:
-        return math.isfinite(float(value))
-    except ValueError:
-        return False
-
-
-def mesh_arrays(case: Path):
-    mesh = case / "constant/polyMesh"
-    paths = [foam_path(mesh, name) for name in ("points", "faces", "owner", "neighbour")]
-    if any(path is None for path in paths):
-        raise ValueError("incomplete retained polyMesh")
-    points = np.asarray(read_vector_list(paths[0]), dtype=float)
-    faces = read_faces(paths[1])
-    owner = np.asarray(read_label_list(paths[2]), dtype=int)
-    neighbour = np.asarray(read_label_list(paths[3]), dtype=int)
-    if len(owner) != len(faces) or len(neighbour) > len(owner) or not len(owner):
-        raise ValueError("mesh topology length mismatch")
-    if np.min(owner) < 0 or (len(neighbour) and (np.min(neighbour) < 0 or np.max(neighbour) > np.max(owner))):
-        raise ValueError("invalid cell indices")
-    if not np.isfinite(points).all() or any(min(face) < 0 or max(face) >= len(points) for face in faces):
-        raise ValueError("invalid mesh points/face indices")
-    return points, faces, owner, neighbour, paths
-
-
-def planar_face_geometry(points, faces):
-    """Oriented area and volume moments, grouped by face size for bounded cost."""
-    origin = points.mean(axis=0)
-    vectors = np.zeros((len(faces), 3))
-    volumes = np.zeros(len(faces))
-    moments = np.zeros((len(faces), 3))
-    sizes = {}
-    for i, face in enumerate(faces):
-        sizes.setdefault(len(face), []).append(i)
-    for size, ids in sizes.items():
-        vertices = points[np.asarray([faces[i] for i in ids])] - origin
-        center = vertices.mean(axis=1)
-        nxt = np.roll(vertices, -1, axis=1)
-        triangles = np.cross(vertices - center[:, None], nxt - center[:, None]) / 2
-        area = triangles.sum(axis=1)
-        norms = np.linalg.norm(area, axis=1)
-        if np.any(norms <= 0):
-            raise ValueError("degenerate face")
-        distances = np.abs(np.einsum('fvi,fi->fv', vertices - center[:, None], area)) / norms[:, None]
-        scale = np.max(np.linalg.norm(vertices - center[:, None], axis=2), axis=1)
-        if np.any(distances > 1e-8 * scale[:, None]):
-            raise ValueError("nonplanar face: native geometry evidence required")
-        # Signed tetrahedra (origin, face center, edge endpoints).
-        tetra = np.einsum('fi,fvi->fv', center, np.cross(vertices, nxt)) / 6
-        vectors[ids] = area
-        volumes[ids] = tetra.sum(axis=1)
-        moments[ids] = np.sum(tetra[:, :, None] * (center[:, None] + vertices + nxt) / 4, axis=1)
-    return origin, vectors, volumes, moments
-
-
-def derive_cell_geometry(case: Path):
-    if not static_mesh(case):
-        raise ValueError("static geometry derivation disabled for changing meshes")
-    points, faces, owner, neighbour, paths = mesh_arrays(case)
-    origin, areas, face_volumes, face_moments = planar_face_geometry(points, faces)
-    count = int(owner.max()) + 1
-    volumes = np.zeros(count)
-    moments = np.zeros((count, 3))
-    closure = np.zeros((count, 3))
-    surface = np.zeros(count)
-    for cells, sign, sl in ((owner, 1, slice(None)), (neighbour, -1, slice(0, len(neighbour)))):
-        np.add.at(volumes, cells, sign * face_volumes[sl])
-        np.add.at(moments, cells, sign * face_moments[sl])
-        np.add.at(closure, cells, sign * areas[sl])
-        np.add.at(surface, cells, np.linalg.norm(areas[sl], axis=1))
-    if np.any(volumes <= 0) or not np.isfinite(volumes).all():
-        raise ValueError("nonpositive/nonfinite reconstructed cell volume")
-    if np.any(np.linalg.norm(closure, axis=1) > 1e-9 * surface):
-        raise ValueError("cell face surface does not close")
-    centers = moments / volumes[:, None] + origin
-    if not np.isfinite(centers).all():
-        raise ValueError("nonfinite cell centers")
-    return volumes.tolist(), [tuple(row) for row in centers.tolist()], paths
-
-
-def boundary_specs(case: Path) -> dict:
-    path = foam_path(case / "constant/polyMesh", "boundary")
-    if path is None:
-        raise ValueError("boundary file absent")
-    text = _body(_bytes(path)).decode('ascii')
-    result = {}
-    for name, block in re.findall(r'([\w]+)\s*\{([^{}]*)\}', text):
-        start = re.search(r'\bstartFace\s+(\d+)\s*;', block)
-        size = re.search(r'\bnFaces\s+(\d+)\s*;', block)
-        if start and size:
-            result[name] = (int(start[1]), int(size[1]))
-    return result
-
-
-def scalar_boundary(path: Path, patch: str, owners: list[int]) -> tuple[list[float], str]:
-    data = _bytes(path)
-    # Locate boundaryField after the internal payload, never inside binary data.
-    internal = re.search(rb'internalField\s+nonuniform\s+List<scalar>\s*', data)
-    if internal and _format(data) == 'binary':
-        endian, _, bits = _arch(data)
-        _, tail = _binary_list(data[internal.end():], 'f' if bits == 32 else 'd', endian)
-    else:
-        tail = data
-    anchor = re.search(rb'\bboundaryField\s*\{', tail)
-    if anchor is None:
-        raise ValueError('boundaryField absent')
-    tail = tail[anchor.end():]
-    # Replace length-delimited binary lists before parsing braces. Binary bytes
-    # may themselves contain braces, newlines or apparent dictionary keywords.
-    arrays = {}
-    if _format(data) == 'binary':
-        endian, _, bits = _arch(data)
-        parts = []
-        while (match := re.search(rb'nonuniform\s+List<scalar>\s*', tail)) is not None:
-            values, rest = _binary_list(tail[match.end():], 'f' if bits == 32 else 'd', endian)
-            key = f'__array_{len(arrays)}'
-            arrays[key] = values
-            parts.append(tail[:match.start()] + key.encode())
-            tail = rest
-        tail = b''.join(parts) + tail
-    text = tail.decode('ascii')
-    blocks = dict(re.findall(r'([\w]+)\s*\{([^{}]*)\}', text))
-    block = blocks.get(patch)
-    if block is None:
-        raise ValueError(f'patch {patch} has no explicit dictionary')
-    bc = re.search(r'\btype\s+(\w+)\s*;', block)
-    uniform = re.search(r'\bvalue\s+uniform\s+([-+0-9.eE]+)\s*;', block)
-    stored = re.search(r'\bvalue\s+(__array_\d+)\s*;', block)
-    listed = re.search(r'\bvalue\s+nonuniform\s+List<scalar>\s+(\d+)\s*\(([^()]*)\)\s*;', block)
-    if uniform:
-        values, method = [float(uniform[1])] * len(owners), 'stored_boundary_value'
-    elif stored:
-        values, method = arrays[stored[1]], 'stored_boundary_value'
-    elif listed:
-        values, method = [float(x) for x in listed[2].split()], 'stored_boundary_value'
-        if len(values) != int(listed[1]):
-            raise ValueError('boundary list length mismatch')
-    elif bc and bc[1] == 'zeroGradient' and path.name.removesuffix('.gz') == 'p':
-        internal_values = read_scalar_field(path)
-        if re.search(rb'internalField\s+uniform\s+', data):
-            values = internal_values * len(owners)
-        else:
-            values = [internal_values[i] for i in owners]
-        method = 'zeroGradient_exact_owner_value'
-    else:
-        raise ValueError(f'{patch}: unsupported boundary without stored values')
-    if len(values) != len(owners) or not all(math.isfinite(x) for x in values):
-        raise ValueError('boundary value count/nonfinite mismatch')
-    return values, method
-
-
-def dimensions(path: Path) -> str | None:
-    match = re.search(rb'\bdimensions\s*\[([^]]+)\]', _bytes(path)[:4096])
-    return ' '.join(match[1].decode('ascii').split()) if match else None
-
-
-def pump_measurements(case: Path) -> tuple[dict, dict, list[str]]:
-    """All retained positive times, with signed inlet phi and boundary p.
-
-    Only the unique inlet/outlet names (case insensitive) are recognized. No
-    reference times or values enter extraction; time alignment is comparator work.
-    """
-    values, evidence, errors = {}, {}, []
-    try:
-        if not static_mesh(case):
-            raise ValueError('pump retained-field fallback requires a static mesh')
-        points, faces, owner, _, paths = mesh_arrays(case)
-        _, vectors, _, _ = planar_face_geometry(points, faces)
-        areas = np.linalg.norm(vectors, axis=1)
-        specs = boundary_specs(case)
-        names = {}
-        for role in ('inlet', 'outlet'):
-            matches = [name for name in specs if name.lower() == role]
-            if len(matches) != 1:
-                raise ValueError(f'ambiguous or absent {role} patch')
-            names[role] = matches[0]
-        slices = {role: slice(specs[name][0], sum(specs[name])) for role, name in names.items()}
-        if any(sl.stop > len(owner) or sl.start == sl.stop for sl in slices.values()):
-            raise ValueError('invalid inlet/outlet face range')
-    except (OSError, ValueError, RuntimeError) as exc:
-        return {}, {}, [str(exc)]
-    histories = {'mass_flow_rate': [], 'pressure_rise': []}
-    phi_dimension: str | None = None
-    refs = {key: set() for key in histories}
-    boundary = foam_path(case / 'constant/polyMesh', 'boundary')
-    mesh_refs = [str(p.relative_to(case)) for p in [*paths, boundary] if p]
-    for directory in sorted((p for p in case.iterdir() if p.is_dir() and _is_time(p.name) and float(p.name) > 0), key=lambda p: float(p.name)):
-        for metric, field in (('mass_flow_rate', 'phi'), ('pressure_rise', 'p')):
-            path = foam_path(directory, field)
-            if path is None:
-                continue
-            try:
-                actual_dimensions = dimensions(path)
-                allowed_dimensions = (
-                    {'1 0 -1 0 0 0 0', '0 3 -1 0 0 0 0'} if field == 'phi'
-                    else {'1 -1 -2 0 0 0 0', '0 2 -2 0 0 0 0'}
-                )
-                if actual_dimensions not in allowed_dimensions:
-                    raise ValueError('unsupported physical dimensions')
-                if field == 'phi':
-                    phi_dimension = actual_dimensions
-                inlet, _ = scalar_boundary(path, names['inlet'], owner[slices['inlet']].tolist())
-                if field == 'phi':
-                    value = math.fsum(inlet)
-                else:
-                    outlet, _ = scalar_boundary(path, names['outlet'], owner[slices['outlet']].tolist())
-                    value = float(np.average(outlet, weights=areas[slices['outlet']]) - np.average(inlet, weights=areas[slices['inlet']]))
-                histories[metric].append({'time': float(directory.name), 'value': value})
-                refs[metric].add(str(path.relative_to(case)))
-            except (OSError, ValueError, RuntimeError, IndexError) as exc:
-                errors.append(f'{directory.name}/{field}: {exc}')
-    for metric, history in histories.items():
-        if history:
-            values[metric] = {'kind': 'time_history', 'quantity': (
-                'explicit_mass_flow' if phi_dimension == '1 0 -1 0 0 0 0' else 'explicit_volumetric_flow'
-            ) if metric == 'mass_flow_rate' else 'pressure_rise', 'points': history}
-            if metric == 'mass_flow_rate':
-                    values[metric]['field_dimensions'] = phi_dimension
-            else:
-                values[metric].update(definition='outlet_minus_inlet_patch_average', source_patches=names)
-            evidence[metric] = sorted(refs[metric] | set(mesh_refs))
-    return values, evidence, errors

benchmarks/evaluation/schema.py

@@ -1,21 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-from jsonschema import Draft202012Validator, FormatChecker
-
-from .io import read_object
-
-
-SCHEMA_ROOT = Path(__file__).resolve().parents[2] / "schemas"
-
-
-def validate(value: Any, schema_name: str) -> None:
-    schema = read_object(SCHEMA_ROOT / schema_name)
-    validator = Draft202012Validator(schema, format_checker=FormatChecker())
-    errors = sorted(validator.iter_errors(value), key=lambda error: list(error.absolute_path))
-    if errors:
-        error = errors[0]
-        location = ".".join(str(item) for item in error.absolute_path) or "<root>"
-        raise ValueError(f"{schema_name} validation failed at {location}: {error.message}")

benchmarks/evaluation/stability.py

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-import math
-import re
-from pathlib import Path
-from typing import Any
-
-from .foam_io import read_text
-
-
-def numerical_scheme(case_dir: Path) -> str:
-    block = re.search(r"ddtSchemes\s*\{(?P<body>.*?)\}", read_text(case_dir / "system/fvSchemes"), re.S)
-    default = re.search(r"\bdefault\s+([^;\s]+)", block.group("body")) if block else None
-    return default.group(1) if default else "unknown"
-
-
-def steady_plateau(
-    qois: dict[str, Any],
-    baseline_spans: dict[str, float] | None = None,
-    *,
-    final_window_fraction: float = 0.2,
-    minimum_snapshots: int = 3,
-) -> dict[str, Any]:
-    metrics = {}
-    passed = True
-    for name, value in sorted(qois.items()):
-        if not isinstance(value, dict) or value.get("kind") != "time_history":
-            continue
-        points = value.get("points", [])
-        samples = [float(point["value"]) for point in points if isinstance(point, dict)
-                   and isinstance(point.get("value"), (int, float))]
-        if len(samples) < minimum_snapshots:
-            metrics[name] = {"status": "fail", "sample_count": len(samples), "expected_minimum": minimum_snapshots}
-            passed = False
-            continue
-        count = max(minimum_snapshots, math.ceil(len(samples) * final_window_fraction))
-        selected = samples[-count:]
-        span = (max(selected) - min(selected)) / max(abs(selected[-1]), 1e-12)
-        limit = max(0.02, (baseline_spans or {}).get(name, 0.0) * 2.0)
-        ok = span <= limit
-        metrics[name] = {"status": "pass" if ok else "fail", "relative_span": span,
-                         "limit": limit, "sample_count": count}
-        passed = passed and ok
-    return {
-        "status": "pass" if metrics and passed else "fail" if metrics else "not_applicable",
-        "applicable": bool(metrics),
-        "metrics": metrics,
-    }