Release ExtFoamBench v1.0.0

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.venv/
+.cache/
+outputs/
+.env
+.env.*

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

LICENSE.md

@@ -0,0 +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.

LICENSES/FoamBench-BSD-3-Clause.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Alliance for Sustainable Energy, LLC and Rensselaer Polytechnic Institute
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

LICENSES/GPL-3.txt

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -0,0 +1,170 @@
+---
+pretty_name: ExtFoamBench — CFD Tasks, Evaluation Protocols and Offline Reference Data
+language:
+- en
+license: other
+license_name: easyfoam-benchmarks-component-licenses
+license_link: LICENSE.md
+size_categories:
+- n<1K
+tags:
+- benchmark
+- computational-fluid-dynamics
+- openfoam
+- scientific-computing
+- agents
+- physics
+- evaluation
+- reference-data
+configs:
+- config_name: extended
+  default: true
+  data_files:
+  - split: test
+    path: data/extended.jsonl
+- config_name: basic
+  data_files:
+  - split: test
+    path: data/basic.jsonl
+- config_name: advanced
+  data_files:
+  - split: test
+    path: data/advanced.jsonl
+- config_name: all
+  data_files:
+  - split: test
+    path:
+    - data/extended.jsonl
+    - data/basic.jsonl
+    - data/advanced.jsonl
+---
+
+# ExtFoamBench
+
+**100 new CFD tasks, task-specific QoI acceptance rules, and offline reference data for evaluating OpenFOAM agents.**
+
+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**.
+
+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.
+
+## Contributions and attribution
+
+| 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 |
+
+**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.
+
+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.
+
+## ExtFoamBench coverage
+
+Each of the ten families contains ten tasks: a baseline and nine variants.
+
+| 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 |
+
+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.
+
+## What is downloaded?
+
+| 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:
+
+```python
+from datasets import load_dataset
+
+tasks = load_dataset("Eurus132/ExtFoamBench", "extended", split="test")
+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:
+
+```bash
+python benchmarks/scripts/materialize_benchmark.py --benchmark benchmarks/FoamBench_basic_openfoam13_fixed_final.json --case-id Cavity/1 --output-root outputs/reference-input
+```
+
+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.
+
+## Data completeness and versioning
+
+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.
+
+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).
+
+## Attribution 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).
+
+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/`.

SHA256SUMS

@@ -0,0 +1,102 @@
+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
+02f25f876414a9a4cbdb9cfb08da9916ac49f7851d4658067abc371447f882ce  benchmarks/assets/openfoam13/drivaerFastback/rearWheels.obj.gz
+9fd098e03da6178852d4f9837bc06d2f24599065644f951b481907513d835d90  benchmarks/assets/openfoam13/naca0012/NACA0012.obj.gz
+612cb86bfa2c842444ba86f203af31c712da3e807ed537013fefff8ab40f42a2  benchmarks/assets/openfoam13/simpleRushtonMRF/baffles.obj
+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
+6f91688f7c97b3ef6b8191256c14af7f8accb168e8d384aba763681e01c34724  benchmarks/FoamBench_basic_openfoam13_reference_qois.json
+4f0eae169c7d575da991d7c23c313ce6e4971887fbbaffbbbf9bc65105c2b676  benchmarks/FoamBench_extended_openfoam13_evidence_contract.v1.json
+1e247ddfec51cc2a716ca5690661acb367a3f919ceb1a99fd2d40123cb1b4d5b  benchmarks/FoamBench_extended_openfoam13_fixed.json
+0bddaf5b3abc3569d105c89cbdeef8cf3c4cce381ba9f7a3d622cadadaf8a68b  benchmarks/FoamBench_extended_openfoam13_measurement_specs.json
+fb1db5034a1d2688ad360c6b0810bab68c33d4c6dc1dc5bec29095e93b077393  benchmarks/FoamBench_extended_openfoam13_qoi_design.json
+65e5c2d9968d1dbc798d585c9398c6fba2646f7463909040ae0c039727c8a1f9  benchmarks/FoamBench_extended_openfoam13_reference_qois.json
+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
+cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30  LICENSE
+1c8f0e5ad4fe2f145137ef723f54d62e8891a2b1b3467c90bc33c4c6680c907f  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

VERSION

@@ -0,0 +1 @@
+1.0.0

benchmarks/FoamBench_extended_openfoam13_evidence_contract.v1.json

