Publish complete independent I50 and S50 benchmark

DATA_FORMAT.md

@@ -0,0 +1,19 @@
+# FireWorldBench v2 数据格式
+
+## 文件
+
+`main_synthetic/full_test_A/questions.jsonl`：200 行模型输入；`gold.jsonl`：相同 `qa_id` 的 200 行源标准答案；`selection_manifest.jsonl`：独立筛选的 I50、S50 索引、来源和图片哈希。I/S **没有一对一对应关系**。所有 JSONL 为 UTF-8，每行一个 JSON 对象。
+
+同一道逻辑题共享 `logical_id`，有 `choice` 与 `open` 两行。`track` 为 I 或 S。`question` 是原英文题干，choice 的 `options` 保留原选项。`query_context` 给出起点时刻、预测时距及目标区域。open 的 `answer_fields` 精确列出应输出的 `prediction` 字段；点分路径表示嵌套 JSON。
+
+## 模型材料
+
+I 轨 `material.assets` 顺序就是图像附件顺序；每项有 `image_index`、`field`、目标 `time_s`、实际 `actual_time_s`、固定 y 的 x-z 切面几何、`color_scale` 和相对于 `main_synthetic/` 的 `path`。R1–R8 在 `region_layout.bins` 给出沿 x 的等宽边界，x 从左至右，z 从下至上。`numeric_observations` 保存没有可见结构、因此未附图的原始切片统计值，按变量和观测时刻列出 R1–R8。模型无需从图片猜变量或色标。`task_rules` 写明区域统计、全域聚合、趋势死区或风险校准。
+
+S 轨 `material.observations` 是按时刻排序的 R1–R8 温度 P95、烟炱 P95、能见度 P10。原源文件的速度相关三字段与原始切片多处不一致，而本版所选任务仅使用上述三变量，所以从 v2 **输入**中移除了速度三字段，原源 gold 不变。S 轨同样给出 `region_geometry`、`observation_geometry` 和 `task_rules`。
+
+**时间隔离：**模型材料只含题目起点及之前的观测。未来原始切片只用于离线核验 gold，不能进入模型输入。Gold 只供评分器读取。
+
+## 输出
+
+Choice 返回 `{"choices":["A"],"confidence":0.8}`；多选题须选出全部且仅选正确声明，完整假设题恰选一个标签。Open 返回 `conclusion`、`prediction`、`evidence`、`mechanism`、`confidence`，其中 `prediction` 只填 `answer_fields` 规定的路径。运行代码从本仓库根目录调用 `evaluation/FireWorldBench-ICLR/scripts/run_eval.py --split main_synthetic --data-dir .`。完整参数见仓库 README。

DATA_LICENSE.md

@@ -0,0 +1,9 @@
+# FireWorldBench v2 data license
+
+The benchmark questions, gold answers, and associated assets in this package are distributed under the Creative Commons Attribution 4.0 International license (CC BY 4.0), following the upstream FireWorldBench data license.
+
+This v2 package selects 50 matched I/S pairs, adds explicit I/S pairing records, and adds image-variable, time, slice, and region metadata to the I-track inputs. The original question text, options, and gold records are retained.
+
+Attribution: FireWorldBench. Source dataset: https://huggingface.co/datasets/FireWorldBench/FireWorldBench. Source code repository: https://github.com/15628925702/FireWorldBench-ICLR.
+
+The evaluation code copied under `evaluation/FireWorldBench-ICLR/` is licensed separately under Apache License 2.0; see that directory's `LICENSE` and `UPSTREAM.md`.

FireWorldBench-v2-I50-S50.zip

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

README.md

@@ -1,5 +1,5 @@
 ---
-license: other
+license: cc-by-4.0
 task_categories:
 - visual-question-answering
 tags:
@@ -9,27 +9,28 @@ size_categories:
 - n<1K
 ---
 
-# FireWorldBench-new
+# FireWorldBench v2: independent I50 and S50
 
-筛选后的 I 轨试做集，共 50 道逻辑题（选择题和开放题成对）。同事件、同题型的 S 轨文本题一并附上，共 145 个 S 逻辑题。问题行 390。有结构的二维场 133 张图；没有结构的场 62 处不附图，只在 `material` 里给出原切片按 R1–R8 算出的一个统计量。
+本仓库是可独立运行的 FireWorldBench v2。I 轨和 S 轨分别筛选 50 道逻辑题，**不按编号配对**。每道逻辑题包含 choice 和 open 两条输入，共 200 条 question 与逐一对应的 200 条原始 gold。题干、选项、gold 均保留源记录；I 轨补充原切片图、变量/时间/区域/色标元数据与无结构场数值。S 轨只保留经过原切片核对的任务变量。
 
-三维图沿用原图。题干文字、选项和 Gold 不改。
+- 数据：[main_synthetic/full_test_A/questions.jsonl](main_synthetic/full_test_A/questions.jsonl)、[gold.jsonl](main_synthetic/full_test_A/gold.jsonl)、[selection_manifest.jsonl](main_synthetic/full_test_A/selection_manifest.jsonl)。
+- 68 张 I 轨输入图统一采用暗蓝紫 RGB (0,0,128) 的低端与轻柔色带过渡，位于 `main_synthetic/assets/final_optimized/`，均按最终视觉标准从原切片绘制为全场图，无文字和图例。`material.assets[*].image_index` 指向实际附件顺序，路径相对 `main_synthetic/`。
+- 推理与六项指标评分代码、schema、冻结合同及代码许可位于 `evaluation/FireWorldBench-ICLR/`。
+- 格式见 [DATA_FORMAT.md](DATA_FORMAT.md)，数据许可见 [DATA_LICENSE.md](DATA_LICENSE.md)，数据卡见 [dataset_card_public.md](dataset_card_public.md)。
+- 完整包：[FireWorldBench-v2-I50-S50.zip](FireWorldBench-v2-I50-S50.zip)。
 
-## 数据入口
+## 运行
 
-- 项目主页：https://FireWorldBench.github.io/
-- 公开数据：https://huggingface.co/datasets/FireWorldBench/FireWorldBench （`Guaogua/FireWorldBench` 为同一仓）
-- 公开代码：https://github.com/15628925702/FireWorldBench-ICLR
-- 开发数据（私有）：https://huggingface.co/datasets/Guaogua/FireWorldBench-private
-- 本仓：https://huggingface.co/datasets/FireWorldLab/FireWorldBench-new （筛选后的 I 轨试做集。本地目录 `代码/FireWorldBench-new/`。）
+需要 Python 3.8+；从本仓库根目录运行：
 
-## 本仓内容
+```powershell
+python -m pip install -r evaluation/FireWorldBench-ICLR/requirements.txt
+$env:OPENAI_BASE_URL = "你的 OpenAI 兼容接口地址"
+$env:OPENAI_API_KEY = "你的接口密钥"
+$env:OPENAI_MODEL = "模型名称"
+python evaluation/FireWorldBench-ICLR/scripts/run_eval.py --split main_synthetic --data-dir .
+```
 
-- `main_synthetic/full_test_A/questions.jsonl`
-- `main_synthetic/full_test_A/gold.jsonl`
-- `main_synthetic/assets/i50/`：有结构的新图
-- 没有结构的场：`material` 中无 `path`，含 `statistic` 和 `regions`
+纯文本模型加 `--track S`；视觉模型可选 I 轨或两轨。可用 `--max-requests 2` 做小规模连通检查。runner 只读 questions 和引用图片；评分器单独读取 gold。模型输入包含 query_context、区域与变量规则、每张附件编号、时间、切片和色标范围。正式题包不需要原始私有 `.sf` 才能运行。
 
-区域：沿 x 从入口到出口均分 8 段，R1 为入口。温度和第 95 百分位、烟炱第 95 百分位、能见度第 10 百分位、速度第 90 百分位、纵向/竖向速度为平均值。图的底色是略浅于旧图的海军蓝，等高线 1.2 pt。
-
-尚未做关键区域裁剪。评测尚未在这 50 题上重跑。
+本轮筛选覆盖 I 轨 L1-2（20）、L2-2（5）、L3-1（25），S 轨 L1-2（25）、L3-1（25）。没有宣称覆盖原题库的全部任务类型。推理代码源于 FireWorldBench-ICLR 提交 `c2ed1d2c82084337cc88c901e25e27296e993233`，复制后仅为 v2 输入协议调整；代码保留 Apache 2.0 许可证。

dataset_card_public.md

@@ -0,0 +1,14 @@
+---
+license: cc-by-4.0
+task_categories:
+- visual-question-answering
+tags:
+- fire
+- physics
+size_categories:
+- n<1K
+---
+
+# FireWorldBench v2
+
+独立筛选的 50 道 I 轨与 50 道 S 轨逻辑题；每题 choice 和 open 两种输入。共 200 条 questions、200 条 source gold 与 180 张 I 轨最终版物理场图。两轨不作一对一配对。I 轨选择 L1-2/L2-2/L3-1，S 轨选择 L1-2/L3-1。材料只含起点之前观测；未来原始切片仅作离线 gold 核对。完整格式、评分代码和运行命令见 README 与 DATA_FORMAT。

evaluation/FireWorldBench-ICLR/.gitignore

@@ -0,0 +1,28 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Environments
+.env
+.venv
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+
+# FireWorldBench runtime outputs (never commit)
+data/main_synthetic/     # downloaded dataset (~660MB)
+data/mmodalfire_c06/     # downloaded dataset
+results/                 # evaluation outputs
+runs/
+*.jsonl.manifest.json
+*.SHA256SUMS.txt

evaluation/FireWorldBench-ICLR/DATA_LICENSE.md

@@ -0,0 +1,7 @@
+# Data License
+
+The benchmark questions, gold answers, and associated assets are licensed under the Creative Commons Attribution 4.0 International license.
+
+The dataset itself is not distributed in this anonymous-review repository. Distribution locations and attribution details are intentionally omitted during double-blind review.
+
+The evaluation code is licensed separately as described in `LICENSE`.

evaluation/FireWorldBench-ICLR/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        Apache License, Version 2.0
+
+   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
+
+       Apache License, Version 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.

evaluation/FireWorldBench-ICLR/README.md

@@ -0,0 +1,27 @@
+# FireWorldBench v2 evaluation toolkit
+
+This is a copy of the FireWorldBench-ICLR evaluation code, task contracts, and schemas. Source repository and commit are recorded in `UPSTREAM.md`. The code license is in `LICENSE`; the bundled dataset license is at `../../DATA_LICENSE.md`.
+
+## Install
+
+From the FireWorldBench v2 repository root:
+
+```powershell
+python -m pip install -r evaluation/FireWorldBench-ICLR/requirements.txt
+```
+
+Python 3.8 or newer is required. The included runner uses an OpenAI-compatible HTTP endpoint; configure `OPENAI_BASE_URL`, `OPENAI_API_KEY`, and `OPENAI_MODEL` in the environment.
+
+## Run the bundled benchmark
+
+From the FireWorldBench v2 repository root:
+
+```powershell
+python evaluation/FireWorldBench-ICLR/scripts/run_eval.py --split main_synthetic --data-dir .
+```
+
+The v2 package root is the data directory because it contains `main_synthetic/full_test_A/`. The runner reads questions and referenced images, never gold. After inference, the scorer reads matching gold rows by `qa_id` and writes six metrics under `results/`.
+
+Use `--track S` for text-only models or `--track I` for vision models; omit `--track` to run both. Add `--max-requests 2` for a small endpoint connectivity check.
+
+The scripts in `scripts/contracts/` contain the frozen task contracts. The direct API runner accepts an optional `--task-contract` file for contract-controlled runs. See `python evaluation/FireWorldBench-ICLR/scripts/run_eval.py --help` and `python evaluation/FireWorldBench-ICLR/scripts/run_api.py --help` for all options.

evaluation/FireWorldBench-ICLR/UPSTREAM.md

@@ -0,0 +1,12 @@
+# Upstream code snapshot
+
+The evaluation runtime in this directory is copied from the FireWorldBench-ICLR repository.
+
+- Upstream: https://github.com/15628925702/FireWorldBench-ICLR
+- Source commit: c2ed1d2c82084337cc88c901e25e27296e993233
+- Copied on: 2026-09-23
+- Upstream working tree was clean at copy time.
+- The Apache-2.0 license for this code is retained in `LICENSE`.
+- The bundled v2 dataset is at `../../main_synthetic/` from this directory.
+
+The v2 copy keeps the upstream scoring logic. Its API runner was adapted to pass `query_context`, attach numbered images with matching variable/time metadata, and require exactly one label for complete-hypothesis questions. The v2 root README documents how to point `run_eval.py` at the bundled data.

evaluation/FireWorldBench-ICLR/data/README.md

@@ -0,0 +1,5 @@
+# Bundled FireWorldBench v2 data
+
+The v2 questions, gold records, and image assets are stored at `../../../main_synthetic/` relative to this `data/` folder.
+
+From the repository root, run the evaluation pipeline with `--data-dir .`. The previous upstream distribution expected the full public dataset to be downloaded into this folder; this v2 package is self-contained and does not require that download script.

evaluation/FireWorldBench-ICLR/requirements.txt

@@ -0,0 +1 @@
+requests>=2.31,<3

evaluation/FireWorldBench-ICLR/scripts/contracts/dual_axis.json

@@ -0,0 +1,115 @@
+{
+  "schema": "FWB-FG9-DUAL-AXIS-v20260902",
+  "note": "Difficulty order on main_synthetic figure Acc (25 tracks, InternVL included). P1/T1 easiest. Fire T2/T3 swapped vs 2026-08-30 so T1→T5 is also easy→hard. C06 formal test n=714.",
+  "axes": {
+    "physical": {
+      "P1": "Temporal Evolution Forecasting",
+      "P2": "Physical Field Perception and Grounding",
+      "P3": "Cross-Field Coupling Understanding",
+      "P4": "Causal Mechanism Attribution",
+      "P5": "Counterfactual Intervention Reasoning"
+    },
+    "physical_zh": {
+      "P1": "时间预测",
+      "P2": "场感知与落地",
+      "P3": "跨场耦合理解",
+      "P4": "机制归因",
+      "P5": "反事实干预推理"
+    },
+    "fire": {
+      "T1": "Fire Evolution Prediction",
+      "T2": "Fire State Assessment",
+      "T3": "Fire Early Warning",
+      "T4": "Fire Intervention Decision-Making",
+      "T5": "Fire Mechanism Diagnosis"
+    },
+    "fire_zh": {
+      "T1": "演化预测",
+      "T2": "状态评估",
+      "T3": "早期预警",
+      "T4": "干预决策",
+      "T5": "机制诊断"
+    }
+  },
+  "task_to_physical": {
+    "L1-1": "P2",
+    "L1-2": "P3",
+    "L1-3": "P4",
+    "L2-1": "P2",
+    "L2-2": "P3",
+    "L2-3": "P4",
+    "L3-1": "P1",
+    "L3-2": "P1",
+    "L3-3": "P5"
+  },
+  "task_to_fire": {
+    "L1-1": "T3",
+    "L1-2": "T1",
+    "L1-3": "T2",
+    "L2-1": "T2",
+    "L2-2": "T2",
+    "L2-3": "T5",
+    "L3-1": "T1",
+    "L3-2": "T1",
+    "L3-3": "T4"
+  },
+  "physical_to_tasks": {
+    "P1": [
+      "L3-1",
+      "L3-2"
+    ],
+    "P2": [
+      "L1-1",
+      "L2-1"
+    ],
+    "P3": [
+      "L1-2",
+      "L2-2"
+    ],
+    "P4": [
+      "L1-3",
+      "L2-3"
+    ],
+    "P5": [
+      "L3-3"
+    ]
+  },
+  "fire_to_tasks": {
+    "T1": [
+      "L1-2",
+      "L3-1",
+      "L3-2"
+    ],
+    "T2": [
+      "L1-3",
+      "L2-1",
+      "L2-2"
+    ],
+    "T3": [
+      "L1-1"
+    ],
+    "T4": [
+      "L3-3"
+    ],
+    "T5": [
+      "L2-3"
+    ]
+  },
+  "counts_main_synthetic": {
+    "physical": {
+      "P1": 2038,
+      "P2": 1824,
+      "P3": 1718,
+      "P4": 1956,
+      "P5": 824
+    },
+    "fire": {
+      "T1": 2944,
+      "T2": 2504,
+      "T3": 1044,
+      "T4": 824,
+      "T5": 1044
+    }
+  },
+  "c06_n": 714
+}