@@ -0,0 +1,59 @@
+{
+  "schema_version": "foambench.evidence.contract.v1",
+  "purpose": "Agent-independent discovery and validation contract for physics-grounded QoI evidence",
+  "normalization": "lowercase ASCII alphanumeric for routing hints only",
+  "roots": [
+    "case/postProcessing",
+    "case/postprocessing",
+    "case/results",
+    "case/outputs",
+    "workspace/postProcessing",
+    "workspace/postprocessing",
+    "workspace/results",
+    "workspace/outputs",
+    "workspace/evidence",
+    "workspace/reports"
+  ],
+  "manifest": {
+    "path": "workspace/evidence/qoi_manifest.v1.json",
+    "required_fields": ["metric", "path", "kind", "columns", "time_semantics", "method_version"],
+    "path_policy": "path must resolve below a canonical evidence root",
+    "priority": ["validated_manifest", "deterministic_field_derivation", "semantic_discovery"]
+  },
+  "kinds": {
+    "force_coefficients": {
+      "aliases": ["forcecoeffs", "forcecoefficients", "forcecoefficient", "aerodynamicloads", "aeroloads", "loads"],
+      "required_columns": ["Time", "at_least_one_of:Cd,Cl,Cm"],
+      "physical_validation": "coefficient table with declared reference normalization"
+    },
+    "patch_flux": {
+      "aliases": ["patchflowrate", "patchflow", "massflow", "massflux", "rhophi", "fluxhistory"],
+      "required_columns": ["Time", "explicit_mass_or_volumetric_flux"],
+      "physical_validation": "patch identity and phi dimensions/unit declaration"
+    },
+    "patch_pressure": {
+      "aliases": ["patchaverage", "patchintegrate", "pressurerise", "pressuredifference", "patchpressure"],
+      "required_columns": ["Time", "pressure", "inlet_identity", "outlet_identity"],
+      "physical_validation": "static/total pressure convention and outlet-minus-inlet orientation"
+    },
+    "wall_law_profile": {
+      "aliases": ["spaldingcomparison", "uplusyplus", "walllawprofile", "velocityprofile", "wallprofile"],
+      "required_columns": ["y_plus_alias"],
+      "optional_columns": ["u_plus_alias", "spalding_prediction_alias"],
+      "physical_validation": "wall/region identity and final-saved-time or declared profile time"
+    },
+    "centerline_profile": {
+      "aliases": ["centerline", "centreline", "horizontal", "vertical", "px0", "py0", "rhox0", "rhoy0"],
+      "required_columns": ["coordinate", "at_least_one_of:p,rho,U"],
+      "physical_validation": "line orientation and sample time must be recoverable"
+    },
+    "bubble_geometry": {
+      "aliases": ["bubblegeometry", "bubblemetrics", "interfacegeometry"],
+      "required_columns": ["component_identity", "geometry_value"],
+      "physical_validation": "derived from alpha/interface fields; undefined topology is not incomplete evidence"
+    }
+  },
+  "proxy_policy": "A routing hint never promotes a file to evidence; metric-specific content, units, dimensions, identity, and time validation are mandatory.",
+  "unresolved_status": "unresolved_evidence",
+  "extractor_method_version": "physics_grounded_qoi.extractors.v3.1"
+}

benchmarks/FoamBench_extended_openfoam13_qoi_design.json

@@ -0,0 +1,266 @@
+{
+  "schema_version": "foambench.qoi.design",
+  "status": "executable_reference_contract",
+  "frozen_reference_unchanged": true,
+  "scope": "Extended FoamBench scientific QoI contract",
+  "global_policy": {
+    "principal_qoi_is": "the declared physical response of the task, not a generic field extreme or output-availability fallback",
+    "acceptance_model": "Every principal response must satisfy its reference-anchored task-response contract and any declared reference-independent physical bounds. Both are reported explicitly and must pass jointly.",
+    "fallback_policy": "A fallback proxy may be reported as diagnostic or coverage evidence, but never silently replaces a principal QoI.",
+    "conditional_policy": "A conditional QoI is mandatory only when its declared applicability evidence is retained. Missing applicability evidence is reported as unavailable and never counted as a passed physical criterion.",
+    "branch_policy": "Cases are aggregated only with cases sharing the same response definition and branch. Variant relations are scored separately from absolute reference agreement.",
+    "time_policy": "Every history QoI declares endpoint, event, steady-window, or transient-trajectory semantics. Full-history means are not a default.",
+    "tolerance_policy": {
+      "global_default_percent": null,
+      "steady_scalar": "max(3*sigma_repeat, discretization_envelope, measurement_floor)",
+      "profile": "normalized L1/L2/Linf error with a declared reference norm and spatial window",
+      "event_location": "max(3*sigma_event, 2*local_cell_size, physical_measurement_floor)",
+      "trajectory": "time-aligned normalized RMSE plus event-time error",
+      "provisional_rule": "If repeatability and discretization evidence are unavailable, the result is provisional and cannot be called strict scientific validation."
+    },
+    "required_provenance": [
+      "source_fields_or_postprocessing_file",
+      "patch_region_or_probe_definition",
+      "unit_and_normalization",
+      "time_window_or_event_rule",
+      "method_version",
+      "reference_uncertainty_or_provisional_flag"
+    ]
+  },
+  "families": [
+    {
+      "family": "ERCOFTA_pump",
+      "scientific_question": "Does the rotating pump surrogate produce the intended pressure/flow response under speed, pressure, mesh, model, and transient branches?",
+      "branches": [
+        {
+          "id": "steady_pressure_flow",
+          "cases": ["1", "2", "3", "4", "6", "7", "8", "10"],
+          "principal_qois": [
+            {"name": "pressure_rise", "definition": "outlet-minus-inlet area-averaged static-pressure difference on the explicitly named patches", "source": "inlet/outlet patchAverage(p) outputs", "aggregation": "time-aligned saved history"},
+            {"name": "mass_flow_rate", "definition": "signed mass or volumetric flow from the explicitly named inlet flux, preserving phi dimensions", "source": "inlet face flux", "aggregation": "saved history; inlet/outlet conservation remains diagnostic until both fluxes are retained"}
+          ],
+          "diagnostics": ["shaft_torque", "shaft_power", "mass_balance_residual", "rotor_zone_extent"],
+          "relations": ["speed-response branch", "outlet-pressure branch", "mesh/rotor-zone sensitivity"]
+        },
+        {
+          "id": "transient_pressure_flow",
+          "cases": ["5", "9"],
+          "principal_qois": [
+            {"name": "pressure_rise_history", "definition": "time-aligned pressure-rise history between declared inlet/outlet patches", "aggregation": "trajectory over declared transient window"}
+          ],
+          "diagnostics": ["shaft_torque_history", "mass_balance_residual"]
+        }
+      ],
+      "forbidden_principal_proxies": ["domain_pressure_span", "global_p_min_max", "unweighted_internal_pressure_range"]
+    },
+    {
+      "family": "MRF_stirredReactor",
+      "scientific_question": "How do impeller rotation, rheology, baffles, mesh, and rotating formulation change mixer power and phase/interface response?",
+      "branches": [
+        {
+          "id": "single_phase_mixing",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+          "principal_qois": [
+            {"name": "volume_average_speed_final", "definition": "cell-volume-weighted final-time average velocity magnitude", "source": "retained U and cell volumes; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"}
+          ],
+          "diagnostics": ["stirrer_power_history", "volume_average_speed_history", "circulation", "mass_balance_residual"],
+          "relations": ["speed scaling", "mesh convergence", "baffle/model/sliding-mesh paired comparison"]
+        },
+        {
+          "id": "two_phase_interface",
+          "cases": ["10"],
+          "principal_qois": [
+            {"name": "volume_average_speed_history", "definition": "cell-volume-weighted domain average of velocity magnitude over the saved reference time window", "source": "U and cell volumes", "aggregation": "time-aligned trajectory"},
+            {"name": "volume_speed_rms_history", "definition": "cell-volume-weighted RMS spatial fluctuation of velocity magnitude about its instantaneous domain mean", "source": "U and cell volumes", "aggregation": "time-aligned trajectory"}
+          ],
+          "diagnostics": ["phase_volume_conservation", "interface_centroid", "phase_fraction_by_region"]
+        }
+      ],
+      "forbidden_principal_proxies": ["alpha_minimum_history", "global_alpha_minimum", "unrelated_phase_extreme"]
+    },
+    {
+      "family": "aerofoilNACA0012",
+      "scientific_question": "How do Mach number, angle of attack, turbulence model, mesh, and transient treatment change aerodynamic loads?",
+      "branches": [
+        {
+          "id": "aerodynamic_loads",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+          "principal_qois": [
+            {"name": "Cd", "definition": "drag coefficient from the forceCoeffs header-addressed Cd column", "source": "declared aerofoil wall patches and drag direction", "aggregation": "steady-window mean, or transient mean plus RMS"},
+            {"name": "Cl", "definition": "lift coefficient from the header-addressed Cl column", "source": "declared wall patches and lift direction", "aggregation": "same window"},
+            {"name": "Cm", "definition": "moment coefficient about declared reference center and pitch axis", "source": "forceCoeffs output", "aggregation": "same window"}
+          ],
+          "diagnostics": ["surface_pressure_coefficient_profile", "separation_location", "residual_and_force_plateau"],
+          "relations": ["Mach response", "angle-of-attack load trend", "mesh convergence", "model comparison"]
+        }
+      ],
+      "extractor_requirements": ["parse forceCoeffs header by field name; never assume row index", "verify dragDir, liftDir, Aref, lRef, CofR", "do not compare a transient endpoint to a steady-window reference"]
+    },
+    {
+      "family": "compressibleBubbleCollapse",
+      "scientific_question": "How do pressure, bubble geometry, density ratio, wall distance, mesh, and compressibility change bubble-collapse dynamics?",
+      "branches": [
+        {
+          "id": "collapse_dynamics",
+          "cases": ["1", "3", "4", "5", "6", "7", "8", "9"],
+          "principal_qois": [
+            {"name": "equivalent_radius_final", "definition": "final radius from connected gas-phase volume, R=(3V/(4*pi))^(1/3) in 3D or the declared 2D area-equivalent convention", "source": "gas-phase alpha and cell volumes; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"},
+            {"name": "final_component_count", "definition": "number of retained connected gas components at the final saved field", "source": "gas-phase alpha and cell connectivity", "aggregation": "final saved field"}
+          ],
+          "diagnostics": ["bubble_centroid_history", "bubble_count", "interface_area", "minimum_pressure", "phase_volume_conservation"],
+          "relations": ["ambient-pressure trend", "wall-distance effect", "mesh/AMR convergence"]
+        },
+        {
+          "id": "materialized_single_bubble_response",
+          "cases": ["2"],
+          "principal_qois": [
+            {"name": "equivalent_radius_final", "definition": "final connected-gas equivalent radius for the single 50 um bubble actually materialized by setFieldsDict", "source": "gas-phase alpha and cell volumes; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"},
+            {"name": "final_component_count", "definition": "number of retained connected gas components at the final saved field", "source": "gas-phase alpha and cell connectivity", "aggregation": "final saved field"}
+          ],
+          "diagnostics": ["collapse_time_censored_diagnostic", "bubble_centroid_history", "phase_volume_conservation"],
+          "relations": []
+        },
+        {
+          "id": "axisymmetric_ring_interaction",
+          "cases": ["10"],
+          "principal_qois": [
+            {"name": "equivalent_radius_final", "definition": "final connected gas-region equivalent radius under the materialized axisymmetric wedge convention", "source": "gas-phase alpha and cell volumes with wedge volume factor; measurement-only C/Vc preparation is permitted", "aggregation": "component-preserving final field"},
+            {"name": "final_component_count", "definition": "number of retained connected gas components at the final saved field", "source": "gas-phase alpha and cell connectivity", "aggregation": "final saved field"}
+          ],
+          "diagnostics": ["component_count", "collapse_time_censored_diagnostic", "phase_volume_conservation"],
+          "relations": ["axisymmetric connected-region interaction"]
+        }
+      ],
+      "extractor_requirements": ["identify gas phase explicitly", "use connected components when multiple bubbles exist", "do not use global alpha minimum as a bubble-response substitute"]
+    },
+    {
+      "family": "drivaerFastback",
+      "scientific_question": "How do speed, mesh, wheel/ground treatment, turbulence model, and DDES treatment change vehicle aerodynamic loads?",
+      "branches": [
+        {
+          "id": "steady_aerodynamic_loads",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
+          "principal_qois": [
+            {"name": "Cd", "definition": "header-addressed drag coefficient for body, wheels, and declared force patches", "source": "forceCoeffs", "aggregation": "last steady window"},
+            {"name": "Cl", "definition": "header-addressed lift coefficient", "source": "forceCoeffs", "aggregation": "last steady window"},
+            {"name": "Cm", "definition": "header-addressed moment coefficient about declared center", "source": "forceCoeffs", "aggregation": "last steady window"}
+          ],
+          "relations": ["speed scaling", "mesh convergence", "wheel/ground treatment comparison", "turbulence-model comparison"]
+        },
+        {
+          "id": "transient_ddes",
+          "cases": ["10"],
+          "principal_qois": [
+            {"name": "Cd_mean", "definition": "time mean over statistically stationary DDES window", "source": "forceCoeffs", "aggregation": "stationary-window mean"},
+            {"name": "Cd_rms", "definition": "RMS fluctuation over the same window", "source": "forceCoeffs", "aggregation": "stationary-window RMS"}
+          ],
+          "diagnostics": ["Cl_mean", "Cl_rms", "dominant_force_frequency", "stationarity_test"]
+        }
+      ],
+      "extractor_requirements": ["parse forceCoeffs headers and reference quantities", "do not compare DDES endpoint to steady reference", "report body/wheel patch coverage"]
+    },
+    {
+      "family": "nozzleCDV",
+      "scientific_question": "How do back pressure, mesh, discretisation, boundary specification, solver, turbulence, and dimension change nozzle flow structure and mass-flow response?",
+      "branches": [
+        {
+          "id": "shock_present",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+          "principal_qois": [
+            {"name": "mass_flow_rate", "definition": "signed mass flux through the declared inlet section, preserving operating-point branches and the OpenFOAM phi sign", "source": "section face flux with phi dimensions [1 0 -1 0 0 0 0]", "aggregation": "final saved time per operating-point branch"}
+          ],
+          "conditional_qois": [
+            {"name": "shock_location", "condition": "a retained named centerline or versioned shock-detector output resolves one discontinuity", "definition": "location of maximum pressure-gradient or density-gradient on the declared centerline", "missing_evidence_status": "unavailable_not_passed"},
+            {"name": "pressure_ratio", "condition": "named inlet/outlet thermodynamic evidence and its static-or-total convention are retained", "definition": "declared static or total pressure ratio", "missing_evidence_status": "unavailable_not_passed"}
+          ],
+          "relations": ["back-pressure shock movement", "mesh convergence", "solver/discretisation comparison", "axisymmetric-vs-planar geometry"]
+        }
+      ],
+      "forbidden_principal_proxies": ["global_pressure_span", "pressure_min_max_without_section_or_centerline_definition"]
+    },
+    {
+      "family": "riemann2D",
+      "scientific_question": "How do numerical choices alter a four-quadrant compressible interaction while preserving the known/reference solution structure?",
+      "branches": [
+        {
+          "id": "profile_and_event_error",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+          "principal_qois": [
+            {"name": "centerline_profiles", "definition": "named rho, p, T, and velocity profiles on fixed horizontal and vertical centerlines", "source": "named sample profiles", "aggregation": "declared final time or aligned time; L1 and Linf errors are computed by the comparison layer"},
+            {"name": "event_locations", "definition": "declared shock, contact, and rarefaction feature locations from the versioned feature detector", "source": "feature detector on centerline profiles", "aggregation": "same time; location error is computed by the comparison layer"}
+          ],
+          "diagnostics": ["rho_min", "p_min", "positivity_failures", "mass_momentum_energy_balance", "parallel_difference_norm"],
+          "relations": ["mesh convergence", "Courant sensitivity", "flux/limiter comparison", "domain-size sensitivity", "restart/decomposition invariance"]
+        }
+      ],
+      "extractor_requirements": ["the reference profile and variable columns must be explicit", "a sampled value or last column is never called error without candidate-reference subtraction", "feature detector and sampling coordinates are versioned"]
+    },
+    {
+      "family": "risingBubble",
+      "scientific_question": "How do mesh, interface treatment, density/viscosity, gravity, and solver choices change bubble rise and deformation?",
+      "branches": [
+        {
+          "id": "bubble_trajectory",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+          "principal_qois": [
+            {"name": "bubble_centroid_y_final", "definition": "final volume-weighted centroid of the connected gas region from alpha threshold", "source": "gas-phase alpha and cell volumes; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"},
+            {"name": "equivalent_radius_final", "definition": "final connected gas-region equivalent radius", "source": "gas-phase alpha and cell volumes; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"},
+            {"name": "shape_aspect_ratio_final", "definition": "final principal-axis aspect ratio of the connected gas region", "source": "gas-phase alpha geometry and cell centres; measurement-only C/Vc preparation is permitted", "aggregation": "final saved field"}
+          ],
+          "diagnostics": ["bubble_centroid_y_history", "rise_velocity", "shape_aspect_ratio_history", "equivalent_diameter", "phase_volume_conservation", "interface_area", "breakup_or_coalescence_events"],
+          "relations": ["mesh convergence", "surface-tension/gravity branch", "density/viscosity branch", "solver/interface-scheme comparison"]
+        }
+      ],
+      "extractor_requirements": ["identify gas phase and connected component explicitly", "do not use global alpha minimum", "preserve transient histories rather than averaging all times into one scalar"]
+    },
+    {
+      "family": "supersonicCrossJet",
+      "scientific_question": "How do Mach number, jet/mainflow pressure ratio, injection angle, mesh, schemes, and solver formulation change jet penetration and shock structure?",
+      "branches": [
+        {
+          "id": "jet_trajectory_and_shock",
+          "cases": ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+          "principal_qois": [
+            {"name": "jet_to_mainstream_mass_flux_ratio", "definition": "absolute ratio of the explicit phi mass flux through inlet2 to inlet1 at the final saved time", "source": "inlet1 and inlet2 patch fluxes; phi dimensions must be mass/time", "aggregation": "final saved time with branches kept separate"},
+            {"name": "interior_pressure_span", "definition": "max(p)-min(p) in the declared internal shock-search window -1<=x<=1 and 0.1<=y<=0.95", "source": "final retained p field and cell centres; uniform p fields are expanded over the retained cells", "aggregation": "final saved field; boundary cells outside the search window are excluded"}
+          ],
+          "diagnostics": ["jet_centerline_trajectory", "section_pressure_ratio", "shock_strength", "mass_balance_residual"],
+          "relations": ["Mach trend", "pressure-ratio trend", "injection-angle trend", "mesh/scheme/solver sensitivity"]
+        }
+      ],
+      "extractor_requirements": ["declare the jet-identifying field or momentum criterion", "declare section coordinates and interpolation", "do not use global pressure span as principal response"]
+    },
+    {
+      "family": "yPlusVerification",
+      "scientific_question": "Does the wall-normal velocity profile and first-cell wall resolution agree with the declared turbulent-wall-law or low-Reynolds-number verification target?",
+      "branches": [
+        {
+          "id": "wall_law_profile",
+          "cases": ["1", "2", "8", "9"],
+          "principal_qois": [
+            {"name": "first_cell_yplus", "definition": "wall-normal y+ of first cell center on the declared wall patch", "source": "wall distance and wall shear, or an explicitly named wall-normal profile with y+", "aggregation": "patch/profile endpoint"}
+          ],
+          "diagnostics": ["spalding_log_rmse", "achieved_Re_tau", "u_tau", "profile_residual_by_yplus_bin"],
+          "relations": ["mesh resolution", "turbulence-model comparison"]
+        },
+        {
+          "id": "low_re_profile",
+          "cases": ["3", "4", "5", "6", "7"],
+          "principal_qois": [
+            {"name": "first_cell_yplus", "definition": "first-cell wall resolution on the declared wall patch", "source": "wall distance and wall shear, or an explicitly named wall-normal profile with y+", "aggregation": "patch/profile endpoint"}
+          ],
+          "diagnostics": ["spalding_log_rmse", "achieved_Re_tau", "wall_shear_distribution", "boundedness"]
+        },
+        {
+          "id": "multi_reynolds_branch",
+          "cases": ["10"],
+          "principal_qois": [
+            {"name": "branchwise_wall_law_metrics", "definition": "Spalding log-RMSE and first-cell yPlus preserved separately for Re_tau_180, Re_tau_395, and Re_tau_590 viscosity branches", "source": "branch-labelled spalding_comparison.raw or explicitly named branch profiles", "aggregation": "no cross-branch averaging"}
+          ],
+          "diagnostics": ["branchwise_achieved_Re_tau", "branchwise_first_cell_yplus"]
+        }
+      ],
+      "extractor_requirements": ["use spalding_comparison.raw residual by name only as an intermediate evidence source", "recompute/verify u_tau, nu, y+, U+, and valid y+ range", "never let a U_z column or an all-zero placeholder define profile error"]
+    }
+  ]
+}