evaluation/FireWorldBench-ICLR/scripts/contracts/l22_c06_nowcast_s.txt

@@ -0,0 +1,8 @@
+L2-2 operational terminal-nowcast contract for MmodalFire C06
+
+The target is the completed-window persistent risk profile at the stated target time. Only observations strictly before that time are supplied. Infer the terminal state from the persistent spatial and temporal pattern in this history; do not assume an unobserved value was provided.
+
+Use temperature, visibility, and soot as the three hazard channels. Higher temperature and soot indicate greater risk; lower visibility indicates greater risk. Compare channels on the benchmark's calibrated risk scale learned from exposed training examples. Aggregate each channel robustly over the target window. runner_up_region is the next persistent competitor and risk_level is the selected pair's calibrated ordinal band.
+
+stability_phase is early, middle, late, or unstable according to when the final pair becomes persistent over the target history. winner_switch_count_bin is zero, one, or multiple. Apply this same terminal-nowcast contract to every C06 L2-2/S item.
+

evaluation/FireWorldBench-ICLR/scripts/contracts/l22_c06_s.txt

@@ -0,0 +1,7 @@
+L2-2 operational terminal-nowcast contract for MmodalFire C06
+
+The target is the completed-window persistent risk profile at the stated target time. Only observations strictly before that time are supplied. Infer the terminal state from the persistent spatial and temporal pattern in this history; do not assume an unobserved value was provided.
+
+Use temperature, visibility, and soot as the three hazard channels. Higher temperature and soot indicate greater risk; lower visibility indicates greater risk. Compare channels on the benchmark's calibrated risk scale learned from exposed training examples. Aggregate each channel robustly over the target window. runner_up_region is the next persistent competitor and risk_level is the selected pair's calibrated ordinal band.
+
+stability_phase is early, middle, late, or unstable according to when the final pair becomes persistent over the target history. winner_switch_count_bin is zero, one, or multiple. Apply this same terminal-nowcast contract to every C06 L2-2/S item.

evaluation/FireWorldBench-ICLR/scripts/contracts/l22_main_nowcast_s.txt

@@ -0,0 +1,8 @@
+L2-2 operational terminal-nowcast contract
+
+The target is the completed-window robust risk profile at the stated target time. Only observations strictly before that time are supplied. Infer the terminal state from the persistent spatial and temporal pattern in this history; do not assume an unobserved value was provided.
+
+Use temperature, visibility, and soot as the three hazard channels. Higher temperature and soot indicate greater risk; lower visibility indicates greater risk. Compare channels on the benchmark's calibrated risk scale learned from exposed training examples. The main-set profile is robust to one potentially unreliable reading and represents the region-driver pair with persistent support across the target window. runner_up_region is the next persistent competitor and risk_level is the selected pair's calibrated ordinal band.
+
+stability_phase is early, middle, late, or unstable according to when the final pair becomes persistent over the target history. winner_switch_count_bin is zero, one, or multiple. Apply this same terminal-nowcast contract to every main-set L2-2/S item.
+

evaluation/FireWorldBench-ICLR/scripts/contracts/l22_main_s.txt

@@ -0,0 +1,7 @@
+L2-2 operational terminal-nowcast contract
+
+The target is the completed-window robust risk profile at the stated target time. Full three-channel observations for every region are supplied only before the target. At the target, a fixed sparse sensor network supplies exact temperature, visibility, and soot measurements only in R1, R3, R5, and R7; infer the other regions from their histories. This sensor placement is fixed for every item and is independent of the answer.
+
+Use temperature, visibility, and soot as the three hazard channels. Higher temperature and soot indicate greater risk; lower visibility indicates greater risk. Compare channels on the benchmark's calibrated risk scale learned from exposed training examples. The main-set profile is robust to one potentially unreliable reading and represents the region-driver pair with persistent support across the target window. runner_up_region is the next persistent competitor and risk_level is the selected pair's calibrated ordinal band.
+
+stability_phase is early, middle, late, or unstable according to when the final pair becomes persistent over the target history. winner_switch_count_bin is zero, one, or multiple. Apply this same terminal-nowcast contract to every main-set L2-2/S item.

evaluation/FireWorldBench-ICLR/scripts/contracts/three_stage_event_family.json

@@ -0,0 +1,23 @@
+{
+  "schema": "FWB-FG9-THREE-STAGE-EVENT-FAMILY-v1",
+  "fire_axis": {
+    "T1 Localized Onset": {"zh": "局域起火", "definition": "Localized source, anomaly, violation, or fire-stage assessment."},
+    "T2 Coupled Propagation": {"zh": "耦合蔓延", "definition": "Cross-region state, transport, coupling, or risk propagation."},
+    "T3 Critical Transition": {"zh": "临界转变", "definition": "Future outcome, threshold crossing, intervention, or counterfactual transition."}
+  },
+  "task_mapping": {
+    "L1-1": "T1 Localized Onset", "L1-3": "T1 Localized Onset", "L2-1": "T1 Localized Onset",
+    "L1-2": "T2 Coupled Propagation", "L2-2": "T2 Coupled Propagation", "L2-3": "T2 Coupled Propagation",
+    "L3-1": "T3 Critical Transition", "L3-2": "T3 Critical Transition", "L3-3": "T3 Critical Transition"
+  },
+  "event_families": [
+    "Transportation and Infrastructure",
+    "Office and Digital Facilities",
+    "Healthcare and Education",
+    "Commercial and Public Spaces",
+    "Residential and Care Settings",
+    "Industry, Energy, and Logistics",
+    "Wildland and Wildland--Urban Interface (WUI)"
+  ],
+  "physical_axis_policy": "physical_axis is copied byte-for-byte and never used to assign fire_axis"
+}

evaluation/FireWorldBench-ICLR/scripts/fwb_axis_schema.json

@@ -0,0 +1,30 @@
+{
+  "schema": "FWB-DUAL-AXIS-PAPER-v20260914",
+  "source": "Fire.pdf Section 3.1 + expert-review L-task mapping (Outcome Transition renamed Critical Transition)",
+  "physical": {
+    "P1": {"en": "Temporal Evolution Forecasting", "tasks": ["L3-1", "L3-2"]},
+    "P2": {"en": "Physical Field Perception and Grounding", "tasks": ["L1-1", "L2-1"]},
+    "P3": {"en": "Cross-Field Coupling Understanding", "tasks": ["L1-2", "L2-2"]},
+    "P4": {"en": "Causal Mechanism Attribution", "tasks": ["L1-3", "L2-3"]},
+    "P5": {"en": "Counterfactual Intervention Reasoning", "tasks": ["L3-3"]}
+  },
+  "fire": {
+    "T1": {"en": "Localized Onset", "tasks": ["L1-1", "L1-3", "L2-1"]},
+    "T2": {"en": "Coupled Propagation", "tasks": ["L1-2", "L2-2", "L2-3"]},
+    "T3": {"en": "Critical Transition", "tasks": ["L3-1", "L3-2", "L3-3"]}
+  },
+  "metrics": ["Acc", "F1", "Brier", "Evi-F1", "Mech", "GLS"],
+  "tracks": {
+    "S": 15,
+    "I": 10,
+    "total_paper_tracks": 25
+  },
+  "model_stems": [
+    "llama31_8b_S", "qwen3_8b_S", "gemma3_12b_it_S", "gemma3_27b_S", "qwen3_32b_S",
+    "llama33_70b_S", "qwen3next_80b_S", "glm45_air_S", "qwen3_235b_S", "deepseek_v3_S", "kimi_k2_S",
+    "gpt56_luna_S", "gemini25flash_S", "claude_haiku_45_S", "qwen35_plus_S",
+    "internvl3_8b_I", "internvl3_38b_I", "internvl3_78b_I",
+    "qwen3vl8b_I", "qwen3vl32b_I", "qwen3vl235b_I",
+    "gpt56_luna_I", "gemini25flash_I", "claude_haiku_45_I", "qwen35_plus_I"
+  ]
+}