benchmarks/__init__.py

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

benchmarks/assets/README.md

@@ -0,0 +1,15 @@
+# ExtBench Geometry Assets
+
+These files are copied from the OpenFOAM 13 tutorial distribution used to
+build the benchmark reference cases. The OpenFOAM 13 distribution states in
+`README.org` and `COPYING` that the distributed files may be redistributed
+under the GNU General Public License, version 3 or later.
+
+The asset manifest records the original tutorial location and SHA-256 digest
+for every file. Materialization verifies the digest before copying an asset
+into a case. The assets are kept separate from the case JSON so the benchmark
+data remains readable and cases do not depend on a machine-specific `/opt`
+path.
+
+If a downstream distribution has additional provenance or licensing notices
+for the DrivAer geometry, add them here and to `manifest.json` before release.

benchmarks/assets/manifest.json

@@ -0,0 +1,41 @@
+{
+  "schema_version": "foambench.asset-manifest.v1",
+  "license": "GPL-3.0-or-later (OpenFOAM 13 tutorial-derived files)",
+  "assets": {
+    "simpleRushtonMRF/stirrer4": {
+      "path": "benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer4.obj",
+      "sha256": "d64e176d6aa872857bb5b01791cc0441aa15ff8456440be7235f7481f658a117",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/simpleRushtonMRF/constant/geometry/stirrer4.obj"
+    },
+    "simpleRushtonMRF/stirrer6": {
+      "path": "benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer6.obj",
+      "sha256": "d0572aec19c41b2454ba0d7eecd1e07a7aae6aa98695f35ce781715e663ae40b",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/simpleRushtonMRF/constant/geometry/stirrer6.obj"
+    },
+    "simpleRushtonMRF/baffles": {
+      "path": "benchmarks/assets/openfoam13/simpleRushtonMRF/baffles.obj",
+      "sha256": "612cb86bfa2c842444ba86f203af31c712da3e807ed537013fefff8ab40f42a2",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/simpleRushtonMRF/constant/geometry/baffles.obj"
+    },
+    "naca0012/NACA0012": {
+      "path": "benchmarks/assets/openfoam13/naca0012/NACA0012.obj.gz",
+      "sha256": "9fd098e03da6178852d4f9837bc06d2f24599065644f951b481907513d835d90",
+      "source": "OpenFOAM-13/tutorials/resources/geometry/NACA0012.obj.gz"
+    },
+    "drivaerFastback/body": {
+      "path": "benchmarks/assets/openfoam13/drivaerFastback/body.obj.gz",
+      "sha256": "0622638e6d9e2ef61d739ef2ae699ce4d5fb212abeaaa6f4583da54f3da24efe",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/drivaerFastback/constant/geometry/body.obj.gz"
+    },
+    "drivaerFastback/frontWheels": {
+      "path": "benchmarks/assets/openfoam13/drivaerFastback/frontWheels.obj.gz",
+      "sha256": "f3e4f7f432c3e76d4f509fbba2429825acfc25ab696265df73f828504e6483b7",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/drivaerFastback/constant/geometry/frontWheels.obj.gz"
+    },
+    "drivaerFastback/rearWheels": {
+      "path": "benchmarks/assets/openfoam13/drivaerFastback/rearWheels.obj.gz",
+      "sha256": "02f25f876414a9a4cbdb9cfb08da9916ac49f7851d4658067abc371447f882ce",
+      "source": "OpenFOAM-13/tutorials/incompressibleFluid/drivaerFastback/constant/geometry/rearWheels.obj.gz"
+    }
+  }
+}

benchmarks/assets/openfoam13/drivaerFastback/body.obj.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0622638e6d9e2ef61d739ef2ae699ce4d5fb212abeaaa6f4583da54f3da24efe
+size 2839115

benchmarks/assets/openfoam13/drivaerFastback/frontWheels.obj.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3e4f7f432c3e76d4f509fbba2429825acfc25ab696265df73f828504e6483b7
+size 860951

benchmarks/assets/openfoam13/drivaerFastback/rearWheels.obj.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02f25f876414a9a4cbdb9cfb08da9916ac49f7851d4658067abc371447f882ce
+size 940038

benchmarks/assets/openfoam13/naca0012/NACA0012.obj.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9fd098e03da6178852d4f9837bc06d2f24599065644f951b481907513d835d90
+size 112656

benchmarks/assets/openfoam13/simpleRushtonMRF/baffles.obj

@@ -0,0 +1,38 @@
+# Wavefront OBJ file written 2024-10-12T17:20:59
+o baffles
+
+# points : 16
+# faces  : 8
+# zones  : 1
+#   0  patch0  (nFaces: 8)
+
+# <points count="16">
+v 0.353553 0.353553 0
+v 0.33234 0.33234 0
+v 0.353553 0.353553 1.2
+v 0.33234 0.33234 1.2
+v -0.33234 -0.33234 0
+v -0.353553 -0.353553 0
+v -0.33234 -0.33234 1.2
+v -0.353553 -0.353553 1.2
+v -0.353553 0.353553 0
+v -0.33234 0.33234 0
+v -0.353553 0.353553 1.2
+v -0.33234 0.33234 1.2
+v 0.33234 -0.33234 0
+v 0.353553 -0.353553 0
+v 0.33234 -0.33234 1.2
+v 0.353553 -0.353553 1.2
+# </points>
+
+# <faces count="8">
+g patch0
+f 2 4 3
+f 2 3 1
+f 6 8 7
+f 6 7 5
+f 10 12 11
+f 10 11 9
+f 14 16 15
+f 14 15 13
+# </faces>

benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer4.obj

@@ -0,0 +1,32 @@
+# Wavefront OBJ file
+# Regions:
+#     0    patch0
+#
+# points    : 16
+# triangles : 8
+#
+v -1.37773e-17 -0.075 0.57
+v -2.75546e-17 -0.15 0.57
+v -1.37773e-17 -0.075 0.63
+v -2.75546e-17 -0.15 0.63
+v -0.075 9.18485e-18 0.57
+v -0.15 1.83697e-17 0.57
+v -0.075 9.18485e-18 0.63
+v -0.15 1.83697e-17 0.63
+v 4.59243e-18 0.075 0.57
+v 9.18485e-18 0.15 0.57
+v 4.59243e-18 0.075 0.63
+v 9.18485e-18 0.15 0.63
+v 0.075 0 0.57
+v 0.15 0 0.57
+v 0.075 0 0.63
+v 0.15 0 0.63
+g patch0
+f 1 2 4
+f 1 4 3
+f 5 6 8
+f 5 8 7
+f 9 10 12
+f 9 12 11
+f 13 14 16
+f 13 16 15

benchmarks/assets/openfoam13/simpleRushtonMRF/stirrer6.obj

@@ -0,0 +1,47 @@
+# Wavefront OBJ file
+# Regions:
+#     0    zone0
+#     1    patch0
+#
+# points    : 24
+# triangles : 12
+#
+v 0.0375 -0.0649519 0.57
+v 0.075 -0.129904 0.57
+v 0.0375 -0.0649519 0.63
+v 0.075 -0.129904 0.63
+v -0.0375 -0.0649519 0.57
+v -0.075 -0.129904 0.57
+v -0.0375 -0.0649519 0.63
+v -0.075 -0.129904 0.63
+v -0.075 9.18485e-18 0.57
+v -0.15 1.83697e-17 0.57
+v -0.075 9.18485e-18 0.63
+v -0.15 1.83697e-17 0.63
+v -0.0375 0.0649519 0.57
+v -0.075 0.129904 0.57
+v -0.0375 0.0649519 0.63
+v -0.075 0.129904 0.63
+v 0.075 0 0.57
+v 0.15 0 0.57
+v 0.075 0 0.63
+v 0.15 0 0.63
+v 0.0375 0.0649519 0.57
+v 0.075 0.129904 0.57
+v 0.0375 0.0649519 0.63
+v 0.075 0.129904 0.63
+g zone0
+f 1 2 4
+f 1 4 3
+f 5 6 8
+f 5 8 7
+f 9 10 12
+f 9 12 11
+f 13 14 16
+f 13 16 15
+g patch0
+f 17 18 20
+f 17 20 19
+g zone0
+f 21 22 24
+f 21 24 23

benchmarks/evaluation/README.md

@@ -0,0 +1,12 @@
+# 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

@@ -0,0 +1,31 @@
+"""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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,71 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,807 @@
+#!/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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,750 @@
+#!/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

@@ -0,0 +1,119 @@
+"""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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,1572 @@
+#!/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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,421 @@
+#!/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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,129 @@
+#!/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

@@ -0,0 +1,155 @@
+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

@@ -0,0 +1,29 @@
+"""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

@@ -0,0 +1,713 @@
+#!/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}