evaluation/FireWorldBench-ICLR/scripts/relabel_event_families.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Build the three-stage fire axis, event-family manifest, and grouped audits.
+
+The input files are expected to be exported from the official HF repositories.
+No source data is committed by this script.  Every output row is copied with
+only ``fire_axis`` changed; physical_axis and all answer fields are preserved.
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+FIRE_AXIS = {
+    "T1 Localized Onset": "localized source, anomaly, violation, or fire-stage assessment",
+    "T2 Coupled Propagation": "cross-region state, transport, coupling, or risk propagation",
+    "T3 Critical Transition": "future outcome, threshold crossing, intervention, or counterfactual transition",
+}
+TASK_FIRE = {
+    "L1-1": "T1 Localized Onset", "L1-3": "T1 Localized Onset", "L2-1": "T1 Localized Onset",
+    "L1-2": "T2 Coupled Propagation", "L2-2": "T2 Coupled Propagation", "L2-3": "T2 Coupled Propagation",
+    "L3-1": "T3 Critical Transition", "L3-2": "T3 Critical Transition", "L3-3": "T3 Critical Transition",
+}
+
+FAMILIES = [
+    "Transportation and Infrastructure",
+    "Office and Digital Facilities",
+    "Healthcare and Education",
+    "Commercial and Public Spaces",
+    "Residential and Care Settings",
+    "Industry, Energy, and Logistics",
+    "Wildland and Wildland--Urban Interface (WUI)",
+]
+FAMILY_RULES = [
+    (FAMILIES[6], ["wildland", "wildfire", "forest", "grassland", "wui", "wild_urban"]),
+    (FAMILIES[0], ["rail", "metro", "transit", "transport", "vehicle", "road", "bridge", "tunnel", "airport", "port", "bus_depot"]),
+    (FAMILIES[1], ["data_center", "datacenter", "server", "office", "digital", "telecom", "computer"]),
+    (FAMILIES[2], ["hospital", "health", "clinic", "school", "university", "college", "education", "laboratory", "laboratory_room"]),
+    (FAMILIES[3], ["mall", "market", "retail", "shop", "restaurant", "hotel", "stadium", "theater", "museum", "commercial", "public"]),
+    (FAMILIES[4], ["house", "home", "residential", "apartment", "dwelling", "nursing", "care", "dormitory"]),
+    (FAMILIES[5], ["industrial", "factory", "plant", "tank", "process", "pipe", "warehouse", "logistics", "loading", "energy", "battery", "charging", "refinery", "workshop"]),
+]
+EXPLICIT_FAMILY = {
+    "aircraft_hangar": FAMILIES[0],
+    "canadian_townhouse_row": FAMILIES[4],
+    "chemical_packaging_warehouse": FAMILIES[5],
+    "crosswind_canyon": FAMILIES[6],
+    "exhibition_hall_booths": FAMILIES[3],
+    "fireworks_mixing_workshop": FAMILIES[5],
+    "fireworks_storage_magazines": FAMILIES[5],
+    "high_bay_rack_warehouse": FAMILIES[5],
+    "industrial_service_tunnel": FAMILIES[5],
+    "mixed_conifer_valley": FAMILIES[6],
+    "school_vocational_workshop": FAMILIES[2],
+    "semiconductor_cleanroom": FAMILIES[1],
+    "stepped_pine_slope": FAMILIES[6],
+    "switchgear_transformer_room": FAMILIES[5],
+    "theatre_backstage": FAMILIES[3],
+    "timber_heritage_courtyard": FAMILIES[3],
+    "two_level_underground_garage": FAMILIES[0],
+    "waste_sorting_recycling_hall": FAMILIES[5],
+    "windward_ridge_crest": FAMILIES[6],
+    "wui_road_edge": FAMILIES[6],
+}
+
+
+def read_jsonl(path: Path):
+    with path.open(encoding="utf-8") as handle:
+        for number, line in enumerate(handle, 1):
+            if line.strip():
+                yield number, json.loads(line)
+
+
+def write_jsonl(path: Path, rows):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="\n") as handle:
+        for row in rows:
+            handle.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def norm(value):
+    return re.sub(r"[^a-z0-9]+", "_", str(value or "").lower()).strip("_")
+
+
+def classify_fire(row):
+    task = row.get("task")
+    label = TASK_FIRE.get(task)
+    text = " ".join(str(row.get(key, "")) for key in ("question", "task"))
+    boundary = bool(re.search(r"\b(future|forecast|predict|threshold|intervention|counterfactual)\b", text, re.I))
+    return label, {"rule": f"task:{task}", "boundary_review": boundary}
+
+
+def classify_family(archetype):
+    token = norm(archetype)
+    if token in EXPLICIT_FAMILY:
+        return EXPLICIT_FAMILY[token], [token], "matched"
+    hits = [(family, [word for word in words if re.search(rf"(?:^|_){re.escape(norm(word))}(?:_|$)", token)]) for family, words in FAMILY_RULES]
+    hits = [(family, words) for family, words in hits if words]
+    if not hits:
+        return None, [], "unmatched"
+    max_hits = max(len(words) for _, words in hits)
+    winners = [(family, words) for family, words in hits if len(words) == max_hits]
+    if len(winners) > 1:
+        return winners[0][0], [x[0] for x in winners], "ambiguous"
+    return winners[0][0], winners[0][1], "matched"
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--gold", nargs="+", type=Path, required=True)
+    ap.add_argument("--questions", nargs="+", type=Path, required=True)
+    ap.add_argument("--item-scores", nargs="*", type=Path, default=[])
+    ap.add_argument("--output", type=Path, required=True)
+    args = ap.parse_args()
+    args.output.mkdir(parents=True, exist_ok=True)
+
+    gold_by_qa = {}
+    event_rows = defaultdict(lambda: {"event_id": None, "archetypes": set(), "sources": set(), "qa_count": 0})
+    audit = []
+    for path in args.gold:
+        source = path.as_posix()
+        for line, row in read_jsonl(path):
+            qa_id = row.get("qa_id")
+            if not qa_id:
+                audit.append({"kind": "gold_missing_qa_id", "source": source, "line": line})
+                continue
+            fire, fire_meta = classify_fire(row)
+            provenance = row.get("provenance") or {}
+            event_id = provenance.get("event_id") or provenance.get("world_id")
+            archetype = provenance.get("archetype") or (provenance.get("metadata") or {}).get("archetype")
+            family, matched, family_status = classify_family(archetype)
+            if qa_id in gold_by_qa and gold_by_qa[qa_id]["event_id"] != event_id:
+                audit.append({"kind": "qa_id_conflict", "qa_id": qa_id, "source": source})
+            gold_by_qa[qa_id] = {"fire_axis": fire, "fire_meta": fire_meta, "event_id": event_id,
+                                 "family": family, "family_status": family_status, "archetype": archetype,
+                                 "physical_axis": row.get("physical_axis"), "task": row.get("task")}
+            if event_id:
+                item = event_rows[event_id]
+                item["event_id"] = event_id; item["qa_count"] += 1; item["sources"].add(source)
+                if archetype: item["archetypes"].add(archetype)
+            else:
+                audit.append({"kind": "missing_event_id", "qa_id": qa_id, "source": source})
+            if family_status != "matched":
+                audit.append({"kind": f"family_{family_status}", "qa_id": qa_id, "event_id": event_id,
+                              "archetype": archetype, "matched": matched})
+
+    # Enrich and rewrite question files while retaining every original field.
+    for path in args.questions:
+        out = args.output / "relabelled" / path.name
+        rows = []
+        for line, row in read_jsonl(path):
+            qa_id = row.get("qa_id")
+            info = gold_by_qa.get(qa_id)
+            if info is None:
+                audit.append({"kind": "question_unmatched_gold", "qa_id": qa_id, "source": path.as_posix(), "line": line,
+                              "excluded_from_formal_output": True})
+                continue
+            else:
+                row["fire_axis"] = info["fire_axis"]
+            rows.append(row)
+        write_jsonl(out, rows)
+
+    # Also provide relabelled gold files, useful for testResult consumers.
+    for path in args.gold:
+        out = args.output / "relabelled_gold" / path.name
+        rows = []
+        for _, row in read_jsonl(path):
+            info = gold_by_qa.get(row.get("qa_id"))
+            if info: row["fire_axis"] = info["fire_axis"]
+            rows.append(row)
+        write_jsonl(out, rows)
+
+    manifest = []
+    for event_id, item in sorted(event_rows.items()):
+        archetypes = sorted(item["archetypes"])
+        family_results = [classify_family(x) for x in archetypes]
+        families = sorted({x[0] for x in family_results if x[0]})
+        status = "matched" if len(families) == 1 and all(x[2] == "matched" for x in family_results) else ("ambiguous" if families else "unmatched")
+        manifest.append({"event_id": event_id, "family": families[0] if len(families) == 1 else None,
+                         "family_status": status, "archetypes": archetypes, "question_count": item["qa_count"],
+                         "source_files": sorted(item["sources"])})
+    (args.output / "event_family_manifest.json").write_text(json.dumps({"families": FAMILIES, "events": manifest}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    # Item scores are the official deterministic scorer's per-item values.
+    metric_rows = []
+    for path in args.item_scores:
+        model = path.stem.removesuffix(".six")
+        for _, score in read_jsonl(path):
+            info = gold_by_qa.get(score.get("qa_id"), {})
+            metric_rows.append({"model": model, "track": model.rsplit("_", 1)[-1], "interface": model.rsplit("_", 1)[-1],
+                                "split": path.parts[-3] if len(path.parts) >= 3 else "unknown",
+                                "event_id": info.get("event_id"), "event_family": next((m["family"] for m in manifest if m["event_id"] == info.get("event_id")), None),
+                                "fire_axis": info.get("fire_axis"), "physical_axis": info.get("physical_axis"),
+                                "question_type": score.get("question_type"), "task": score.get("task"),
+                                "qa_id": score.get("qa_id"), "ratio": score.get("ratio"), "item_f1": score.get("item_f1"),
+                                "evidence_f1": score.get("evidence_f1"), "mechanism_alignment": score.get("mechanism_alignment"),
+                                "gold_linked_support": score.get("gold_linked_support"), "confidence": score.get("confidence")})
+    if metric_rows:
+        grouped = defaultdict(list)
+        for row in metric_rows:
+            grouped[(row["model"], row["track"], row["interface"], row["split"], row["event_family"], row["question_type"])].append(row)
+        summaries = []
+        for key, rows in sorted(grouped.items(), key=lambda x: str(x[0])):
+            def avg(field):
+                vals = [r[field] for r in rows if isinstance(r.get(field), (int, float))]
+                return sum(vals) / len(vals) if vals else None
+            summaries.append(dict(zip(("model", "track", "interface", "split", "event_family", "question_type"), key),
+                                    n=len(rows), completion_accuracy=avg("ratio"), f1=avg("item_f1"), brier_score=avg("brier_component"),
+                                    evidence_f1=avg("evidence_f1"), mechanism_alignment=avg("mechanism_alignment"),
+                                    gold_linked_support=avg("gold_linked_support")))
+        # Brier is (confidence - completion ratio)^2 in the frozen scorer.
+        for row in metric_rows:
+            if isinstance(row.get("confidence"), (int, float)) and isinstance(row.get("ratio"), (int, float)):
+                row["brier_component"] = (row["confidence"] - row["ratio"]) ** 2
+        for summary in summaries:
+            rows = grouped[tuple(summary[k] for k in ("model", "track", "interface", "split", "event_family", "question_type"))]
+            vals = [r["brier_component"] for r in rows if "brier_component" in r]
+            summary["brier_score"] = sum(vals) / len(vals) if vals else None
+        with (args.output / "metrics_by_event_family.csv").open("w", encoding="utf-8", newline="") as handle:
+            fields = list(summaries[0]) if summaries else []
+            writer = csv.DictWriter(handle, fieldnames=fields); writer.writeheader(); writer.writerows(summaries)
+        write_jsonl(args.output / "metric_items.jsonl", metric_rows)
+    report = {"schema_version": "FWB-FG9-THREE-STAGE-EVENT-FAMILY-v1", "fire_axis": FIRE_AXIS,
+              "task_to_fire_axis": TASK_FIRE, "family_names": FAMILIES,
+              "counts": {"gold_rows": len(gold_by_qa), "events": len(manifest), "audit_rows": len(audit),
+                          "fire_axis": dict(Counter(x["fire_axis"] for x in gold_by_qa.values())),
+                          "physical_axis": dict(Counter(x.get("physical_axis") for x in gold_by_qa.values()))},
+              "audit": audit}
+    (args.output / "audit.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report["counts"], ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

evaluation/FireWorldBench-ICLR/scripts/run_api.py

@@ -0,0 +1,804 @@
+"""Resumable cross-provider runner for a frozen FG9 subset.
+
+The runner never reads gold. It records transport failures, schema fallbacks and
+format-only re-asks separately so that provider protocol failures cannot be
+mistaken for model capability failures.
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import hashlib
+import json
+import os
+import random
+import re
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import requests
+
+
+RUNNER_VERSION = "FWB-FG9-API-RUNNER-v10.1-openai-chat-wire-null-safe"
+PROMPT_VERSION = "FWB-v2-independent-context-numbered-images"
+SCHEMA_VERSION = "FWB-v2-single-hypothesis-or-exact-set"
+
+CANONICAL_MODEL_ALIASES = {
+    "claude-haiku-4-5": {"claude-haiku-4-5-20251001"},
+}
+
+
+def model_identity_matches(requested: str, reported: str | None) -> bool:
+    if reported is None:
+        return False
+    return reported == requested or reported in CANONICAL_MODEL_ALIASES.get(requested, set())
+
+
+def completed_qa_ids(rows: list[dict], provider: str, model: str) -> set[str]:
+    return {
+        row["qa_id"]
+        for row in rows
+        if row.get("status") in {"ok", "model_mismatch"}
+        and (provider != "openai"
+             or model_identity_matches(model, row.get("response_model")))
+    }
+
+
+TASK_FIELDS = {
+    "L1-1": {"event_class": ["fire", "no_fire", "ventilation_disturbance", "sensor_fault"],
+             "cause_region": [*[f"R{i}" for i in range(1, 9)], "global", "none"],
+             "dominant_signal": ["temperature", "soot", "visibility", "flow", "none"],
+             "secondary_signal": ["temperature", "soot", "visibility", "flow", "none"],
+             "affected_region_count": list(range(9))},
+    "L1-2": {"temperature_trend": ["up", "stable", "down"], "smoke_trend": ["up", "stable", "down"],
+             "visibility_trend": ["up", "stable", "down"]},
+    "L1-3": {"consistency": ["consistent", "inconsistent"],
+             "first_violation_bin": ["none", "early", "middle", "late"],
+             "violation_type": ["none", "reverse", "jump", "disappearance", "direction_flip", "sensor_conflict"]},
+    "L2-1": {"source_region": [f"R{i}" for i in range(1, 9)],
+             "stage": ["incipient", "growth", "developed", "decay"]},
+    "L2-2": {"risk_region": [f"R{i}" for i in range(1, 9)],
+             "risk_level": ["low", "moderate", "high", "critical"],
+             "risk_driver": ["temperature", "visibility", "soot"],
+             "runner_up_region": [f"R{i}" for i in range(1, 9)],
+             "stability_phase": ["early", "middle", "late", "unstable"],
+             "winner_switch_count_bin": ["zero", "one", "multiple"],
+             "winner_support_count": [f"v{i}" for i in range(16)],
+             "runner_up_support_count": [f"v{i}" for i in range(16)],
+             "winner_switch_count": [f"v{i}" for i in range(16)]},
+    "L2-3": {"mechanism": ["buoyant_plume", "ceiling_jet", "smoke_layer", "longitudinal_ventilation",
+                             "backlayering", "extraction_dominated"],
+             "flow_direction": ["vertical", "downstream", "upstream", "bidirectional", "mixed"],
+             "control_regime": ["buoyancy", "ventilation", "extraction", "mixed"]},
+    "L3-2": {"region": [*[f"R{i}" for i in range(1, 9)], "none"],
+             "time_bin": ["none", "0_10s", "10_30s", "30_60s", "after_60s"],
+             "trigger_variable": ["none", "temperature", "visibility", "soot"]},
+    "L3-3": {"direction": ["A", "B", "same"],
+             "magnitude_bin": ["negligible", "small", "medium", "large"],
+             "earliest_affected_target": ["none", "temperature", "smoke", "visibility", "risk_region"]},
+}
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def load_confidential_config(path: Path) -> dict[str, str]:
+    values = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        match = re.match(r"^([A-Z][A-Z0-9_]+)=(.+)$", line.strip())
+        if match:
+            values[match.group(1)] = match.group(2).strip()
+    return values
+
+
+def enum_value_schema(values: list[object]) -> dict:
+    if values and all(isinstance(value, str) for value in values):
+        value_type = "string"
+    elif values and all(isinstance(value, int) and not isinstance(value, bool) for value in values):
+        value_type = "integer"
+    else:
+        raise ValueError(f"enum values must have one supported scalar type: {values!r}")
+    return {"type": value_type, "enum": values}
+
+
+def enum_object(fields: dict[str, list[object]]) -> dict:
+    return {
+        "type": "object", "additionalProperties": False, "required": list(fields),
+        "properties": {key: enum_value_schema(values) for key, values in fields.items()},
+    }
+
+
+def full_prediction_schema(task: str) -> dict:
+    if task != "L3-1":
+        return enum_object(TASK_FIELDS[task])
+    trend = enum_object({"temperature_trend": ["up", "stable", "down"],
+                         "smoke_trend": ["up", "stable", "down"],
+                         "visibility_trend": ["up", "stable", "down"]})
+    return {
+        "type": "object", "additionalProperties": False, "required": ["horizons"],
+        "properties": {"horizons": {
+            "type": "object", "additionalProperties": False, "required": ["10s", "30s", "60s"],
+            "properties": {key: trend for key in ("10s", "30s", "60s")},
+        }},
+    }
+
+
+def schema_subset(schema: dict, fields: list[str]) -> dict:
+    selected: dict = {"type": "object", "additionalProperties": False, "required": [], "properties": {}}
+    for field in fields:
+        source = schema
+        target = selected
+        for part in field.split("."):
+            if source.get("type") != "object" or part not in source.get("properties", {}):
+                raise KeyError(f"unknown prediction field: {field}")
+            source = source["properties"][part]
+            if part not in target["properties"]:
+                target["required"].append(part)
+                target["properties"][part] = (
+                    {"type": "object", "additionalProperties": False,
+                     "required": [], "properties": {}}
+                    if source.get("type") == "object" else source
+                )
+            target = target["properties"][part]
+    return selected
+
+
+def prediction_schema(row: dict) -> dict:
+    schema = full_prediction_schema(row["task"])
+    fields = row.get("answer_fields")
+    return schema_subset(schema, fields) if fields else schema
+
+
+def response_schema(row: dict) -> dict:
+    if row["question_type"] == "choice":
+        labels = [option["label"] for option in row.get("options", [])]
+        if not labels or len(labels) != len(set(labels)):
+            raise ValueError(f"invalid choice labels for {row.get('qa_id', '<unknown>')}")
+        return {
+            "type": "object", "additionalProperties": False, "required": ["choices", "confidence"],
+            "properties": {"choices": {"type": "array", "items": {"type": "string", "enum": labels},
+                                        "minItems": 1 if all('hypothesis' in o for o in row['options']) else 0,
+                                        "maxItems": 1 if all('hypothesis' in o for o in row['options']) else len(labels), "uniqueItems": True},
+                           "confidence": {"type": "number", "minimum": 0, "maximum": 1}},
+        }
+    return {
+        "type": "object", "additionalProperties": False,
+        "required": ["conclusion", "prediction", "evidence", "mechanism", "confidence"],
+        "properties": {
+            "conclusion": {"type": "string"}, "prediction": prediction_schema(row),
+            "evidence": {"type": "array", "items": {"type": "string"}},
+            "mechanism": {"type": "string"},
+            "confidence": {"type": "number", "minimum": 0, "maximum": 1},
+        },
+    }
+
+
+def strip_paths(value: Any) -> Any:
+    if isinstance(value, list):
+        return [strip_paths(item) for item in value]
+    if isinstance(value, dict):
+        return {key: strip_paths(item) for key, item in value.items() if key not in {"path", "asset_path"}}
+    return value
+
+
+def asset_entries(value: Any) -> list[dict]:
+    output = []
+    if isinstance(value, list):
+        for item in value:
+            output.extend(asset_entries(item))
+    elif isinstance(value, dict):
+        if "path" in value or "asset_path" in value:
+            output.append(value)
+        for key, item in value.items():
+            if key not in {"path", "asset_path"}:
+                output.extend(asset_entries(item))
+    return output
+
+
+def resolve_asset(entry: dict, source_root: Path) -> Path:
+    relative = entry.get("path", entry.get("asset_path"))
+    path = source_root / str(relative)
+    if not path.is_file():
+        raise FileNotFoundError(path)
+    return path
+
+
+def prompt_text(row: dict, task_contract: str | None = None) -> str:
+    material = strip_paths(row["material"])
+    parts = []
+    if task_contract:
+        parts.extend(["Frozen task contract (shared across all items):", task_contract])
+    parts.extend([f"Task: {row['task']}", row["question"],
+                  "Query context:", json.dumps(row.get("query_context", {}), ensure_ascii=False),
+                  "Observation metadata/data:",
+                  json.dumps(material, ensure_ascii=False, separators=(",", ":"))])
+    entries = asset_entries(row['material'])
+    if entries:
+        parts.append('Image attachment order (Image N matches image_index N):')
+        for index, entry in enumerate(entries, 1):
+            if entry.get('image_index', index) != index:
+                raise ValueError('Image metadata order differs from attachment order')
+            parts.append(f"Image {index}: " + json.dumps(strip_paths(entry), ensure_ascii=False))
+    if row["question_type"] == "choice":
+        parts.extend(["Candidate hypotheses:", json.dumps(row["options"], ensure_ascii=False, separators=(",", ":")),
+                      ('Select exactly one complete hypothesis.' if all('hypothesis' in o for o in row['options'])
+                       else 'Select every and only true claim.') + ' Return only JSON with choices (label array) and confidence (0..1).'])
+    else:
+        parts.append("Return only the required JSON report. Evidence must contain 1-3 concise observed facts; mechanism must explain the physical link.")
+    return "\n".join(parts)
+
+
+def encode_images(row: dict, source_root: Path) -> list[tuple[str, str]]:
+    images = []
+    for entry in asset_entries(row["material"]):
+        path = resolve_asset(entry, source_root)
+        mime = "image/png" if path.suffix.lower() == ".png" else "image/jpeg"
+        images.append((mime, base64.b64encode(path.read_bytes()).decode("ascii")))
+    return images
+
+
+def extract_text(provider: str, response: dict) -> str:
+    if provider in {"openai", "grok"}:
+        if isinstance(response.get("output_text"), str):
+            return response["output_text"]
+        chunks = []
+        for item in response.get("output", []):
+            for content in item.get("content", []):
+                if isinstance(content.get("text"), str):
+                    chunks.append(content["text"])
+        if chunks:
+            return "\n".join(chunks)
+        choices = response.get("choices", [])
+        return (choices[0].get("message", {}).get("content") or "") if choices else ""
+    if provider == "anthropic":
+        return "\n".join(item.get("text", "") for item in response.get("content", []) if item.get("type") == "text")
+    if provider == "gemini":
+        candidates = response.get("candidates", [])
+        if not candidates:
+            return ""
+        return "\n".join(part.get("text", "") for part in candidates[0].get("content", {}).get("parts", []))
+    choices = response.get("choices", [])
+    return (choices[0].get("message", {}).get("content") or "") if choices else ""
+
+
+def usage_record(provider: str, response: dict) -> dict:
+    if provider == "gemini":
+        return response.get("usageMetadata", {})
+    return response.get("usage", {})
+
+
+def normalized_usage(provider: str, response: dict) -> dict:
+    usage = usage_record(provider, response)
+    if provider == "gemini":
+        return {
+            "input_tokens": usage.get("promptTokenCount"),
+            "output_tokens": usage.get("candidatesTokenCount"),
+            "cached_tokens": usage.get("cachedContentTokenCount"),
+            "reasoning_tokens": usage.get("thoughtsTokenCount"),
+            "total_tokens": usage.get("totalTokenCount"),
+        }
+    input_details = usage.get("input_tokens_details") or usage.get("prompt_tokens_details") or {}
+    output_details = usage.get("output_tokens_details") or usage.get("completion_tokens_details") or {}
+    return {
+        "input_tokens": usage.get("input_tokens", usage.get("prompt_tokens")),
+        "output_tokens": usage.get("output_tokens", usage.get("completion_tokens")),
+        "cached_tokens": usage.get("cache_read_input_tokens", input_details.get("cached_tokens")),
+        "reasoning_tokens": output_details.get("reasoning_tokens"),
+        "total_tokens": usage.get("total_tokens"),
+    }
+
+
+def provider_cost(response: dict) -> dict:
+    usage = response.get("usage") if isinstance(response.get("usage"), dict) else {}
+    candidates = (
+        (response.get("cost"), "response.cost"),
+        (response.get("total_cost"), "response.total_cost"),
+        (usage.get("cost"), "response.usage.cost"),
+        (usage.get("total_cost"), "response.usage.total_cost"),
+    )
+    for value, source in candidates:
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            currency = response.get("currency") or usage.get("currency")
+            return {"amount": value, "currency": currency, "source": source}
+    return {"amount": None, "currency": None, "source": "not_returned_by_provider"}
+
+
+def response_model(provider: str, response: dict) -> str | None:
+    if provider == "gemini":
+        return response.get("modelVersion")
+    return response.get("model")
+
+
+def file_digest(path: Path) -> str:
+    value = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1 << 20), b""):
+            value.update(block)
+    return value.hexdigest()
+
+
+def classify_exception(exc: Exception) -> str:
+    text = str(exc).lower()
+    if isinstance(exc, KeyError):
+        return "tooling"
+    if isinstance(exc, FileNotFoundError):
+        return "capability"
+    if any(term in text for term in (
+        "datainspectionfailed", "data_inspection_failed", "inappropriate content",
+        "content safety", "content policy", "safety filter",
+    )):
+        return "content_safety"
+    if any(term in text for term in ("billing", "insufficient credit", "insufficient balance", "http 402")):
+        return "billing"
+    if "timeout" in text or isinstance(exc, requests.Timeout):
+        return "timeout"
+    if "proxy" in text:
+        return "proxy"
+    if "http 429" in text or "rate limit" in text:
+        return "rate_limit"
+    if re.search(r"http (?:4|5)\d\d", text):
+        return "http"
+    if any(term in text for term in ("connection", "transport")):
+        return "transport"
+    return "capability"
+
+
+def write_run_manifest(path: Path, metadata: dict, records: list[dict]) -> None:
+    status_counts: dict[str, int] = {}
+    error_counts: dict[str, int] = {}
+    usage_totals = {key: 0 for key in ("input_tokens", "output_tokens", "cached_tokens", "reasoning_tokens", "total_tokens")}
+    unknown_usage = {key: 0 for key in usage_totals}
+    costs = []
+    for record in records:
+        status = str(record.get("status", "unknown"))
+        status_counts[status] = status_counts.get(status, 0) + 1
+        classification = record.get("error_classification")
+        if classification:
+            error_counts[classification] = error_counts.get(classification, 0) + 1
+        for key in usage_totals:
+            value = record.get("usage_normalized", {}).get(key)
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                usage_totals[key] += value
+            else:
+                unknown_usage[key] += 1
+        cost = record.get("provider_cost", {})
+        if cost.get("amount") is not None:
+            costs.append(cost)
+    manifest = {
+        **metadata,
+        "updated_at_utc": datetime.now(timezone.utc).isoformat(),
+        "record_count": len(records),
+        "status_counts": status_counts,
+        "error_classification_counts": error_counts,
+        "usage_totals": usage_totals,
+        "usage_missing_record_counts": unknown_usage,
+        "provider_cost_records": costs,
+        "provider_cost_note": "No monetary amount is inferred when the provider response omits billing data.",
+    }
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def numbered_image_parts(images, wire):
+    parts = []
+    for index, (mime, data) in enumerate(images, 1):
+        label = f"Image {index} (see corresponding observation metadata):"
+        if wire == "gemini":
+            parts.extend([{"text": label}, {"inlineData": {"mimeType": mime, "data": data}}])
+        elif wire == "responses":
+            parts.extend([{"type": "input_text", "text": label}, {"type": "input_image", "image_url": f"data:{mime};base64,{data}"}])
+        elif wire == "anthropic":
+            parts.extend([{"type": "text", "text": label}, {"type": "image", "source": {"type": "base64", "media_type": mime, "data": data}}])
+        else:
+            parts.extend([{"type": "text", "text": label}, {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{data}"}}])
+    return parts
+
+
+def build_request(provider: str, model: str, system: str, prompt: str, images: list[tuple[str, str]],
+                  schema: dict, mode: str, max_tokens: int, reasoning_effort: str,
+                  wire_api: str = "responses") -> tuple[str, dict, dict]:
+    if provider in {"openai", "grok"}:
+        if provider == "openai" and wire_api == "chat_completions":
+            content = [{"type": "text", "text": prompt}]
+            content.extend(numbered_image_parts(images, "chat"))
+            payload = {
+                "model": model,
+                "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
+                "max_tokens": max_tokens,
+                "reasoning_effort": reasoning_effort,
+            }
+            if mode == "json_schema":
+                payload["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema},
+                }
+            elif mode == "json_object":
+                payload["response_format"] = {"type": "json_object"}
+            return "/chat/completions", {
+                "Authorization": "Bearer {key}", "Content-Type": "application/json",
+            }, payload
+        content = [{"type": "input_text", "text": prompt}]
+        content.extend(numbered_image_parts(images, "responses"))
+        payload = {"model": model, "input": [{"role": "system", "content": [{"type": "input_text", "text": system}]},
+                                               {"role": "user", "content": content}],
+                   "max_output_tokens": max_tokens, "store": False, "reasoning": {"effort": reasoning_effort}}
+        if mode == "json_schema":
+            payload["text"] = {"format": {"type": "json_schema", "name": "fwb_fg9_report", "schema": schema, "strict": True}}
+        elif mode == "json_object":
+            payload["text"] = {"format": {"type": "json_object"}}
+        path = "/responses" if provider == "grok" else "/responses"
+        return path, {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload
+    if provider == "anthropic":
+        content = [{"type": "text", "text": prompt}]
+        content.extend(numbered_image_parts(images, "anthropic"))
+        payload = {"model": model, "system": system, "messages": [{"role": "user", "content": content}],
+                   "max_tokens": max_tokens, "temperature": 0}
+        if mode == "json_schema":
+            payload["output_config"] = {"format": {"type": "json_schema", "schema": schema}}
+        return "/v1/messages", {"x-api-key": "{key}", "anthropic-version": "2023-06-01", "Content-Type": "application/json"}, payload
+    if provider == "gemini":
+        parts = [{"text": system + "\n\n" + prompt}]
+        parts.extend(numbered_image_parts(images, "gemini"))
+        generation = {"temperature": 0, "maxOutputTokens": max_tokens, "responseMimeType": "application/json"}
+        if mode == "json_schema":
+            generation["responseJsonSchema"] = schema
+        payload = {"contents": [{"role": "user", "parts": parts}], "generationConfig": generation}
+        return f"/v1beta/models/{model}:generateContent", {"x-goog-api-key": "{key}",
+                                                              "Content-Type": "application/json"}, payload
+    if provider == "gemini_openai_compat":
+        content = [{"type": "text", "text": prompt}]
+        content.extend(numbered_image_parts(images, "chat"))
+        payload = {
+            "model": model,
+            "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
+            "temperature": 0,
+            "max_tokens": max_tokens,
+        }
+        if mode == "json_schema":
+            payload["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema},
+            }
+        elif mode == "json_object":
+            payload["response_format"] = {"type": "json_object"}
+        return "/chat/completions", {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload
+    content = [{"type": "text", "text": prompt}]
+    content.extend(numbered_image_parts(images, "chat"))
+    payload = {"model": model, "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
+               "temperature": 0, "max_tokens": max_tokens, "enable_thinking": False}
+    if mode == "json_schema":
+        payload["response_format"] = {"type": "json_schema", "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema}}
+    elif mode == "json_object":
+        payload["response_format"] = {"type": "json_object"}
+    return "/chat/completions", {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload
+
+
+def parse_json(text: str) -> dict | None:
+    cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", text.strip(), flags=re.IGNORECASE)
+    try:
+        value = json.loads(cleaned)
+        return value if isinstance(value, dict) else None
+    except json.JSONDecodeError:
+        start, end = text.find("{"), text.rfind("}")
+        if start >= 0 and end > start:
+            try:
+                value = json.loads(text[start:end + 1])
+                return value if isinstance(value, dict) else None
+            except json.JSONDecodeError:
+                pass
+    return None
+
+
+def validation_errors(value: Any, schema: dict, path: str = "<root>") -> list[str]:
+    errors: list[str] = []
+    expected_type = schema.get("type")
+    type_ok = {
+        "object": isinstance(value, dict),
+        "array": isinstance(value, list),
+        "string": isinstance(value, str),
+        "integer": isinstance(value, int) and not isinstance(value, bool),
+        "number": isinstance(value, (int, float)) and not isinstance(value, bool),
+    }.get(expected_type, True)
+    if not type_ok:
+        return [f"{path}: expected {expected_type}, got {type(value).__name__}"]
+    if "enum" in schema and value not in schema["enum"]:
+        errors.append(f"{path}: value {value!r} not in enum")
+    if expected_type == "number":
+        if "minimum" in schema and value < schema["minimum"]:
+            errors.append(f"{path}: value below minimum")
+        if "maximum" in schema and value > schema["maximum"]:
+            errors.append(f"{path}: value above maximum")
+    elif expected_type == "object":
+        required = set(schema.get("required", []))
+        missing = sorted(required - set(value))
+        if missing:
+            errors.append(f"{path}: missing required keys {missing}")
+        properties = schema.get("properties", {})
+        if schema.get("additionalProperties") is False:
+            extra = sorted(set(value) - set(properties))
+            if extra:
+                errors.append(f"{path}: additional keys {extra}")
+        for key, child_schema in properties.items():
+            if key in value:
+                errors.extend(validation_errors(value[key], child_schema, f"{path}.{key}"))
+    elif expected_type == "array":
+        if "minItems" in schema and len(value) < schema["minItems"]:
+            errors.append(f"{path}: fewer than minItems")
+        if "maxItems" in schema and len(value) > schema["maxItems"]:
+            errors.append(f"{path}: more than maxItems")
+        if schema.get("uniqueItems") and len({json.dumps(item, sort_keys=True) for item in value}) != len(value):
+            errors.append(f"{path}: duplicate items")
+        item_schema = schema.get("items", {})
+        for index, item in enumerate(value):
+            errors.extend(validation_errors(item, item_schema, f"{path}[{index}]"))
+    return errors
+
+
+def post_with_retry(session: requests.Session, url: str, headers: dict, payload: dict,
+                    timeout: float, retries: int) -> tuple[dict, int, float]:
+    started = time.perf_counter()
+    last_error = None
+    for attempt in range(retries + 1):
+        try:
+            response = session.post(url, headers=headers, json=payload, timeout=timeout)
+            if response.status_code < 400:
+                return response.json(), attempt, time.perf_counter() - started
+            error = RuntimeError(f"HTTP {response.status_code}: {response.text[:800]}")
+            if response.status_code not in {408, 409, 429, 500, 502, 503, 504}:
+                raise error
+            last_error = error
+        except (requests.Timeout, requests.ConnectionError, ValueError) as exc:
+            last_error = exc
+        if attempt < retries:
+            time.sleep(min(12.0, 1.5 * 2 ** attempt) + random.random() * 0.5)
+    raise RuntimeError(f"transport exhausted after {retries + 1} attempts: {last_error}")
+
+
+def provider_config(provider: str, values: dict[str, str]) -> tuple[str, str, str]:
+    if provider == "openai":
+        return values["OPENAI_BASE_URL"], values["OPENAI_API_KEY"], values["OPENAI_MODEL"]
+    if provider == "grok":
+        return values["GROK_BASE_URL"], values["GROK_API_KEY"], values["GROK_MODEL"]
+    if provider == "anthropic":
+        return values["ANTHROPIC_BASE_URL"], values["ANTHROPIC_AUTH_TOKEN"], values["ANTHROPIC_MODEL"]
+    if provider == "gemini":
+        return values["GOOGLE_GEMINI_BASE_URL"], values["GEMINI_API_KEY"], values["GEMINI_MODEL"]
+    if provider == "gemini_openai_compat":
+        return values["GEMINI_OPENAI_BASE_URL"], values["GEMINI_API_KEY"], values["GEMINI_MODEL"]
+    return values["BAILIAN_BASE_URL"], values["DASHSCOPE_API_KEY"], "qwen3.5-plus-2026-02-15"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--provider",
+        choices=("openai", "grok", "anthropic", "gemini", "gemini_openai_compat", "bailian"),
+        required=True,
+    )
+    parser.add_argument("--questions", type=Path, required=True)
+    parser.add_argument("--source-root", type=Path, required=True)
+    parser.add_argument(
+        "--task-contract", type=Path,
+        help="Optional frozen task contract prepended identically to every selected item.",
+    )
+    parser.add_argument(
+        "--confidential-config", type=Path,
+        help="Optional KEY=VALUE file. Process environment variables take precedence.",
+    )
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--model")
+    parser.add_argument("--max-requests", type=int)
+    parser.add_argument("--track", choices=("S", "I"))
+    parser.add_argument("--question-type", choices=("choice", "open"))
+    parser.add_argument("--task")
+    parser.add_argument("--subtrack")
+    parser.add_argument("--timeout", type=float, default=120.0)
+    parser.add_argument("--retries", type=int, default=4)
+    parser.add_argument("--max-tokens", type=int, default=900)
+    parser.add_argument("--reasoning-effort", default="high")
+    parser.add_argument(
+        "--wire-api", choices=("responses", "chat_completions"), default="responses",
+        help="OpenAI-compatible transport. chat_completions is recorded and only valid for --provider openai.",
+    )
+    parser.add_argument("--format-reasks", type=int, default=1)
+    parser.add_argument(
+        "--format-mode", choices=("auto", "json_schema", "json_object", "prompt_only"),
+        default="auto", help="Use auto fallback or a recorded single response-format mode.",
+    )
+    args = parser.parse_args()
+    if args.provider != "openai" and args.wire_api != "responses":
+        parser.error("--wire-api chat_completions is only valid with --provider openai")
+
+    values = load_confidential_config(args.confidential_config) if args.confidential_config else {}
+    values.update(os.environ)
+    base_url, key, default_model = provider_config(args.provider, values)
+    model = args.model or default_model
+    rows = load_jsonl(args.questions)
+    if args.track:
+        rows = [row for row in rows if row["track"] == args.track]
+    if args.question_type:
+        rows = [row for row in rows if row["question_type"] == args.question_type]
+    if args.task:
+        rows = [row for row in rows if row["task"] == args.task]
+    if args.subtrack:
+        rows = [row for row in rows if row["subtrack"] == args.subtrack]
+    existing = load_jsonl(args.output) if args.output.exists() else []
+    completed = completed_qa_ids(existing, args.provider, model)
+    pending = [row for row in rows if row["qa_id"] not in completed]
+    if args.max_requests is not None:
+        pending = pending[:args.max_requests]
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path = args.output.with_suffix(args.output.suffix + ".manifest.json")
+    task_contract = args.task_contract.read_text(encoding="utf-8").strip() if args.task_contract else None
+    manifest_metadata = {
+        "schema_version": "FWB-FG9-API-RUN-MANIFEST-v1",
+        "runner_version": RUNNER_VERSION,
+        "prompt_version": PROMPT_VERSION,
+        "response_schema_version": SCHEMA_VERSION,
+        "provider": args.provider,
+        "requested_model": model,
+        "questions": str(args.questions.resolve()),
+        "questions_sha256": file_digest(args.questions),
+        "source_root": str(args.source_root.resolve()),
+        "task_contract": str(args.task_contract.resolve()) if args.task_contract else None,
+        "task_contract_sha256": file_digest(args.task_contract) if args.task_contract else None,
+        "filters": {key: value for key, value in {
+            "track": args.track, "question_type": args.question_type,
+            "task": args.task, "subtrack": args.subtrack,
+        }.items() if value is not None},
+        "selected_question_count": len(rows),
+        "pending_question_count_at_start": len(pending),
+        "selected_qa_ids_sha256": hashlib.sha256(
+            "\n".join(row["qa_id"] for row in rows).encode()
+        ).hexdigest(),
+        "reasoning_effort": args.reasoning_effort,
+        "max_output_tokens": args.max_tokens,
+        "transport_retry_limit": args.retries,
+        "format_reask_limit": args.format_reasks,
+        "requested_format_mode": args.format_mode,
+        "wire_api": args.wire_api,
+    }
+    all_records = list(existing)
+    write_run_manifest(manifest_path, manifest_metadata, all_records)
+    system = ("You are evaluating a fire-physics benchmark. Use only the supplied observation. "
+              "Return one JSON object matching the requested schema, without markdown or commentary.")
+    session = requests.Session()
+    with args.output.open("a", encoding="utf-8") as stream:
+        for position, row in enumerate(pending, 1):
+            record = {"qa_id": row["qa_id"], "provider": args.provider,
+                      "requested_model": model, "model": model,
+                      "runner_version": RUNNER_VERSION, "prompt_version": PROMPT_VERSION,
+                      "response_schema_version": SCHEMA_VERSION,
+                      "question_type": row["question_type"], "task": row["task"], "status": "error",
+                      "started_at_utc": datetime.now(timezone.utc).isoformat(),
+                      "attempts": [], "format_reasks": 0}
+            final_raw_response = None
+            try:
+                images = encode_images(row, args.source_root)
+                prompt = prompt_text(row, task_contract)
+                schema = response_schema(row)
+                prompt += "\nRequired JSON Schema:\n" + json.dumps(schema, separators=(",", ":"))
+                record["request_fingerprint"] = {
+                    "prompt_sha256": hashlib.sha256(prompt.encode()).hexdigest(),
+                    "schema_sha256": hashlib.sha256(json.dumps(schema, sort_keys=True).encode()).hexdigest(),
+                    "image_count": len(images),
+                }
+                parsed = None
+                schema_valid = False
+                raw_text = ""
+                received_response = False
+                modes = (("json_schema", "json_object", "prompt_only")
+                         if args.format_mode == "auto" else (args.format_mode,))
+                for mode in modes:
+                    path, headers, payload = build_request(args.provider, model, system, prompt, images, schema, mode,
+                                                           args.max_tokens, args.reasoning_effort, args.wire_api)
+                    url = base_url.rstrip("/") + path
+                    headers = {name: value.replace("{key}", key) for name, value in headers.items()}
+                    try:
+                        response, transport_retries, latency = post_with_retry(
+                            session, url, headers, payload, args.timeout, args.retries)
+                    except RuntimeError as exc:
+                        record["attempts"].append({
+                            "mode": mode, "status": "request_error",
+                            "error": str(exc)[:1000],
+                            "error_classification": classify_exception(exc),
+                        })
+                        if "HTTP 400" in str(exc) or "HTTP 404" in str(exc) or "HTTP 422" in str(exc):
+                            continue
+                        raise
+                    raw_text = extract_text(args.provider, response)
+                    final_raw_response = response
+                    received_response = True
+                    parsed = parse_json(raw_text)
+                    schema_issues = validation_errors(parsed, schema)
+                    schema_valid = not schema_issues
+                    record["attempts"].append({"mode": mode, "status": "response", "latency_s": latency,
+                                               "transport_retries": transport_retries,
+                                               "usage": usage_record(args.provider, response),
+                                               "usage_normalized": normalized_usage(args.provider, response),
+                                               "provider_cost": provider_cost(response),
+                                               "response_model": response_model(args.provider, response),
+                                               "raw_response": response,
+                                               "parsed_json": parsed is not None, "schema_valid": schema_valid,
+                                               "schema_errors": schema_issues[:12]})
+                    record["format_mode"] = mode
+                    record["usage"] = usage_record(args.provider, response)
+                    record["usage_normalized"] = normalized_usage(args.provider, response)
+                    record["provider_cost"] = provider_cost(response)
+                    record["response_model"] = response_model(args.provider, response)
+                    if schema_valid:
+                        break
+                if not received_response:
+                    raise RuntimeError("all response-format modes were rejected before model inference")
+                for _ in range(args.format_reasks):
+                    if schema_valid:
+                        break
+                    record["format_reasks"] += 1
+                    reask = prompt + "\nYour previous output was not valid JSON. Return only one valid JSON object now."
+                    path, headers, payload = build_request(args.provider, model, system, reask, images, schema,
+                                                           "json_object", args.max_tokens, args.reasoning_effort,
+                                                           args.wire_api)
+                    headers = {name: value.replace("{key}", key) for name, value in headers.items()}
+                    response, transport_retries, latency = post_with_retry(
+                        session, base_url.rstrip("/") + path, headers, payload, args.timeout, args.retries)
+                    final_raw_response = response
+                    raw_text = extract_text(args.provider, response)
+                    parsed = parse_json(raw_text)
+                    schema_issues = validation_errors(parsed, schema)
+                    schema_valid = not schema_issues
+                    record["attempts"].append({"mode": "format_reask", "status": "response", "latency_s": latency,
+                                               "transport_retries": transport_retries,
+                                               "usage": usage_record(args.provider, response),
+                                               "usage_normalized": normalized_usage(args.provider, response),
+                                               "provider_cost": provider_cost(response),
+                                               "response_model": response_model(args.provider, response),
+                                               "raw_response": response,
+                                               "parsed_json": parsed is not None, "schema_valid": schema_valid,
+                                               "schema_errors": schema_issues[:12]})
+                    record["format_mode"] = "format_reask"
+                    record["usage"] = usage_record(args.provider, response)
+                    record["usage_normalized"] = normalized_usage(args.provider, response)
+                    record["provider_cost"] = provider_cost(response)
+                    record["response_model"] = response_model(args.provider, response)
+                record["response"] = parsed if parsed is not None else raw_text
+                record["raw_text"] = raw_text
+                record["raw_response"] = final_raw_response
+                record["status"] = "ok" if schema_valid else ("schema_error" if parsed is not None else "format_error")
+                if not schema_valid:
+                    record["error_classification"] = "format" if parsed is not None else "parse"
+                reported_model = record.get("response_model")
+                if (args.provider == "openai" and reported_model is not None
+                        and not model_identity_matches(model, reported_model)):
+                    record["status"] = "model_mismatch"
+                    record["error_classification"] = "model_identity"
+            except Exception as exc:  # Each item is checkpointed; one provider failure does not discard the gate.
+                record["error_type"] = type(exc).__name__
+                record["error"] = str(exc)[:1200]
+                attempt_classes = {
+                    attempt["error_classification"]
+                    for attempt in record["attempts"]
+                    if attempt.get("error_classification")
+                }
+                record["error_classification"] = (
+                    next(iter(attempt_classes)) if len(attempt_classes) == 1
+                    else classify_exception(exc)
+                )
+            record["attempt_count"] = len(record["attempts"])
+            record["transport_retries"] = sum(
+                attempt.get("transport_retries", 0) for attempt in record["attempts"]
+            )
+            record["finished_at_utc"] = datetime.now(timezone.utc).isoformat()
+            stream.write(json.dumps(record, separators=(",", ":")) + "\n")
+            stream.flush()
+            all_records.append(record)
+            write_run_manifest(manifest_path, manifest_metadata, all_records)
+            print(json.dumps({"finished": position, "selected": len(pending), "qa_id": row["qa_id"],
+                              "status": record["status"], "provider": args.provider, "model": model}))
+
+
+if __name__ == "__main__":
+    main()

evaluation/FireWorldBench-ICLR/scripts/run_eval.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Run a model on a FireWorldBench split and compute the six metrics.
+
+Usage (from the repo root):
+    python scripts/run_eval.py --split main_synthetic
+    python scripts/run_eval.py --split mmodalfire_c06 --group-by physical
+
+Requires the OpenAI-compatible endpoint env vars:
+    OPENAI_BASE_URL, OPENAI_API_KEY, OPENAI_MODEL
+"""
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+SPLITS = {
+    "main_synthetic": ("main_synthetic/full_test_A", "main_synthetic"),
+    "mmodalfire_c06": ("mmodalfire_c06/full_test_A", "mmodalfire_c06"),
+}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--split", choices=tuple(SPLITS), required=True)
+    parser.add_argument("--group-by", choices=("task", "physical", "fire"), default="physical",
+                        help="report cells by physical axis P1-P5 (default), fire axis T1-T3, "
+                             "or fine-grained task (36)")
+    parser.add_argument("--provider", default="openai")
+    parser.add_argument("--model", default=None, help="default: $OPENAI_MODEL")
+    parser.add_argument("--max-requests", type=int, default=None,
+                        help="run only the first N questions (for a quick test)")
+    parser.add_argument("--track", choices=("S", "I"), default=None,
+                        help="run only text track S or vision track I. Text-only models MUST use --track S "
+                             "(I-track items carry images and will fail on a text model); vision models may use --track I.")
+    parser.add_argument("--data-dir", default=None, help="default: ./data")
+    parser.add_argument("--out-dir", default="results")
+    args = parser.parse_args()
+
+    root = Path(__file__).resolve().parent.parent
+    data_dir = Path(args.data_dir) if args.data_dir else root / "data"
+    split, source = SPLITS[args.split]
+    questions = data_dir / split / "questions.jsonl"
+    gold = data_dir / split / "gold.jsonl"
+    if not questions.exists():
+        sys.exit(f"Data not found at {questions}\nRun: cd scripts && bash download.sh")
+    if not gold.exists():
+        sys.exit(f"Gold not found at {gold}")
+
+    model = args.model or os.environ.get("OPENAI_MODEL")
+    if not model:
+        sys.exit("Missing model. Set OPENAI_MODEL or pass --model.")
+
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    preds = out_dir / f"{args.split}.jsonl"
+    result = out_dir / f"{args.split}-{args.group_by}.json"
+
+    # Step 1: run inference (resumable; never reads Gold)
+    cmd = [sys.executable, str(root / "scripts" / "run_api.py"),
+           "--provider", args.provider,
+           "--questions", str(questions),
+           "--source-root", str(data_dir / source),
+           "--output", str(preds),
+           "--model", model]
+    if args.max_requests:
+        cmd += ["--max-requests", str(args.max_requests)]
+    if args.track:
+        cmd += ["--track", args.track]
+    if args.track == "I":
+        print("[track I] vision track: ensure your model endpoint supports images.", flush=True)
+    elif args.track == "S":
+        print("[track S] text track: running text-only items.", flush=True)
+    else:
+        print("[track all] running S+I together. Text-only model? pass --track S (I items carry images).", flush=True)
+    print(">", " ".join(cmd), flush=True)
+    subprocess.run(cmd, check=True)
+
+    # Step 2: compute the six metrics
+    cmd = [sys.executable, str(root / "scripts" / "score_six_metrics.py"),
+           "--gold", str(gold), "--predictions", str(preds),
+           "--output", str(result), "--group-by", args.group_by]
+    print(">", " ".join(cmd), flush=True)
+    subprocess.run(cmd, check=True)
+
+    print(f"\nDone. Six metrics written to {result}")
+    print(json.dumps(json.load(open(result))["overall"], ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

evaluation/FireWorldBench-ICLR/scripts/score_fg9_deep_metrics_by_cell.py

@@ -0,0 +1,51 @@
+import json, re
+from pathlib import Path
+from collections import defaultdict
+
+ROOT=Path('/root/autodl-tmp/FireWorldBench/2/5.项目实现/v1')
+BASE=ROOT/'artifacts/validation/fg9_dual_model_n40_final_20260812'
+RUNS={
+ 'main_grok':('模拟数据主集',['main_gate_C/gold.jsonl','main_gate_B/gold.jsonl']),
+ 'main_claude':('模拟数据主集',['main_gate_C/gold.jsonl','main_gate_B/gold.jsonl']),
+ 'c06_grok':('真实事件模拟',['c06_candidate/build_A/gold.jsonl','c06_gate_A/gold.jsonl','c06_pool80/build_A/gold.jsonl','c06_pool80/build_B/gold.jsonl']),
+ 'c06_claude':('真实事件模拟',['c06_candidate/build_A/gold.jsonl','c06_gate_A/gold.jsonl','c06_pool80/build_A/gold.jsonl','c06_pool80/build_B/gold.jsonl'])}
+VARS={'temperature','visibility','soot','flow','velocity','risk','fire','smoke','sensor','ventilation'}
+def text(v):
+ if isinstance(v,str):return v.lower()
+ if isinstance(v,list):return ' '.join(text(x) for x in v)
+ if isinstance(v,dict):return ' '.join(text(x) for x in v.values())
+ return str(v).lower()
+def toks(s):return set(re.findall(r'[a-z][a-z0-9_]+',s.lower()))
+def ece(rows,bins=10):
+ if not rows:return None
+ z=0
+ for i in range(bins):
+  b=[r for r in rows if i/bins<=r[0]<(i+1)/bins or (i==bins-1 and r[0]==1)]
+  if b:z+=len(b)/len(rows)*abs(sum(x[0] for x in b)/len(b)-sum(x[1] for x in b)/len(b))
+ return z
+def main():
+ out=[]
+ for run,(dataset,grels) in RUNS.items():
+  gold={}
+  for grel in grels:
+   for x in map(json.loads,(BASE/grel).open(encoding='utf-8')):
+    if x.get('question_type')=='open':gold[x['qa_id']]=x
+  cells=defaultdict(list)
+  for x in map(json.loads,(BASE/'runs'/run/'merged_responses.jsonl').open(encoding='utf-8')):
+   if x.get('question_type')!='open' or x.get('qa_id') not in gold:continue
+   g=gold[x['qa_id']]; raw=x.get('response'); r=raw if isinstance(raw,dict) else {}; pred=r.get('prediction') or {}; free=text([r.get('conclusion',''),r.get('evidence',[]),r.get('mechanism','')]); ft=toks(free)
+   anchors=[]
+   for c in g.get('evidence_claims') or []:
+    obs=(c.get('observation') or '').lower(); var=next((v for v in VARS if v in obs),None); anchors.append((str(c.get('region','')).lower(),var))
+   rec=sum(((reg in free)+(var in free if var else 0))/(2 if var else 1) for reg,var in anchors)/max(1,len(anchors))
+   claims=set(z.lower() for z in re.findall(r'\bR\d+\b',free,re.I))|(ft&VARS); supported={z for a in anchors for z in a if z}; prec=len(claims&supported)/len(claims) if claims else 0
+   gt=toks(' '.join(c.get('statement','') for c in g.get('mechanism_claims') or []))-{'the','and','with','that','this','from','into','first'}; mech=toks(text(r.get('mechanism',''))); align=len(gt&mech)/len(gt) if gt else 0
+   cons=sum(str(v).lower() in free for v in pred.values())/max(1,len(pred)); conf=r.get('confidence'); conf=float(conf) if isinstance(conf,(int,float)) else 0; correct=int(pred==g.get('prediction')); valid=int(x.get('status')=='ok')
+   cells[(g.get('task'),g.get('track'))].append((rec,prec,align,cons,conf,correct,valid))
+  for (task,track),rs in cells.items():
+   valid=[r for r in rs if r[6]]; cal=[(r[4],r[5]) for r in valid]
+   def avg(i):return sum(r[i] for r in valid)/len(valid) if valid else 0
+   out.append({'dataset':dataset,'model':'Grok' if run.endswith('grok') else 'Claude','task':task,'track':track,'cell':f'{task}-{track}','n':len(rs),'valid_n':len(valid),'format_valid_rate':len(valid)/len(rs),'evidence_anchor_recall':avg(0),'evidence_precision_proxy':avg(1),'mechanism_alignment':avg(2),'prediction_explanation_consistency':avg(3),'brier_score':sum((c-y)**2 for c,y in cal)/len(cal) if cal else None,'ece_10bin':ece(cal)})
+ out.sort(key=lambda x:(x['dataset'],x['task'],x['track'],x['model']))
+ dest=BASE/'final_report_20260813/n40_open_deep_metrics_18cells.json'; dest.write_text(json.dumps({'schema_version':'FWB-FG9-DEEP-CELL-METRICS-v1','open_only':True,'rows':out},ensure_ascii=False,indent=2),encoding='utf-8'); print(dest,len(out))
+if __name__=='__main__':main()

evaluation/FireWorldBench-ICLR/scripts/score_fg9_gold_linked_support.py

@@ -0,0 +1,167 @@
+import json
+import math
+import re
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+BASE = ROOT / "artifacts/validation/fg9_dual_model_n40_final_20260812"
+RUNS = {
+    "main_grok": ("模拟数据主集", ["main_gate_C/gold.jsonl", "main_gate_B/gold.jsonl"]),
+    "main_claude": ("模拟数据主集", ["main_gate_C/gold.jsonl", "main_gate_B/gold.jsonl"]),
+    "c06_grok": ("真实事件模拟", ["c06_candidate/build_A/gold.jsonl", "c06_gate_A/gold.jsonl", "c06_pool80/build_A/gold.jsonl", "c06_pool80/build_B/gold.jsonl"]),
+    "c06_claude": ("真实事件模拟", ["c06_candidate/build_A/gold.jsonl", "c06_gate_A/gold.jsonl", "c06_pool80/build_A/gold.jsonl", "c06_pool80/build_B/gold.jsonl"]),
+}
+
+ALIASES = {
+    "temperature": ("temperature", "thermal", "heat", "hot"),
+    "smoke": ("smoke", "soot", "obscuration"),
+    "soot": ("soot", "smoke", "combustion signature"),
+    "visibility": ("visibility", "visible", "obscuration"),
+    "flow": ("flow", "velocity", "ventilation", "transport"),
+    "up": ("increase", "increasing", "rise", "rising", "grow", "growth", "up", "higher"),
+    "down": ("decrease", "decreasing", "fall", "falling", "decline", "down", "lower"),
+    "stable": ("stable", "steady", "unchanged", "constant", "plateau"),
+    "critical": ("critical", "extreme", "severe"),
+    "high": ("high", "hazardous"),
+    "incipient": ("incipient", "early", "initial", "ignition"),
+    "growth": ("growth", "growing", "developing"),
+    "global": ("global", "across", "all regions", "domain-wide"),
+    "mixed": ("mixed", "bidirectional", "multiple directions"),
+    "vertical": ("vertical", "upward", "buoyant", "rise"),
+}
+
+
+def norm(value):
+    return re.sub(r"[^a-z0-9]+", " ", str(value).lower()).strip()
+
+
+def text(value):
+    if isinstance(value, str):
+        return norm(value)
+    if isinstance(value, dict):
+        return " ".join(text(item) for item in value.values())
+    if isinstance(value, list):
+        return " ".join(text(item) for item in value)
+    return norm(value)
+
+
+def flatten(value, prefix=""):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            path = f"{prefix}.{key}" if prefix else key
+            yield from flatten(item, path)
+    else:
+        yield prefix, value
+
+
+def equivalent(predicted, expected):
+    if isinstance(expected, (int, float)):
+        try:
+            return float(predicted) == float(expected)
+        except (TypeError, ValueError):
+            return False
+    return norm(predicted) == norm(expected)
+
+
+def mentions(needle, corpus):
+    key = norm(needle)
+    variants = ALIASES.get(key, (key,))
+    return any(re.search(rf"(?<![a-z0-9]){re.escape(norm(v))}(?![a-z0-9])", corpus) for v in variants)
+
+
+def field_supported(path, expected, response_text, gold_text):
+    parts = path.lower().split(".")
+    field = parts[-1]
+    expected_text = norm(expected)
+    gold_linked = mentions(expected_text, gold_text)
+
+    if re.fullmatch(r"r\d+", expected_text) or "region" in field:
+        return gold_linked and mentions(expected_text, response_text)
+    if field.endswith("trend"):
+        variable = field.removesuffix("_trend")
+        horizon = parts[-2] if len(parts) > 1 and re.fullmatch(r"\d+s", parts[-2]) else None
+        context = mentions(variable, response_text) and mentions(expected_text, response_text)
+        if horizon:
+            context = context and mentions(horizon, response_text)
+        return context
+    if any(token in field for token in ("signal", "driver", "variable", "target")):
+        return gold_linked and mentions(expected_text, response_text)
+    if isinstance(expected, (int, float)):
+        return mentions(expected_text, response_text) or any(word in response_text for word in ("all regions", "across regions"))
+    return gold_linked and mentions(expected_text, response_text)
+
+
+def pearson(left, right):
+    mean_left = sum(left) / len(left)
+    mean_right = sum(right) / len(right)
+    numerator = sum((x - mean_left) * (y - mean_right) for x, y in zip(left, right))
+    denom_left = sum((x - mean_left) ** 2 for x in left)
+    denom_right = sum((y - mean_right) ** 2 for y in right)
+    return numerator / math.sqrt(denom_left * denom_right) if denom_left and denom_right else None
+
+
+def main():
+    prior_rows = json.load(open(BASE / "final_report_20260813/n40_open_deep_metrics_18cells.json", encoding="utf-8"))["rows"]
+    prior = {(row["dataset"], row["model"], row["cell"]): row for row in prior_rows}
+    rows = []
+    item_audit = []
+
+    for run, (dataset, gold_paths) in RUNS.items():
+        gold = {}
+        for gold_path in gold_paths:
+            for line in open(BASE / gold_path, encoding="utf-8"):
+                item = json.loads(line)
+                if item.get("question_type") == "open":
+                    gold[item["qa_id"]] = item
+        cells = defaultdict(list)
+        for line in open(BASE / "runs" / run / "merged_responses.jsonl", encoding="utf-8"):
+            response_record = json.loads(line)
+            qa_id = response_record.get("qa_id")
+            if response_record.get("question_type") != "open" or qa_id not in gold:
+                continue
+            gold_item = gold[qa_id]
+            response = response_record.get("response") if isinstance(response_record.get("response"), dict) else {}
+            predicted = response.get("prediction") if isinstance(response.get("prediction"), dict) else {}
+            predicted_flat = dict(flatten(predicted))
+            expected_flat = dict(flatten(gold_item.get("prediction", {})))
+            response_explanation = text([response.get("evidence", []), response.get("mechanism", ""), response.get("conclusion", "")])
+            gold_anchors = text([gold_item.get("evidence_claims", []), gold_item.get("mechanism_claims", [])])
+            field_scores = []
+            for path, expected in expected_flat.items():
+                correct = path in predicted_flat and equivalent(predicted_flat[path], expected)
+                supported = correct and field_supported(path, expected, response_explanation, gold_anchors)
+                field_scores.append(float(supported))
+            score = sum(field_scores) / len(field_scores) if field_scores else 0.0
+            cell = f'{gold_item["task"]}-{gold_item["track"]}'
+            cells[cell].append(score)
+            item_audit.append({"qa_id": qa_id, "dataset": dataset, "model": "Grok" if run.endswith("grok") else "Claude", "cell": cell, "score": score, "field_scores": field_scores})
+
+        model = "Grok" if run.endswith("grok") else "Claude"
+        for cell, scores in cells.items():
+            old = prior[(dataset, model, cell)]
+            precision = old["evidence_precision_proxy"]
+            recall = old["evidence_anchor_recall"]
+            evidence_f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+            rows.append({"dataset": dataset, "model": model, "cell": cell, "n": len(scores), "gold_linked_support": sum(scores) / len(scores), "evidence_f1": evidence_f1, "mechanism_alignment": old["mechanism_alignment"]})
+
+    rows.sort(key=lambda row: (row["dataset"], row["cell"], row["model"]))
+    values = [row["gold_linked_support"] for row in rows]
+    summary = {
+        "row_count": len(rows), "min": min(values), "max": max(values), "mean": sum(values) / len(values),
+        "cells_le_0_05": sum(value <= 0.05 for value in values), "cells_ge_0_95": sum(value >= 0.95 for value in values),
+        "cells_eq_0": sum(value == 0 for value in values), "cells_eq_1": sum(value == 1 for value in values),
+        "pearson_with_evidence_f1": pearson(values, [row["evidence_f1"] for row in rows]),
+        "pearson_with_mechanism_alignment": pearson(values, [row["mechanism_alignment"] for row in rows]),
+    }
+    output = {"schema_version": "FWB-FG9-GOLD-LINKED-SUPPORT-v1", "definition": "mean fraction of Gold-correct prediction fields supported by task-aware evidence or mechanism anchors", "rows": rows, "summary": summary, "item_audit": item_audit}
+    destination = BASE / "final_report_20260813/n40_gold_linked_support_18cells.json"
+    destination.write_text(json.dumps(output, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+    for dataset in ("模拟数据主集", "真实事件模拟"):
+        print(dataset)
+        print([(row["cell"], row["model"], round(row["gold_linked_support"], 3)) for row in rows if row["dataset"] == dataset])
+
+
+if __name__ == "__main__":
+    main()

evaluation/FireWorldBench-ICLR/scripts/score_fg9_predictions.py

@@ -0,0 +1,600 @@
+"""Score FG9 choice/open predictions with format, ability, evidence and calibration separated."""
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+REQUIRED_OPEN_KEYS = {"conclusion", "prediction", "evidence", "mechanism", "confidence"}
+TOKEN_PATTERN = re.compile(r"[a-z0-9_]+(?:\.[0-9]+)?", re.IGNORECASE)
+NUMBER_PATTERN = re.compile(r"(?<![a-z0-9_])[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[-+]?\d+)?", re.IGNORECASE)
+STOP_WORDS = {
+    "a", "an", "and", "are", "as", "at", "be", "by", "for", "from", "has", "in", "is", "it",
+    "of", "on", "or", "that", "the", "this", "to", "under", "while", "with",
+}
+ALIASES = {
+    "thermal": "temperature", "heat": "temperature", "hot": "temperature",
+    "smoke": "soot", "smoky": "soot", "obscuration": "visibility",
+    "airflow": "flow", "velocity": "flow", "movement": "flow",
+    "extract": "extraction", "extracted": "extraction", "exhaust": "extraction",
+    "buoyant": "buoyancy", "plume": "buoyancy",
+}
+
+# Provider wording varies substantially even for the same physical explanation.
+# These concepts form a small, frozen ontology for deterministic auxiliary
+# evidence/mechanism scoring; exact task labels remain scored separately above.
+CONCEPT_PATTERNS = {
+    "fire_source": (r"\bfire\b", r"\bflame\w*\b", r"\bcombust\w*\b", r"\bignition\b", r"\bhrrpua\b"),
+    "heat": (r"\btemperature\b", r"\bthermal\b", r"\bheat\w*\b", r"\bhot\w*\b"),
+    "smoke": (r"\bsmoke\b", r"\bsoot\b", r"\bobscur\w*\b"),
+    "visibility": (r"\bvisibility\b", r"\bvisible\b"),
+    "flow": (r"\bflow\b", r"\bairflow\b", r"\bvelocity\b", r"\btransport\b", r"\badvection\b"),
+    "ventilation": (r"\bventilat\w*\b", r"\blongitudinal\s+flow\b"),
+    "extraction": (r"\bextract\w*\b", r"\bexhaust\w*\b"),
+    "buoyancy": (r"\bbuoyan\w*\b", r"\bconvect\w*\b", r"\bplume\b"),
+    "ceiling_jet": (r"\bceiling\s+jet\b",),
+    "backlayering": (r"\bbacklayer\w*\b", r"\bupstream\s+smoke\b"),
+    "sensor": (r"\bsensor\w*\b", r"\bmeasurement\s+(?:fault|conflict)\b"),
+    "forecast": (r"\bforecast\w*\b", r"\bpredict\w*\b", r"\bextrapolat\w*\b"),
+    "threshold": (r"\bthreshold\b", r"\bcross(?:es|ed|ing)?\b"),
+    "risk": (r"\brisk\b", r"\bhazard\w*\b"),
+    "growth": (r"\bgrowth\b", r"\bdeveloped\b", r"\bexpan\w*\b", r"\bincreas\w*\b", r"\brise\b"),
+    "decay": (r"\bdecay\b", r"\bdecreas\w*\b", r"\bdeclin\w*\b", r"\bdissipat\w*\b"),
+    "continuity": (r"\bcontinuit\w*\b", r"\bconsistent\b", r"\bcoupl\w*\b"),
+    "anomaly": (r"\banomal\w*\b", r"\binconsistent\b", r"\bviolation\b", r"\bconflict\b"),
+}
+
+
+def load_jsonl(path: Path) -> list[dict]:
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def balanced_object(text: str) -> str | None:
+    start = text.find("{")
+    while start >= 0:
+        depth = 0
+        quoted = False
+        escaped = False
+        for index in range(start, len(text)):
+            char = text[index]
+            if quoted:
+                if escaped:
+                    escaped = False
+                elif char == "\\":
+                    escaped = True
+                elif char == '"':
+                    quoted = False
+                continue
+            if char == '"':
+                quoted = True
+            elif char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+                if depth == 0:
+                    return text[start:index + 1]
+        start = text.find("{", start + 1)
+    return None
+
+
+def response_value(row: dict) -> Any:
+    for key in ("response", "parsed", "output", "answer", "content", "text", "raw_response"):
+        if key in row:
+            return row[key]
+    return row
+
+
+def parse_object(value: Any) -> tuple[dict | None, bool]:
+    if isinstance(value, dict):
+        return value, True
+    if isinstance(value, list) and len(value) == 1 and isinstance(value[0], dict):
+        return value[0], False
+    if not isinstance(value, str):
+        return None, False
+    text = value.strip()
+    direct = text
+    if text.startswith("```"):
+        direct = re.sub(r"^```(?:json)?\s*|\s*```$", "", text, flags=re.IGNORECASE)
+    try:
+        parsed = json.loads(direct)
+        return (parsed, text == direct) if isinstance(parsed, dict) else (None, False)
+    except json.JSONDecodeError:
+        candidate = balanced_object(text)
+        if candidate:
+            try:
+                parsed = json.loads(candidate)
+                return (parsed, False) if isinstance(parsed, dict) else (None, False)
+            except json.JSONDecodeError:
+                pass
+    return None, False
+
+
+def flatten(value: Any, prefix: str = "") -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {prefix: value}
+    output = {}
+    for key, item in value.items():
+        path = f"{prefix}.{key}" if prefix else str(key)
+        output.update(flatten(item, path))
+    return output
+
+
+def normalize_choices(value: Any) -> list[str] | None:
+    if isinstance(value, dict):
+        if "choices" in value:
+            return normalize_choices(value["choices"])
+        for key in ("choice", "selected_option", "answer", "label", "prediction"):
+            if key in value:
+                result = normalize_choices(value[key])
+                if result is not None:
+                    return result
+        return None
+    if isinstance(value, list):
+        labels = []
+        for item in value:
+            if not isinstance(item, str) or not re.fullmatch(r"[A-Z]", item.strip(), re.IGNORECASE):
+                return None
+            labels.append(item.strip().upper())
+        return sorted(labels) if len(labels) == len(set(labels)) else None
+    if not isinstance(value, str):
+        return None
+    match = re.fullmatch(r"\s*([A-Z])\s*", value, re.IGNORECASE)
+    return [match.group(1).upper()] if match else None
+
+
+def normalize_choice(value: Any) -> str | None:
+    """Legacy single-choice adapter retained for older analysis scripts."""
+    choices = normalize_choices(value)
+    return choices[0] if choices and len(choices) == 1 else None
+
+
+def normalize_open(value: Any) -> tuple[dict | None, dict | None, bool]:
+    parsed, strict_json = parse_object(value)
+    if parsed is None:
+        return None, None, False
+    report = parsed
+    if "report" in parsed and isinstance(parsed["report"], dict):
+        report = parsed["report"]
+        strict_json = False
+    prediction = report.get("prediction")
+    if not isinstance(prediction, dict):
+        for key in ("answer", "result", "fields"):
+            if isinstance(report.get(key), dict):
+                prediction = report[key]
+                break
+    format_valid = (
+        strict_json and REQUIRED_OPEN_KEYS.issubset(report) and isinstance(report.get("prediction"), dict)
+        and isinstance(report.get("evidence"), list) and isinstance(report.get("mechanism"), (str, list, dict))
+        and isinstance(report.get("confidence"), (int, float)) and 0 <= float(report["confidence"]) <= 1
+    )
+    return prediction if isinstance(prediction, dict) else None, report, format_valid
+
+
+def tokens(value: Any) -> Counter[str]:
+    if isinstance(value, dict):
+        value = " ".join(str(item) for item in value.values())
+    elif isinstance(value, list):
+        value = " ".join(str(item) for item in value)
+    text = str(value).lower().replace("kg/m3", "kg m3").replace("m/s", "mps")
+    text = re.sub(r"_(?:p10|p50|p90|p95|mean)\b", " ", text)
+    text = text.replace("_", " ").replace("-", " ")
+    text = NUMBER_PATTERN.sub(lambda match: f" num{float(match.group()):.2g} ", text)
+    normalized = []
+    for token in TOKEN_PATTERN.findall(text):
+        if token in STOP_WORDS:
+            continue
+        normalized.append(ALIASES.get(token, token))
+    return Counter(normalized)
+
+
+def token_f1(a: Any, b: Any) -> float:
+    left, right = tokens(a), tokens(b)
+    if not left and not right:
+        return 1.0
+    if not left or not right:
+        return 0.0
+    overlap = sum((left & right).values())
+    precision = overlap / sum(left.values())
+    recall = overlap / sum(right.values())
+    return 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+
+
+def claim_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, dict):
+        if "observation" in value:
+            prefix = str(value.get("region", ""))
+            return [f"{prefix} {value['observation']}".strip()]
+        for key in ("statement", "observation", "claim", "text"):
+            if key in value:
+                return [str(value[key])]
+        return [json.dumps(value, sort_keys=True)]
+    if isinstance(value, list):
+        output = []
+        for item in value:
+            output.extend(claim_list(item))
+        return output
+    return [str(value)]
+
+
+def claim_metrics(predicted: Any, gold: Any, threshold: float = 0.30) -> tuple[float, float, float, float]:
+    pred_claims, gold_claims = claim_list(predicted), claim_list(gold)
+    if not pred_claims and not gold_claims:
+        return 1.0, 1.0, 1.0, 0.0
+    if not pred_claims:
+        return 0.0, 0.0, 0.0, 0.0
+    if not gold_claims:
+        return 0.0, 0.0, 0.0, 1.0
+    scores = [[token_f1(pred, target) for target in gold_claims] for pred in pred_claims]
+    matched_pred = sum(max(row) >= threshold for row in scores)
+    matched_gold = sum(max(scores[p][g] for p in range(len(pred_claims))) >= threshold
+                       for g in range(len(gold_claims)))
+    precision = matched_pred / len(pred_claims)
+    recall = matched_gold / len(gold_claims)
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+    hallucination = 1.0 - precision
+    return precision, recall, f1, hallucination
+
+
+def physical_concepts(value: Any) -> set[str]:
+    text = " ".join(claim_list(value)).lower().replace("_", " ")
+    return {
+        concept
+        for concept, patterns in CONCEPT_PATTERNS.items()
+        if any(re.search(pattern, text) for pattern in patterns)
+    }
+
+
+def concept_metrics(predicted: Any, gold: Any) -> tuple[float, float, float, float]:
+    predicted_concepts = physical_concepts(predicted)
+    gold_concepts = physical_concepts(gold)
+    if not predicted_concepts and not gold_concepts:
+        return 1.0, 1.0, 1.0, 0.0
+    if not predicted_concepts:
+        return 0.0, 0.0, 0.0, 0.0
+    if not gold_concepts:
+        return 0.0, 0.0, 0.0, 1.0
+    overlap = predicted_concepts & gold_concepts
+    precision = len(overlap) / len(predicted_concepts)
+    recall = len(overlap) / len(gold_concepts)
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+    return precision, recall, f1, 1.0 - precision
+
+
+def numeric_values(value: Any) -> list[float]:
+    return [float(match.group()) for claim in claim_list(value) for match in NUMBER_PATTERN.finditer(claim)]
+
+
+def numeric_grounding_metrics(predicted: Any, gold: Any) -> tuple[float, float, float, float]:
+    pred_values, gold_values = numeric_values(predicted), numeric_values(gold)
+    if not pred_values and not gold_values:
+        return 1.0, 1.0, 1.0, 0.0
+    if not pred_values:
+        return 0.0, 0.0, 0.0, 0.0
+    if not gold_values:
+        return 0.0, 0.0, 0.0, 0.0
+    available = set(range(len(gold_values)))
+    matched = 0
+    for predicted_value in pred_values:
+        candidates = []
+        for index in available:
+            expected = gold_values[index]
+            tolerance = (max(0.02, 0.05 * abs(expected)) if abs(expected) >= 0.1 else
+                         max(1e-7, 0.10 * abs(expected)))
+            error = abs(predicted_value - expected)
+            if error <= tolerance:
+                candidates.append((error, index))
+        if candidates:
+            _, index = min(candidates)
+            available.remove(index)
+            matched += 1
+    precision = matched / len(pred_values)
+    recall = matched / len(gold_values)
+    f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+    # Coverage measures whether required numeric slots were attempted, not whether
+    # extra numbers were emitted. Correctness remains isolated in P/R/F1.
+    coverage = min(len(pred_values), len(gold_values)) / len(gold_values)
+    return precision, recall, f1, coverage
+
+
+def macro_f1(pairs: list[tuple[Any, Any]]) -> float:
+    labels = sorted({str(gold) for gold, _ in pairs} | {str(pred) for _, pred in pairs})
+    if not labels:
+        return 0.0
+    scores = []
+    for label in labels:
+        tp = sum(str(gold) == label and str(pred) == label for gold, pred in pairs)
+        fp = sum(str(gold) != label and str(pred) == label for gold, pred in pairs)
+        fn = sum(str(gold) == label and str(pred) != label for gold, pred in pairs)
+        precision = tp / (tp + fp) if tp + fp else 0.0
+        recall = tp / (tp + fn) if tp + fn else 0.0
+        scores.append(2 * precision * recall / (precision + recall) if precision + recall else 0.0)
+    return sum(scores) / len(scores)
+
+
+# --- Slot-MacroF1 primitives (per-slot exact-match F1, macro-averaged over slots) ---
+def dice(pred: Any, gold: Any) -> float:
+    """Sørensen–Dice on option sets (choice component, unchanged from prior definition)."""
+    ps, gs = set(pred or []), set(gold)
+    if not ps and not gs:
+        return 1.0
+    if not ps or not gs:
+        return 0.0
+    return 2 * len(ps & gs) / (len(ps) + len(gs))
+
+
+def slot_norm(v: Any) -> str:
+    return re.sub(r"[^a-z0-9]+", " ", str(v).lower()).strip()
+
+
+def slot_f1(pairs: list[tuple[Any, Any]]) -> float:
+    """Per-slot exact-match F1 = 2TP/(2TP+FP+FN). pairs = list[(gold, pred_or_None)]."""
+    tp = fp = fn = 0
+    for e, p in pairs:
+        if p is None:
+            fn += 1
+        elif slot_norm(e) == slot_norm(p):
+            tp += 1
+        else:
+            fp += 1
+    denom = 2 * tp + fp + fn
+    return 2 * tp / denom if denom else 0.0
+
+
+def slot_macro_f1(field_pairs: dict[str, list]) -> float:
+    """Macro-average per-slot exact-match F1 over fields. field_pairs = {field: [(gold,pred)]}."""
+    if not field_pairs:
+        return 0.0
+    vals = [slot_f1(ps) for ps in field_pairs.values()]
+    return sum(vals) / len(vals) if vals else 0.0
+
+
+def combine(choice_macro: float, open_slot_macro: float, has_c: bool, has_o: bool) -> float:
+    if has_c and has_o:
+        return (choice_macro + open_slot_macro) / 2
+    if has_c:
+        return choice_macro
+    if has_o:
+        return open_slot_macro
+    return 0.0
+
+
+def ece(rows: list[tuple[float, float]], bins: int = 10) -> float | None:
+    if not rows:
+        return None
+    total = len(rows)
+    value = 0.0
+    for index in range(bins):
+        low, high = index / bins, (index + 1) / bins
+        bucket = [(confidence, correct) for confidence, correct in rows
+                  if low <= confidence < high or index == bins - 1 and confidence == 1.0]
+        if bucket:
+            value += len(bucket) / total * abs(
+                sum(confidence for confidence, _ in bucket) / len(bucket) -
+                sum(correct for _, correct in bucket) / len(bucket)
+            )
+    return value
+
+
+def wilson_interval(successes: int, total: int, z: float = 1.959963984540054) -> tuple[float, float]:
+    """Return the two-sided 95% Wilson interval for a binomial proportion."""
+    if total <= 0:
+        return 0.0, 0.0
+    proportion = successes / total
+    denominator = 1.0 + z * z / total
+    centre = (proportion + z * z / (2.0 * total)) / denominator
+    margin = z * math.sqrt(
+        proportion * (1.0 - proportion) / total + z * z / (4.0 * total * total)
+    ) / denominator
+    return max(0.0, centre - margin), min(1.0, centre + margin)
+
+
+def aggregate(scored: list[dict], key_fields: tuple[str, ...]) -> list[dict]:
+    groups: dict[tuple, list[dict]] = defaultdict(list)
+    for row in scored:
+        groups[tuple(row.get(key) for key in key_fields)].append(row)
+    reports = []
+    for key, rows in sorted(groups.items(), key=lambda item: tuple(str(value) for value in item[0])):
+        field_pairs: dict[str, list[tuple[Any, Any]]] = defaultdict(list)
+        for row in rows:
+            for field, pair in row["field_pairs"].items():
+                field_pairs[field].append(tuple(pair))
+        component = {
+            field: {
+                "accuracy": sum(gold == pred for gold, pred in pairs) / len(pairs),
+                "macro_f1": macro_f1(pairs),
+                "gold_label_counts": dict(sorted(Counter(str(gold) for gold, _ in pairs).items())),
+                "predicted_label_counts": dict(sorted(Counter(
+                    "<missing>" if pred is None else str(pred) for _, pred in pairs
+                ).items())),
+                "confusion_counts": dict(sorted(Counter(
+                    f"{gold} -> {'<missing>' if pred is None else pred}" for gold, pred in pairs
+                ).items())),
+            }
+            for field, pairs in sorted(field_pairs.items())
+        }
+        joint_successes = sum(row["joint_correct"] for row in rows)
+        joint_ci_low, joint_ci_high = wilson_interval(int(joint_successes), len(rows))
+        field_correct = sum(
+            expected == actual
+            for row in rows for expected, actual in row["field_pairs"].values()
+        )
+        field_total = sum(len(row["field_pairs"]) for row in rows)
+        field_micro_accuracy = field_correct / field_total if field_total else 0.0
+        nonlinear_partial_credit = sum(row["completion_ratio"] ** 3.5 for row in rows) / len(rows)
+        completion_micro_accuracy = sum(row["completion_ratio"] for row in rows) / len(rows)
+        partial_credit_by_exponent = {
+            str(exponent): sum(row["completion_ratio"] ** exponent for row in rows) / len(rows)
+            for exponent in (1.5, 2.0, 2.5, 3.0, 3.25, 3.5)
+        }
+        component_macro_f1 = (
+            sum(metrics["macro_f1"] for metrics in component.values()) / len(component)
+            if component else 0.0
+        )
+        calibration = [(row["confidence"], row["joint_correct"]) for row in rows if row["confidence"] is not None]
+        reports.append({
+            **dict(zip(key_fields, key)),
+            "count": len(rows),
+            "response_rate": sum(row["responded"] for row in rows) / len(rows),
+            "format_valid_rate": sum(row["format_valid"] for row in rows) / len(rows),
+            "joint_accuracy": joint_successes / len(rows),
+            "joint_accuracy_wilson_95": [joint_ci_low, joint_ci_high],
+            "field_correct": field_correct,
+            "field_total": field_total,
+            "field_micro_accuracy": field_micro_accuracy,
+            "completion_micro_accuracy": completion_micro_accuracy,
+            "nonlinear_partial_credit": nonlinear_partial_credit,
+            "nonlinear_partial_credit_exponent": 3.5,
+            "quadratic_partial_credit": partial_credit_by_exponent["2.0"],
+            "partial_credit_by_exponent": partial_credit_by_exponent,
+            "component_macro_f1": component_macro_f1,
+            "component_metrics": component,
+            "evidence_precision": sum(row["evidence_precision"] for row in rows) / len(rows),
+            "evidence_recall": sum(row["evidence_recall"] for row in rows) / len(rows),
+            "evidence_f1": sum(row["evidence_f1"] for row in rows) / len(rows),
+            "mechanism_f1": sum(row["mechanism_f1"] for row in rows) / len(rows),
+            "evidence_lexical_f1": sum(row["evidence_lexical_f1"] for row in rows) / len(rows),
+            "mechanism_lexical_f1": sum(row["mechanism_lexical_f1"] for row in rows) / len(rows),
+            "hallucination_rate": sum(row["hallucination_rate"] for row in rows) / len(rows),
+            "numeric_grounding_precision": sum(row["numeric_grounding_precision"] for row in rows) / len(rows),
+            "numeric_grounding_recall": sum(row["numeric_grounding_recall"] for row in rows) / len(rows),
+            "numeric_grounding_f1": sum(row["numeric_grounding_f1"] for row in rows) / len(rows),
+            "numeric_evidence_coverage": sum(row["numeric_evidence_coverage"] for row in rows) / len(rows),
+            "confidence_coverage": len(calibration) / len(rows),
+            "brier": (sum((confidence - correct) ** 2 for confidence, correct in calibration) / len(calibration)
+                      if calibration else None),
+            "ece_10": ece(calibration),
+        })
+    return reports
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--gold", type=Path, required=True)
+    parser.add_argument("--predictions", type=Path, nargs="+", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    gold_rows = load_jsonl(args.gold)
+    prediction_rows = [row for path in args.predictions for row in load_jsonl(path)]
+    predictions = {}
+    for row in prediction_rows:
+        qa_id = row.get("qa_id")
+        if not qa_id:
+            continue
+        previous = predictions.get(qa_id)
+        if previous is None or (previous.get("status") != "ok" and row.get("status") == "ok"):
+            predictions[qa_id] = row
+    scored = []
+    for gold in gold_rows:
+        record = predictions.get(gold["qa_id"])
+        record_ok = record is not None and record.get("status") == "ok"
+        value = response_value(record) if record_ok else None
+        confidence = None
+        format_valid = False
+        if gold["question_type"] == "choice":
+            predicted_choices = normalize_choices(value)
+            parsed_choice, _ = parse_object(value)
+            if parsed_choice and isinstance(parsed_choice.get("confidence"), (int, float)):
+                raw_confidence = float(parsed_choice["confidence"])
+                if 0 <= raw_confidence <= 1:
+                    confidence = raw_confidence
+            expected = gold.get("correct_options")
+            if expected is None:
+                expected = [gold["correct_option"]]
+            expected_choices = sorted(expected)
+            expected_set = set(expected_choices)
+            predicted_set = set(predicted_choices or [])
+            choice_union = expected_set | predicted_set
+            completion_ratio = (len(expected_set & predicted_set) / len(choice_union)
+                                if choice_union else 0.0)
+            field_pairs = {"choice_exact_set": (
+                ",".join(expected_choices),
+                ",".join(predicted_choices) if predicted_choices is not None else None,
+            )}
+            joint_correct = float(predicted_choices == expected_choices)
+            format_valid = predicted_choices is not None
+            evidence_p = evidence_r = evidence_score = mechanism_score = hallucination = 0.0
+            evidence_lexical = mechanism_lexical = 0.0
+            numeric_p = numeric_r = numeric_score = numeric_coverage = 0.0
+        else:
+            predicted, report, format_valid = normalize_open(value)
+            gold_flat = flatten(gold["prediction"])
+            predicted_flat = flatten(predicted or {})
+            field_pairs = {field: (expected, predicted_flat.get(field)) for field, expected in gold_flat.items()}
+            joint_correct = float(bool(field_pairs) and all(expected == actual for expected, actual in field_pairs.values()))
+            completion_ratio = (sum(expected == actual for expected, actual in field_pairs.values()) /
+                                len(field_pairs) if field_pairs else 0.0)
+            if report:
+                raw_confidence = report.get("confidence")
+                if isinstance(raw_confidence, (int, float)) and 0 <= float(raw_confidence) <= 1:
+                    confidence = float(raw_confidence)
+                _, _, evidence_lexical, _ = claim_metrics(
+                    report.get("evidence"), gold.get("evidence_claims", []))
+                _, _, mechanism_lexical, _ = claim_metrics(
+                    report.get("mechanism"), gold.get("mechanism_claims", []))
+                evidence_p, evidence_r, evidence_score, evidence_h = concept_metrics(
+                    report.get("evidence"), gold.get("evidence_claims", []))
+                _, _, mechanism_score, mechanism_h = concept_metrics(
+                    report.get("mechanism"), gold.get("mechanism_claims", []))
+                hallucination = (evidence_h + mechanism_h) / 2
+                numeric_p, numeric_r, numeric_score, numeric_coverage = numeric_grounding_metrics(
+                    report.get("evidence"), gold.get("evidence_claims", []))
+            else:
+                evidence_p = evidence_r = evidence_score = mechanism_score = 0.0
+                evidence_lexical = mechanism_lexical = 0.0
+                hallucination = 0.0
+                numeric_p = numeric_r = numeric_score = numeric_coverage = 0.0
+        provenance = gold.get("provenance", {})
+        scored.append({
+            "qa_id": gold["qa_id"], "task": gold["task"], "track": gold["track"],
+            "subtrack": gold["subtrack"], "question_type": gold["question_type"],
+            "state_family": provenance.get("state_family"), "archetype": provenance.get("archetype"),
+            "responded": record_ok, "format_valid": format_valid,
+            "joint_correct": joint_correct, "field_pairs": field_pairs,
+            "completion_ratio": completion_ratio,
+            "evidence_precision": evidence_p, "evidence_recall": evidence_r, "evidence_f1": evidence_score,
+            "mechanism_f1": mechanism_score, "hallucination_rate": hallucination,
+            "evidence_lexical_f1": evidence_lexical, "mechanism_lexical_f1": mechanism_lexical,
+            "numeric_grounding_precision": numeric_p, "numeric_grounding_recall": numeric_r,
+            "numeric_grounding_f1": numeric_score, "numeric_evidence_coverage": numeric_coverage,
+            "confidence": confidence,
+        })
+    report = {
+        "schema_version": "FWB-FG9-SCORE-v2-exact-set-full-open",
+        "gold_count": len(gold_rows), "prediction_record_count": len(prediction_rows),
+        "prediction_file_count": len(args.predictions),
+        "prediction_status_counts": dict(sorted(Counter(row.get("status", "missing") for row in prediction_rows).items())),
+        "matched_prediction_count": sum(row["responded"] for row in scored),
+        "overall": aggregate(scored, ("question_type",)),
+        "by_track_type": aggregate(scored, ("track", "question_type")),
+        "by_task_track_type": aggregate(scored, ("task", "track", "question_type")),
+        "by_subtrack_type": aggregate(scored, ("subtrack", "question_type")),
+        "by_state_type": aggregate(scored, ("state_family", "question_type")),
+        "by_archetype_type": aggregate(scored, ("archetype", "question_type")),
+        "notes": {
+            "core": "Joint and component label metrics include missing/malformed outputs as incorrect.",
+            "primary_metrics": "All question types use nonlinear_partial_credit = mean(completion_ratio^3.5). Open completion_ratio is correct_required_fields/requested_fields. Choice completion_ratio is Jaccard similarity between predicted and gold selected-option sets. Exact-set/JEM, linear completion, and component_macro_f1 remain mandatory audit metrics.",
+            "partial_credit": "The global exponent 3.5 is fixed for every item, dataset, cell, question type, and model. Choice Jaccard penalizes both omissions and extra selections without rewarding true-negative unselected options. The score is deterministic and contains no per-cell or model-specific tuning.",
+            "interval": "joint_accuracy_wilson_95 is the two-sided 95% Wilson interval for choice Accuracy or open JEM.",
+            "format": "format_valid_rate is reported separately and never replaces ability metrics.",
+            "evidence": "Evidence/mechanism F1 use a frozen physical-concept ontology; lexical F1 is also retained as a surface-form diagnostic.",
+            "numeric": "Numeric grounding separately checks cited values against gold physical observations.",
+            "judge": "LLM-judge scoring is optional and excluded from the primary leaderboard.",
+        },
+    }
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"gold_count": report["gold_count"], "matched": report["matched_prediction_count"],
+                      "overall": report["overall"]}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

evaluation/FireWorldBench-ICLR/scripts/score_six_metrics.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Compute the six FireWorldBench leaderboard metrics without an LLM judge."""
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import re
+from collections import defaultdict
+from pathlib import Path
+
+
+def load_jsonl(path: Path):
+    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+
+
+def gold_linked_items(gold_rows, prediction_rows, support_scorer):
+    predictions = {}
+    for row in prediction_rows:
+        if row.get("qa_id") and (row["qa_id"] not in predictions or row.get("status") == "ok"):
+            predictions[row["qa_id"]] = row
+    output = []
+    for gold in gold_rows:
+        record = predictions.get(gold["qa_id"], {})
+        response = record.get("response") if record.get("status") == "ok" and isinstance(record.get("response"), dict) else {}
+        predicted = response.get("prediction") if isinstance(response.get("prediction"), dict) else {}
+        predicted_flat = dict(support_scorer.flatten(predicted))
+        expected_flat = dict(support_scorer.flatten(gold.get("prediction", {})))
+        explanation = support_scorer.text([response.get("evidence", []), response.get("mechanism", ""), response.get("conclusion", "")])
+        anchors = support_scorer.text([gold.get("evidence_claims", []), gold.get("mechanism_claims", [])])
+        scores = []
+        for path, expected in expected_flat.items():
+            correct = path in predicted_flat and support_scorer.equivalent(predicted_flat[path], expected)
+            scores.append(float(correct and support_scorer.field_supported(path, expected, explanation, anchors)))
+        output.append({"qa_id": gold["qa_id"], "task": gold["task"], "track": gold["track"],
+                       "question_type": gold["question_type"],
+                       "gold_linked_support": sum(scores) / len(scores) if scores else 0.0})
+    return output
+
+
+BIN_MAP = {"none": "none", "early": "present", "middle": "present", "late": "present", "present": "present"}
+
+
+def coarsen_l13(pred):
+    """L1-3 open: collapse first_violation_bin to {none, present}; lowercase violation_type."""
+    if not isinstance(pred, dict):
+        return pred
+    out = dict(pred)
+    if "first_violation_bin" in out:
+        out["first_violation_bin"] = BIN_MAP.get(str(out["first_violation_bin"]).lower(),
+                                                str(out["first_violation_bin"]).lower())
+    if "violation_type" in out:
+        out["violation_type"] = str(out["violation_type"]).lower()
+    return out
+
+
+def layer_label(row, group_by):
+    """Return the cell label for a row under the requested grouping."""
+    if group_by == "physical":
+        return row.get("physical_axis") or row.get("task")
+    if group_by == "fire":
+        return row.get("fire_axis") or row.get("task")
+    return row.get("task")
+
+
+def key(row, group_by="task"):
+    return (layer_label(row, group_by), row.get("track"), row.get("question_type"))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--gold", type=Path, required=True)
+    parser.add_argument("--predictions", type=Path, nargs="+", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--group-by", choices=("task", "physical", "fire"), default="physical",
+                        help="group cells by the five-layer physical axis (physical -> P1-P5, 20 cells, default), "
+                             "fire axis (fire -> T1-T3) or fine-grained task (9 tasks). "
+                             "Requires gold rows carrying physical_axis / fire_axis labels.")
+    args = parser.parse_args()
+    package = Path(__file__).resolve().parent
+    spec = importlib.util.spec_from_file_location("fwb_base_scorer", package / "score_fg9_predictions.py")
+    scorer = importlib.util.module_from_spec(spec); spec.loader.exec_module(scorer)
+    support_spec = importlib.util.spec_from_file_location("fwb_support_scorer", package / "score_fg9_gold_linked_support.py")
+    support_scorer = importlib.util.module_from_spec(support_spec); support_spec.loader.exec_module(support_scorer)
+    deep_spec = importlib.util.spec_from_file_location("fwb_deep_scorer", package / "score_fg9_deep_metrics_by_cell.py")
+    deep_scorer = importlib.util.module_from_spec(deep_spec); deep_spec.loader.exec_module(deep_scorer)
+    gold_rows = load_jsonl(args.gold)
+    prediction_rows = [row for path in args.predictions for row in load_jsonl(path)]
+    prediction_map = {}
+    for row in prediction_rows:
+        if row.get("qa_id") and (row["qa_id"] not in prediction_map or row.get("status") == "ok"):
+            prediction_map[row["qa_id"]] = row
+    # Reuse the frozen public scorer by invoking its normalization/metric primitives.
+    scored = []
+    for gold in gold_rows:
+        record = prediction_map.get(gold["qa_id"]); ok = record is not None and record.get("status") == "ok"
+        value = scorer.response_value(record) if ok else None
+        confidence = None
+        if gold["question_type"] == "choice":
+            pred = scorer.normalize_choices(value); expected = sorted(gold.get("correct_options", [gold.get("correct_option")]))
+            union = set(pred or []) | set(expected); ratio = len(set(pred or []) & set(expected)) / len(union) if union else 0
+            pairs = {"choice_exact_set": (",".join(expected), ",".join(pred) if pred is not None else None)}
+            parsed, _ = scorer.parse_object(value)
+            if parsed and isinstance(parsed.get("confidence"), (int, float)): confidence = float(parsed["confidence"])
+            ef1 = mf1 = 0.0
+            cd = scorer.dice(pred, expected)
+        else:
+            pred, report, _ = scorer.normalize_open(value)
+            if gold.get("task") == "L1-3":
+                pred = coarsen_l13(pred)
+            gf, pf = scorer.flatten(gold["prediction"]), scorer.flatten(pred or {})
+            pairs = {field: (expected, pf.get(field)) for field, expected in gf.items()}; ratio = sum(a == b for a,b in pairs.values()) / len(pairs)
+            if report:
+                confidence = float(report["confidence"]) if isinstance(report.get("confidence"), (int,float)) else None
+                free=deep_scorer.text([report.get("conclusion",""),report.get("evidence",[]),report.get("mechanism","")]); ft=deep_scorer.toks(free)
+                anchors=[]
+                for claim in gold.get("evidence_claims") or []:
+                    observation=(claim.get("observation") or "").lower()
+                    variable=next((v for v in deep_scorer.VARS if v in observation),None)
+                    anchors.append((str(claim.get("region","")).lower(),variable))
+                recall=sum(((region in free)+(variable in free if variable else 0))/(2 if variable else 1) for region,variable in anchors)/max(1,len(anchors))
+                claims=set(value.lower() for value in re.findall(r"\bR\d+\b",free,re.I))|(ft&deep_scorer.VARS)
+                anchored={value for anchor in anchors for value in anchor if value}
+                precision=len(claims&anchored)/len(claims) if claims else 0
+                ef1=2*precision*recall/(precision+recall) if precision+recall else 0
+                gold_tokens=deep_scorer.toks(" ".join(c.get("statement","") for c in gold.get("mechanism_claims") or []))-{"the","and","with","that","this","from","into","first"}
+                mechanism_tokens=deep_scorer.toks(deep_scorer.text(report.get("mechanism","")))
+                mf1=len(gold_tokens&mechanism_tokens)/len(gold_tokens) if gold_tokens else 0
+            else: ef1 = mf1 = 0.0
+            cd = None
+        scored.append({"task":gold["task"],"physical_axis":gold.get("physical_axis"),"fire_axis":gold.get("fire_axis"),
+                       "track":gold["track"],"question_type":gold["question_type"],"pairs":pairs,"ratio":ratio,
+                       "confidence":confidence,"correct":float(ratio==1),"evidence_f1":ef1,"mechanism_alignment":mf1,
+                       "choice_dice":cd})
+    gls = {row["qa_id"]:row["gold_linked_support"] for row in gold_linked_items(gold_rows,prediction_rows,support_scorer)}
+    for row,gold in zip(scored,gold_rows): row["gold_linked_support"] = gls[gold["qa_id"]]
+    groups=defaultdict(list)
+    for row in scored: groups[key(row, args.group_by)].append(row)
+    def summarize(rows):
+        fp=defaultdict(list)
+        for row in rows:
+            for field,pair in row["pairs"].items(): fp[field].append(pair)
+        calibration=[(r["confidence"],r["correct"]) for r in rows if r["confidence"] is not None and 0<=r["confidence"]<=1]
+        open_rows=[r for r in rows if r["question_type"]=="open"]
+        choice_rows=[r for r in rows if r["question_type"]=="choice"]
+        open_fp=defaultdict(list)
+        for row in open_rows:
+            for field,pair in row["pairs"].items(): open_fp[field].append(pair)
+        c_dice=[r["choice_dice"] for r in choice_rows]
+        choice_macro=sum(c_dice)/len(c_dice) if c_dice else 0.0
+        open_slot_macro=scorer.slot_macro_f1(open_fp)
+        macro_f1=scorer.combine(choice_macro, open_slot_macro, bool(choice_rows), bool(open_rows))
+        return {"n":len(rows),"completion_accuracy":sum(r["ratio"] for r in rows)/len(rows),
+                "macro_f1":macro_f1,
+                "evidence_f1":sum(r["evidence_f1"] for r in open_rows)/len(open_rows) if open_rows else None,
+                "mechanism_alignment":sum(r["mechanism_alignment"] for r in open_rows)/len(open_rows) if open_rows else None,
+                "brier_score":sum((c-y)**2 for c,y in calibration)/len(calibration) if calibration else None,
+                "gold_linked_support":sum(r["gold_linked_support"] for r in open_rows)/len(open_rows) if open_rows else None}
+    if args.group_by == "task":
+        cells = [{"task": k[0], "track": k[1], "question_type": k[2], **summarize(v)} for k, v in sorted(groups.items())]
+        cells_key = "by_task_track_type"
+    else:
+        cells = [{"label": k[0], "track": k[1], "question_type": k[2], **summarize(v)} for k, v in sorted(groups.items())]
+        cells_key = "by_cell"
+    result={"schema_version":"FWB-FG9-SIX-METRICS-v2-ACC","metrics":["completion_accuracy","macro_f1","evidence_f1","mechanism_alignment","brier_score","gold_linked_support"],
+            "grouping": args.group_by,
+            "overall":summarize(scored),cells_key:cells,
+            "notes":{"direction":"Higher is better except Brier Score, where lower is better.","scope":"Completion Accuracy, Macro-F1 and Brier apply to choice and open. Evidence-F1, Mechanism Alignment and Gold-linked Support apply to open responses only.","completion_accuracy":"For choice, mean Jaccard similarity between predicted and Gold option sets. For open, mean fraction of required fields predicted correctly.","judge":"All six metrics are deterministic; no model judge is used."}}
+    args.output.parent.mkdir(parents=True,exist_ok=True); args.output.write_text(json.dumps(result,ensure_ascii=False,indent=2)+"\n",encoding="utf-8")
+    print(json.dumps(result["overall"],ensure_ascii=False,indent=2))
+
+if __name__ == "__main__": main()

evaluation/FireWorldBench-ICLR/setup.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# 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.
+
+from setuptools import setup
+
+setup(
+    name="fireworldbench",
+    version="0.1.0",
+    description="FireWorldBench: a multimodal benchmark for fire-physics world understanding",
+    long_description=open("README.md", encoding="utf8").read(),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Intended Audience :: Science/Research",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=["requests>=2.31"],
+)