Upload GeoDisasterBenchmark (attempt 1)

.gitattributes

@@ -58,3 +58,97 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/data/core/geodisaster_2921_source_with_splits.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/core/geodisaster_2921_train_source.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_test/ga_eval.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_test/orc_eval.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_train/ga_train.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_train/orc_train.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_train/pa_train.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/sft_train/vra_train.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/test_conversations.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/multi_agent/train_conversations.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/single_agent/test_turns.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/single_agent/train_conversations.jsonl filter=lfs diff=lfs merge=lfs -text
+data/data/single_agent/train_turns.jsonl filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000007/cache/s2/pre_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000029/cache/s2/pre_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000086/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000102/cache/s2/pre_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000105/cache/s2/pre_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000106/cache/s2/pre_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s2/pre_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000113/cache/s2/pre_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s1_grd/s1_00.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s1_grd/s1_03.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s1_grd/s1_06.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s1_grd/s1_09.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s1_grd/s1_11.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s2/post_1.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s2/post_2.tif filter=lfs diff=lfs merge=lfs -text
+data/source_assets/deforestation/000135/cache/s2/post_3.tif filter=lfs diff=lfs merge=lfs -text

data/ATTRIBUTIONS.md

@@ -0,0 +1,500 @@
+# Source Provenance, Citations, and Upstream Terms
+
+Verified against the packaged files and official provider pages on 2026-10-14.
+This document is the source registry for `source_assets/`; it is not legal
+advice and does not replace upstream terms.
+
+## License boundary
+
+The GeoDisaster Project Contributors apply CC-BY-4.0 only to project-authored
+questions, answer schemas, tool chains, documentation, and annotations for
+which they hold the rights. That license does **not** relicense imagery,
+rasters, labels, OSM extracts, CEMS products, or derivatives of upstream data.
+Each upstream source below retains its own terms. Google Earth Engine is an
+access/processing platform, not the copyright source; cite the underlying
+product, not Earth Engine alone.
+
+Status labels used below:
+
+- **verified**: an official provider page states reuse/redistribution terms.
+- **conditional**: reuse is allowed subject to attribution, share-alike,
+  non-commercial, or product-specific conditions that the distributor must
+  satisfy.
+
+## Family-to-source map
+
+| Packaged family | Direct upstream data | Project-derived/support data |
+|---|---|---|
+| `deforestation` | Sentinel-2 SR Harmonized; Sentinel-1 GRD; Hansen GFC v1.13 | RGB previews, annual loss masks, and quality reports derived from those products |
+| `multi_hazard/wildfire` | MCD64A1.061; VNP14A1.002; NIFC WFIGS incident perimeters; Sentinel-2 SR Harmonized; Landsat 8/9 C2 L2; WorldPop; OSM | dNBR and Landsat dNBR; `nifc_perimeter__event` is the clipped/rasterized authoritative incident geometry |
+| `multi_hazard/deforestation` | Hansen GFC v1.13; JRC TMF v1_2023 AnnualChanges; WUR/GFW RADD v1; Sentinel-2 SR Harmonized; WorldPop; OSM | NDVI change; 2022 TMF annual loss; `radd_alerts__event` decodes official `date_conf` alerts inside the declared event window |
+| `multi_hazard/urban_expansion` | Dynamic World V1; GHSL P2023A GHS_BUILT_S; ESA WorldCover v100/v200; Sentinel-2 SR Harmonized; WorldPop; OSM | NDBI change and source-native built-gain masks |
+| `multi_hazard/drought` | CHIRPS Daily; ERA5-Land Daily Aggregated; MOD13Q1.061; VNP21A1D.002; WorldPop; OSM | SPI/NDVI anomalies and drought masks; VNP21 LST is optional context and two QA-empty AOIs are explicitly omitted |
+| `multi_hazard/air_pollution` | Sentinel-5P OFFL L3 NO2/SO2/CO; MCD19A2.061; CAMS NRT total-column NO2; WorldPop; OSM | Train-only S5P quartile footprint and per-source regional-intensity normalization; no WHO or surface-health claim |
+| `routing` | Sentinel-2 L2A; CEMS On-Demand Mapping flood products; OpenStreetMap | OSMnx-derived road graphs, candidate routes, scores, selected routes, and rendered overlays |
+| `sen1_flood` | Sen1Floods11 packaging of Sentinel-1, Sentinel-2, JRC Global Surface Water, and hand labels | Public previews/packaged overlays; LabelHand-derived hidden reference files excluded from agent inputs; current S1-only Otsu runtime outputs |
+| `xbd_damage` | xBD/xView2 imagery and damage labels supplied through the project’s coauthor-managed preparation | Coordinate conversions, grids/quadrants, masks, questions, and deterministic summaries |
+
+## Complete development-snapshot registry
+
+This registry classifies the **10,831 physical files** in the complete internal
+development snapshot. That inventory includes files named directly by the
+canonical records, files reached through a declared sample-directory handle,
+optional context, evaluator-only hidden/reference files, support exports, and
+GDAL `.aux.xml` sidecars. The public thin release contains **9,328** source
+files. Running the pinned Sen1Floods11 hydrator adds exactly 300 execution files
+(100 `S1Hand.tif`, 100 `JRCWaterHand.tif`, and 100 generated
+`S1Portable.tif` files), producing a **9,628-file hydrated execution release**.
+The remaining internal Sen1Floods11 labels, cached derivatives, and hidden
+evaluation products in this table are not public agent inputs.
+
+“Required” and “optional” below refer to unique canonical path declarations;
+“support/internal” means a development-snapshot file is not directly named as
+an initial path. Directory-resolving worker reads are tracked by the
+opened-handle exact-path authorization audit.
+
+| Key | Packaged path family | Physical files | Canonical role | Registered origin |
+|---|---|---:|---|---|
+| D01 | `deforestation/*/cache/s1_grd/*.tif[.aux.xml]` | 245 | 240 required | Sentinel-1 GRD; entry 1 below. XML files are GDAL metadata sidecars. |
+| D02 | `deforestation/*/cache/s2/*.tif[.aux.xml]` | 273 | 267 required | Sentinel-2 L2A; entry 2. |
+| D03 | `deforestation/*/visible/s2_rgb/*.png` | 267 | 267 required | Project render derived from D02. |
+| D04 | `deforestation/*/masks/*.tif[.aux.xml]` | 147 | 144 required | Hansen GFC `lossyear`, annual-loss, and tree-cover products; entry 5. |
+| D05 | `deforestation/*/questions/*.json` | 384 | 384 required | Project-authored questions/schemas; CC-BY-4.0 project layer. |
+| D06 | `deforestation/*/quality_report.json` | 48 | support/internal | Project-generated fetch-time reports derived from D01–D04; runtime recomputation is authoritative. |
+| MH00 | `multi_hazard/<hazard>/<sample>/` | — | 108 required directory handles | Container path for the registered MH01–MH13 children. |
+| MH01 | `multi_hazard/*/*/{aoi,available_handles,metadata}.*` | 324 | 108 required AOIs; remainder support | Project-authored AOI, handle, and acquisition metadata. |
+| MH02 | `multi_hazard/*/*/{questions,gt,trajectories}/*.json` | 1,296 | 432 required questions; remainder internal | Project-authored questions, reference answers, and recorded tool trajectories. |
+| MH03 | `multi_hazard/*/*/quality_report.json` | 108 | support/internal | Project-generated report derived from the registered rasters. |
+| MH04 | `multi_hazard/{drought,air_pollution}/*/baselines/*.csv` | 123 | directory-resolved support | Derived summaries of CHIRPS, ERA5-Land, MOD13Q1, S5P NO2, CAMS AOD, and MODIS MAIAC. |
+| MH05 | `multi_hazard/*/*/osm/pois.geojson` | 108 | directory-resolved support | OpenStreetMap extract; entry 21. |
+| MH06 | `multi_hazard/*/*/panels/*.png` | 432 | 432 required | Project visualizations derived from the corresponding raster, WorldPop, and OSM inputs. |
+| MH07 | `multi_hazard/*/*/tabular/worldpop.{tif,json}` | 216 | 216 required for D | WorldPop 2020 population and provider/source sidecar; entry 20. |
+| MH08 | `multi_hazard/wildfire/*/rasters/*` | 339 | 45 required and 120 optional TIFF paths; JSON/XML support | Sentinel-2, Landsat 8/9, MCD64A1, exact VNP14A1 and NIFC WFIGS perimeter products, and derived NBR/dNBR; entries 2, 11–12, 16, and 11a. |
+| MH09 | `multi_hazard/deforestation/*/rasters/*` | 368 | 92 required and 92 optional TIFF paths; JSON support | Hansen GFC, JRC TMF, Sentinel-2, exact WUR/GFW RADD, and derived NDVI products; entries 2, 5, 6, and 6a. |
+| MH10 | `multi_hazard/urban_expansion/*/rasters/*` | 522 | 261 optional TIFFs; JSON support | Sentinel-2, Dynamic World, GHSL, WorldCover, and derived NDBI/built-gain products; entries 2 and 8–10. |
+| MH11 | `multi_hazard/drought/*/rasters/*` | 206 | 84 required and 19 optional TIFF paths; JSON support | CHIRPS, ERA5-Land, MOD13Q1, exact VNP21A1D where QA-valid, and derived drought products; entries 13, 14, 17, and 18. |
+| MH12 | `multi_hazard/air_pollution/*/rasters/*` | 280 | 80 required and 60 optional TIFF paths; JSON support | Sentinel-5P, MODIS MAIAC, exact CAMS total-column NO2, and derived benchmark-relative NO2 products; entries 4, 15, and 19. |
+| MH13 | `multi_hazard/air_pollution/*/tabular/openaq_*` | 40 | support/internal | OpenAQ empty-query provenance only; entry 23. The CSVs contain headers but no measurements. |
+| MH14 | `multi_hazard/air_pollution/{source_normalization.json,*/normalization.json}` | 21 | 20 required; one support copy | Identical project-authored copies of the train-only normalization contract, declared per sample so isolated evaluation has no undeclared global dependency. |
+| MH15 | `multi_hazard/drought/*/drought_normalization.json` | 21 | 21 required for B/C/D | Identical project-authored copies of the train-only per-source drought quartile contract; no test sample is used to fit it. |
+| R01 | `routing/{train,val,test}.json` | 3 | support exports | Project-authored routing conversations and split records; not upstream data. |
+| R02 | `routing/*/copernicus/flood_extent.geojson` | 200 | 200 required | CEMS On-Demand Mapping; entry 22. |
+| R03 | `routing/*/input/rgb*` | 401 | 400 required; one XML support | Sentinel-2 L2A imagery, project preview, and GDAL sidecar; entry 2. |
+| R04 | `routing/*/input/metadata.json` | 200 | 200 required | Project metadata retaining Sentinel-2 item IDs and CEMS product identifiers. |
+| R05 | `routing/*/derived/*` | 600 | 600 required | OSM+CEMS-derived roads, candidates, and route scores; entries 21–22. |
+| R06 | `routing/*/ground_truth/selected_routes.json` | 200 | 200 required reference | Project selection from the R05 candidate products. |
+| R07 | `routing/*/overlays/routes_overlay.png` | 200 | 200 required | Project render derived from Sentinel-2, OSM, CEMS, and R05. |
+| S01 | `sen1_flood/*/{labels/S1Hand.tif[.aux.xml],derived/S1Portable.tif}` | 201 | 100 portable derivatives required; 100 official source TIFFs retained plus one sidecar | Sen1Floods11 Sentinel-1 chip and value-preserving finite-nodata derivative; parent entry 24 and Sentinel entry 1. |
+| S02 | `sen1_flood/*/labels/JRCWaterHand.tif[.aux.xml]` | 101 | 100 optional | Sen1Floods11-packaged JRC Global Surface Water context; entries 7 and 24. |
+| S03 | `sen1_flood/*/labels/LabelHand.tif[.aux.xml]` | 101 | support/internal, forbidden as answer input | Sen1Floods11 human flood labels; entry 24. |
+| S04 | `sen1_flood/*/labels/S1OtsuLabelHand.tif[.aux.xml]` | 101 | support/internal, forbidden as answer input | Cached Sen1Floods11 Otsu derivative of S01; entry 24. |
+| S05 | `sen1_flood/*/public/*.png` | 399 | 299 optional; 100 packaged overlays internal | Source-derived S1/S2/JRC previews plus packaged overlays; entries 1, 3, 7, and 24. The current renderer generates separate run artifacts from the current prediction handle. |
+| S06 | `sen1_flood/*/hidden/*` | 600 | hidden/internal, forbidden as answer input | Project-generated binary masks, vectors, grids, components, and reports derived from Sen1Floods11 `LabelHand`, not from the current S1-only prediction. |
+| X01 | `xbd_damage/*/{pre,post}.png` | 458 | 177 required and 281 optional paths | xBD/xView2 imagery; entry 25. |
+| X02 | `xbd_damage/*/post_target.png` | 177 | 177 required; 52 additional optional paths explicitly absent | Mask rendering derived from xBD damage labels; entry 25. |
+| X03 | `xbd_damage/*/building_damage_{xy,lnglat}.geojson` | 458 | 229 required and 229 optional | xBD damage polygons and project coordinate conversion; entry 25. |
+| X04 | `xbd_damage/*/{grid_4x4,quadrants}.geojson` | 458 | 458 optional | Project-generated geometry derived from X01/X03 extents. |
+
+The reproducible check is `release_tools/audit_c01_source_registry.py`. It is
+check-only unless `--output` is supplied. `--mode thin` validates the public
+archive before hydration; `--mode hydrated` requires the complete pinned
+execution subset. The retained development-snapshot evidence is
+`release_tools/evidence/source_asset_registry_development_snapshot.json`; it
+reports zero unclassified physical files, zero unclassified referenced paths,
+zero missing required paths, zero outside-repository paths, zero
+`exists`-flag mismatches, and zero uncited direct raster-sidecar source labels
+for the complete 10,831-file internal snapshot.
+
+## Product-by-product registry
+
+### Copernicus satellite products
+
+1. **Sentinel-1 GRD — `COPERNICUS/S1_GRD`.** Used for deforestation SAR
+   stacks and as the original SAR source inside
+   Sen1Floods11. Packaged patterns include
+   `source_assets/deforestation/*/cache/s1_grd/*.tif`,
+   and `source_assets/sen1_flood/*/labels/S1Hand.tif`. Product description and
+   processing: [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S1_GRD).
+   Terms: Copernicus Sentinel Data Terms and Conditions; modified data must
+   carry the required Copernicus notice. **Status: conditional.**
+
+2. **Sentinel-2 Level-2A surface reflectance —
+   `COPERNICUS/S2_SR_HARMONIZED`.** Used for deforestation optical stacks,
+   multi-hazard RGB/NBR/NDVI/NDBI inputs, routing RGB mosaics, and their
+   derived indices. Packaged patterns include
+   `source_assets/deforestation/*/cache/s2/*.tif`, all
+   `source_assets/multi_hazard/*/*/rasters/s2_*`, and
+   `source_assets/routing/*/input/rgb*`. Routing metadata records the exact
+   mosaic item IDs and acquisition dates per sample. Product description:
+   [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_SR_HARMONIZED).
+   Terms: Copernicus Sentinel Data Terms and Conditions. **Status:
+   conditional.**
+
+3. **Sentinel-2 Level-1C top-of-atmosphere imagery.** Sen1Floods11 documents
+   its optional S2 chips as L1C. The packaged pattern is
+   `source_assets/sen1_flood/*/public/s2_rgb_optional.png`. L1C reference:
+   [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S2_HARMONIZED).
+   Terms: Copernicus Sentinel Data Terms and Conditions. **Status:
+   conditional.**
+
+4. **Sentinel-5P/TROPOMI OFFL L3 NO2, SO2, and CO —
+   `COPERNICUS/S5P/OFFL/L3_NO2`, `COPERNICUS/S5P/OFFL/L3_SO2`, and
+   `COPERNICUS/S5P/OFFL/L3_CO`.** Used in
+   `source_assets/multi_hazard/air_pollution/*/rasters/s5p_*`. Product pages:
+   [NO2](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S5P_OFFL_L3_NO2),
+   [SO2](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S5P_OFFL_L3_SO2), and
+   [CO](https://developers.google.com/earth-engine/datasets/catalog/COPERNICUS_S5P_OFFL_L3_CO).
+   Terms: Copernicus Sentinel Data Terms and Conditions. **Status:
+   conditional.**
+
+### Forest, water, land-cover, and settlement products
+
+5. **Hansen/UMD Global Forest Change v1.13 (2000–2025) —
+   `UMD/hansen/global_forest_change_2025_v1_13`.** `treecover2000` and
+   `lossyear` supply `source_assets/deforestation/*/masks/*` and the
+   multi-hazard Hansen/forest-mask handles. Official product, citation, and
+   CC-BY-4.0 terms:
+   [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/UMD_hansen_global_forest_change_2025_v1_13),
+   including Hansen et al. (2013), DOI
+   [10.1126/science.1244693](https://doi.org/10.1126/science.1244693).
+   **Status: verified; attribution required.**
+
+6. **JRC Tropical Moist Forest v1_2023 —
+   `projects/JRC/TMF/v1_2023/AnnualChanges`.** The December 2021 and December
+   2022 annual-state bands are differenced for class 3 (deforestation) to build
+   the event-aligned 2022
+   `source_assets/multi_hazard/deforestation/*/rasters/tmf_loss__event.*` masks.
+   Official access, license, and citation instructions:
+   [JRC TMF data access](https://forobs.jrc.ec.europa.eu/TMF/data) and
+   [JRC citation guidance](https://forobs.jrc.ec.europa.eu/TMF/resources).
+   Required map attribution: “Source: EC JRC”; cite Vancutsem et al. (2021).
+   **Status: verified; attribution required.**
+
+6a. **RADD Forest Disturbance Alerts v1 — WUR/GFW.** The official `date_conf`
+    tiles supply `radd_alerts__event`; values are decoded into event-window
+    low/high-confidence classes plus a separate binary mask. The source contract pins
+    the GFW archive version `v20261011`; the Earth Engine source identifier is
+    `projects/radar-wur/raddalert/v1`. Product description, method, and
+    access: [Wageningen University RADD](https://www.wur.nl/en/research/products-services/radd-forest-disturbance-alert).
+    The packaged source contract records CC BY 4.0. **Status: verified;
+    attribution required.**
+
+7. **JRC Global Surface Water.** The `occurrence` layer appears in
+   `source_assets/sen1_flood/*/labels/JRCWaterHand.tif` as known-water context.
+   Official terms and citation:
+   [JRC Global Surface Water data access](https://global-surface-water.appspot.com/download),
+   including Pekel et al. (2016), DOI
+   [10.1038/nature20584](https://doi.org/10.1038/nature20584). Required map
+   attribution: “Source: EC JRC/Google.” **Status: verified; attribution
+   required.**
+
+8. **Dynamic World V1 — `GOOGLE/DYNAMICWORLD/V1`.** Used by
+   `source_assets/multi_hazard/urban_expansion/*/rasters/dynamic_world_built__*`.
+   Official product, CC-BY-4.0 terms, required attribution, and paper citation:
+   [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/GOOGLE_DYNAMICWORLD_V1),
+   Brown et al. (2022), DOI
+   [10.1038/s41597-022-01307-4](https://doi.org/10.1038/s41597-022-01307-4).
+   **Status: verified; attribution required.**
+
+9. **Global Human Settlement Layer P2023A —
+   `JRC/GHSL/P2023A/GHS_BUILT_S`.** Used by
+   `source_assets/multi_hazard/urban_expansion/*/rasters/ghsl_built__*` for the
+   2020 and 2025 epochs. Official product and reuse terms:
+   [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/JRC_GHSL_P2023A_GHS_BUILT_S).
+   Reuse is authorized when EC JRC/GHSL is acknowledged. **Status: verified;
+   attribution required.**
+
+10. **ESA WorldCover 10 m 2020 v100 and 2021 v200 —
+    `ESA/WorldCover/v100` and `ESA/WorldCover/v200`.** Class 50 supplies the
+    source-native pre/post masks used to derive `worldcover_built_gain`.
+    Official products, CC-BY-4.0 terms, and citation:
+    [2020 Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/ESA_WorldCover_v100),
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/ESA_WorldCover_v200),
+    Zanaga et al. (2022), DOI
+    [10.5281/zenodo.7254221](https://doi.org/10.5281/zenodo.7254221).
+    **Status: verified; attribution required.**
+
+### NASA/USGS fire, vegetation, temperature, aerosol, and Landsat products
+
+11. **MODIS MCD64A1.061 burned area — `MODIS/061/MCD64A1`.** Supplies
+    `mcd64a1__event`. Official product, unrestricted
+    redistribution statement, and DOI:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MCD64A1),
+    [10.5067/MODIS/MCD64A1.061](https://doi.org/10.5067/MODIS/MCD64A1.061).
+    **Status: verified; cite NASA LP DAAC.**
+
+11a. **NIFC WFIGS Interagency Fire Perimeters.** Supplies
+    `nifc_perimeter__event` for the named 2021 Dixie and Bootleg incidents.
+    Exact incident features are clipped to each AOI and rasterized; this is not
+    an EFFIS product or an MCD64 dilation. The service layer identifier is
+    `WFIGS_Interagency_Perimeters/FeatureServer/0`. Authoritative ArcGIS item and its
+    no-warranty/appropriate-use notice:
+    [WFIGS Interagency Fire Perimeters](https://www.arcgis.com/home/item.html?id=5e72b1699bf74eefb3f3aff6f4ba5511).
+    **Status: verified public authoritative item; retain the NIFC disclaimer.**
+
+12. **VIIRS VNP14A1.002 active fire — `NASA/VIIRS/002/VNP14A1`.** Supplies
+    `viirs_active_fire__event`. Sidecars record the official 1 km native grid
+    separately from the 128x128 nearest-neighbor benchmark export; users must
+    not interpret resampling as new native resolution. Official
+    product, terms, and DOI:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/NASA_VIIRS_002_VNP14A1),
+    [10.5067/VIIRS/VNP14A1.002](https://doi.org/10.5067/VIIRS/VNP14A1.002).
+    **Status: verified; citation requested.**
+
+13. **MODIS MOD13Q1.061 vegetation indices — `MODIS/061/MOD13Q1`.** Supplies
+    the multi-hazard drought NDVI input/anomaly. Official product and LP DAAC
+    terms:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MOD13Q1).
+    **Status: verified; cite NASA LP DAAC.**
+
+14. **VIIRS VNP21A1D.002 Day LST and Emissivity Daily 1 km —
+    `NASA/VIIRS/002/VNP21A1D`.** Supplies optional `viirs_lst__target` context.
+    The builder masks mandatory-QA, data-quality, and cloud bits uniformly and
+    uses a 32-day median with nearest-neighbor export. Two AOIs have no
+    QA-valid pixel and therefore omit the optional handle rather than using a
+    proxy. Official product and terms:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/NASA_VIIRS_002_VNP21A1D).
+    **Status: verified; cite NASA LP DAAC.**
+
+15. **MODIS MAIAC MCD19A2.061 AOD —
+    `MODIS/061/MCD19A2_GRANULES`.** Supplies `modis_aod__peak`. Official
+    product and LP DAAC terms:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/MODIS_061_MCD19A2_GRANULES).
+    **Status: verified; cite NASA LP DAAC.**
+
+16. **USGS Landsat 8 and 9 Collection 2 Tier 1 Level 2 —
+    `LANDSAT/LC08/C02/T1_L2` and `LANDSAT/LC09/C02/T1_L2`.** Supplies the
+    wildfire Landsat NBR and derived dNBR. Official product:
+    [Landsat 8 catalog](https://developers.google.com/earth-engine/datasets/catalog/LANDSAT_LC08_C02_T1_L2).
+    USGS states there are no use or redistribution restrictions and requests a
+    source statement:
+    [USGS redistribution FAQ](https://www.usgs.gov/faqs/are-there-any-restrictions-use-or-redistribution-landsat-data).
+    **Status: verified; acknowledge USGS.**
+
+### Climate, atmosphere, population, and map data
+
+17. **CHIRPS Daily — `UCSB-CHG/CHIRPS/DAILY`.** Supplies rainfall used to
+    compute the same-window SPI/z-score. Official public-domain terms and
+    citation:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/UCSB-CHG_CHIRPS_DAILY),
+    Funk et al. (2015), DOI
+    [10.1038/sdata.2015.66](https://doi.org/10.1038/sdata.2015.66).
+    **Status: verified.**
+
+18. **ERA5-Land Daily Aggregated — `ECMWF/ERA5_LAND/DAILY_AGGR`.** Supplies
+    layer-1 volumetric soil water for drought cases. Official product and
+    required Copernicus acknowledgement:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/ECMWF_ERA5_LAND_DAILY_AGGR).
+    **Status: conditional; attribution required.**
+
+19. **CAMS Global Near-Real-Time — `ECMWF/CAMS/NRT`.** The packaged
+    `cams_no2__peak` uses `total_column_nitrogen_dioxide_surface` in kg m-2;
+    no AOD substitution or invented conversion is used. Official product and
+    Copernicus attribution terms:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/ECMWF_CAMS_NRT).
+    **Status: verified; attribution required.**
+
+20. **WorldPop Global Project 100 m population —
+    `WorldPop/GP/100m/pop`, 2020 clips.** Supplies
+    `source_assets/multi_hazard/*/*/tabular/worldpop.tif`. Official product,
+    CC-BY-4.0 terms, and citation:
+    [Earth Engine catalog](https://developers.google.com/earth-engine/datasets/catalog/WorldPop_GP_100m_pop).
+    **Status: verified; clear WorldPop attribution required.**
+
+21. **OpenStreetMap.** Supplies multi-hazard POIs and routing road/shelter
+    data, including `source_assets/multi_hazard/*/*/osm/pois.geojson` and the
+    OSM-derived properties in `source_assets/routing/*/derived/*`. Terms and
+    required notice:
+    [OpenStreetMap copyright and licence](https://www.openstreetmap.org/copyright).
+    Use “© OpenStreetMap contributors” and disclose ODbL; assess whether a
+    released derived database triggers share-alike obligations. **Status:
+    conditional (ODbL 1.0).**
+
+22. **Copernicus Emergency Management Service On-Demand Mapping.** Supplies
+    `source_assets/routing/*/copernicus/flood_extent.geojson`. Each routing
+    sample records its `activation_code`, `product_type`, `product_id`, and
+    `product_key` in `input/metadata.json`. CEMS permits reproduction,
+    distribution, public communication, adaptation, and combination subject
+    to its terms and citation guidelines:
+    [CEMS terms and conditions](https://mapping.emergency.copernicus.eu/terms-and-conditions/).
+    **Status: conditional; CEMS source citation required and restricted
+    products must be excluded.**
+
+23. **OpenAQ v3.** Construction queried OpenAQ, but all accepted air-pollution
+    AOIs contain zero target-window measurements: `openaq_stations.csv` is
+    header-only and `openaq_status.json` records
+    `completed_no_window_measurements`. OpenAQ contributes provenance of the
+    empty query only, not analytical evidence or answer values. Official terms:
+    [OpenAQ terms of use](https://docs.openaq.org/about/terms). **Status: no
+    measurement payload bundled; do not cite OpenAQ as answer evidence.**
+
+### Parent benchmark datasets
+
+24. **Sen1Floods11 v1.1.** The 100 packaged flood samples retain S1, optional
+    S2/JRC views, and hand/cached labels from the structure documented by the
+    original project. The required dataset citation is Bonafilia, D., Tellman,
+    B., Anderson, T., and Issenberg, E. (2020), “Sen1Floods11: A Georeferenced
+    Dataset to Train and Test Deep Learning Flood Algorithms for Sentinel-1,”
+    *IEEE/CVF CVPR Workshops*, pp. 210–211. Use the
+    [official Cloud to Street GitHub repository and data-access instructions](https://github.com/cloudtostreet/Sen1Floods11)
+    together with the
+    [official CVPR paper](https://openaccess.thecvf.com/content_CVPRW_2020/html/w11/Bonafilia_Sen1Floods11_A_Georeferenced_Dataset_to_Train_and_Test_Deep_Learning_CVPRW_2020_paper.html).
+    The upstream repository provides a public bucket and citation but does not
+    declare an explicit dataset `LICENSE` file. The Apache-2.0 license in the
+    separate EOEPCA mirror is not treated as authority for Cloud to Street’s
+    original data. The public package therefore excludes the Sen1Floods11
+    payload and supplies the checksum-pinned upstream hydrator described
+    below. Redistributing those files instead requires written permission or
+    an authoritative dataset license.
+
+25. **xBD / xView2.** All `source_assets/xbd_damage/*` pre/post images and
+    damage polygons originate from xBD. Their intermediate preparation was
+    performed within this project by a coauthor and is not an external data
+    source, so that internal package is intentionally not cited. Cite Gupta et
+    al. (2019), DOI
+    [10.48550/arXiv.1911.09296](https://doi.org/10.48550/arXiv.1911.09296), the
+    [official xBD dataset page](https://xview2.org/dataset), and the
+    [CMU Software Engineering Institute xView2 project](https://www.sei.cmu.edu/projects/xview-2-challenge/).
+    CMU/SEI states that xBD is available for public use under a Creative
+    Commons license; its official
+    [xView2 imagery credit](https://insights.sei.cmu.edu/annual-reviews/2020-year-in-review/wildfire-response-tests-xview2-damage-assessment-prototype/)
+    identifies the raw imagery as CC BY-NC 4.0. Preserve attribution and
+    non-commercial restrictions for xBD imagery and derivatives, and do not
+    represent them as CC-BY-4.0.
+    **Status: conditional and documented; no undeclared third-party mirror is
+    part of the provenance chain.**
+
+## Sen1Floods11 download and local placement
+
+The development workspace retains its Sen1Floods11 files for the reproducible
+2,921-record replay. The public distribution contract is a thin package: it
+excludes the packaged `source_assets/sen1_flood/` payload, and users hydrate
+the selected inputs directly from the official Cloud to Street bucket.
+
+Official references:
+
+- Repository, citation, and access instructions:
+  [cloudtostreet/Sen1Floods11](https://github.com/cloudtostreet/Sen1Floods11)
+- Official bucket root: `gs://sen1floods11/v1.1/`
+- Upstream S1 folder:
+  `gs://sen1floods11/v1.1/data/flood_events/HandLabeled/S1Hand/`
+- Upstream JRC folder:
+  `gs://sen1floods11/v1.1/data/flood_events/HandLabeled/JRCWaterHand/`
+
+Only 100 selected chips are used. The installer downloads 200 official
+GeoTIFFs: one `S1Hand` raster for each chip, plus one `JRCWaterHand` raster for
+the D/E known-water comparison tasks. It then generates the 100 portable S1
+runtime derivatives. The resulting layout is:
+
+```text
+source_assets/sen1_flood/<chip_id>/labels/S1Hand.tif
+source_assets/sen1_flood/<chip_id>/labels/JRCWaterHand.tif
+source_assets/sen1_flood/<chip_id>/derived/S1Portable.tif
+```
+
+The upstream filenames include the chip ID, whereas the benchmark-local names
+do not. For example:
+
+```text
+gs://sen1floods11/v1.1/data/flood_events/HandLabeled/S1Hand/Bolivia_103757_S1Hand.tif
+  -> source_assets/sen1_flood/Bolivia_103757/labels/S1Hand.tif
+
+gs://sen1floods11/v1.1/data/flood_events/HandLabeled/JRCWaterHand/Bolivia_103757_JRCWaterHand.tif
+  -> source_assets/sen1_flood/Bolivia_103757/labels/JRCWaterHand.tif
+```
+
+From the repository root, the supported installer hydrates exactly the pinned
+100-chip subset over the official bucket's public HTTPS endpoint. It downloads
+atomically and accepts a file only when both its byte size and SHA-256 match
+the pinned manifest:
+
+```bash
+# Inspect the plan without writing files.
+python3 release_tools/fetch_sen1floods11_subset.py --dry-run
+
+# Download missing files, retaining already verified files.
+python3 release_tools/fetch_sen1floods11_subset.py
+
+# Verify an existing installation without network access.
+python3 release_tools/fetch_sen1floods11_subset.py --verify-only
+```
+
+The installer is `release_tools/fetch_sen1floods11_subset.py`; its immutable
+selection, official source URLs, local destinations, sizes, and checksums are
+in `release_tools/manifests/sen1floods11_required_100.json`. It refuses to
+overwrite a mismatched existing file unless the user explicitly supplies
+`--replace-mismatched`. After verifying an official S1 file, it creates or
+validates `S1Portable.tif` by replacing only non-finite/declared-nodata pixels
+with `-9999.0`; valid values and georeferencing are unchanged. The manifest is
+bound to canonical dataset SHA-256
+`03988b960e6b09ae01fb622fe45b35d763eb705485cddc3cea68bcac7ae63fe1`, so a
+changed canonical file requires an explicit manifest update rather than silently changing the
+download selection.
+
+For transparency, this is the equivalent unpinned `gsutil` procedure. The
+manifest-backed installer above is preferred because this loop does not check
+integrity:
+
+```bash
+for chip_id in $(python3 -c 'import json; print(" ".join(sorted({r["sample_id"] for r in map(json.loads, open("data/core/geodisaster_2921_source_with_splits.jsonl")) if r["id"].startswith("sen1_flood/")})))'); do
+  mkdir -p "source_assets/sen1_flood/${chip_id}/labels"
+  gsutil cp \
+    "gs://sen1floods11/v1.1/data/flood_events/HandLabeled/S1Hand/${chip_id}_S1Hand.tif" \
+    "source_assets/sen1_flood/${chip_id}/labels/S1Hand.tif"
+  gsutil cp \
+    "gs://sen1floods11/v1.1/data/flood_events/HandLabeled/JRCWaterHand/${chip_id}_JRCWaterHand.tif" \
+    "source_assets/sen1_flood/${chip_id}/labels/JRCWaterHand.tif"
+done
+```
+
+The current benchmark does **not** require users to download `LabelHand`,
+`S1OtsuLabelHand`, hidden reference products, prepared overlays, or Sentinel-2
+chips. `LabelHand`, cached Otsu labels, and `hidden/*` are forbidden answer
+inputs. Cached Otsu files are explicitly excluded by
+`release_tools/manifests/c10_excluded_legacy_rasters.json`. Public S1/JRC
+previews may be generated locally but are not analytical inputs. The official
+selected S1+JRC download is approximately 157 MiB; generated portable S1 files
+add approximately 145 MiB locally.
+
+The public-release builder enforces this contract:
+
+1. All 1,503 development files below `source_assets/sen1_flood/` are excluded
+   from the published archive; the complete development snapshot is preserved.
+2. The installer and pinned 100-chip checksum manifest are bound to the
+   canonical dataset SHA-256.
+3. `JRCWaterHand` is a required declared input for D/E; A/B/C do not receive
+   that handle.
+4. Optional previews not regenerated by the installer are not required agent
+   inputs.
+5. A hydrated release must pass the source-registry/path audit and complete
+   500-question Sen1 replay before upload.
+
+## Project-derived and software-only items
+
+- Raster indices, threshold masks, panels, grids, polygons, route scores,
+  reports, and overlays are transformations or combinations of the applicable
+  inputs above. Their provenance is inherited; project authorship does not
+  erase upstream conditions.
+- The source contracts use `nifc_perimeter__event`, `radd_alerts__event`,
+  `viirs_lst__target`, `cams_no2__peak`, and `viirs_active_fire__event`
+  sidecars identify the exact products, bands, physical units, native
+  resolutions, transformations, and checksums. Air-pollution classes are
+  benchmark-relative column/intensity states, not WHO or health categories.
+- OSMnx is software used to create routing products, not a data source. Cite
+  Boeing (2025), DOI [10.1111/gean.70009](https://doi.org/10.1111/gean.70009);
+  OSMnx itself is MIT licensed. See the
+  [official documentation](https://osmnx.readthedocs.io/en/stable/).
+- Google Earth Engine is the processing/access platform for many cached
+  products. Its use does not replace any product-specific citation or terms.
+- The project-authored JSONL records, questions, schemas, and chains may be
+  CC-BY-4.0, but a mixed-source archive containing `source_assets/` must use a
+  mixed/custom license declaration and ship this registry.
+
+## Release licensing requirements
+
+xBD provenance is attributed to the original xBD/xView2 sources, while the
+coauthor-managed preparation is treated as an internal project transformation.
+The public package uses the Sen1Floods11 thin-release procedure above unless
+an explicit redistribution license is obtained. Every release must also
+retain the required upstream notices and apply the ODbL requirements to any
+released routing or POI databases.

data/README.md

@@ -0,0 +1,289 @@
+---
+license: other
+language:
+- en
+pretty_name: GeoDisaster Agentic 2921 (Multi-Agent + Single-Agent Tool-Use Chains)
+tags:
+- geospatial
+- remote-sensing
+- disaster-response
+- earth-observation
+- tool-use
+- agentic
+- multi-agent
+- single-agent
+- supervised-fine-tuning
+- reasoning-chains
+task_categories:
+- question-answering
+- image-text-to-text
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: evaluation_inputs
+  data_files:
+  - split: test
+    path: data/core/geodisaster_2921_test_inputs.jsonl
+- config_name: multi_agent
+  data_files:
+  - split: train
+    path: data/multi_agent/train_conversations.jsonl
+  - split: test
+    path: data/multi_agent/test_conversations.jsonl
+- config_name: single_agent
+  data_files:
+  - split: train
+    path: data/single_agent/train_conversations.jsonl
+  - split: test
+    path: data/single_agent/test_reference_conversations.jsonl
+- config_name: single_agent_sft
+  data_files:
+  - split: train
+    path: data/single_agent/train_turns.jsonl
+  - split: test
+    path: data/single_agent/test_turns.jsonl
+- config_name: multi_agent_sft_orc
+  data_files:
+  - split: train
+    path: data/multi_agent/sft_train/orc_train.jsonl
+  - split: test
+    path: data/multi_agent/sft_test/orc_eval.jsonl
+- config_name: multi_agent_sft_ga
+  data_files:
+  - split: train
+    path: data/multi_agent/sft_train/ga_train.jsonl
+  - split: test
+    path: data/multi_agent/sft_test/ga_eval.jsonl
+- config_name: multi_agent_sft_pa
+  data_files:
+  - split: train
+    path: data/multi_agent/sft_train/pa_train.jsonl
+  - split: test
+    path: data/multi_agent/sft_test/pa_eval.jsonl
+- config_name: multi_agent_sft_vra
+  data_files:
+  - split: train
+    path: data/multi_agent/sft_train/vra_train.jsonl
+  - split: test
+    path: data/multi_agent/sft_test/vra_eval.jsonl
+- config_name: core
+  data_files:
+  - split: train
+    path: data/core/geodisaster_2921_train_source.jsonl
+  - split: test
+    path: data/core/geodisaster_2921_test_source.jsonl
+---
+
+# GeoDisaster Agentic 2921
+
+Ground-truth **agentic tool-use chains** for geospatial disaster analysis: **2,921 tasks**, each a
+question grounded in real Earth-observation artifacts (optical/SAR imagery, forest masks, hazard
+rasters, building-damage polygons, routing graphs), solved end-to-end by a tool-using agent — in
+**two settings**:
+
+- **single-agent** — one agent plans + calls tools itself.
+- **multi-agent** — orchestrator **ORC** delegates to specialists **GA / PA / VRA**.
+
+**2,921 tasks** (train 2,629 / test 292) · **43 question types** · 5 families:
+`deforestation`, `multi_hazard`, `xbd_damage`, `routing`, `sen1_flood`.
+
+## IDs & paths
+
+Each record has `id` = `"<family>/<sample>/<question_type>"` (e.g.
+`deforestation/000086/multi_year_loss_attribution`) — the key that links the same task across all
+forms — plus `sample_id` and `question_type`. Artifacts live at `source_assets/<family>/<sample>/…`.
+
+## Tool ownership
+
+| Role | Tools |
+|---|---|
+| **ORC** | plans & delegates (no tools) |
+| **GA** | ReadData, PrepareScene, MeasureArea, ExtractObjects, MapFlood, RenderMap |
+| **PA** | ComputeStats, CompareSources, DetectChange, ClassifyChange, ScoreHazard, EstimateExposure, RankRegions, PlanRoutes, CompareRoutes |
+| **VRA** | AssessDamage, DescribeFlood, CompareScenes |
+
+## Files & forms
+
+```
+data/
+  core/        geodisaster_2921_{train,test}_source.jsonl   # evaluator/reference task specs
+               geodisaster_2921_test_inputs.jsonl           # gold-free agent-visible test view
+  single_agent/
+    {train_conversations,test_reference_conversations}.jsonl  # full episodes
+    {train_turns,test_turns}.jsonl                            # per-turn SFT rows
+    single_agent_system_prompt.md
+  multi_agent/
+    {train,test}_conversations.jsonl                          # full ORC↔GA/PA/VRA episodes
+    sft_{train,test}/{orc,ga,pa,vra}_{train,eval}.jsonl       # weighted per-role SFT rows
+    tool_ownership_and_prompt_context.md
+source_assets/   bundled inputs; pinned installer hydrates Sen1Floods11 execution inputs
+user-guide-final.md  authoritative benchmark, runtime, release, and 43-type guide
+ATTRIBUTIONS.md  upstream sources & licenses
+SHA256SUMS      integrity manifest for the distributable thin archive
+```
+
+`SHA256SUMS` deliberately excludes locally hydrated
+`source_assets/sen1_flood/` files. Those 300 files are verified against the
+pinned upstream manifest by the hydrator itself.
+
+Read `user-guide-final.md` for the complete current contract. It is the sole
+task, interpretation, runtime, and release guide included in the package.
+
+The same 2,921 tasks come in three forms: **core** (task spec + GT toolchain + answer),
+**conversation** (full episode: question → turns → answer), **turns** (the episode sliced to one
+assistant target per row, for SFT). All files are JSONL (one record per line).
+
+The release contains 2,629 train and 292 test tasks in each full agent form. Its turn-level
+training projections contain 35,195 multi-agent role rows and 20,453 single-agent rows (55,648
+total). All 5,842 terminal targets use the same reference-only action contract.
+
+The only multi-agent role-SFT locations are `data/multi_agent/sft_train/` and
+`data/multi_agent/sft_test/`. Every conversation and SFT row carries the shared
+`id`, `sample_id`, and `question_type` identity fields. Packaged inputs use
+repository-relative paths; non-distributed replay outputs, when mentioned in
+teacher evidence, use portable `generated-artifact://` logical locators.
+
+In the 500 Sen1Floods11 records, `exists: true` describes the hydrated
+execution contract. The thin public archive intentionally lacks the exact 200
+manifest-declared S1/JRC source paths until the pinned installer downloads and
+verifies them and generates the 100 portable execution rasters.
+
+## Dataset structure (fields per record)
+
+**Shared (all files):** `id` (string, unique linking key) · `sample_id` (string) ·
+`question_type` (string).
+
+**`data/multi_agent/{train,test}_conversations.jsonl`** — one full episode:
+
+| Field | Type | Meaning |
+|---|---|---|
+| `raw_question` | string | plain question used to construct active ORC/specialist prompts |
+| `question` | string | stored evaluator/display context: question + declared input handles + answer schema; executable prompts use `raw_question` plus sanitized handle cards and keep the schema runtime-side |
+| `initial_artifacts` | object | handle cards `{path,label,exists,optional}`; lists each file once |
+| `available_initial_handles` | list | handle names the task exposes |
+| `plan` | object | ORC plan `{goal, steps:[{id,agent,subtask,needs}]}` |
+| `multiagentic_gt_chain` | list | turn-by-turn episode (USER↔ORC↔GA/PA/VRA) with actions + observations |
+| `executions` | list | per-step `{action, tool_output}` log |
+| `expected_final_answer` | object | canonical audit copy; core JSONL is authoritative |
+| `final_answer_ref` | string | terminal transport token, always `ANSWER_JSON:answer_1` |
+| `resolved_final_answer` | object | schema-valid worker projection resolved by the runtime |
+| `resolved_answer_sha256` | string | canonical-JSON checksum linking derived exports |
+| `resolved_answer_provenance` | string | whether the export retained full worker evidence or used its validated compact-trace cache |
+| `answer_support` | object | supporting evidence metadata |
+| `pure_toolchain_sim_status` | string | replay status |
+
+**`data/single_agent/{train_conversations,test_reference_conversations}.jsonl`:** `messages`
+(chat turns `{role,content}`), `tool_sequence` (list), `final_answer_ref`, and
+`resolved_answer_sha256` linking the corresponding verified multi-agent payload.
+
+**`data/single_agent/{train_turns,test_turns}.jsonl`** (SFT): `messages` (context → one assistant
+target), `kind`, `assistant_action`, `assistant_turn_index`.
+
+**`data/multi_agent/sft_{train,test}/...jsonl`** (SFT): `messages`, `role`, `step_id`,
+`turn_no`, `kind`.
+
+**`data/core/..._source.jsonl`:** `question` (obj), `initial_artifacts`, `available_initial_handles`,
+`gt_chain` (canonical tool sequence), `expected_final_answer`, `source_replay`, `path_summary`,
+`split_seed`.
+
+**Splits:** train 2,629 / test 292 per form. They are disjoint by `id`, source
+sample, declared path, normalized routing content, and exact complete
+model-visible single-agent trajectory. Exact episodes retained within one
+split use inverse complete-trajectory multiplicity in `training_weight`.
+
+## Public-reference evaluation isolation
+
+Use `data/core/geodisaster_2921_test_inputs.jsonl` as the only test-record file
+visible to an evaluated agent. The canonical, `test_source`, multi-agent test
+conversations, and single-agent test-reference files contain evaluator targets
+and must remain evaluator-side.
+
+For filesystem isolation, build a fresh root containing only the 292 test
+records and their permitted inputs:
+
+```bash
+python3 release_tools/build_isolated_test_bundle.py --output /path/outside/repository/eval_bundle
+export GEODISASTER_DATASET_ROOT=/path/outside/repository/eval_bundle
+export GEODISASTER_STRICT_DATA_ROOT=1
+```
+
+The builder rejects private path declarations, omits `gt/`, `ground_truth/`,
+`hidden/`, and trajectory products when a declared input is a directory, and
+writes a SHA-256 file manifest. Strict runtime mode disables fallback searches
+through the development repository. Keep gold scoring in a separate evaluator
+process or mount; never mount the repository root into the agent/tool sandbox.
+
+## Example instances
+
+Core (task spec):
+```json
+{"id":"deforestation/000086/multi_year_loss_attribution","sample_id":"000086",
+ "question_type":"multi_year_loss_attribution",
+ "question":{"handle":"question_1","text":"… identify the year with the largest forest loss …"},
+ "initial_artifacts":{"forest_loss_history_1":{"handle":"forest_loss_history_1","type":"forest_loss_history","paths":{"…":[{"path":"source_assets/deforestation/000086/masks/lossyear.tif","label":"lossyear.tif","exists":true,"optional":false}]}}},
+ "gt_chain":[{"tool":"ReadData","args":{"input":"forest_loss_history_1"}},{"tool":"ComputeStats","args":{}}],
+ "expected_final_answer":{"year":2016,"loss_ha":201.039833}}
+```
+
+Single-agent conversation:
+```json
+{"id":"deforestation/000086/multi_year_loss_attribution","sample_id":"000086","question_type":"multi_year_loss_attribution",
+ "tool_sequence":["ReadData","PrepareScene","ComputeStats","DetectChange"],
+ "messages":[{"role":"system","content":"You are a single geospatial-disaster tool-use agent. …"},
+   {"role":"user","content":"QUESTION …\n\nAVAILABLE INPUT HANDLES\n- forest_loss_history_1: …"},
+   {"role":"assistant","content":"{\"thought\":\"…\",\"action\":{\"tool\":\"ReadData\",\"args\":{\"input\":\"forest_loss_history_1\"}}}"},
+   {"role":"assistant","content":"{\"thought\":\"…\",\"action\":{\"tool\":\"FinalAnswer\",\"answer_ref\":\"ANSWER_JSON:answer_1\"}}"}]}
+```
+
+Multi-agent: same `id`, plus `plan`, `multiagentic_gt_chain` (USER/ORC/GA/PA/VRA turns), `executions`,
+`final_answer_ref`, `resolved_final_answer`, and `expected_final_answer`. Every role-SFT row carries
+the exact system-prompt snapshot used for that target. The standalone single-agent prompt and the
+multi-agent role/tool context are also included with the data; executable prompt builders live in
+the code repository and are authoritative at inference.
+
+The reference is transport, not a second answer format. Agents never reproduce large answer JSON.
+The runtime owns `answer_1`, creates it only from a schema-valid projection of worker evidence,
+resolves it at termination, and passes the resolved JSON to the strict evaluator. Missing or unknown
+references fail explicitly; there is no gold-answer or best-effort fallback during live execution.
+`TaskComplete` closes one specialist subgoal and never carries the final answer. Multi-agent ORC
+uses `Terminate`; the single-agent baseline uses `FinalAnswer`; both carry exactly
+`ANSWER_JSON:answer_1`.
+
+The active answer policy is `data/core/scoring_policy_43.json`
+(`geodisaster_structured_answer_v2`). A v1 policy name nested under
+`correction_provenance.publication_contract` records the historical publication
+pass and does not configure evaluation. Values under
+`correction_provenance.evidence` are opaque build-run provenance labels, not
+runtime filesystem paths and not agent inputs. Single-agent learning consists of SFT
+and deterministic/live evaluation; GRPO/RCEA is supported only for the four
+multi-agent roles.
+
+## Load
+
+```python
+from datasets import load_dataset
+multi  = load_dataset("vimageiitb/geodisaster-agentic-2921", "multi_agent")
+single = load_dataset("vimageiitb/geodisaster-agentic-2921", "single_agent")
+single_sft = load_dataset("vimageiitb/geodisaster-agentic-2921", "single_agent_sft")
+ga_sft = load_dataset("vimageiitb/geodisaster-agentic-2921", "multi_agent_sft_ga")
+core   = load_dataset("vimageiitb/geodisaster-agentic-2921", "core")
+eval_inputs = load_dataset("vimageiitb/geodisaster-agentic-2921", "evaluation_inputs")
+```
+Or read any JSONL line-by-line.
+
+## Sources & license
+
+Project-authored annotations/questions/chains: **CC-BY-4.0**. This repository as
+a whole is **mixed-license**, so the dataset-card license is `other`. Bundled
+`source_assets/` retain their upstream terms. xBD is attributed to the original
+xBD/xView2 sources and remains non-commercial. The public package excludes the
+Sen1Floods11 payload; users hydrate the pinned 100-chip S1/JRC subset directly
+from the official bucket with:
+
+```bash
+python3 release_tools/fetch_sen1floods11_subset.py
+python3 release_tools/fetch_sen1floods11_subset.py --verify-only
+```
+
+See the exact provenance, download, integrity, and placement details in
+[`ATTRIBUTIONS.md`](ATTRIBUTIONS.md).

data/data/core/geodisaster_2921_source_with_splits.jsonl

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

data/data/core/geodisaster_2921_train_source.jsonl

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

data/data/core/scoring_policy_43.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": "geodisaster_structured_answer_v2",
+  "answer_contract": "A prediction must be a JSON value with exactly the reference object keys, value types, null states, string values, and array order.",
+  "numeric": {
+    "absolute_tolerance": 1e-06,
+    "relative_tolerance": 0.0,
+    "finite_values_required": true
+  },
+  "objects": {
+    "required_keys": "all reference keys",
+    "extra_keys_allowed": false
+  },
+  "arrays": {
+    "order_sensitive": true,
+    "length_must_match": true
+  },
+  "diagnostic_only_metrics": [
+    "token_f1",
+    "sequence_ratio"
+  ],
+  "forbidden_correctness_shortcut": "numeric subset matching",
+  "public_test_policy": "public reference split; not a secret/blind leaderboard test"
+}

data/data/multi_agent/manifest.json

@@ -0,0 +1,278 @@
+{
+  "schema_version": "geodisaster_multi_agent_release_v3",
+  "canonical_source": "data/core/geodisaster_2921_source_with_splits.jsonl",
+  "canonical_sha256": "03988b960e6b09ae01fb622fe45b35d763eb705485cddc3cea68bcac7ae63fe1",
+  "tool_ownership": {
+    "GA": [
+      "ReadData",
+      "PrepareScene",
+      "MeasureArea",
+      "ExtractObjects",
+      "MapFlood",
+      "RenderMap"
+    ],
+    "PA": [
+      "ComputeStats",
+      "CompareSources",
+      "DetectChange",
+      "ClassifyChange",
+      "ScoreHazard",
+      "EstimateExposure",
+      "RankRegions",
+      "PlanRoutes",
+      "CompareRoutes"
+    ],
+    "VRA": [
+      "AssessDamage",
+      "DescribeFlood",
+      "CompareScenes"
+    ]
+  },
+  "splits": {
+    "train": {
+      "records": 2629,
+      "conversations": "data/multi_agent/train_conversations.jsonl",
+      "summary": {
+        "records": 2629,
+        "question_type_count": 43,
+        "plan_steps_mean": 2.5245,
+        "plan_step_counts_by_agent": {
+          "GA": 2899,
+          "PA": 2381,
+          "VRA": 1357
+        },
+        "tool_call_counts": {
+          "ReadData": 4414,
+          "PrepareScene": 2629,
+          "AssessDamage": 907,
+          "RankRegions": 699,
+          "ComputeStats": 546,
+          "PlanRoutes": 540,
+          "MapFlood": 450,
+          "DescribeFlood": 450,
+          "CompareSources": 449,
+          "ExtractObjects": 422,
+          "CompareRoutes": 360,
+          "ScoreHazard": 346,
+          "EstimateExposure": 277,
+          "RenderMap": 270,
+          "ClassifyChange": 215,
+          "DetectChange": 86,
+          "CompareScenes": 49,
+          "MeasureArea": 43
+        },
+        "role_tool_call_counts": {
+          "GA::ReadData": 4414,
+          "GA::PrepareScene": 2629,
+          "VRA::AssessDamage": 907,
+          "PA::RankRegions": 699,
+          "PA::ComputeStats": 546,
+          "PA::PlanRoutes": 540,
+          "GA::MapFlood": 450,
+          "VRA::DescribeFlood": 450,
+          "PA::CompareSources": 449,
+          "GA::ExtractObjects": 422,
+          "PA::CompareRoutes": 360,
+          "PA::ScoreHazard": 346,
+          "PA::EstimateExposure": 277,
+          "GA::RenderMap": 270,
+          "PA::ClassifyChange": 215,
+          "PA::DetectChange": 86,
+          "VRA::CompareScenes": 49,
+          "GA::MeasureArea": 43
+        },
+        "question_type_counts": {
+          "deforestation_data::forest_loss_detection": 43,
+          "deforestation_data::area_estimation": 43,
+          "deforestation_data::change_window_estimation": 43,
+          "deforestation_data::false_positive_rejection": 43,
+          "deforestation_data::baseline_canopy_assessment": 43,
+          "deforestation_data::multi_year_loss_attribution": 43,
+          "deforestation_data::cross_modal_concordance": 43,
+          "deforestation_data::severity_proxy_numeric": 43,
+          "data/multi_hazard::wildfire:A": 13,
+          "data/multi_hazard::wildfire:B": 13,
+          "data/multi_hazard::wildfire:C": 13,
+          "data/multi_hazard::wildfire:D": 13,
+          "data/multi_hazard::deforestation:A": 21,
+          "data/multi_hazard::deforestation:B": 21,
+          "data/multi_hazard::deforestation:C": 21,
+          "data/multi_hazard::deforestation:D": 21,
+          "data/multi_hazard::urban_expansion:A": 27,
+          "data/multi_hazard::urban_expansion:B": 27,
+          "data/multi_hazard::urban_expansion:C": 27,
+          "data/multi_hazard::urban_expansion:D": 27,
+          "data/multi_hazard::drought:A": 18,
+          "data/multi_hazard::drought:B": 18,
+          "data/multi_hazard::drought:C": 18,
+          "data/multi_hazard::drought:D": 18,
+          "data/multi_hazard::air_pollution:A": 18,
+          "data/multi_hazard::air_pollution:B": 18,
+          "data/multi_hazard::air_pollution:C": 18,
+          "data/multi_hazard::air_pollution:D": 18,
+          "geodisaster::XBD-Q1": 160,
+          "geodisaster::XBD-Q2": 160,
+          "geodisaster::XBD-Q3": 160,
+          "geodisaster::XBD-Q8": 160,
+          "geodisaster::XBD-Q5": 109,
+          "geodisaster::XBD-Q7": 109,
+          "geodisaster::XBD-Q4": 49,
+          "ourdata/final_routing_subset_v1::nearest_shelter": 180,
+          "ourdata/final_routing_subset_v1::fastest_safest": 180,
+          "ourdata/final_routing_subset_v1::visual_overlay": 180,
+          "ourdata/sen1_hand_final_hidden_eval_5q::A": 90,
+          "ourdata/sen1_hand_final_hidden_eval_5q::B": 90,
+          "ourdata/sen1_hand_final_hidden_eval_5q::C": 90,
+          "ourdata/sen1_hand_final_hidden_eval_5q::D": 90,
+          "ourdata/sen1_hand_final_hidden_eval_5q::E": 90
+        }
+      },
+      "sft": {
+        "records": 2629,
+        "roles": {
+          "ORC": {
+            "path": "data/multi_agent/sft_train/orc_train.jsonl",
+            "rows": 11895
+          },
+          "GA": {
+            "path": "data/multi_agent/sft_train/ga_train.jsonl",
+            "rows": 11127
+          },
+          "PA": {
+            "path": "data/multi_agent/sft_train/pa_train.jsonl",
+            "rows": 5899
+          },
+          "VRA": {
+            "path": "data/multi_agent/sft_train/vra_train.jsonl",
+            "rows": 2763
+          }
+        }
+      }
+    },
+    "test": {
+      "records": 292,
+      "conversations": "data/multi_agent/test_conversations.jsonl",
+      "summary": {
+        "records": 292,
+        "question_type_count": 43,
+        "plan_steps_mean": 2.5137,
+        "plan_step_counts_by_agent": {
+          "GA": 322,
+          "PA": 264,
+          "VRA": 148
+        },
+        "tool_call_counts": {
+          "ReadData": 489,
+          "PrepareScene": 292,
+          "AssessDamage": 98,
+          "RankRegions": 76,
+          "ComputeStats": 60,
+          "PlanRoutes": 60,
+          "CompareSources": 51,
+          "MapFlood": 50,
+          "DescribeFlood": 50,
+          "ExtractObjects": 47,
+          "CompareRoutes": 40,
+          "ScoreHazard": 39,
+          "EstimateExposure": 31,
+          "RenderMap": 30,
+          "ClassifyChange": 25,
+          "DetectChange": 10,
+          "CompareScenes": 6,
+          "MeasureArea": 5
+        },
+        "role_tool_call_counts": {
+          "GA::ReadData": 489,
+          "GA::PrepareScene": 292,
+          "VRA::AssessDamage": 98,
+          "PA::RankRegions": 76,
+          "PA::ComputeStats": 60,
+          "PA::PlanRoutes": 60,
+          "PA::CompareSources": 51,
+          "GA::MapFlood": 50,
+          "VRA::DescribeFlood": 50,
+          "GA::ExtractObjects": 47,
+          "PA::CompareRoutes": 40,
+          "PA::ScoreHazard": 39,
+          "PA::EstimateExposure": 31,
+          "GA::RenderMap": 30,
+          "PA::ClassifyChange": 25,
+          "PA::DetectChange": 10,
+          "VRA::CompareScenes": 6,
+          "GA::MeasureArea": 5
+        },
+        "question_type_counts": {
+          "deforestation_data::forest_loss_detection": 5,
+          "deforestation_data::area_estimation": 5,
+          "deforestation_data::change_window_estimation": 5,
+          "deforestation_data::false_positive_rejection": 5,
+          "deforestation_data::baseline_canopy_assessment": 5,
+          "deforestation_data::multi_year_loss_attribution": 5,
+          "deforestation_data::cross_modal_concordance": 5,
+          "deforestation_data::severity_proxy_numeric": 5,
+          "data/multi_hazard::wildfire:A": 2,
+          "data/multi_hazard::wildfire:B": 2,
+          "data/multi_hazard::wildfire:C": 2,
+          "data/multi_hazard::wildfire:D": 2,
+          "data/multi_hazard::deforestation:A": 2,
+          "data/multi_hazard::deforestation:B": 2,
+          "data/multi_hazard::deforestation:C": 2,
+          "data/multi_hazard::deforestation:D": 2,
+          "data/multi_hazard::urban_expansion:A": 2,
+          "data/multi_hazard::urban_expansion:B": 2,
+          "data/multi_hazard::urban_expansion:C": 2,
+          "data/multi_hazard::urban_expansion:D": 2,
+          "data/multi_hazard::drought:A": 3,
+          "data/multi_hazard::drought:B": 3,
+          "data/multi_hazard::drought:C": 3,
+          "data/multi_hazard::drought:D": 3,
+          "data/multi_hazard::air_pollution:A": 2,
+          "data/multi_hazard::air_pollution:B": 2,
+          "data/multi_hazard::air_pollution:C": 2,
+          "data/multi_hazard::air_pollution:D": 2,
+          "geodisaster::XBD-Q1": 17,
+          "geodisaster::XBD-Q2": 17,
+          "geodisaster::XBD-Q3": 17,
+          "geodisaster::XBD-Q8": 17,
+          "geodisaster::XBD-Q5": 12,
+          "geodisaster::XBD-Q7": 12,
+          "geodisaster::XBD-Q4": 6,
+          "ourdata/final_routing_subset_v1::nearest_shelter": 20,
+          "ourdata/final_routing_subset_v1::fastest_safest": 20,
+          "ourdata/final_routing_subset_v1::visual_overlay": 20,
+          "ourdata/sen1_hand_final_hidden_eval_5q::A": 10,
+          "ourdata/sen1_hand_final_hidden_eval_5q::B": 10,
+          "ourdata/sen1_hand_final_hidden_eval_5q::C": 10,
+          "ourdata/sen1_hand_final_hidden_eval_5q::D": 10,
+          "ourdata/sen1_hand_final_hidden_eval_5q::E": 10
+        }
+      },
+      "sft": {
+        "records": 292,
+        "roles": {
+          "ORC": {
+            "path": "data/multi_agent/sft_test/orc_eval.jsonl",
+            "rows": 1318
+          },
+          "GA": {
+            "path": "data/multi_agent/sft_test/ga_eval.jsonl",
+            "rows": 1235
+          },
+          "PA": {
+            "path": "data/multi_agent/sft_test/pa_eval.jsonl",
+            "rows": 656
+          },
+          "VRA": {
+            "path": "data/multi_agent/sft_test/vra_eval.jsonl",
+            "rows": 302
+          }
+        }
+      }
+    }
+  },
+  "terminal_answer_protocol": {
+    "action_field": "answer_ref",
+    "reference": "ANSWER_JSON:answer_1",
+    "resolution": "runtime answer registry populated from schema-valid worker evidence"
+  }
+}

data/data/multi_agent/sft_test/ga_eval.jsonl

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

data/data/multi_agent/sft_test/manifest.json

@@ -0,0 +1,21 @@
+{
+  "records": 292,
+  "roles": {
+    "ORC": {
+      "path": "orc_eval.jsonl",
+      "rows": 1318
+    },
+    "GA": {
+      "path": "ga_eval.jsonl",
+      "rows": 1235
+    },
+    "PA": {
+      "path": "pa_eval.jsonl",
+      "rows": 656
+    },
+    "VRA": {
+      "path": "vra_eval.jsonl",
+      "rows": 302
+    }
+  }
+}

data/data/multi_agent/sft_test/orc_eval.jsonl

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

data/data/multi_agent/sft_train/ga_train.jsonl

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

data/data/multi_agent/sft_train/manifest.json

@@ -0,0 +1,21 @@
+{
+  "records": 2629,
+  "roles": {
+    "ORC": {
+      "path": "orc_train.jsonl",
+      "rows": 11895
+    },
+    "GA": {
+      "path": "ga_train.jsonl",
+      "rows": 11127
+    },
+    "PA": {
+      "path": "pa_train.jsonl",
+      "rows": 5899
+    },
+    "VRA": {
+      "path": "vra_train.jsonl",
+      "rows": 2763
+    }
+  }
+}

data/data/multi_agent/sft_train/orc_train.jsonl

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

data/data/multi_agent/sft_train/pa_train.jsonl

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

data/data/multi_agent/sft_train/vra_train.jsonl

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

data/data/multi_agent/test_conversations.jsonl

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

data/data/multi_agent/tool_ownership_and_prompt_context.md

@@ -0,0 +1,32 @@
+# GeoDisaster Dataset Multi-Agent Tool Ownership
+
+Enable this benchmark profile with `MAS_AGENT_PROFILE=geodisaster`. The ownership table below is the active GeoDisaster contract.
+
+## Ownership
+
+| Agent | Tools | Rationale |
+|---|---|---|
+| `GA` | `ReadData`, `PrepareScene`, `MeasureArea`, `ExtractObjects`, `MapFlood`, `RenderMap` | Spatial/data operations and artifact creation: open handles, prepare scenes, measure areas, extract objects, map flood extent, render overlays. |
+| `PA` | `ComputeStats`, `CompareSources`, `DetectChange`, `ClassifyChange`, `ScoreHazard`, `EstimateExposure`, `RankRegions`, `PlanRoutes`, `CompareRoutes` | Largest set: numeric/statistical reasoning, comparisons, classifications, exposure, ranking, route planning, route tradeoffs. |
+| `VRA` | `AssessDamage`, `DescribeFlood`, `CompareScenes` | Small visual interpretation set: damage/flood/scene semantic summaries after evidence is prepared. |
+
+## Agent-Facing Signatures
+
+- `ReadData(question: str, input: str, role?: 'pre_post'|'hansen'|'ndvi_nbr'|'vh'|'wildfire'|'deforestation'|'urban_expansion'|'drought'|'air_pollution'|'hospitals_and_schools'|'highways'|'nearest_highway'|'population_in_footprint'|'schools'|'population'|'post_disaster'|'buildings'|'target_classes'|'scene_a'|'scene_b'|'roads_shelters_flood'|'roads_shelters_flood_rgb'|'primary'|'known_water_reference', time?: 'event'|'event_window'|'pre_post_epochs'|'2001_2023', options?: dict)  # Open a named input handle for the current question, validate its local artifact paths, and return a scene handle containing the discovered raster/vector/image/report refs. The evaluator must initialize the session first with code/scripts/initialize_tool_session.py; case contents are not agent-visible tool arguments.`
+- `PrepareScene(question: str, inputs: dict, mode: 'forest'|'hazard'|'xbd_damage'|'sar_flood'|'routing'|'scene_compare'|'forest_change'|'forest_timeseries'|'forest_false_positive'|'baseline_canopy'|'forest_loss_history'|'forest_cross_modal'|'sar_change'|'wildfire_burn'|'forest_loss'|'built_up_gain'|'drought_anomaly'|'pollution_peak'|'multisource_hazard'|'wildfire_burn_exposure'|'forest_loss_exposure'|'built_up_gain_exposure'|'drought_anomaly_exposure'|'pollution_peak_exposure'|'xbd_grid'|'xbd_quadrants'|'xbd_scene_summary'|'flood_safe_routing'|'sar_flood_reference'|'sar_flood_diagnostic', checks?: dict)  # Build an aligned work context from one or more opened scene handles. It checks handle types and records the processing mode before downstream analytics.`
+- `ComputeStats(question: str, work: str, metrics: dict, region?: 'aoi'|'scene')  # Compute numeric statistics for a work/damage/hazard handle, including area, counts, means, z-scores, class histograms, or footprint summaries.`
+- `MeasureArea(question: str, work: str, target: 'forest_loss', unit: 'hectares')  # Measure area for extracted objects or masks in the requested units by reading the underlying raster/vector data referenced by the input handle.`
+- `CompareSources(question: str, work: str, compare: dict)  # Compare multiple modalities or source layers, such as optical-vs-SAR, multi-source hazard agreement, or predicted-flood overlap versus pixels outside a known-water reference. Known-water context does not by itself establish temporal novelty.`
+- `DetectChange(question: str, work: str, change: 'largest_loss_year'|'dominant_clearing_interval', window?: '2001_2023'|'pre_post_epochs')  # Detect or localize temporal change windows or dominant change events from a work handle.`
+- `ClassifyChange(question: str, work: str, labels: dict, rule: 'forest_loss'|'change_window'|'false_positive_type'|'canopy_density'|'concordance'|'cross_modal_concordance')  # Classify a change, canopy state, concordance state, or false-positive category using explicit labels/rules.`
+- `ScoreHazard(question: str, work: str, hazard: 'forest_disturbance'|'wildfire'|'deforestation'|'urban_expansion'|'drought'|'air_pollution'|'building_damage', scale: 'vh_delta_severity'|'question_defined_class'|'benchmark_relative_column_quartile'|'impact_footprint'|'spatial_concentration')  # Score hazard class, severity, concentration, or impact footprint from a prepared/analytic handle.`
+- `EstimateExposure(question: str, work: str, exposure: 'blocked_roads'|'high_no2_column_population'|'highway_representatives_within_5km'|'nearest_highway'|'population_in_footprint'|'schools', metrics: dict)  # Estimate exposure of people/assets/roads/facilities to a hazard footprint or blocked-road layer.`
+- `AssessDamage(question: str, work: str, aggregation: 'scene'|'grid_4x4'|'quadrant_2x2'|'severe_only'|'pair_compare', severity?: 'severe'|'major_or_destroyed')  # Aggregate building-damage polygons into scene, grid, quadrant, severe-only, or pair-comparison summaries.`
+- `RankRegions(question: str, work: str, by: 'severe_footprint_area_m2'|'severe_area_m2'|'severe_damage_count'|'severe_count'|'normalized_damage_severity'|'normalized_severity'|'severity_score'|'severity_score_normalized'|'flood_percentage'|'flood_pixels'|'flood_area', candidates: 'grid_4x4'|'quadrants_2x2', top_k?: int)  # Rank regions, components, grid cells, quadrants, or route candidates by the requested score.`
+- `CompareScenes(question: str, work: str, by: 'severe_damage_ratio_and_footprint')  # Compare two prepared scene summaries and decide which scene has the larger damage/risk signal.`
+- `ExtractObjects(question: str, work: str, target: 'forest_loss_patches'|'severe_buildings'|'flood_polygons'|'flood_components', filters?: dict)  # Extract object sets such as forest-loss patches, severe buildings, flood polygons, or flood components. Sentinel flood polygons and components use 8-neighbour connectivity and produce validated run-scoped GeoJSON or label-raster artifacts.`
+- `MapFlood(question: str, work: str, method: 's1_min_backscatter_otsu_v1')  # Produce a run-scoped 0/1/255 candidate-flood mask from a prepared SAR scene. The published Sentinel contract supports the validated s1_min_backscatter_otsu_v1 method.`
+- `DescribeFlood(question: str, work: str, metrics: dict)  # Select and summarize requested flood-mask/component/polygon metrics, including exact-grid areas, centroids, 4x4 grids, and known-water overlap statistics from the causal handle.`
+- `PlanRoutes(question: str, work: str, objective: 'nearest_reachable_shelter'|'candidate_routes'|'overlay_routes', avoid: dict)  # Recompute route metrics and composite edge costs from declared packaged geometry/road products, then select eligible fastest, safest-weighted, and balanced candidates; this worker does not run a new graph search.`
+- `CompareRoutes(question: str, work: str, prefer: dict)  # Compare requested validated fastest, safest-weighted, and balanced candidates and compute the full trade-off when all three are requested, without adding an evacuation recommendation.`
+- `RenderMap(question: str, work: str, layers: dict, style: 'route_overlay'|'flood_diagnostic')  # Render a fresh run-scoped map/image artifact and validation manifest from the current analytical handle and exactly the requested declared layers; prepared answer overlays and unrequested context layers are not retrieved.`

data/data/multi_agent/train_conversations.jsonl

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

data/data/single_agent/manifest.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": "geodisaster_single_agent_release_v2",
+  "canonical_source": "data/core/geodisaster_2921_source_with_splits.jsonl",
+  "canonical_sha256": "03988b960e6b09ae01fb622fe45b35d763eb705485cddc3cea68bcac7ae63fe1",
+  "files": {
+    "train_conversations": "data/single_agent/train_conversations.jsonl",
+    "train_turns": "data/single_agent/train_turns.jsonl",
+    "test_reference_conversations": "data/single_agent/test_reference_conversations.jsonl",
+    "test_turns": "data/single_agent/test_turns.jsonl",
+    "system_prompt": "data/single_agent/single_agent_system_prompt.md"
+  },
+  "counts": {
+    "train_cases": 2629,
+    "train_sft_turns": 18410,
+    "test_cases": 292,
+    "test_sft_turns": 2043
+  },
+  "terminal_answer_protocol": {
+    "action_field": "answer_ref",
+    "reference": "ANSWER_JSON:answer_1",
+    "resolution": "runtime answer registry populated from schema-valid worker evidence"
+  }
+}

data/data/single_agent/single_agent_system_prompt.md

@@ -0,0 +1,70 @@
+# Single-Agent System Prompt
+
+```text
+You are a single geospatial-disaster tool-use agent.
+You do your own planning and tool execution. There are no specialist agents and
+no orchestrator. You receive one question plus visible handles, then solve it
+by emitting one JSON object per turn.
+
+Response schema:
+{
+  "thought": "<compact reasoning for the next action>",
+  "action": <Plan | ToolCall | FinalAnswer>
+}
+
+Actions:
+- Plan = {"tool":"Plan","goal":"...","steps":[{"id":"s1","objective":"...","needs":["..."]}]}
+- ToolCall = {"tool":"<tool name>","args":{...}}
+- FinalAnswer = {"tool":"FinalAnswer","answer_ref":"ANSWER_JSON:answer_1"}
+
+Core rules:
+- On the first turn, produce a high-level Plan unless the answer is already
+  visible. The plan should explain evidence objectives, not list every tool by
+  rote.
+- After a Plan, execute one tool call per turn. Use LAST OBSERVATION and SHARED
+  MEMORY to decide the next action.
+- Use exact tool names and exact argument names from ALLOWED TOOLS. Do not
+  invent keys or handles.
+- Use visible canonical handles, not raw filesystem paths. For GeoDisaster
+  questions, `question` is normally `"question_1"`.
+- Raw GeoDisaster handles such as `optical_stack_1`, `damage_scene_1`,
+  `sar_chip_1`, `hazard_stack_1`, and `route_network_1` are opened with
+  ReadData. Later GeoDisaster tools consume produced handles such as `scene_N`,
+  `work_N`, `stats_N`, `compare_N`, `rank_N`, `route_N`, or `map_N`.
+- When ReadData returns `latest_handle = scene_N`, use that produced scene
+  handle in later PrepareScene calls. Do not pass the raw input handle where a
+  work/scene handle is required.
+- For PrepareScene, choose semantic slot names from the evidence: forest
+  optical/sar/forest/loss_history; hazard hazard/sources/exposure; damage
+  image/labels/masks; flood sar/water; routing routing; comparison scene_a and
+  scene_b.
+- Stop when the evidence needed for the answer is present. Do not re-run a
+  successful tool call with the same arguments.
+- Finish only when AVAILABLE ANSWER REFERENCES publishes
+  `ANSWER_JSON:answer_1`, then copy it into `answer_ref`. The runtime resolves
+  it only from a schema-validated projection of worker evidence. Inline answer
+  JSON, prose, partial fields, worker handles, and invented references are
+  rejected.
+- Reply with one JSON object only. No prose, no markdown fences.
+
+ALLOWED TOOLS
+- AssessDamage(question: str, work: str, aggregation: 'scene'|'grid_4x4'|'quadrant_2x2'|'severe_only'|'pair_compare', severity?: 'severe'|'major_or_destroyed')  # Aggregate building-damage polygons into scene, grid, quadrant, severe-only, or pair-comparison summaries.
+- ClassifyChange(question: str, work: str, labels: dict, rule: 'forest_loss'|'change_window'|'false_positive_type'|'canopy_density'|'concordance'|'cross_modal_concordance')  # Classify a change, canopy state, concordance state, or false-positive category using explicit labels/rules.
+- CompareRoutes(question: str, work: str, prefer: dict)  # Compare requested validated fastest, safest-weighted, and balanced candidates and compute the full trade-off when all three are requested, without adding an evacuation recommendation.
+- CompareScenes(question: str, work: str, by: 'severe_damage_ratio_and_footprint')  # Compare two prepared scene summaries and decide which scene has the larger damage/risk signal.
+- CompareSources(question: str, work: str, compare: dict)  # Compare multiple modalities or source layers, such as optical-vs-SAR, multi-source hazard agreement, or predicted-flood overlap versus pixels outside a known-water reference. Known-water context does not by itself establish temporal novelty.
+- ComputeStats(question: str, work: str, metrics: dict, region?: 'aoi'|'scene')  # Compute numeric statistics for a work/damage/hazard handle, including area, counts, means, z-scores, class histograms, or footprint summaries.
+- DescribeFlood(question: str, work: str, metrics: dict)  # Select and summarize requested flood-mask/component/polygon metrics, including exact-grid areas, centroids, 4x4 grids, and known-water overlap statistics from the causal handle.
+- DetectChange(question: str, work: str, change: 'largest_loss_year'|'dominant_clearing_interval', window?: '2001_2023'|'pre_post_epochs')  # Detect or localize temporal change windows or dominant change events from a work handle.
+- EstimateExposure(question: str, work: str, exposure: 'blocked_roads'|'high_no2_column_population'|'highway_representatives_within_5km'|'nearest_highway'|'population_in_footprint'|'schools', metrics: dict)  # Estimate exposure of people/assets/roads/facilities to a hazard footprint or blocked-road layer.
+- ExtractObjects(question: str, work: str, target: 'forest_loss_patches'|'severe_buildings'|'flood_polygons'|'flood_components', filters?: dict)  # Extract object sets such as forest-loss patches, severe buildings, flood polygons, or flood components. Sentinel flood polygons and components use 8-neighbour connectivity and produce validated run-scoped GeoJSON or label-raster artifacts.
+- MapFlood(question: str, work: str, method: 's1_min_backscatter_otsu_v1')  # Produce a run-scoped 0/1/255 candidate-flood mask from a prepared SAR scene. The published Sentinel contract supports the validated s1_min_backscatter_otsu_v1 method.
+- MeasureArea(question: str, work: str, target: 'forest_loss', unit: 'hectares')  # Measure area for extracted objects or masks in the requested units by reading the underlying raster/vector data referenced by the input handle.
+- PlanRoutes(question: str, work: str, objective: 'nearest_reachable_shelter'|'candidate_routes'|'overlay_routes', avoid: dict)  # Recompute route metrics and composite edge costs from declared packaged geometry/road products, then select eligible fastest, safest-weighted, and balanced candidates; this worker does not run a new graph search.
+- PrepareScene(question: str, inputs: dict, mode: 'forest'|'hazard'|'xbd_damage'|'sar_flood'|'routing'|'scene_compare'|'forest_change'|'forest_timeseries'|'forest_false_positive'|'baseline_canopy'|'forest_loss_history'|'forest_cross_modal'|'sar_change'|'wildfire_burn'|'forest_loss'|'built_up_gain'|'drought_anomaly'|'pollution_peak'|'multisource_hazard'|'wildfire_burn_exposure'|'forest_loss_exposure'|'built_up_gain_exposure'|'drought_anomaly_exposure'|'pollution_peak_exposure'|'xbd_grid'|'xbd_quadrants'|'xbd_scene_summary'|'flood_safe_routing'|'sar_flood_reference'|'sar_flood_diagnostic', checks?: dict)  # Build an aligned work context from one or more opened scene handles. It checks handle types and records the processing mode before downstream analytics.
+- RankRegions(question: str, work: str, by: 'severe_footprint_area_m2'|'severe_area_m2'|'severe_damage_count'|'severe_count'|'normalized_damage_severity'|'normalized_severity'|'severity_score'|'severity_score_normalized'|'flood_percentage'|'flood_pixels'|'flood_area', candidates: 'grid_4x4'|'quadrants_2x2', top_k?: int)  # Rank regions, components, grid cells, quadrants, or route candidates by the requested score.
+- ReadData(question: str, input: str, role?: 'pre_post'|'hansen'|'ndvi_nbr'|'vh'|'wildfire'|'deforestation'|'urban_expansion'|'drought'|'air_pollution'|'hospitals_and_schools'|'highways'|'nearest_highway'|'population_in_footprint'|'schools'|'population'|'post_disaster'|'buildings'|'target_classes'|'scene_a'|'scene_b'|'roads_shelters_flood'|'roads_shelters_flood_rgb'|'primary'|'known_water_reference', time?: 'event'|'event_window'|'pre_post_epochs'|'2001_2023', options?: dict)  # Open a named input handle for the current question, validate its local artifact paths, and return a scene handle containing the discovered raster/vector/image/report refs. The evaluator must initialize the session first with code/scripts/initialize_tool_session.py; case contents are not agent-visible tool arguments.
+- RenderMap(question: str, work: str, layers: dict, style: 'route_overlay'|'flood_diagnostic')  # Render a fresh run-scoped map/image artifact and validation manifest from the current analytical handle and exactly the requested declared layers; prepared answer overlays and unrequested context layers are not retrieved.
+- ScoreHazard(question: str, work: str, hazard: 'forest_disturbance'|'wildfire'|'deforestation'|'urban_expansion'|'drought'|'air_pollution'|'building_damage', scale: 'vh_delta_severity'|'question_defined_class'|'benchmark_relative_column_quartile'|'impact_footprint'|'spatial_concentration')  # Score hazard class, severity, concentration, or impact footprint from a prepared/analytic handle.
+
+```

data/data/single_agent/test_turns.jsonl

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

data/data/single_agent/train_conversations.jsonl

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

data/data/single_agent/train_turns.jsonl

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

data/release_tools/audit_c01_source_registry.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""Audit C01 path completeness and file-family provenance coverage.
+
+This audit is intentionally independent of the tool replay. It checks every
+path declaration in the canonical 2,921-record source file, every physical
+file under source_assets/, and every multi-hazard raster-sidecar source label.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_ROOT = Path(__file__).resolve().parents[1]
+
+
+CATEGORY_PROVENANCE = {
+    "D01": "Sentinel-1 GRD source raster or GDAL sidecar",
+    "D02": "Sentinel-2 L2A source raster or GDAL sidecar",
+    "D03": "Sentinel-2-derived RGB preview",
+    "D04": "Hansen GFC source/derived mask or GDAL sidecar",
+    "D05": "project-authored deforestation question",
+    "D06": "project-generated deforestation quality report",
+    "MH00": "multi-hazard sample-directory container handle",
+    "MH01": "project-authored AOI/metadata/handle manifest",
+    "MH02": "project-authored question, answer, or trajectory record",
+    "MH03": "project-generated quality report",
+    "MH04": "source-derived tabular baseline",
+    "MH05": "OpenStreetMap POI extract",
+    "MH06": "source-derived visualization panel",
+    "MH07": "WorldPop population raster and provider sidecar",
+    "MH08": "wildfire source/derived raster, sidecar, or GDAL sidecar",
+    "MH09": "deforestation source/derived raster or sidecar",
+    "MH10": "urban-expansion source/derived raster or sidecar",
+    "MH11": "drought source/derived raster or sidecar",
+    "MH12": "air-pollution source/derived raster or sidecar",
+    "MH13": "OpenAQ empty-query provenance (no measurements)",
+    "MH14": "project-authored train-only air-pollution normalization contract",
+    "MH15": "project-authored train-only drought normalization contract",
+    "R01": "legacy project-authored routing split export",
+    "R02": "CEMS flood-extent source vector",
+    "R03": "Sentinel-2 L2A raster/preview or GDAL sidecar",
+    "R04": "project-authored routing metadata with source identifiers",
+    "R05": "OSM+CEMS-derived road/route/score product",
+    "R06": "project-selected route answer",
+    "R07": "Sentinel-2+OSM+CEMS-derived route overlay",
+    "S01": "Sen1Floods11 Sentinel-1 chip or GDAL sidecar",
+    "S02": "Sen1Floods11 JRC-water layer or GDAL sidecar",
+    "S03": "Sen1Floods11 hand label or GDAL sidecar",
+    "S04": "legacy Sen1Floods11 Otsu derivative or GDAL sidecar",
+    "S05": "source-derived public preview or packaged overlay",
+    "S06": "project-generated hidden derivative of Sen1Floods11 hand labels",
+    "X01": "xBD pre/post imagery",
+    "X02": "xBD-label-derived target mask",
+    "X03": "xBD damage polygons or coordinate conversion",
+    "X04": "project-generated grid/quadrant geometry",
+}
+
+
+SOURCE_MARKERS = {
+    "COPERNICUS/S2_SR_HARMONIZED NBR": "COPERNICUS/S2_SR_HARMONIZED",
+    "COPERNICUS/S2_SR_HARMONIZED NDBI": "COPERNICUS/S2_SR_HARMONIZED",
+    "COPERNICUS/S2_SR_HARMONIZED NDVI": "COPERNICUS/S2_SR_HARMONIZED",
+    "COPERNICUS/S2_SR_HARMONIZED RGB": "COPERNICUS/S2_SR_HARMONIZED",
+    "COPERNICUS/S5P/OFFL/L3_CO CO": "COPERNICUS/S5P/OFFL/L3_CO",
+    "COPERNICUS/S5P/OFFL/L3_NO2 tropospheric NO2 * 1e6": "COPERNICUS/S5P/OFFL/L3_NO2",
+    "COPERNICUS/S5P/OFFL/L3_SO2 SO2 * 1e6": "COPERNICUS/S5P/OFFL/L3_SO2",
+    "ECMWF Copernicus Atmosphere Monitoring Service — CAMS Global Near-Real-Time": "ECMWF/CAMS/NRT",
+    "ECMWF/ERA5_LAND/DAILY_AGGR volumetric_soil_water_layer_1": "ECMWF/ERA5_LAND/DAILY_AGGR",
+    "ESA/WorldCover/v200 Map class 50 built-up": "ESA/WorldCover/v200",
+    "ESA WorldCover 2020 class 50 built-up": "ESA/WorldCover/v100",
+    "GOOGLE/DYNAMICWORLD/V1 built probability": "GOOGLE/DYNAMICWORLD/V1",
+    "JRC/GHSL/P2023A/GHS_BUILT_S 2020 built_surface>0": "JRC/GHSL/P2023A/GHS_BUILT_S",
+    "JRC/GHSL/P2023A/GHS_BUILT_S 2025 built_surface>0": "JRC/GHSL/P2023A/GHS_BUILT_S",
+    "LANDSAT/LC08+LC09/C02/T1_L2 NBR": "LANDSAT/LC08/C02/T1_L2",
+    "MODIS/061/MCD19A2_GRANULES Optical_Depth_047 * 0.001": "MODIS/061/MCD19A2_GRANULES",
+    "MODIS/061/MCD64A1 BurnDate": "MODIS/061/MCD64A1",
+    "MODIS/061/MOD13Q1 NDVI": "MODIS/061/MOD13Q1",
+    "NASA LP DAAC — VNP14A1.002 Thermal Anomalies/Fire Daily L3 Global 1 km": "NASA/VIIRS/002/VNP14A1",
+    "NASA LP DAAC — VNP21A1D.002 Day LST and Emissivity Daily 1 km": "NASA/VIIRS/002/VNP21A1D",
+    "National Interagency Fire Center — WFIGS Interagency Fire Perimeters": "WFIGS_Interagency_Perimeters/FeatureServer/0",
+    "Wageningen University & Research / Global Forest Watch — RADD Forest Disturbance Alerts v1": "projects/radar-wur/raddalert/v1",
+    "UCSB-CHG/CHIRPS/DAILY same-window z-score": "UCSB-CHG/CHIRPS/DAILY",
+    "UMD/hansen/global_forest_change_2025_v1_13 lossyear=2022": "UMD/hansen/global_forest_change_2025_v1_13",
+    "UMD/hansen/global_forest_change_2025_v1_13 treecover2000>30": "UMD/hansen/global_forest_change_2025_v1_13",
+    "EC JRC TMF v1_2023 AnnualChanges": "projects/JRC/TMF/v1_2023/AnnualChanges",
+}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def classify(relative: str) -> str | None:
+    parts = Path(relative).parts
+    if len(parts) < 2 or parts[0] != "source_assets":
+        return None
+    family = parts[1]
+    tail = "/".join(parts[2:])
+
+    if family == "deforestation":
+        if "/cache/s1_grd/" in f"/{tail}/":
+            return "D01"
+        if "/cache/s2/" in f"/{tail}/":
+            return "D02"
+        if "/visible/s2_rgb/" in f"/{tail}/":
+            return "D03"
+        if "/masks/" in f"/{tail}/":
+            return "D04"
+        if "/questions/" in f"/{tail}/":
+            return "D05"
+        if tail.endswith("/quality_report.json"):
+            return "D06"
+
+    if family == "multi_hazard":
+        if tail == "air_pollution/source_normalization.json":
+            return "MH14"
+        if len(parts) == 4:
+            return "MH00"
+        if tail.endswith(("/aoi.geojson", "/available_handles.json", "/metadata.json")):
+            return "MH01"
+        if any(f"/{name}/" in f"/{tail}/" for name in ("questions", "gt", "trajectories")):
+            return "MH02"
+        if tail.endswith("/quality_report.json"):
+            return "MH03"
+        if "/baselines/" in f"/{tail}/":
+            return "MH04"
+        if tail.endswith("/osm/pois.geojson"):
+            return "MH05"
+        if "/panels/" in f"/{tail}/":
+            return "MH06"
+        if tail.endswith(("/tabular/worldpop.tif", "/tabular/worldpop.json")):
+            return "MH07"
+        if tail.endswith("/drought_normalization.json"):
+            return "MH15"
+        if tail.endswith("/normalization.json"):
+            return "MH14"
+        if tail.endswith(("/tabular/openaq_stations.csv", "/tabular/openaq_status.json")):
+            return "MH13"
+        hazard = parts[2] if len(parts) > 2 else ""
+        if "/rasters/" in f"/{tail}/":
+            return {
+                "wildfire": "MH08",
+                "deforestation": "MH09",
+                "urban_expansion": "MH10",
+                "drought": "MH11",
+                "air_pollution": "MH12",
+            }.get(hazard)
+
+    if family == "routing":
+        if len(parts) == 3 and parts[2] in {"train.json", "val.json", "test.json"}:
+            return "R01"
+        if "/copernicus/" in f"/{tail}/":
+            return "R02"
+        if "/input/rgb" in f"/{tail}/":
+            return "R03"
+        if tail.endswith("/input/metadata.json"):
+            return "R04"
+        if "/derived/" in f"/{tail}/":
+            return "R05"
+        if tail.endswith("/ground_truth/selected_routes.json"):
+            return "R06"
+        if tail.endswith("/overlays/routes_overlay.png"):
+            return "R07"
+
+    if family == "sen1_flood":
+        if "/labels/S1Hand.tif" in f"/{tail}" or "/derived/S1Portable.tif" in f"/{tail}":
+            return "S01"
+        if "/labels/JRCWaterHand.tif" in f"/{tail}":
+            return "S02"
+        if "/labels/LabelHand.tif" in f"/{tail}":
+            return "S03"
+        if "/labels/S1OtsuLabelHand.tif" in f"/{tail}":
+            return "S04"
+        if "/public/" in f"/{tail}/":
+            return "S05"
+        if "/hidden/" in f"/{tail}/":
+            return "S06"
+
+    if family == "xbd_damage":
+        if tail.endswith(("/pre.png", "/post.png")):
+            return "X01"
+        if tail.endswith("/post_target.png"):
+            return "X02"
+        if tail.endswith(("/building_damage_xy.geojson", "/building_damage_lnglat.geojson")):
+            return "X03"
+        if tail.endswith(("/grid_4x4.geojson", "/quadrants.geojson")):
+            return "X04"
+    return None
+
+
+def collect_path_cards(value: Any, record_id: str, trail: str = "") -> list[dict[str, Any]]:
+    cards: list[dict[str, Any]] = []
+    if isinstance(value, dict):
+        if isinstance(value.get("path"), str):
+            cards.append(
+                {
+                    "record_id": record_id,
+                    "trail": trail,
+                    "path": value["path"],
+                    "optional": bool(value.get("optional", False)),
+                    "declared_exists": value.get("exists"),
+                }
+            )
+        for key, child in value.items():
+            child_trail = f"{trail}.{key}" if trail else key
+            cards.extend(collect_path_cards(child, record_id, child_trail))
+    elif isinstance(value, list):
+        for index, child in enumerate(value):
+            cards.extend(collect_path_cards(child, record_id, f"{trail}[{index}]"))
+    return cards
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=DEFAULT_ROOT)
+    parser.add_argument(
+        "--mode",
+        choices=("thin", "hydrated", "development"),
+        default="thin",
+        help=(
+            "thin permits only the documented Sen1Floods11 hydration gap; "
+            "hydrated and development require every declared path."
+        ),
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Optional report path. The audit is check-only and never overwrites tracked evidence by default.",
+    )
+    args = parser.parse_args()
+
+    root = args.root.expanduser().resolve()
+    canonical = root / "data/core/geodisaster_2921_source_with_splits.jsonl"
+    attributions = root / "ATTRIBUTIONS.md"
+    records = [json.loads(line) for line in canonical.open() if line.strip()]
+    declarations: list[dict[str, Any]] = []
+    for record in records:
+        declarations.extend(collect_path_cards(record, record["id"]))
+
+    by_path: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for card in declarations:
+        by_path[card["path"]].append(card)
+
+    required = {path for path, cards in by_path.items() if any(not card["optional"] for card in cards)}
+    optional_only = set(by_path) - required
+    missing_required = sorted(path for path in required if not (root / path).exists())
+    missing_optional = sorted(path for path in optional_only if not (root / path).exists())
+    permitted_thin_missing = sorted(
+        path
+        for path in missing_required
+        if path.startswith("source_assets/sen1_flood/")
+        and path.endswith(("/derived/S1Portable.tif", "/labels/JRCWaterHand.tif"))
+    )
+    unexpected_missing_required = (
+        sorted(set(missing_required) - set(permitted_thin_missing))
+        if args.mode == "thin"
+        else missing_required
+    )
+    outside = sorted(path for path in by_path if not path.startswith("source_assets/"))
+    flag_mismatches = []
+    for path, cards in by_path.items():
+        actual_exists = (root / path).exists()
+        for card in cards:
+            if card["declared_exists"] is not None and bool(card["declared_exists"]) != actual_exists:
+                if not (args.mode == "thin" and path in permitted_thin_missing):
+                    flag_mismatches.append(card | {"actual_exists": actual_exists})
+
+    physical_files = [path for path in (root / "source_assets").rglob("*") if path.is_file()]
+    relative_files = [str(path.relative_to(root)) for path in physical_files]
+    unclassified_files = sorted(path for path in relative_files if classify(path) is None)
+    unclassified_references = sorted(path for path in by_path if classify(path) is None)
+
+    category_counts: dict[str, Counter[str]] = defaultdict(Counter)
+    for path in relative_files:
+        category = classify(path)
+        if category:
+            category_counts[category]["physical_files"] += 1
+    for path in by_path:
+        category = classify(path)
+        if category:
+            status = "required_paths" if path in required else "optional_paths"
+            category_counts[category][status] += 1
+            if not (root / path).exists():
+                category_counts[category]["missing_paths"] += 1
+
+    source_labels = set()
+    for sidecar in (root / "source_assets/multi_hazard").glob("*/*/rasters/*.json"):
+        payload = json.loads(sidecar.read_text())
+        if isinstance(payload.get("source"), str):
+            source_labels.add(payload["source"])
+    direct_labels = sorted(label for label in source_labels if not label.startswith("derived "))
+    derived_labels = sorted(label for label in source_labels if label.startswith("derived "))
+    attribution_text = attributions.read_text()
+    unmapped_labels = sorted(label for label in direct_labels if label not in SOURCE_MARKERS)
+    uncited_markers = sorted(
+        {SOURCE_MARKERS[label] for label in direct_labels if label in SOURCE_MARKERS and SOURCE_MARKERS[label] not in attribution_text}
+    )
+
+    referenced_existing_files = sum(1 for path in by_path if (root / path).is_file())
+    referenced_existing_directories = sum(1 for path in by_path if (root / path).is_dir())
+    physical_unreferenced = len(set(relative_files) - set(by_path))
+    suffix_counts = Counter(path.suffix.lower() or "<none>" for path in physical_files)
+    unregistered_category_keys = sorted(
+        category for category in category_counts if f"| {category} |" not in attribution_text
+    )
+
+    report = {
+        "audit": "c01_source_asset_registry_v1",
+        "inventory_mode": args.mode,
+        "root": str(root),
+        "canonical": str(canonical.relative_to(root)),
+        "canonical_sha256": sha256(canonical),
+        "record_count": len(records),
+        "path_declarations": {
+            "occurrences": len(declarations),
+            "unique": len(by_path),
+            "required_unique": len(required),
+            "optional_only_unique": len(optional_only),
+            "required_missing": len(missing_required),
+            "permitted_thin_missing": len(permitted_thin_missing) if args.mode == "thin" else 0,
+            "unexpected_required_missing": len(unexpected_missing_required),
+            "optional_missing": len(missing_optional),
+            "outside_source_assets": len(outside),
+            "declared_exists_mismatches": len(flag_mismatches),
+            "existing_file_paths": referenced_existing_files,
+            "existing_directory_paths": referenced_existing_directories,
+        },
+        "physical_inventory": {
+            "files": len(physical_files),
+            "referenced_files": referenced_existing_files,
+            "packaged_support_or_internal_files_not_directly_referenced": physical_unreferenced,
+            "suffix_counts": dict(sorted(suffix_counts.items())),
+            "unclassified_files": len(unclassified_files),
+            "unregistered_category_keys": unregistered_category_keys,
+        },
+        "source_sidecars": {
+            "unique_source_labels": len(source_labels),
+            "direct_source_labels": len(direct_labels),
+            "derived_source_labels": len(derived_labels),
+            "unmapped_direct_labels": unmapped_labels,
+            "citation_markers_absent_from_attributions": uncited_markers,
+        },
+        "category_counts": {
+            category: {"description": CATEGORY_PROVENANCE[category], **dict(sorted(counts.items()))}
+            for category, counts in sorted(category_counts.items())
+        },
+        "missing_required": missing_required,
+        "permitted_thin_missing": permitted_thin_missing if args.mode == "thin" else [],
+        "unexpected_missing_required": unexpected_missing_required,
+        "missing_optional": missing_optional,
+        "outside_source_assets": outside,
+        "declared_exists_mismatches": flag_mismatches,
+        "unclassified_physical_files": unclassified_files,
+        "unclassified_referenced_paths": unclassified_references,
+        "direct_source_labels": direct_labels,
+        "derived_source_labels": derived_labels,
+    }
+
+    output = args.output.expanduser().resolve() if args.output else None
+    if output is not None:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({
+        "mode": args.mode,
+        "output": str(output) if output else None,
+        "required_missing": len(missing_required),
+        "permitted_thin_missing": len(permitted_thin_missing) if args.mode == "thin" else 0,
+        "unexpected_required_missing": len(unexpected_missing_required),
+        "optional_missing": len(missing_optional),
+        "unclassified_files": len(unclassified_files),
+        "unclassified_references": len(unclassified_references),
+        "unmapped_source_labels": len(unmapped_labels),
+        "uncited_source_markers": len(uncited_markers),
+        "unregistered_category_keys": len(unregistered_category_keys),
+    }, indent=2))
+    if unexpected_missing_required or missing_optional or outside or flag_mismatches or unclassified_files or unclassified_references or unmapped_labels or uncited_markers or unregistered_category_keys:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

data/release_tools/build_isolated_test_bundle.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""Materialize a gold-free filesystem root for GeoDisaster test execution."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+from eval_isolation import (
+    DEFAULT_OUTPUT,
+    ROOT,
+    agent_input_surface,
+    audit_agent_rows,
+    path_entries,
+    private_path,
+    read_jsonl,
+)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def inside(path: Path, parent: Path) -> bool:
+    try:
+        path.relative_to(parent)
+        return True
+    except ValueError:
+        return False
+
+
+def safe_relative(path_value: str) -> Path:
+    relative = Path(path_value)
+    if relative.is_absolute() or ".." in relative.parts:
+        raise ValueError(f"unsafe declared path: {path_value}")
+    if private_path(path_value):
+        raise ValueError(f"private path reached bundle builder: {path_value}")
+    return relative
+
+
+def validate_public_question_json(path: Path, relative: Path) -> None:
+    """Reject legacy private hints in a question sidecar before packaging."""
+    if path.suffix.lower() != ".json" or "questions" not in relative.parts:
+        return
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    forbidden = {
+        "aoi_type_hidden",
+        "gt_path_hidden",
+        "gt_link",
+        "oracle_trajectory_link",
+        "expected_final_answer",
+        "final_answer",
+    }
+
+    def walk(value: Any, prefix: str = "") -> list[str]:
+        found: list[str] = []
+        if isinstance(value, dict):
+            for key, child in value.items():
+                field = f"{prefix}.{key}" if prefix else str(key)
+                if key in forbidden:
+                    found.append(field)
+                found.extend(walk(child, field))
+        elif isinstance(value, list):
+            for index, child in enumerate(value):
+                found.extend(walk(child, f"{prefix}[{index}]"))
+        return found
+
+    violations = walk(payload)
+    if violations:
+        raise ValueError(f"private fields in public question sidecar {relative}: {violations}")
+
+
+def declared_files(source_root: Path, rows: list[dict[str, Any]]) -> tuple[dict[Path, set[str]], list[str]]:
+    selected: dict[Path, set[str]] = defaultdict(set)
+    missing_optional: set[str] = set()
+    missing_required: set[str] = set()
+    for row in rows:
+        record_id = str(row["id"])
+        for entry in path_entries(agent_input_surface(row)):
+            relative = safe_relative(str(entry["path"]))
+            source = source_root / relative
+            optional = bool(entry.get("optional"))
+            if not source.exists():
+                (missing_optional if optional else missing_required).add(relative.as_posix())
+                continue
+            if source.is_symlink():
+                raise ValueError(f"symlinks are not allowed in an isolated bundle: {relative}")
+            if source.is_file():
+                validate_public_question_json(source, relative)
+                selected[relative].add(record_id)
+                continue
+            if not source.is_dir():
+                raise ValueError(f"unsupported declared input type: {relative}")
+            for candidate in source.rglob("*"):
+                if not candidate.is_file():
+                    continue
+                child = candidate.relative_to(source_root)
+                if candidate.is_symlink():
+                    raise ValueError(f"symlinks are not allowed in an isolated bundle: {child}")
+                if private_path(child.as_posix()):
+                    continue
+                selected[child].add(record_id)
+    if missing_required:
+        raise RuntimeError(f"required inputs missing: {sorted(missing_required)[:10]}")
+    return dict(selected), sorted(missing_optional)
+
+
+def install_file(source: Path, destination: Path, mode: str) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    if mode == "hardlink":
+        os.link(source, destination)
+    else:
+        shutil.copy2(source, destination)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source-root", type=Path, default=ROOT)
+    parser.add_argument("--inputs", type=Path, default=DEFAULT_OUTPUT)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--mode", choices=("copy", "hardlink"), default="copy")
+    args = parser.parse_args()
+
+    source_root = args.source_root.resolve()
+    output = args.output.resolve()
+    if output == source_root or inside(output, source_root) or inside(source_root, output):
+        raise ValueError("--output must be separate from, and not contain, the source repository")
+    if output.exists() and any(output.iterdir()):
+        raise ValueError("--output must not exist or must be empty")
+    output.mkdir(parents=True, exist_ok=True)
+
+    rows = read_jsonl(args.inputs.resolve())
+    audit = audit_agent_rows(rows)
+    if not audit["ready"]:
+        raise RuntimeError(f"agent-visible input audit failed: {audit}")
+    files, missing_optional = declared_files(source_root, rows)
+
+    manifest_entries = []
+    for relative in sorted(files, key=lambda item: item.as_posix()):
+        source = source_root / relative
+        destination = output / relative
+        install_file(source, destination, args.mode)
+        manifest_entries.append(
+            {
+                "path": relative.as_posix(),
+                "bytes": source.stat().st_size,
+                "sha256": sha256(source),
+                "declared_by": sorted(files[relative]),
+            }
+        )
+
+    input_destination = output / "data/core/geodisaster_2921_test_inputs.jsonl"
+    install_file(args.inputs.resolve(), input_destination, args.mode)
+    manifest = {
+        "schema_version": "geodisaster_isolated_test_bundle_v1",
+        "records": len(rows),
+        "files": len(manifest_entries),
+        "bytes": sum(entry["bytes"] for entry in manifest_entries),
+        "missing_optional_paths": missing_optional,
+        "strict_runtime_environment": {
+            "GEODISASTER_DATASET_ROOT": str(output),
+            "GEODISASTER_STRICT_DATA_ROOT": "1",
+        },
+        "input_audit": audit,
+        "entries": manifest_entries,
+    }
+    manifest_path = output / "evaluation_bundle_manifest.json"
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(
+        json.dumps(
+            {
+                "output": str(output),
+                "records": len(rows),
+                "files": len(manifest_entries),
+                "bytes": manifest["bytes"],
+                "missing_optional": len(missing_optional),
+                "private_paths": len(audit["private_declared_paths"]),
+                "ready": True,
+            },
+            indent=2,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

data/release_tools/compile_c11_replay_lock.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+
+project_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+cache_dir="${GEODISASTER_UV_CACHE_DIR:-${TMPDIR:-/tmp}/geodisaster_uv_cache}"
+
+uv pip compile "$project_root/release_tools/environments/requirements-replay.in" \
+  --python-version 3.10.12 \
+  --python-platform x86_64-manylinux_2_17 \
+  --only-binary :all: \
+  --generate-hashes \
+  --cache-dir "$cache_dir" \
+  --custom-compile-command 'release_tools/compile_c11_replay_lock.sh' \
+  --output-file "$project_root/release_tools/environments/requirements-replay.lock.txt"

data/release_tools/create_c11_replay_environment.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+set -eu
+
+project_root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
+venv_dir="${GEODISASTER_REPLAY_VENV:-$project_root/.venv-geodisaster-replay}"
+cache_dir="${GEODISASTER_UV_CACHE_DIR:-${TMPDIR:-/tmp}/geodisaster_uv_cache}"
+lock="$project_root/release_tools/environments/requirements-replay.lock.txt"
+python_version=$(tr -d '[:space:]' <"$project_root/release_tools/environments/python-replay.version")
+
+if ! command -v uv >/dev/null 2>&1; then
+  echo "uv is required to create the hash-locked replay environment" >&2
+  exit 2
+fi
+if [ ! -f "$lock" ]; then
+  echo "missing replay lock: $lock" >&2
+  exit 2
+fi
+if [ -e "$venv_dir" ] && [ -n "$(find "$venv_dir" -mindepth 1 -print -quit 2>/dev/null)" ]; then
+  echo "refusing to overwrite non-empty environment: $venv_dir" >&2
+  exit 2
+fi
+
+uv venv --python "$python_version" --cache-dir "$cache_dir" "$venv_dir"
+uv pip sync \
+  --python "$venv_dir/bin/python" \
+  --require-hashes \
+  --only-binary :all: \
+  --strict \
+  --cache-dir "$cache_dir" \
+  "$lock"
+uv pip check --python "$venv_dir/bin/python"
+"$venv_dir/bin/python" "$project_root/release_tools/verify_c11_environment.py"
+
+printf '%s\n' "$venv_dir"

data/release_tools/environments/python-replay.version

@@ -0,0 +1 @@
+3.10.12

data/release_tools/environments/requirements-replay.in

@@ -0,0 +1,10 @@
+# Direct dependencies of the deterministic GeoDisaster replay/audit surface.
+# Model training, LLM inference, and HTTP serving are intentionally out of scope.
+# Affine is explicit because 3.x warns on Rasterio 1.4.3's multiplication API.
+affine==2.4.0
+numpy==1.26.4
+scipy==1.11.4
+rasterio==1.4.3
+pyproj==3.7.1
+shapely==2.1.2
+pillow==11.3.0

data/release_tools/environments/requirements-replay.lock.txt

@@ -0,0 +1,331 @@
+# This file was autogenerated by uv via the following command:
+#    release_tools/compile_c11_replay_lock.sh
+affine==2.4.0 \
+    --hash=sha256:8a3df80e2b2378aef598a83c1392efd47967afec4242021a0b06b4c7cbc61a92 \
+    --hash=sha256:a24d818d6a836c131976d22f8c27b8d3ca32d0af64c1d8d29deb7bafa4da1eea
+    # via
+    #   -r release_tools/environments/requirements-replay.in
+    #   rasterio
+attrs==26.1.0 \
+    --hash=sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 \
+    --hash=sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32
+    # via rasterio
+certifi==2026.7.22 \
+    --hash=sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775 \
+    --hash=sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55
+    # via
+    #   pyproj
+    #   rasterio
+click==8.5.0 \
+    --hash=sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360 \
+    --hash=sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34
+    # via
+    #   click-plugins
+    #   cligj
+    #   rasterio
+click-plugins==1.1.1.2 \
+    --hash=sha256:008d65743833ffc1f5417bf0e78e8d2c23aab04d9745ba817bd3e71b0feb6aa6 \
+    --hash=sha256:d7af3984a99d243c131aa1a828331e7630f4a88a9741fd05c927b204bcf92261
+    # via rasterio
+cligj==0.7.2 \
+    --hash=sha256:a4bc13d623356b373c2c27c53dbd9c68cae5d526270bfa71f6c6fa69669c6b27 \
+    --hash=sha256:c1ca117dbce1fe20a5809dc96f01e1c2840f6dcc939b3ddbb1111bf330ba82df
+    # via rasterio
+numpy==1.26.4 \
+    --hash=sha256:03a8c78d01d9781b28a6989f6fa1bb2c4f2d51201cf99d3dd875df6fbd96b23b \
+    --hash=sha256:08beddf13648eb95f8d867350f6a018a4be2e5ad54c8d8caed89ebca558b2818 \
+    --hash=sha256:1af303d6b2210eb850fcf03064d364652b7120803a0b872f5211f5234b399f20 \
+    --hash=sha256:1dda2e7b4ec9dd512f84935c5f126c8bd8b9f2fc001e9f54af255e8c5f16b0e0 \
+    --hash=sha256:2a02aba9ed12e4ac4eb3ea9421c420301a0c6460d9830d74a9df87efa4912010 \
+    --hash=sha256:2e4ee3380d6de9c9ec04745830fd9e2eccb3e6cf790d39d7b98ffd19b0dd754a \
+    --hash=sha256:3373d5d70a5fe74a2c1bb6d2cfd9609ecf686d47a2d7b1d37a8f3b6bf6003aea \
+    --hash=sha256:47711010ad8555514b434df65f7d7b076bb8261df1ca9bb78f53d3b2db02e95c \
+    --hash=sha256:4c66707fabe114439db9068ee468c26bbdf909cac0fb58686a42a24de1760c71 \
+    --hash=sha256:50193e430acfc1346175fcbdaa28ffec49947a06918b7b92130744e81e640110 \
+    --hash=sha256:52b8b60467cd7dd1e9ed082188b4e6bb35aa5cdd01777621a1658910745b90be \
+    --hash=sha256:60dedbb91afcbfdc9bc0b1f3f402804070deed7392c23eb7a7f07fa857868e8a \
+    --hash=sha256:62b8e4b1e28009ef2846b4c7852046736bab361f7aeadeb6a5b89ebec3c7055a \
+    --hash=sha256:666dbfb6ec68962c033a450943ded891bed2d54e6755e35e5835d63f4f6931d5 \
+    --hash=sha256:675d61ffbfa78604709862923189bad94014bef562cc35cf61d3a07bba02a7ed \
+    --hash=sha256:679b0076f67ecc0138fd2ede3a8fd196dddc2ad3254069bcb9faf9a79b1cebcd \
+    --hash=sha256:7349ab0fa0c429c82442a27a9673fc802ffdb7c7775fad780226cb234965e53c \
+    --hash=sha256:7ab55401287bfec946ced39700c053796e7cc0e3acbef09993a9ad2adba6ca6e \
+    --hash=sha256:7e50d0a0cc3189f9cb0aeb3a6a6af18c16f59f004b866cd2be1c14b36134a4a0 \
+    --hash=sha256:95a7476c59002f2f6c590b9b7b998306fba6a5aa646b1e22ddfeaf8f78c3a29c \
+    --hash=sha256:96ff0b2ad353d8f990b63294c8986f1ec3cb19d749234014f4e7eb0112ceba5a \
+    --hash=sha256:9fad7dcb1aac3c7f0584a5a8133e3a43eeb2fe127f47e3632d43d677c66c102b \
+    --hash=sha256:9ff0f4f29c51e2803569d7a51c2304de5554655a60c5d776e35b4a41413830d0 \
+    --hash=sha256:a354325ee03388678242a4d7ebcd08b5c727033fcff3b2f536aea978e15ee9e6 \
+    --hash=sha256:a4abb4f9001ad2858e7ac189089c42178fcce737e4169dc61321660f1a96c7d2 \
+    --hash=sha256:ab47dbe5cc8210f55aa58e4805fe224dac469cde56b9f731a4c098b91917159a \
+    --hash=sha256:afedb719a9dcfc7eaf2287b839d8198e06dcd4cb5d276a3df279231138e83d30 \
+    --hash=sha256:b3ce300f3644fb06443ee2222c2201dd3a89ea6040541412b8fa189341847218 \
+    --hash=sha256:b97fe8060236edf3662adfc2c633f56a08ae30560c56310562cb4f95500022d5 \
+    --hash=sha256:bfe25acf8b437eb2a8b2d49d443800a5f18508cd811fea3181723922a8a82b07 \
+    --hash=sha256:cd25bcecc4974d09257ffcd1f098ee778f7834c3ad767fe5db785be9a4aa9cb2 \
+    --hash=sha256:d209d8969599b27ad20994c8e41936ee0964e6da07478d6c35016bc386b66ad4 \
+    --hash=sha256:d5241e0a80d808d70546c697135da2c613f30e28251ff8307eb72ba696945764 \
+    --hash=sha256:edd8b5fe47dab091176d21bb6de568acdd906d1887a4584a15a9a96a1dca06ef \
+    --hash=sha256:f870204a840a60da0b12273ef34f7051e98c3b5961b61b0c2c1be6dfd64fbcd3 \
+    --hash=sha256:ffa75af20b44f8dba823498024771d5ac50620e6915abac414251bd971b4529f
+    # via
+    #   -r release_tools/environments/requirements-replay.in
+    #   rasterio
+    #   scipy
+    #   shapely
+pillow==11.3.0 \
+    --hash=sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2 \
+    --hash=sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214 \
+    --hash=sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e \
+    --hash=sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59 \
+    --hash=sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50 \
+    --hash=sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632 \
+    --hash=sha256:092c80c76635f5ecb10f3f83d76716165c96f5229addbd1ec2bdbbda7d496e06 \
+    --hash=sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a \
+    --hash=sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51 \
+    --hash=sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced \
+    --hash=sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f \
+    --hash=sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12 \
+    --hash=sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8 \
+    --hash=sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6 \
+    --hash=sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580 \
+    --hash=sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f \
+    --hash=sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac \
+    --hash=sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860 \
+    --hash=sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd \
+    --hash=sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722 \
+    --hash=sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8 \
+    --hash=sha256:23cff760a9049c502721bdb743a7cb3e03365fafcdfc2ef9784610714166e5a4 \
+    --hash=sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673 \
+    --hash=sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788 \
+    --hash=sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542 \
+    --hash=sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e \
+    --hash=sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd \
+    --hash=sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8 \
+    --hash=sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523 \
+    --hash=sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967 \
+    --hash=sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809 \
+    --hash=sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477 \
+    --hash=sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027 \
+    --hash=sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae \
+    --hash=sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b \
+    --hash=sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c \
+    --hash=sha256:48d254f8a4c776de343051023eb61ffe818299eeac478da55227d96e241de53f \
+    --hash=sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e \
+    --hash=sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b \
+    --hash=sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7 \
+    --hash=sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27 \
+    --hash=sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361 \
+    --hash=sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae \
+    --hash=sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d \
+    --hash=sha256:6359a3bc43f57d5b375d1ad54a0074318a0844d11b76abccf478c37c986d3cfc \
+    --hash=sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58 \
+    --hash=sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad \
+    --hash=sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6 \
+    --hash=sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024 \
+    --hash=sha256:6a418691000f2a418c9135a7cf0d797c1bb7d9a485e61fe8e7722845b95ef978 \
+    --hash=sha256:6abdbfd3aea42be05702a8dd98832329c167ee84400a1d1f61ab11437f1717eb \
+    --hash=sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d \
+    --hash=sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0 \
+    --hash=sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9 \
+    --hash=sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f \
+    --hash=sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874 \
+    --hash=sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa \
+    --hash=sha256:7aee118e30a4cf54fdd873bd3a29de51e29105ab11f9aad8c32123f58c8f8081 \
+    --hash=sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149 \
+    --hash=sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6 \
+    --hash=sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d \
+    --hash=sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd \
+    --hash=sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f \
+    --hash=sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c \
+    --hash=sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31 \
+    --hash=sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e \
+    --hash=sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db \
+    --hash=sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6 \
+    --hash=sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f \
+    --hash=sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494 \
+    --hash=sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69 \
+    --hash=sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94 \
+    --hash=sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77 \
+    --hash=sha256:97afb3a00b65cc0804d1c7abddbf090a81eaac02768af58cbdcaaa0a931e0b6d \
+    --hash=sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7 \
+    --hash=sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a \
+    --hash=sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438 \
+    --hash=sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288 \
+    --hash=sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b \
+    --hash=sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635 \
+    --hash=sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3 \
+    --hash=sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d \
+    --hash=sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe \
+    --hash=sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0 \
+    --hash=sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe \
+    --hash=sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a \
+    --hash=sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805 \
+    --hash=sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8 \
+    --hash=sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36 \
+    --hash=sha256:cadc9e0ea0a2431124cde7e1697106471fc4c1da01530e679b2391c37d3fbb3a \
+    --hash=sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b \
+    --hash=sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e \
+    --hash=sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25 \
+    --hash=sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12 \
+    --hash=sha256:e5c5858ad8ec655450a7c7df532e9842cf8df7cc349df7225c60d5d348c8aada \
+    --hash=sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c \
+    --hash=sha256:ea944117a7974ae78059fcc1800e5d3295172bb97035c0c1d9345fca1419da71 \
+    --hash=sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d \
+    --hash=sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c \
+    --hash=sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6 \
+    --hash=sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1 \
+    --hash=sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50 \
+    --hash=sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653 \
+    --hash=sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c \
+    --hash=sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4 \
+    --hash=sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3
+    # via -r release_tools/environments/requirements-replay.in
+pyparsing==3.3.3 \
+    --hash=sha256:928ae7e20211f3b6f3915a72f06a0cfd29ab9d24279dd6346b6b1a7146397d36 \
+    --hash=sha256:ece8c00a69cf01b45d0b1dedabb469c90d8caf996d4fda40f147627a122849a4
+    # via rasterio
+pyproj==3.7.1 \
+    --hash=sha256:04abc517a8555d1b05fcee768db3280143fe42ec39fdd926a2feef31631a1f2f \
+    --hash=sha256:0829865c1d3a3543f918b3919dc601eea572d6091c0dd175e1a054db9c109274 \
+    --hash=sha256:084c0a475688f934d386c2ab3b6ce03398a473cd48adfda70d9ab8f87f2394a0 \
+    --hash=sha256:0b853ae99bda66cbe24b4ccfe26d70601d84375940a47f553413d9df570065e0 \
+    --hash=sha256:1e47c4e93b88d99dd118875ee3ca0171932444cdc0b52d493371b5d98d0f30ee \
+    --hash=sha256:263b54ba5004b6b957d55757d846fc5081bc02980caa0279c4fc95fa0fff6067 \
+    --hash=sha256:2781029d90df7f8d431e29562a3f2d8eafdf233c4010d6fc0381858dc7373217 \
+    --hash=sha256:3537668992a709a2e7f068069192138618c00d0ba113572fdd5ee5ffde8222f3 \
+    --hash=sha256:3c2e7449840a44ce860d8bea2c6c1c4bc63fa07cba801dcce581d14dcb031a02 \
+    --hash=sha256:3e8d276caeae34fcbe4813855d0d97b9b825bab8d7a8b86d859c24a6213a5a0d \
+    --hash=sha256:5ad0ff443a785d84e2b380869fdd82e6bfc11eba6057d25b4409a9bbfa867970 \
+    --hash=sha256:5f0da2711364d7cb9f115b52289d4a9b61e8bca0da57f44a3a9d6fc9bdeb7274 \
+    --hash=sha256:5f8d02ef4431dee414d1753d13fa82a21a2f61494737b5f642ea668d76164d6d \
+    --hash=sha256:60d72facd7b6b79853f19744779abcd3f804c4e0d4fa8815469db20c9f640a47 \
+    --hash=sha256:6181960b4b812e82e588407fe5c9c68ada267c3b084db078f248db5d7f45d18a \
+    --hash=sha256:6575b2e53cc9e3e461ad6f0692a5564b96e7782c28631c7771c668770915e169 \
+    --hash=sha256:83db380c52087f9e9bdd8a527943b2e7324f275881125e39475c4f9277bdeec4 \
+    --hash=sha256:87229e42b75e89f4dad6459200f92988c5998dfb093c7c631fb48524c86cd5dc \
+    --hash=sha256:8c5dcf24ede53d8abab7d8a77f69ff1936c6a8843ef4fcc574646e4be66e5739 \
+    --hash=sha256:8cb516ee35ed57789b46b96080edf4e503fdb62dbb2e3c6581e0d6c83fca014b \
+    --hash=sha256:a20727a23b1e49c7dc7fe3c3df8e56a8a7acdade80ac2f5cca29d7ca5564c145 \
+    --hash=sha256:a8b15b0463d1303bab113d1a6af2860a0d79013c3a66fcc5475ce26ef717fd4f \
+    --hash=sha256:a94e26c1a4950cea40116775588a2ca7cf56f1f434ff54ee35a84718f3841a3d \
+    --hash=sha256:aee664a9d806612af30a19dba49e55a7a78ebfec3e9d198f6a6176e1d140ec98 \
+    --hash=sha256:b35ed213892e211a3ce2bea002aa1183e1a2a9b79e51bb3c6b15549a831ae528 \
+    --hash=sha256:bf09dbeb333c34e9c546364e7df1ff40474f9fddf9e70657ecb0e4f670ff0b0e \
+    --hash=sha256:bf84d766646f1ebd706d883755df4370aaf02b48187cedaa7e4239f16bc8213d \
+    --hash=sha256:d3caac7473be22b6d6e102dde6c46de73b96bc98334e577dfaee9886f102ea2e \
+    --hash=sha256:d61bf8ab04c73c1da08eedaf21a103b72fa5b0a9b854762905f65ff8b375d394 \
+    --hash=sha256:d666c3a3faaf3b1d7fc4a544059c4eab9d06f84a604b070b7aa2f318e227798e \
+    --hash=sha256:f173f851ee75e54acdaa053382b6825b400cb2085663a9bb073728a59c60aebb \
+    --hash=sha256:f550281ed6e5ea88fcf04a7c6154e246d5714be495c50c9e8e6b12d3fb63e158 \
+    --hash=sha256:f6d6a2ccd5607cd15ef990c51e6f2dd27ec0a741e72069c387088bba3aab60fa
+    # via -r release_tools/environments/requirements-replay.in
+rasterio==1.4.3 \
+    --hash=sha256:1839960e2f3057a6daa323ccf67b330f8f2f0dbd4a50cc7031e88e649301c5c0 \
+    --hash=sha256:1a6e6ca9ec361599b48c9918ce25adb1a9203b8c8ca9b34ad78dccb3aef7945a \
+    --hash=sha256:201f05dbc7c4739dacb2c78a1cf4e09c0b7265b0a4d16ccbd1753ce4f2af350a \
+    --hash=sha256:38a126f8dbf405cd3450b5bd10c6cc493a2e1be4cf83442d26f5e4f412372d36 \
+    --hash=sha256:3f411a6a5bcb81ab6dc9128a8bccd13d3822cfa4a50c239e3a0528751a1ad5fc \
+    --hash=sha256:4009f7ce4e0883d8e5b400970daa3f1ca309caac8916d955722ee4486654d452 \
+    --hash=sha256:54eef32d20a0dfbba59a8bb9828e562c3e9e97e2355b8dfe4a5274117976059f \
+    --hash=sha256:597f8dcf494d0ca4254434496e83b1723fec206d23d64da5751a582a2b01e1d3 \
+    --hash=sha256:5b8a4311582274de2346450e5361d092b80b8b5c7b02fda6203402ba101ffabf \
+    --hash=sha256:5d4fcb635379b3d7b2f5e944c153849e3d27e93f35ad73ad4d3f0b8a580f0c8e \
+    --hash=sha256:80f994b92e5dda78f13291710bd5c43efcfd164f69a8a2c20489115df9d178c8 \
+    --hash=sha256:812c854e7177064aeb58def2d59752887ad6b3d39ff3f858ed9df3f2ddc95613 \
+    --hash=sha256:8e90c2c300294265c16becc9822337ded0f01fb8664500b4d77890d633d8cd0e \
+    --hash=sha256:98a9c89eade8c779e8ac1e525269faaa18c6b9818fc3c72cfc4627df71c66d0d \
+    --hash=sha256:9c30114d95ebba4ff49f078b3c193d29ff56d832588649400a3fa78f1dda1c96 \
+    --hash=sha256:a702e21712ba237e34515d829847f9f5f06d8e665e864a7bb0a3d4d8f6dec10d \
+    --hash=sha256:a962ad4c29feaf38b1d7a94389313127de3646a5b9b734fbf9a04e16051a27ff \
+    --hash=sha256:af04f788f6f814569184bd9da6c5d9889512212385ab58c52720dfb1f972671d \
+    --hash=sha256:d9bab1a0bb22b8bed1db34b5258db93d790ed4e61ef21ac055a7c6933c8d5e84 \
+    --hash=sha256:e703e4b2c74c678786d5d110a3f30e26f3acfd65f09ccf35f69683a532f7a772 \
+    --hash=sha256:e79847a5a0e01399457a1e02d8c92040cb56729d054fe7796f0c17b246b18bf0
+    # via -r release_tools/environments/requirements-replay.in
+scipy==1.11.4 \
+    --hash=sha256:00150c5eae7b610c32589dda259eacc7c4f1665aedf25d921907f4d08a951b1c \
+    --hash=sha256:028eccd22e654b3ea01ee63705681ee79933652b2d8f873e7949898dda6d11b6 \
+    --hash=sha256:1b7c3dca977f30a739e0409fb001056484661cb2541a01aba0bb0029f7b68db8 \
+    --hash=sha256:2c6ff6ef9cc27f9b3db93a6f8b38f97387e6e0591600369a297a50a8e96e835d \
+    --hash=sha256:36750b7733d960d7994888f0d148d31ea3017ac15eef664194b4ef68d36a4a97 \
+    --hash=sha256:530f9ad26440e85766509dbf78edcfe13ffd0ab7fec2560ee5c36ff74d6269ff \
+    --hash=sha256:5e347b14fe01003d3b78e196e84bd3f48ffe4c8a7b8a1afbcb8f5505cb710993 \
+    --hash=sha256:6550466fbeec7453d7465e74d4f4b19f905642c89a7525571ee91dd7adabb5a3 \
+    --hash=sha256:6df1468153a31cf55ed5ed39647279beb9cfb5d3f84369453b49e4b8502394fd \
+    --hash=sha256:6e619aba2df228a9b34718efb023966da781e89dd3d21637b27f2e54db0410d7 \
+    --hash=sha256:8fce70f39076a5aa62e92e69a7f62349f9574d8405c0a5de6ed3ef72de07f446 \
+    --hash=sha256:90a2b78e7f5733b9de748f589f09225013685f9b218275257f8a8168ededaeaa \
+    --hash=sha256:91af76a68eeae0064887a48e25c4e616fa519fa0d38602eda7e0f97d65d57937 \
+    --hash=sha256:933baf588daa8dc9a92c20a0be32f56d43faf3d1a60ab11b3f08c356430f6e56 \
+    --hash=sha256:acf8ed278cc03f5aff035e69cb511741e0418681d25fbbb86ca65429c4f4d9cd \
+    --hash=sha256:ad669df80528aeca5f557712102538f4f37e503f0c5b9541655016dd0932ca79 \
+    --hash=sha256:b030c6674b9230d37c5c60ab456e2cf12f6784596d15ce8da9365e70896effc4 \
+    --hash=sha256:b9999c008ccf00e8fbcce1236f85ade5c569d13144f77a1946bef8863e8f6eb4 \
+    --hash=sha256:bc9a714581f561af0848e6b69947fda0614915f072dfd14142ed1bfe1b806710 \
+    --hash=sha256:ce7fff2e23ab2cc81ff452a9444c215c28e6305f396b2ba88343a567feec9660 \
+    --hash=sha256:cf00bd2b1b0211888d4dc75656c0412213a8b25e80d73898083f402b50f47e41 \
+    --hash=sha256:d10e45a6c50211fe256da61a11c34927c68f277e03138777bdebedd933712fea \
+    --hash=sha256:ee410e6de8f88fd5cf6eadd73c135020bfbbbdfcd0f6162c36a7638a1ea8cc65 \
+    --hash=sha256:f313b39a7e94f296025e3cffc2c567618174c0b1dde173960cf23808f9fae4be \
+    --hash=sha256:f3cd9e7b3c2c1ec26364856f9fbe78695fe631150f94cd1c22228456404cf1ec
+    # via -r release_tools/environments/requirements-replay.in
+shapely==2.1.2 \
+    --hash=sha256:0036ac886e0923417932c2e6369b6c52e38e0ff5d9120b90eef5cd9a5fc5cae9 \
+    --hash=sha256:01d0d304b25634d60bd7cf291828119ab55a3bab87dc4af1e44b07fb225f188b \
+    --hash=sha256:0bd308103340030feef6c111d3eb98d50dc13feea33affc8a6f9fa549e9458a3 \
+    --hash=sha256:136ab87b17e733e22f0961504d05e77e7be8c9b5a8184f685b4a91a84efe3c26 \
+    --hash=sha256:16a9c722ba774cf50b5d4541242b4cce05aafd44a015290c82ba8a16931ff63d \
+    --hash=sha256:16c5d0fc45d3aa0a69074979f4f1928ca2734fb2e0dde8af9611e134e46774e7 \
+    --hash=sha256:19efa3611eef966e776183e338b2d7ea43569ae99ab34f8d17c2c054d3205cc0 \
+    --hash=sha256:1d0bfb4b8f661b3b4ec3565fa36c340bfb1cda82087199711f86a88647d26b2f \
+    --hash=sha256:1e7d4d7ad262a48bb44277ca12c7c78cb1b0f56b32c10734ec9a1d30c0b0c54b \
+    --hash=sha256:1f2f33f486777456586948e333a56ae21f35ae273be99255a191f5c1fa302eb4 \
+    --hash=sha256:1ff629e00818033b8d71139565527ced7d776c269a49bd78c9df84e8f852190c \
+    --hash=sha256:21952dc00df38a2c28375659b07a3979d22641aeb104751e769c3ee825aadecf \
+    --hash=sha256:2d93d23bdd2ed9dc157b46bc2f19b7da143ca8714464249bef6771c679d5ff40 \
+    --hash=sha256:2ed4ecb28320a433db18a5bf029986aa8afcfd740745e78847e330d5d94922a9 \
+    --hash=sha256:2fa78b49485391224755a856ed3b3bd91c8455f6121fee0db0e71cefb07d0ef6 \
+    --hash=sha256:346ec0c1a0fcd32f57f00e4134d1200e14bf3f5ae12af87ba83ca275c502498c \
+    --hash=sha256:361b6d45030b4ac64ddd0a26046906c8202eb60d0f9f53085f5179f1d23021a0 \
+    --hash=sha256:40d784101f5d06a1fd30b55fc11ea58a61be23f930d934d86f19a180909908a4 \
+    --hash=sha256:4a44bc62a10d84c11a7a3d7c1c4fe857f7477c3506e24c9062da0db0ae0c449c \
+    --hash=sha256:5860eb9f00a1d49ebb14e881f5caf6c2cf472c7fd38bd7f253bbd34f934eb076 \
+    --hash=sha256:5ebe3f84c6112ad3d4632b1fd2290665aa75d4cef5f6c5d77c4c95b324527c6a \
+    --hash=sha256:61edcd8d0d17dd99075d320a1dd39c0cb9616f7572f10ef91b4b5b00c4aeb566 \
+    --hash=sha256:6305993a35989391bd3476ee538a5c9a845861462327efe00dd11a5c8c709a99 \
+    --hash=sha256:6ddc759f72b5b2b0f54a7e7cde44acef680a55019eb52ac63a7af2cf17cb9cd2 \
+    --hash=sha256:743044b4cfb34f9a67205cee9279feaf60ba7d02e69febc2afc609047cb49179 \
+    --hash=sha256:7ae48c236c0324b4e139bea88a306a04ca630f49be66741b340729d380d8f52f \
+    --hash=sha256:7ed1a5bbfb386ee8332713bf7508bc24e32d24b74fc9a7b9f8529a55db9f4ee6 \
+    --hash=sha256:8cff473e81017594d20ec55d86b54bc635544897e13a7cfc12e36909c5309a2a \
+    --hash=sha256:8d8382dd120d64b03698b7298b89611a6ea6f55ada9d39942838b79c9bc89801 \
+    --hash=sha256:9111274b88e4d7b54a95218e243282709b330ef52b7b86bc6aaf4f805306f454 \
+    --hash=sha256:91121757b0a36c9aac3427a651a7e6567110a4a67c97edf04f8d55d4765f6618 \
+    --hash=sha256:980c777c612514c0cf99bc8a9de6d286f5e186dcaf9091252fcd444e5638193d \
+    --hash=sha256:9a522f460d28e2bf4e12396240a5fc1518788b2fcd73535166d748399ef0c223 \
+    --hash=sha256:9c3a3c648aedc9f99c09263b39f2d8252f199cb3ac154fadc173283d7d111350 \
+    --hash=sha256:a1fd0ea855b2cf7c9cddaf25543e914dd75af9de08785f20ca3085f2c9ca60b0 \
+    --hash=sha256:a444e7afccdb0999e203b976adb37ea633725333e5b119ad40b1ca291ecf311c \
+    --hash=sha256:a84e0582858d841d54355246ddfcbd1fce3179f185da7470f41ce39d001ee1af \
+    --hash=sha256:b510dda1a3672d6879beb319bc7c5fd302c6c354584690973c838f46ec3e0fa8 \
+    --hash=sha256:b54df60f1fbdecc8ebc2c5b11870461a6417b3d617f555e5033f1505d36e5735 \
+    --hash=sha256:b705c99c76695702656327b819c9660768ec33f5ce01fa32b2af62b56ba400a1 \
+    --hash=sha256:ba4d1333cc0bc94381d6d4308d2e4e008e0bd128bdcff5573199742ee3634359 \
+    --hash=sha256:c64d5c97b2f47e3cd9b712eaced3b061f2b71234b3fc263e0fcf7d889c6559dc \
+    --hash=sha256:c8876673449f3401f278c86eb33224c5764582f72b653a415d0e6672fde887bf \
+    --hash=sha256:ca2591bff6645c216695bdf1614fca9c82ea1144d4a7591a466fef64f28f0715 \
+    --hash=sha256:cc4f7397459b12c0b196c9efe1f9d7e92463cbba142632b4cc6d8bbbbd3e2b09 \
+    --hash=sha256:cf831a13e0d5a7eb519e96f58ec26e049b1fad411fc6fc23b162a7ce04d9cffc \
+    --hash=sha256:dc3487447a43d42adcdf52d7ac73804f2312cbfa5d433a7d2c506dcab0033dfd \
+    --hash=sha256:df90e2db118c3671a0754f38e36802db75fe0920d211a27481daf50a711fdf26 \
+    --hash=sha256:e38a190442aacc67ff9f75ce60aec04893041f16f97d242209106d502486a142 \
+    --hash=sha256:e9eddfe513096a71896441a7c37db72da0687b34752c4e193577a145c71736fc \
+    --hash=sha256:eba6710407f1daa8e7602c347dfc94adc02205ec27ed956346190d66579eb9ea \
+    --hash=sha256:ef4a456cc8b7b3d50ccec29642aa4aeda959e9da2fe9540a92754770d5f0cf1f \
+    --hash=sha256:f67b34271dedc3c653eba4e3d7111aa421d5be9b4c4c7d38d30907f796cb30df \
+    --hash=sha256:f6f6cd5819c50d9bcf921882784586aab34a4bd53e7553e175dece6db513a6f0 \
+    --hash=sha256:fe2533caae6a91a543dec62e8360fe86ffcdc42a7c55f9dfd0128a977a896b94 \
+    --hash=sha256:fe7b77dc63d707c09726b7908f575fc04ff1d1ad0f3fb92aec212396bc6cfe5e \
+    --hash=sha256:fe9627c39c59e553c90f5bc3128252cb85dc3b3be8189710666d2f8bc3a5503e
+    # via -r release_tools/environments/requirements-replay.in

data/release_tools/eval_isolation.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+"""Build and validate the agent-visible GeoDisaster test projection.
+
+Reference/gold records remain evaluator-only.  This module owns the narrower
+record contract passed to an evaluated agent and its tools.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Iterable
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_REFERENCE = ROOT / "data/core/geodisaster_2921_test_source.jsonl"
+DEFAULT_OUTPUT = ROOT / "data/core/geodisaster_2921_test_inputs.jsonl"
+
+REFERENCE_ONLY_TOP_LEVEL_KEYS = {
+    "correction_provenance",
+    "executions",
+    "expected_final_answer",
+    "final_answer",
+    "gt_chain",
+    "multiagentic_gt_chain",
+    "source_replay",
+    "tool_sequence",
+}
+
+AGENT_VISIBLE_TOP_LEVEL_KEYS = {
+    "available_initial_handles",
+    "id",
+    "initial_artifacts",
+    "question",
+    "question_type",
+    "sample_id",
+    "split",
+    "split_group_id",
+    "split_seed",
+}
+
+PRIVATE_PATH_SEGMENTS = {"gt", "ground_truth", "hidden", "trajectories"}
+PRIVATE_NAME_MARKERS = {
+    "canonical_answer",
+    "expected_answer",
+    "expected_final_answer",
+    "gt_report",
+    "hidden_gt",
+    "selected_routes.json",
+}
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    return [json.loads(line) for line in path.open(encoding="utf-8") if line.strip()]
+
+
+def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    with temporary.open("w", encoding="utf-8") as stream:
+        for row in rows:
+            stream.write(json.dumps(row, separators=(",", ":"), ensure_ascii=False) + "\n")
+    temporary.replace(path)
+
+
+def private_path(path_value: str) -> bool:
+    path = Path(path_value)
+    lowered_parts = {part.lower() for part in path.parts}
+    lowered_name = path.name.lower()
+    return bool(lowered_parts & PRIVATE_PATH_SEGMENTS) or any(
+        marker in lowered_name for marker in PRIVATE_NAME_MARKERS
+    )
+
+
+def scrub_private_paths(value: Any) -> Any:
+    """Remove only explicit private path cards; retain legitimate input cards."""
+
+    if isinstance(value, dict):
+        path_value = value.get("path")
+        if isinstance(path_value, str) and path_value and private_path(path_value):
+            return None
+        cleaned: dict[str, Any] = {}
+        for key, child in value.items():
+            scrubbed = scrub_private_paths(child)
+            if scrubbed is not None:
+                cleaned[key] = scrubbed
+        return cleaned
+    if isinstance(value, list):
+        return [cleaned for child in value if (cleaned := scrub_private_paths(child)) is not None]
+    return value
+
+
+def agent_visible_record(reference: dict[str, Any]) -> dict[str, Any]:
+    record = {
+        key: reference[key]
+        for key in AGENT_VISIBLE_TOP_LEVEL_KEYS
+        if key in reference
+    }
+    record["initial_artifacts"] = scrub_private_paths(record.get("initial_artifacts") or {})
+    return record
+
+
+def path_entries(value: Any) -> Iterable[dict[str, Any]]:
+    if isinstance(value, dict):
+        if isinstance(value.get("path"), str) and value["path"]:
+            yield value
+        for child in value.values():
+            yield from path_entries(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from path_entries(child)
+
+
+def agent_input_surface(row: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "question": row.get("question") or {},
+        "initial_artifacts": row.get("initial_artifacts") or {},
+    }
+
+
+def audit_agent_rows(
+    rows: list[dict[str, Any]], reference_rows: list[dict[str, Any]] | None = None
+) -> dict[str, Any]:
+    ids = [str(row.get("id") or "") for row in rows]
+    forbidden_keys = sorted(
+        {
+            key
+            for row in rows
+            for key in row
+            if key in REFERENCE_ONLY_TOP_LEVEL_KEYS
+        }
+    )
+    unexpected_keys = sorted({key for row in rows for key in row} - AGENT_VISIBLE_TOP_LEVEL_KEYS)
+    declared = [
+        entry
+        for row in rows
+        for entry in path_entries(agent_input_surface(row))
+    ]
+    private = sorted(
+        {
+            str(entry["path"])
+            for entry in declared
+            if private_path(str(entry["path"]))
+        }
+    )
+    reference_ids = [str(row.get("id") or "") for row in reference_rows or []]
+    result = {
+        "records": len(rows),
+        "unique_ids": len(set(ids)),
+        "duplicate_ids": len(ids) - len(set(ids)),
+        "all_test_split": all(row.get("split") == "test" for row in rows),
+        "ids_match_reference_in_order": reference_rows is None or ids == reference_ids,
+        "reference_only_top_level_keys": forbidden_keys,
+        "unexpected_top_level_keys": unexpected_keys,
+        "declared_path_references": len(declared),
+        "unique_declared_paths": len({str(entry["path"]) for entry in declared}),
+        "private_declared_paths": private,
+    }
+    result["ready"] = (
+        result["records"] == 292
+        and result["unique_ids"] == 292
+        and result["duplicate_ids"] == 0
+        and result["all_test_split"]
+        and result["ids_match_reference_in_order"]
+        and not forbidden_keys
+        and not unexpected_keys
+        and not private
+    )
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--reference", type=Path, default=DEFAULT_REFERENCE)
+    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+    parser.add_argument("--check-only", action="store_true")
+    args = parser.parse_args()
+
+    reference = read_jsonl(args.reference.resolve())
+    if args.check_only:
+        rows = read_jsonl(args.output.resolve())
+    else:
+        rows = [agent_visible_record(row) for row in reference]
+        write_jsonl(args.output.resolve(), rows)
+    report = audit_agent_rows(rows, reference)
+    print(json.dumps(report, indent=2))
+    if not report["ready"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

data/release_tools/evaluate_c12_sen1_accuracy.py

@@ -0,0 +1,410 @@
+#!/usr/bin/env python3
+"""Evaluate the declared Sentinel-1 Otsu baseline against evaluator-only labels.
+
+The canonical tasks intentionally ask for properties of a predicted mask.  This
+script is a separate construct-validity check: it recreates that mask from each
+declared S1 input and compares it with the Sen1Floods11 ``LabelHand`` reference.
+Reference labels are never added to the agent's initial artifacts or answers.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+import numpy as np
+import rasterio
+
+
+METHOD = "s1_min_backscatter_otsu_v1"
+REFERENCE_NAME = "Sen1Floods11 v1.1 LabelHand"
+ACCURACY_KEYS = {"accuracy", "iou", "f1", "precision", "recall"}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def round6(value: float | None) -> float | None:
+    return None if value is None else round(float(value), 6)
+
+
+def safe_div(numerator: int, denominator: int) -> float | None:
+    return None if denominator == 0 else numerator / denominator
+
+
+def otsu_threshold(values: np.ndarray) -> float:
+    """Match the worker's 256-bin Otsu implementation exactly."""
+    values = values[np.isfinite(values)]
+    if values.size == 0:
+        return 0.0
+    hist, edges = np.histogram(values, bins=256)
+    centers = (edges[:-1] + edges[1:]) / 2
+    total = int(hist.sum())
+    if total == 0:
+        return float(np.nanmean(values))
+    weight1 = np.cumsum(hist)
+    weight2 = total - weight1
+    mean1 = np.cumsum(hist * centers) / np.maximum(weight1, 1)
+    mean2 = (
+        np.cumsum((hist * centers)[::-1])
+        / np.maximum(np.cumsum(hist[::-1]), 1)
+    )[::-1]
+    between = weight1[:-1] * weight2[:-1] * (mean1[:-1] - mean2[1:]) ** 2
+    if between.size == 0:
+        return float(np.nanmean(values))
+    return float(centers[:-1][int(np.argmax(between))])
+
+
+def predicted_mask(path: Path) -> tuple[np.ndarray, np.ndarray, float, dict[str, Any]]:
+    with rasterio.open(path) as dataset:
+        band1 = dataset.read(1).astype("float32")
+        band2 = dataset.read(2).astype("float32") if dataset.count >= 2 else band1
+        valid = np.isfinite(band1) & np.isfinite(band2)
+        if dataset.nodata is not None and np.isfinite(float(dataset.nodata)):
+            valid &= (band1 != float(dataset.nodata)) & (band2 != float(dataset.nodata))
+        score = np.minimum(band1, band2)
+        threshold = otsu_threshold(score[valid])
+        mask = valid & (score <= threshold)
+        profile = {
+            "shape": [dataset.height, dataset.width],
+            "crs": str(dataset.crs) if dataset.crs else None,
+            "transform": list(dataset.transform)[:6],
+        }
+    return mask, valid, threshold, profile
+
+
+def contains_accuracy_field(value: Any) -> bool:
+    if isinstance(value, dict):
+        if any(str(key).lower() in ACCURACY_KEYS for key in value):
+            return True
+        return any(contains_accuracy_field(item) for item in value.values())
+    if isinstance(value, list):
+        return any(contains_accuracy_field(item) for item in value)
+    return False
+
+
+def declared_paths(value: Any) -> Iterable[str]:
+    if isinstance(value, dict):
+        path = value.get("path")
+        if isinstance(path, str):
+            yield path
+        for item in value.values():
+            yield from declared_paths(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from declared_paths(item)
+
+
+def load_contract(dataset_path: Path) -> tuple[dict[str, dict[str, Any]], dict[str, Any]]:
+    samples: dict[str, dict[str, Any]] = {}
+    records = []
+    forbidden_declarations = []
+    accuracy_answer_ids = []
+    wrong_method_ids = []
+
+    with dataset_path.open(encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, 1):
+            record = json.loads(line)
+            record_id = str(record.get("id", ""))
+            if not record_id.startswith("sen1_flood/"):
+                continue
+            records.append(record)
+            sample_id = str(record["sample_id"])
+            question_type = str(record["question_type"])
+            expected = record.get("expected_final_answer") or {}
+            if expected.get("prediction_method") != METHOD:
+                wrong_method_ids.append(record_id)
+            if contains_accuracy_field(expected):
+                accuracy_answer_ids.append(record_id)
+            for path in declared_paths(record.get("initial_artifacts") or {}):
+                lowered = path.lower()
+                if "/labelhand.tif" in lowered or "s1otsulabelhand.tif" in lowered:
+                    forbidden_declarations.append({"id": record_id, "path": path})
+
+            s1_path = (
+                record["initial_artifacts"]["sar_chip_1"]["paths"]["s1_image"]["path"]
+            )
+            entry = samples.setdefault(
+                sample_id,
+                {
+                    "sample_id": sample_id,
+                    "split": record["split"],
+                    "s1_path": s1_path,
+                    "question_types": [],
+                    "expected_flood_percentages": [],
+                },
+            )
+            if entry["split"] != record["split"] or entry["s1_path"] != s1_path:
+                raise ValueError(f"inconsistent split or S1 path for {sample_id}")
+            entry["question_types"].append(question_type)
+            if "flood_percentage" in expected:
+                entry["expected_flood_percentages"].append(
+                    {"question_type": question_type, "value": float(expected["flood_percentage"])}
+                )
+
+    if len(records) != 500 or len(samples) != 100:
+        raise ValueError(f"expected 500 records/100 samples, found {len(records)}/{len(samples)}")
+    for sample_id, entry in samples.items():
+        if Counter(entry["question_types"]) != Counter("ABCDE"):
+            raise ValueError(f"{sample_id}: expected one record for each of A-E")
+
+    audit = {
+        "records": len(records),
+        "unique_samples": len(samples),
+        "question_types": sorted({str(row["question_type"]) for row in records}),
+        "records_with_declared_reference_label": len(forbidden_declarations),
+        "declared_reference_label_violations": forbidden_declarations,
+        "records_with_accuracy_fields_in_expected_answer": len(accuracy_answer_ids),
+        "accuracy_field_answer_ids": accuracy_answer_ids,
+        "records_with_wrong_or_missing_prediction_method": len(wrong_method_ids),
+        "wrong_method_ids": wrong_method_ids,
+        "expected_answer_contract": (
+            "agent-facing answers describe deterministic Otsu predictions; "
+            "reference-label accuracy is evaluator-only"
+        ),
+    }
+    return samples, audit
+
+
+def evaluate_sample(root: Path, entry: dict[str, Any]) -> dict[str, Any]:
+    sample_id = entry["sample_id"]
+    s1_path = root / entry["s1_path"]
+    label_path = root / "source_assets" / "sen1_flood" / sample_id / "labels" / "LabelHand.tif"
+    if not s1_path.is_file():
+        raise FileNotFoundError(f"missing declared S1 input: {s1_path}")
+    if not label_path.is_file():
+        raise FileNotFoundError(f"missing evaluator-only reference label: {label_path}")
+
+    prediction, source_valid, threshold, source_profile = predicted_mask(s1_path)
+    with rasterio.open(label_path) as dataset:
+        label = dataset.read(1)
+        label_profile = {
+            "shape": [dataset.height, dataset.width],
+            "crs": str(dataset.crs) if dataset.crs else None,
+            "transform": list(dataset.transform)[:6],
+        }
+    same_grid = (
+        source_profile["shape"] == label_profile["shape"]
+        and source_profile["crs"] == label_profile["crs"]
+        and np.allclose(
+            source_profile["transform"],
+            label_profile["transform"],
+            rtol=0.0,
+            atol=1e-12,
+        )
+    )
+    if not same_grid:
+        raise ValueError(f"{sample_id}: S1/reference grids differ")
+    values = {int(value) for value in np.unique(label)}
+    if not values.issubset({-1, 0, 1}):
+        raise ValueError(f"{sample_id}: unsupported reference values {sorted(values)}")
+
+    full_prediction_count = int(prediction.sum())
+    full_valid_count = int(source_valid.sum())
+    full_percentage = full_prediction_count / full_valid_count * 100 if full_valid_count else 0.0
+    expected_percentages = entry["expected_flood_percentages"]
+    canonical_percentage_match = bool(expected_percentages) and all(
+        abs(round(full_percentage, 6) - round(item["value"], 6)) <= 1e-6
+        for item in expected_percentages
+    )
+
+    valid = label != -1
+    ground_truth = label == 1
+    prediction = prediction & valid
+    tp = int((prediction & ground_truth).sum())
+    fp = int((prediction & (label == 0)).sum())
+    fn = int(((~prediction) & ground_truth & valid).sum())
+    tn = int(((~prediction) & (label == 0) & valid).sum())
+    precision = safe_div(tp, tp + fp)
+    recall = safe_div(tp, tp + fn)
+    iou = safe_div(tp, tp + fp + fn)
+    f1 = safe_div(2 * tp, 2 * tp + fp + fn)
+
+    return {
+        "sample_id": sample_id,
+        "split": entry["split"],
+        "question_record_count": 5,
+        "prediction_method": METHOD,
+        "reference": REFERENCE_NAME,
+        "s1_path": entry["s1_path"],
+        "reference_label_path": str(label_path.relative_to(root)),
+        "s1_sha256": sha256(s1_path),
+        "reference_label_sha256": sha256(label_path),
+        "prediction_threshold": round(float(threshold), 8),
+        "computed_full_s1_flood_percentage": round6(full_percentage),
+        "canonical_expected_flood_percentages": expected_percentages,
+        "canonical_prediction_percentage_match": canonical_percentage_match,
+        "valid_reference_pixels": int(valid.sum()),
+        "reference_flood_pixels": int(ground_truth.sum()),
+        "predicted_flood_pixels_in_reference_footprint": int(prediction.sum()),
+        "TP": tp,
+        "FP": fp,
+        "FN": fn,
+        "TN": tn,
+        "IoU": round6(iou),
+        "precision": round6(precision),
+        "recall": round6(recall),
+        "F1": round6(f1),
+    }
+
+
+def summarize(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    def metric_mean(name: str) -> float | None:
+        values = [float(row[name]) for row in rows if row.get(name) is not None]
+        return round6(float(np.mean(values))) if values else None
+
+    aggregate = {name: sum(int(row[name]) for row in rows) for name in ("TP", "FP", "FN", "TN")}
+    tp, fp, fn = aggregate["TP"], aggregate["FP"], aggregate["FN"]
+    return {
+        "samples": len(rows),
+        "question_records_represented": len(rows) * 5,
+        "samples_without_reference_flood_pixels": sum(
+            int(row["reference_flood_pixels"]) == 0 for row in rows
+        ),
+        "macro": {
+            "IoU": metric_mean("IoU"),
+            "precision": metric_mean("precision"),
+            "recall": metric_mean("recall"),
+            "F1": metric_mean("F1"),
+            "recall_defined_samples": sum(row.get("recall") is not None for row in rows),
+        },
+        "aggregate_confusion": aggregate,
+        "micro": {
+            "IoU": round6(safe_div(tp, tp + fp + fn)),
+            "precision": round6(safe_div(tp, tp + fp)),
+            "recall": round6(safe_div(tp, tp + fn)),
+            "F1": round6(safe_div(2 * tp, 2 * tp + fp + fn)),
+        },
+    }
+
+
+def write_report(output_dir: Path, result: dict[str, Any]) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "summary.json").write_text(
+        json.dumps(result, indent=2, sort_keys=False) + "\n", encoding="utf-8"
+    )
+    with (output_dir / "per_sample_metrics.jsonl").open("w", encoding="utf-8") as stream:
+        for row in result["per_sample_metrics"]:
+            stream.write(json.dumps(row, sort_keys=True) + "\n")
+
+    held_out = result["summaries"]["test"]
+    overall = result["summaries"]["all"]
+    audit = result["contract_audit"]
+    text = f"""# C12 Sentinel-1 reference-label evaluation
+
+This is an evaluator-side construct-validity report. The 500 agent-facing
+questions and expected answers describe outputs of `{METHOD}`. They do not
+claim that those outputs equal the Sen1Floods11 hand labels, and the labels are
+not declared agent inputs.
+
+## Contract audit
+
+- Sentinel records: {audit['records']} (100 scenes x A-E)
+- Declared reference-label paths: {audit['records_with_declared_reference_label']}
+- Expected answers containing accuracy/IoU/F1/precision/recall: {audit['records_with_accuracy_fields_in_expected_answer']}
+- Wrong or missing `prediction_method`: {audit['records_with_wrong_or_missing_prediction_method']}
+- Scenes whose recomputed flood percentage matches the canonical answer: {audit['samples_matching_canonical_prediction_percentage']}/100
+
+## Held-out test result
+
+- Scenes: {held_out['samples']} ({held_out['question_records_represented']} question records)
+- Macro IoU / F1: {held_out['macro']['IoU']} / {held_out['macro']['F1']}
+- Macro precision / recall: {held_out['macro']['precision']} / {held_out['macro']['recall']}
+- Micro IoU / F1: {held_out['micro']['IoU']} / {held_out['micro']['F1']}
+- Micro precision / recall: {held_out['micro']['precision']} / {held_out['micro']['recall']}
+
+## All-scene diagnostic
+
+- Scenes: {overall['samples']} ({overall['question_records_represented']} question records)
+- Macro IoU / F1: {overall['macro']['IoU']} / {overall['macro']['F1']}
+- Micro IoU / F1: {overall['micro']['IoU']} / {overall['micro']['F1']}
+- Scenes with no positive reference pixels (recall undefined): {overall['samples_without_reference_flood_pixels']}
+
+## Interpretation
+
+The baseline has relatively high recall and low precision; it is a simple,
+reproducible flood-candidate baseline, not a validated operational flood map.
+The held-out metrics quantify its agreement with `LabelHand`, but do not turn
+the agent-facing targets into ground-truth flood masks. No acceptance threshold
+was selected after observing these results.
+"""
+    (output_dir / "README.md").write_text(text, encoding="utf-8")
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(description=__doc__)
+    root = Path(__file__).resolve().parents[1]
+    result.add_argument("--root", type=Path, default=root)
+    result.add_argument(
+        "--dataset",
+        type=Path,
+        default=Path("data/core/geodisaster_2921_source_with_splits.jsonl"),
+    )
+    result.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("sen1_accuracy_results"),
+    )
+    return result
+
+
+def main() -> None:
+    args = parser().parse_args()
+    root = args.root.resolve()
+    dataset = args.dataset if args.dataset.is_absolute() else root / args.dataset
+    output_dir = args.output_dir if args.output_dir.is_absolute() else root / args.output_dir
+    samples, audit = load_contract(dataset)
+    if audit["records_with_declared_reference_label"]:
+        raise RuntimeError("reference-label leakage detected in declared initial artifacts")
+    if audit["records_with_accuracy_fields_in_expected_answer"]:
+        raise RuntimeError("agent-facing expected answers improperly contain accuracy fields")
+    if audit["records_with_wrong_or_missing_prediction_method"]:
+        raise RuntimeError("Sentinel expected-answer method contract is inconsistent")
+
+    rows = [evaluate_sample(root, samples[key]) for key in sorted(samples)]
+    canonical_mismatches = [
+        row["sample_id"] for row in rows if not row["canonical_prediction_percentage_match"]
+    ]
+    audit["samples_matching_canonical_prediction_percentage"] = len(rows) - len(canonical_mismatches)
+    audit["canonical_prediction_percentage_mismatches"] = canonical_mismatches
+    if canonical_mismatches:
+        raise RuntimeError(
+            "evaluator prediction does not reproduce canonical expected values for: "
+            + ", ".join(canonical_mismatches)
+        )
+    grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        grouped[str(row["split"])].append(row)
+    if set(grouped) != {"train", "test"}:
+        raise ValueError(f"unexpected sample splits: {sorted(grouped)}")
+    result = {
+        "schema_version": "c12_sen1_reference_label_evaluation_v1",
+        "dataset": str(dataset.relative_to(root)),
+        "dataset_sha256": sha256(dataset),
+        "prediction_method": METHOD,
+        "reference": REFERENCE_NAME,
+        "reference_valid_values": [0, 1],
+        "reference_nodata_value": -1,
+        "contract_audit": audit,
+        "summaries": {
+            "all": summarize(rows),
+            "train": summarize(grouped["train"]),
+            "test": summarize(grouped["test"]),
+        },
+        "per_sample_metrics": rows,
+    }
+    write_report(output_dir, result)
+    print(json.dumps({"output_dir": str(output_dir), "summaries": result["summaries"]}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

data/release_tools/evidence/source_asset_registry_development_snapshot.json

@@ -0,0 +1,272 @@
+{
+  "audit": "c01_source_asset_registry_v1",
+  "canonical": "data/core/geodisaster_2921_source_with_splits.jsonl",
+  "canonical_sha256": "03988b960e6b09ae01fb622fe45b35d763eb705485cddc3cea68bcac7ae63fe1",
+  "category_counts": {
+    "D01": {
+      "description": "Sentinel-1 GRD source raster or GDAL sidecar",
+      "physical_files": 245,
+      "required_paths": 240
+    },
+    "D02": {
+      "description": "Sentinel-2 L2A source raster or GDAL sidecar",
+      "physical_files": 273,
+      "required_paths": 267
+    },
+    "D03": {
+      "description": "Sentinel-2-derived RGB preview",
+      "physical_files": 267,
+      "required_paths": 267
+    },
+    "D04": {
+      "description": "Hansen GFC source/derived mask or GDAL sidecar",
+      "physical_files": 147,
+      "required_paths": 144
+    },
+    "D05": {
+      "description": "project-authored deforestation question",
+      "physical_files": 384,
+      "required_paths": 384
+    },
+    "D06": {
+      "description": "project-generated deforestation quality report",
+      "physical_files": 48
+    },
+    "MH00": {
+      "description": "multi-hazard sample-directory container handle",
+      "physical_files": 1
+    },
+    "MH01": {
+      "description": "project-authored AOI/metadata/handle manifest",
+      "physical_files": 324,
+      "required_paths": 108
+    },
+    "MH02": {
+      "description": "project-authored question, answer, or trajectory record",
+      "physical_files": 1296,
+      "required_paths": 432
+    },
+    "MH03": {
+      "description": "project-generated quality report",
+      "physical_files": 108
+    },
+    "MH04": {
+      "description": "source-derived tabular baseline",
+      "physical_files": 123,
+      "required_paths": 21
+    },
+    "MH05": {
+      "description": "OpenStreetMap POI extract",
+      "physical_files": 108,
+      "required_paths": 108
+    },
+    "MH06": {
+      "description": "source-derived visualization panel",
+      "physical_files": 432
+    },
+    "MH07": {
+      "description": "WorldPop population raster and provider sidecar",
+      "physical_files": 216,
+      "required_paths": 216
+    },
+    "MH08": {
+      "description": "wildfire source/derived raster, sidecar, or GDAL sidecar",
+      "physical_files": 369,
+      "required_paths": 120
+    },
+    "MH09": {
+      "description": "deforestation source/derived raster or sidecar",
+      "physical_files": 368,
+      "required_paths": 184
+    },
+    "MH10": {
+      "description": "urban-expansion source/derived raster or sidecar",
+      "physical_files": 696,
+      "required_paths": 232
+    },
+    "MH11": {
+      "description": "drought source/derived raster or sidecar",
+      "physical_files": 206,
+      "required_paths": 168
+    },
+    "MH12": {
+      "description": "air-pollution source/derived raster or sidecar",
+      "physical_files": 280,
+      "required_paths": 160
+    },
+    "MH13": {
+      "description": "OpenAQ empty-query provenance (no measurements)",
+      "physical_files": 40
+    },
+    "MH14": {
+      "description": "project-authored train-only air-pollution normalization contract",
+      "physical_files": 21,
+      "required_paths": 20
+    },
+    "MH15": {
+      "description": "project-authored train-only drought normalization contract",
+      "physical_files": 21,
+      "required_paths": 21
+    },
+    "R01": {
+      "description": "legacy project-authored routing split export",
+      "physical_files": 3
+    },
+    "R02": {
+      "description": "CEMS flood-extent source vector",
+      "physical_files": 200,
+      "required_paths": 200
+    },
+    "R03": {
+      "description": "Sentinel-2 L2A raster/preview or GDAL sidecar",
+      "physical_files": 401,
+      "required_paths": 400
+    },
+    "R04": {
+      "description": "project-authored routing metadata with source identifiers",
+      "physical_files": 200,
+      "required_paths": 200
+    },
+    "R05": {
+      "description": "OSM+CEMS-derived road/route/score product",
+      "physical_files": 600,
+      "required_paths": 600
+    },
+    "R06": {
+      "description": "project-selected route answer",
+      "physical_files": 200
+    },
+    "R07": {
+      "description": "Sentinel-2+OSM+CEMS-derived route overlay",
+      "physical_files": 200
+    },
+    "S01": {
+      "description": "Sen1Floods11 Sentinel-1 chip or GDAL sidecar",
+      "physical_files": 201,
+      "required_paths": 100
+    },
+    "S02": {
+      "description": "Sen1Floods11 JRC-water layer or GDAL sidecar",
+      "physical_files": 101,
+      "required_paths": 100
+    },
+    "S03": {
+      "description": "Sen1Floods11 hand label or GDAL sidecar",
+      "physical_files": 101
+    },
+    "S04": {
+      "description": "legacy Sen1Floods11 Otsu derivative or GDAL sidecar",
+      "physical_files": 101
+    },
+    "S05": {
+      "description": "source-derived public preview or packaged overlay",
+      "physical_files": 399
+    },
+    "S06": {
+      "description": "project-generated hidden derivative of Sen1Floods11 hand labels",
+      "physical_files": 600
+    },
+    "X01": {
+      "description": "xBD pre/post imagery",
+      "physical_files": 458,
+      "required_paths": 229
+    },
+    "X02": {
+      "description": "xBD-label-derived target mask",
+      "physical_files": 177,
+      "required_paths": 177
+    },
+    "X03": {
+      "description": "xBD damage polygons or coordinate conversion",
+      "physical_files": 458,
+      "required_paths": 229
+    },
+    "X04": {
+      "description": "project-generated grid/quadrant geometry",
+      "physical_files": 458,
+      "required_paths": 354
+    }
+  },
+  "declared_exists_mismatches": [],
+  "derived_source_labels": [
+    "derived from CHIRPS SPI and train-only normalization",
+    "derived from Dynamic World built probability",
+    "derived from ESA WorldCover 2020 and 2021 class 50",
+    "derived from GHSL 2020 and 2025 built surface",
+    "derived from Landsat NBR",
+    "derived from Sentinel-2 NBR",
+    "derived from Sentinel-2 NDBI",
+    "derived from Sentinel-2 NDVI",
+    "derived from Sentinel-2 dNBR",
+    "derived from Sentinel-5P NO2 and train-only mean",
+    "derived training-relative S5P NO2 column"
+  ],
+  "direct_source_labels": [
+    "COPERNICUS/S2_SR_HARMONIZED NBR",
+    "COPERNICUS/S2_SR_HARMONIZED NDBI",
+    "COPERNICUS/S2_SR_HARMONIZED NDVI",
+    "COPERNICUS/S2_SR_HARMONIZED RGB",
+    "COPERNICUS/S5P/OFFL/L3_CO CO",
+    "COPERNICUS/S5P/OFFL/L3_NO2 tropospheric NO2 * 1e6",
+    "COPERNICUS/S5P/OFFL/L3_SO2 SO2 * 1e6",
+    "EC JRC TMF v1_2023 AnnualChanges",
+    "ECMWF Copernicus Atmosphere Monitoring Service \u2014 CAMS Global Near-Real-Time",
+    "ECMWF/ERA5_LAND/DAILY_AGGR volumetric_soil_water_layer_1",
+    "ESA WorldCover 2020 class 50 built-up",
+    "ESA/WorldCover/v200 Map class 50 built-up",
+    "GOOGLE/DYNAMICWORLD/V1 built probability",
+    "JRC/GHSL/P2023A/GHS_BUILT_S 2020 built_surface>0",
+    "JRC/GHSL/P2023A/GHS_BUILT_S 2025 built_surface>0",
+    "LANDSAT/LC08+LC09/C02/T1_L2 NBR",
+    "MODIS/061/MCD19A2_GRANULES Optical_Depth_047 * 0.001",
+    "MODIS/061/MCD64A1 BurnDate",
+    "MODIS/061/MOD13Q1 NDVI",
+    "NASA LP DAAC \u2014 VNP14A1.002 Thermal Anomalies/Fire Daily L3 Global 1 km",
+    "NASA LP DAAC \u2014 VNP21A1D.002 Day LST and Emissivity Daily 1 km",
+    "National Interagency Fire Center \u2014 WFIGS Interagency Fire Perimeters",
+    "UCSB-CHG/CHIRPS/DAILY same-window z-score",
+    "UMD/hansen/global_forest_change_2025_v1_13 lossyear=2022",
+    "UMD/hansen/global_forest_change_2025_v1_13 treecover2000>30",
+    "Wageningen University & Research / Global Forest Watch \u2014 RADD Forest Disturbance Alerts v1"
+  ],
+  "missing_optional": [],
+  "missing_required": [],
+  "outside_source_assets": [],
+  "path_declarations": {
+    "declared_exists_mismatches": 0,
+    "existing_directory_paths": 0,
+    "existing_file_paths": 5681,
+    "occurrences": 14963,
+    "optional_missing": 0,
+    "optional_only_unique": 0,
+    "outside_source_assets": 0,
+    "required_missing": 0,
+    "required_unique": 5681,
+    "unique": 5681
+  },
+  "physical_inventory": {
+    "files": 10831,
+    "packaged_support_or_internal_files_not_directly_referenced": 5150,
+    "referenced_files": 5681,
+    "suffix_counts": {
+      ".csv": 143,
+      ".geojson": 2032,
+      ".json": 3881,
+      ".png": 2133,
+      ".tif": 2614,
+      ".xml": 28
+    },
+    "unclassified_files": 0,
+    "unregistered_category_keys": []
+  },
+  "record_count": 2921,
+  "source_sidecars": {
+    "citation_markers_absent_from_attributions": [],
+    "derived_source_labels": 11,
+    "direct_source_labels": 26,
+    "unique_source_labels": 37,
+    "unmapped_direct_labels": []
+  },
+  "unclassified_physical_files": [],
+  "unclassified_referenced_paths": []
+}

data/release_tools/fetch_sen1floods11_subset.py

@@ -0,0 +1,336 @@
+#!/usr/bin/env python3
+"""Hydrate and verify the 100-chip Sen1Floods11 benchmark subset.
+
+The downloader uses the official public Cloud to Street Google Cloud Storage
+bucket over HTTPS. Files are downloaded atomically and accepted only when
+their size and SHA-256 match the pinned manifest. Existing mismatched files are
+never overwritten unless --replace-mismatched is explicitly supplied.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import shutil
+import sys
+import threading
+import urllib.error
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any
+
+from raster_portability import verify_portable_s1, write_portable_s1
+
+
+REPOSITORY_ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_MANIFEST = REPOSITORY_ROOT / "release_tools/manifests/sen1floods11_required_100.json"
+CANONICAL_RELATIVE_PATH = Path("data/core/geodisaster_2921_source_with_splits.jsonl")
+ALLOWED_LOCAL_PREFIX = Path("source_assets/sen1_flood")
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_manifest(path: Path) -> dict[str, Any]:
+    payload = json.loads(path.read_text())
+    entries = payload.get("entries")
+    if payload.get("schema_version") != "sen1floods11_required_subset_v1":
+        raise ValueError("unsupported or missing manifest schema_version")
+    if not isinstance(entries, list) or not entries:
+        raise ValueError("manifest entries must be a non-empty list")
+    chip_ids = [entry.get("chip_id") for entry in entries]
+    if len(chip_ids) != len(set(chip_ids)):
+        raise ValueError("manifest contains duplicate chip IDs")
+    if payload.get("selected_chip_count") != len(entries):
+        raise ValueError("selected_chip_count does not match manifest entries")
+    derivative = payload.get("portable_derivative")
+    if not isinstance(derivative, dict) or derivative.get("schema_version") != "finite_nodata_geotiff_v1":
+        raise ValueError("missing or unsupported portable_derivative contract")
+    for entry in entries:
+        files = entry.get("files")
+        if (
+            not isinstance(files, list)
+            or len(files) != 2
+            or {item.get("role") for item in files} != {"s1", "jrc"}
+        ):
+            raise ValueError(f"{entry.get('chip_id')}: exactly one s1 and one jrc file are required")
+    return payload
+
+
+def safe_target(root: Path, relative: str) -> Path:
+    relative_path = Path(relative)
+    if relative_path.is_absolute() or ".." in relative_path.parts:
+        raise ValueError(f"unsafe local path in manifest: {relative}")
+    try:
+        relative_path.relative_to(ALLOWED_LOCAL_PREFIX)
+    except ValueError as exc:
+        raise ValueError(f"local path is outside {ALLOWED_LOCAL_PREFIX}: {relative}") from exc
+    target = (root / relative_path).resolve()
+    target.relative_to(root.resolve())
+    return target
+
+
+def file_status(target: Path, item: dict[str, Any]) -> dict[str, Any]:
+    if not target.is_file():
+        return {"status": "missing", "path": str(target)}
+    actual_bytes = target.stat().st_size
+    expected_bytes = int(item["bytes"])
+    if actual_bytes != expected_bytes:
+        return {
+            "status": "size_mismatch",
+            "path": str(target),
+            "expected_bytes": expected_bytes,
+            "actual_bytes": actual_bytes,
+        }
+    actual_sha256 = sha256(target)
+    if actual_sha256 != item["sha256"]:
+        return {
+            "status": "sha256_mismatch",
+            "path": str(target),
+            "expected_sha256": item["sha256"],
+            "actual_sha256": actual_sha256,
+        }
+    return {"status": "verified", "path": str(target), "bytes": actual_bytes}
+
+
+def flatten_entries(manifest: dict[str, Any], limit_chips: int | None) -> list[dict[str, Any]]:
+    entries = manifest["entries"]
+    if limit_chips is not None:
+        if limit_chips <= 0:
+            raise ValueError("--limit-chips must be positive")
+        entries = entries[:limit_chips]
+    flattened = []
+    for entry in entries:
+        for item in entry["files"]:
+            flattened.append({"chip_id": entry["chip_id"], **item})
+    return flattened
+
+
+def portable_pair(root: Path, entry: dict[str, Any]) -> tuple[Path, Path]:
+    s1_item = next(item for item in entry["files"] if item["role"] == "s1")
+    source = safe_target(root, s1_item["local_path"])
+    destination = source.parents[1] / "derived/S1Portable.tif"
+    destination.resolve().relative_to(root.resolve())
+    return source, destination
+
+
+def portable_status(root: Path, entry: dict[str, Any]) -> dict[str, Any]:
+    source, destination = portable_pair(root, entry)
+    if not source.is_file():
+        return {"status": "source_missing", "path": str(destination)}
+    if not destination.is_file():
+        return {"status": "missing", "path": str(destination)}
+    try:
+        details = verify_portable_s1(source, destination)
+    except (OSError, ValueError) as exc:
+        return {"status": "invalid", "path": str(destination), "error": str(exc)}
+    return {"status": "verified", "path": str(destination), **details}
+
+
+def generate_portable(root: Path, entry: dict[str, Any]) -> dict[str, Any]:
+    source, destination = portable_pair(root, entry)
+    before = portable_status(root, entry)
+    if before["status"] == "verified":
+        return {"chip_id": entry["chip_id"], "action": "kept", **before}
+    write_portable_s1(source, destination)
+    after = portable_status(root, entry)
+    if after["status"] != "verified":
+        raise RuntimeError(f"portable derivative failed validation for {entry['chip_id']}: {after}")
+    return {"chip_id": entry["chip_id"], "action": "generated", **after}
+
+
+def download_one(
+    root: Path,
+    item: dict[str, Any],
+    replace_mismatched: bool,
+    timeout: int,
+) -> dict[str, Any]:
+    target = safe_target(root, item["local_path"])
+    before = file_status(target, item)
+    if before["status"] == "verified":
+        return {"chip_id": item["chip_id"], "role": item["role"], "action": "kept", **before}
+    if target.exists() and not replace_mismatched:
+        raise RuntimeError(
+            f"refusing to overwrite {target}: {before['status']}; "
+            "use --replace-mismatched only after reviewing the file"
+        )
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    temporary = target.with_name(
+        f".{target.name}.partial.{os.getpid()}.{threading.get_ident()}"
+    )
+    request = urllib.request.Request(
+        item["https_url"],
+        headers={"User-Agent": "GeoDisaster-Sen1Floods11-hydrator/1.0"},
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response, temporary.open("wb") as output:
+            shutil.copyfileobj(response, output, length=1024 * 1024)
+        downloaded = file_status(temporary, item)
+        if downloaded["status"] != "verified":
+            raise RuntimeError(
+                f"downloaded file failed verification for {item['chip_id']} {item['role']}: "
+                f"{downloaded['status']}"
+            )
+        os.replace(temporary, target)
+        return {
+            "chip_id": item["chip_id"],
+            "role": item["role"],
+            "action": "downloaded",
+            "status": "verified",
+            "path": str(target),
+            "bytes": target.stat().st_size,
+        }
+    finally:
+        if temporary.exists():
+            temporary.unlink()
+
+
+def verify_canonical(root: Path, manifest: dict[str, Any]) -> dict[str, Any]:
+    canonical = root / CANONICAL_RELATIVE_PATH
+    if not canonical.is_file():
+        return {"status": "not_present", "path": str(canonical)}
+    actual = sha256(canonical)
+    expected = manifest["canonical_sha256"]
+    if actual != expected:
+        raise RuntimeError(
+            f"canonical SHA-256 mismatch: expected {expected}, found {actual}; "
+            "regenerate/review the manifest before downloading"
+        )
+    return {"status": "verified", "path": str(canonical), "sha256": actual}
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        description="Download and verify the pinned GeoDisaster Sen1Floods11 subset."
+    )
+    result.add_argument("--manifest", type=Path, default=DEFAULT_MANIFEST)
+    result.add_argument(
+        "--root",
+        type=Path,
+        default=REPOSITORY_ROOT,
+        help="Repository root under which source_assets/sen1_flood is created.",
+    )
+    mode = result.add_mutually_exclusive_group()
+    mode.add_argument("--verify-only", action="store_true", help="Check local files without downloading.")
+    mode.add_argument("--dry-run", action="store_true", help="Print the planned files without downloading.")
+    result.add_argument("--workers", type=int, default=6)
+    result.add_argument("--timeout", type=int, default=120)
+    result.add_argument(
+        "--limit-chips",
+        type=int,
+        help="Process the first N sorted chips; intended for clean-room testing.",
+    )
+    result.add_argument(
+        "--replace-mismatched",
+        action="store_true",
+        help="Atomically replace an existing file only when it fails manifest verification.",
+    )
+    return result
+
+
+def main() -> None:
+    args = parser().parse_args()
+    root = args.root.resolve()
+    manifest = read_manifest(args.manifest.resolve())
+    canonical = verify_canonical(root, manifest)
+    items = flatten_entries(manifest, args.limit_chips)
+
+    if args.dry_run:
+        selected_entries = manifest["entries"][:args.limit_chips] if args.limit_chips else manifest["entries"]
+        result = {
+            "mode": "dry_run",
+            "root": str(root),
+            "canonical": canonical,
+            "selected_chips": len({item["chip_id"] for item in items}),
+            "files": len(items),
+            "bytes": sum(int(item["bytes"]) for item in items),
+            "targets": [item["local_path"] for item in items],
+            "generated_targets": [
+                str(portable_pair(root, entry)[1].relative_to(root)) for entry in selected_entries
+            ],
+        }
+        print(json.dumps(result, indent=2))
+        return
+
+    if args.verify_only:
+        checks = []
+        for item in items:
+            status = file_status(safe_target(root, item["local_path"]), item)
+            checks.append({"chip_id": item["chip_id"], "role": item["role"], **status})
+        counts: dict[str, int] = {}
+        for check in checks:
+            counts[check["status"]] = counts.get(check["status"], 0) + 1
+        selected_entries = manifest["entries"][:args.limit_chips] if args.limit_chips else manifest["entries"]
+        portable_checks = [portable_status(root, entry) for entry in selected_entries]
+        portable_counts: dict[str, int] = {}
+        for check in portable_checks:
+            portable_counts[check["status"]] = portable_counts.get(check["status"], 0) + 1
+        result = {
+            "mode": "verify_only",
+            "root": str(root),
+            "canonical": canonical,
+            "selected_chips": len({item["chip_id"] for item in items}),
+            "files": len(items),
+            "status_counts": counts,
+            "portable_derivative_status_counts": portable_counts,
+            "ready": counts == {"verified": len(items)} and portable_counts == {"verified": len(selected_entries)},
+        }
+        print(json.dumps(result, indent=2))
+        if not result["ready"]:
+            raise SystemExit(1)
+        return
+
+    if args.workers <= 0:
+        raise ValueError("--workers must be positive")
+    results = []
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {
+            pool.submit(download_one, root, item, args.replace_mismatched, args.timeout): item
+            for item in items
+        }
+        for future in as_completed(futures):
+            results.append(future.result())
+    action_counts: dict[str, int] = {}
+    for result in results:
+        action_counts[result["action"]] = action_counts.get(result["action"], 0) + 1
+    final_checks = [
+        file_status(safe_target(root, item["local_path"]), item) for item in items
+    ]
+    selected_entries = manifest["entries"][:args.limit_chips] if args.limit_chips else manifest["entries"]
+    portable_results = [generate_portable(root, entry) for entry in selected_entries]
+    portable_action_counts: dict[str, int] = {}
+    for result in portable_results:
+        portable_action_counts[result["action"]] = portable_action_counts.get(result["action"], 0) + 1
+    ready = all(check["status"] == "verified" for check in final_checks) and all(
+        portable_status(root, entry)["status"] == "verified" for entry in selected_entries
+    )
+    summary = {
+        "mode": "hydrate",
+        "root": str(root),
+        "canonical": canonical,
+        "selected_chips": len({item["chip_id"] for item in items}),
+        "files": len(items),
+        "action_counts": action_counts,
+        "portable_derivative_action_counts": portable_action_counts,
+        "ready": ready,
+    }
+    print(json.dumps(summary, indent=2))
+    if not ready:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (OSError, ValueError, RuntimeError, urllib.error.URLError) as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        raise SystemExit(1)

data/release_tools/manifests/c10_excluded_legacy_rasters.json

@@ -0,0 +1,508 @@
+{
+  "canonical_reference_count": 0,
+  "entries": [
+    {
+      "path": "source_assets/sen1_flood/Bolivia_103757/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "dbac4a09ded6cce55eb05441b9ea212cad6ad33297c915f7c5c1730e9c36a37f"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_129334/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "449c5f0ab347ed3c8aaa2c4170ec799603b43a356626bad7ba753926878d38ed"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_195474/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "a86daf3bf911a77711b96dfdb3558c6bf28bc6c5c86f648cf851f704b9765c19"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_23014/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "640432a0ef13bc821c180f878d2526906f53bd5ab6fac293257fd0522c2dd26b"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_233925/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "07265e51fd77ca7e852c4548bb3fca735a6e9b728c0c3bbc80e7b8ec5bfcb797"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_242570/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "04cc4e9e2fb06539a5640367f439f9a59faad29829ebc5ce5ee0c161be6b7e0b"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_290290/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "3576e294fff8e894e0a86bcf7a79984a55ae672df8a78dca7224d97c1c899e21"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_294583/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "a788e94b48281ba003bcd5aa24f95e88669543596885b3a2cfabb76886bdad45"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_312675/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "84022a5b191235eab4b5f5eae9ec338f9242805c2980e5b75377ed2fcd9e9982"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_314919/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "b2e92fad1f13535347cc701ba9a8a9c37084b3972555bce75d9519e66ca951e6"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_360519/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "aa0b491a24844a108015ab8ea82f82c285d184506d734ba4d37042d7addd8291"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_379434/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "3a743661ed3ad96d5dc06b740de7e5ca6a6fd941d7ac1d36a5aa1336f577d7d5"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_432776/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5cf4d39032052e46165c60c5ee3e4d2142d838650b53d31f8f147e3fccaba7d7"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_60373/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "6c862f39e9808f8553f911cfcaedd8cac5c4ffbf040222fd9d247e344f2047ad"
+    },
+    {
+      "path": "source_assets/sen1_flood/Bolivia_76104/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "830689e48fc96080ba711475c1bd8e392e81eb032a99a4354b2ad5d5ff585410"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_103272/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "10c41028eba3d9a475b37584981c77630b85af272a865c00b8b6d412cfa3d9c8"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_1033830/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "07fafdc2da2348ad654ccb726477e30b717da3b0f8c539bf9212abe4f494b9d1"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_1078550/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "6af19035acf34e406538f23fba0c43d5249354d257ad6d59c67b0b5aff8fcbc6"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_1089161/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f90d1c335dde62f005683405724d47c3597cfdbe522a2feeb8432d7f1d8d0004"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_11745/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "8c13cc0c0656b919fa8d78ac96fb122941e22d49a83e206a84b7438f914cca0e"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_124834/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "8b6563bb752706f1dd3cbcdb21a3753676b592e3d4d8a7433e13ad2b22ea7484"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_128663/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c405453216c0d7ae9ad16d40e5b4d3441575532b820a2cee09c2141cf621f502"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_132163/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "885df6b26d5bd6ccad9c9cd1c436566dbe01ca1813a38f4baa7c9d3e7997ead4"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_134751/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "524f432dee818dd6d362c91525f8781bc8051a882ae12334dd72a23fb44b96e2"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_135389/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "9d4457ce1050511fb579cd2d06df02573dcd81cbca2d6c711778bd377c2ab1ef"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_141271/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "8401f92435f5ef7e60fd157ffa502ea799f3827a7b1fd91fa303b233312fbc24"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_141910/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c219b7d5c211b6da8568a04f98cced2f999a36c752b3e19e10309f01851934ee"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_142312/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "53ae9ad8d59ce592e51bd4b299afa44c3a11eaed7be7a9aa9a64c430faa7e936"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_144050/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "3688ece998533a687109bf6e88b381128670d5f5ed9ceed1a2df86b062a825bb"
+    },
+    {
+      "path": "source_assets/sen1_flood/Ghana_146222/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "7cddd620703ae23cd0b5a774774aceee99aa8145ad0c8a7e8be759a995cfbd4b"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1017769/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "ec6fb595dda776991fafe259b09442b1830cc0289bba2081474f8fc2fdb26afa"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1018317/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "202bbe7a4d54bace5a687cafcb88be7a2a330f645d11dca9b3c9f68fb3e78c24"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1018327/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "65b4d519e11bb2d1038c455f0305f8133020d957cfe9816d10a16065a76b6ab6"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_103447/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5659b0f8001f0a817d77f009dd90e17238b9209c41bac0d8b8e65298ebe554b6"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1050276/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "9f8e2bbce1a66cff4314cb024caba451e7308d354664eec4650f10e4c3be9f37"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1068117/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "b8edefcb6c1829d80e0c73e252b379c33a3b24a5ed0f157926f47dc5263b00d3"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_1072277/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "e558cf14a832902931f57beaf145ddc2b4cecfa803cc868a65758a46f5f1f04f"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_118868/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "822c8c1d74759323531bfb459450b489c2d2263c6477dfaf564ed4b2c3926e3f"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_135434/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c9745e56265764e5584d77175a4dd608acaccea37e7e843cf66700618f87f546"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_136196/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "0e13fcef2a3b9d225b4be1779c5b059d643ee3a6515e202da504808ff06e3e09"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_164336/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "3886e57edb91ad3cabc29cf0caea989b8a047ac8ce8d7e5e90be45d31227bec5"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_166709/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f8246bb59472f1f50120d724a42c61e3797483ac58151641e0a2988d2b215201"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_177319/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "53ca896b16f8920a9bb22b8e74dc6181313b227d6350367aa6082bd1cc3b7885"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_179238/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "a753d9e5d69efac62ae77acaf2207bbf57574eef2b28d1b479521294e2082ef8"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_180633/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "7830926ce6deb4f54145219eae0e981862d38dc680f1d385a6ddb4dfa163c363"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_207862/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "6ef4e97137dff8ee9e5abe92b5d51f087c3880d39302b1f9d40bcc7421bae186"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_244057/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "145dffbe4c64c02278f732252d861c58a0d842da3ef09daff4216316567a90a3"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_25540/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "075783c0d0ee98487d5ba587d223fc0986716449d340029cf59fc146931d0635"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_265762/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "62456da1b68564aba1c41ac029cc252b5ff34ff1765c2ad738c40a7dee6b0a68"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_273873/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "a5b49ceb6c9de746c3d9b809b8606adb613dc4c5aceeacde4a63c16b224d8234"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_285297/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "26cabac556923ce2a7b408970f9254b8eb8368d5f8073da1d9de7d2c6bf1a84f"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_287642/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5795303add546a4319782dc677a60639b7e4609b41823153616135c41080f5e4"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_324254/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "d26df053ee8de991ae4be6d5fc73ee687c35db6ec82d0d5b8f33c8da700ef76d"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_373039/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "29e48d40ab9deeb5ee43427b075861467e7a7916eabfbd4bb7b5e90eef6c0cce"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_383430/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "898c104ab00f5bda3efd33727ae4dc95b60de05c7fb1ea99a34b0c449bc470ed"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_391908/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "0b9a16ae7b48a5b8d9b7c09444f06135a931d282f7b1872ef78b935562992391"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_399883/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "0e8861fbd25e1e1cdd69972562569bc765404aa65889bf1e9317d4f6209e63bb"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_44475/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "d0a5840ed59360ccf0ef94e1f925981300e97a77b4fe1aa6edfd94e7435fb045"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_500266/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "bf047a691173603070271dfe8ddf6b077a4f6367c31bdbdda2ef25662a56016a"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_533192/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "1b14c8eb84d302141a4d7b3b2756b43fca5bcc102bcfc72b434e304e31c3965c"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_534470/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "720d789c680d0bb3a03f85b58aafdb14cdf33183e4f496985f2b03e6bc18b760"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_56450/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "e901fd70e8dbd74e249660a08ae8300ef6dbc9f47942f2f4bb7d527fb27efcbc"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_566697/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "4a521e132493d7022854a6894f720fe9c2f9cc4b2930479e0150bca4129628ff"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_570384/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "3b821359dbaf87eabc51d041a1ebe1c03419bf2b0029b2d1c72b654078829cd4"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_591317/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "391e11d293638ab724c52163083eba126bb3ea0970b3c22d757b9c37c22177e1"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_591549/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f5b0247fd05db910f591ac006d64242a1ed62acf30549b8113b6a36f22da44c3"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_592446/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "760b19b6320140e9dc2c1218c82796af0a9eb5e8945240c05ea331ccfa3b31c0"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_59460/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "a6bb52aaea1f18d5ab6ce694f1bf6a9f4ef611b138a5c8156f9514e154fe3c94"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_624341/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "53cb2b34565aeeaea80ff2075c17cf02e8b58f74bc2f2b303a9b5015de1ac09c"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_631692/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c19c18fd21488a9d8f57bf1ce1cb987cfd6cf2125c5e5cb0ca46b397939e6fbd"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_652725/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "ee1e20c4a2c7dc197ec8da0ec164f2e453b4cd5c81071f62cc2ebfa13c0d0fe8"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_664410/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "9e7d60251bb6d6305690faf1e6fdfd4fcaad5f98355f58b8cd9a02dc61e2182d"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_691027/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "df1cd3e6c14124700adc49958f132be52d3083e73cd34feb019bd2ee424820cc"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_698338/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "af97be37210b3245c64d05a0f2c050abb5a33a3e027a5c3714b03dc4f3b77285"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_70352/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c6d025c8aa2840c44b8b846d818b26555c82dc9cba43931b72f751f9cbf1ec1f"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_707886/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "8c257a7a50e44f97817edfdc9c49b6230abdac5f46161185c82e4c6d61414888"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_73419/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "e7dd6dd180cc2281b30028c63d23c5927ac64f96738968497bf9487dd359315e"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_747970/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f7e9f231a3fae080e8fa9f0876d7600b3c1003491be841d22212118c78141905"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_747992/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "75ad79e46e6d7f58b20763e304325f825200cac97908556f72dd82e2ba2dfe6e"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_764946/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5ad1a296bf6c214e54abbfac6596bd35b796d699bbbc942e5d0fe9dd2c1ea6ce"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_769408/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5a93377e5968c66d6b56b7c3fda1c87f4167668ca17d6c2c5f6bde9f3f423c9c"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_772630/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "6da73f90f1b60c98227b294399b6a25b649d47776ac1a10dda4418c6f2745a91"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_773682/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "fede6afd38c02609da69458d71aeeb497cf58f973fd7d740025bf74df07babe5"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_774689/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f65f06129798015a19ab9cfa1e0225a1aa1bdd050e357dcbac5248d5915b6d3e"
+    },
+    {
+      "path": "source_assets/sen1_flood/India_79637/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "5b761d017bbd936c27f8c05955b43035e8c499fca64c45ec0fa2c7f77cd77998"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_1068756/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "7d5c38bb73462f45325653b6f5021fd239c98336f0a8872c33a39c6d5cdadade"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_1087508/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "28d3ae602bdbc43a5ec0420f5cdbb72edb1fe2473c2d474b6c7c852fdaea3775"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_12849/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "29460974cd1962a3e7ef319d18967f75573ca011db03553cfeed723f845894eb"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_166342/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "f99a2acde8e5f6615ac1d6c0ee249e06c5a68e4d1855ddd3b70413ff2eeee1b5"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_167787/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "7557c149b52e6d7d55d1282ef82b15420554ed4e001489b6ff8888b611130159"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_195014/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "797bb3061090bfcb531f0bf10cf6e821bcb8dc33926ccd6575351f96808d4b94"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_205466/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "fffe0cbdb746bbb9e945910b1a980c3e1884df9609d503f5c913068b799fe743"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_230192/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "8c6daa22a2d1c03e12004742d6d590de248262f90c7246ae575e4a4a4f61c00c"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_256539/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "cf2bd3dd1dbfef5b747d7eea882da3b5c147d01b04a56cb088290f6309097d9c"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_295782/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "c39dcfbaff9d72f8a4f255fd093f3ec82991e5b1e2685ef7227fde7957f22f13"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_322855/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "14a393ea20425918e763788adfc6961e7fcff28271021b274afa7cdff84d4f58"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_32375/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "0ce9d2f192ee4ddfb20c2ee0c5c2f94cd37a67b9687d0ec3e0708ce643f67008"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_371421/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "67597bb69cd8ff4da7e83636b78cd20ab25c727559921be6f40977c6a7a98a3f"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_60129/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "27776397eb71b7149b3f6eae7d56fd33f4e6d343b87e39e2b063f4d05f1a401b"
+    },
+    {
+      "path": "source_assets/sen1_flood/Somalia_61368/labels/S1OtsuLabelHand.tif",
+      "release_disposition": "exclude",
+      "sha256": "7ad6c05a7bf39b9a26b53ee9b86e1acb67e419e375fcc23a8968b3ae99cc1534"
+    }
+  ],
+  "public_release_action": "Do not package these historical support files; current predictions are recomputed from the declared portable S1 derivative.",
+  "reason": "Legacy cached Sen1Floods11 Otsu derivatives use -1 nodata, are not declared by any canonical record, and are forbidden answer inputs.",
+  "schema_version": "geodisaster_release_exclusions_v1"
+}

data/release_tools/raster_portability.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Deterministic finite-nodata GeoTIFF conversions used by C10."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import rasterio
+
+
+S1_PORTABLE_NODATA = -9999.0
+BINARY_PORTABLE_NODATA = 255
+
+
+def valid_pixels(data: np.ndarray, nodata: float | int | None) -> np.ndarray:
+    """Return pixels valid in every band, including a finite nodata value."""
+    bands = data if data.ndim == 3 else data[np.newaxis, ...]
+    valid = np.logical_and.reduce([np.isfinite(band) for band in bands])
+    if nodata is not None and np.isfinite(float(nodata)):
+        valid &= np.logical_and.reduce([band != float(nodata) for band in bands])
+    return valid
+
+
+def _copy_tags(source: rasterio.io.DatasetReader, target: rasterio.io.DatasetWriter) -> None:
+    target.update_tags(**source.tags())
+    for index in range(1, source.count + 1):
+        target.update_tags(index, **source.tags(index))
+        if source.descriptions[index - 1]:
+            target.set_band_description(index, source.descriptions[index - 1])
+
+
+def _atomic_raster_write(destination: Path, writer: Any) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.stem}.tmp.{os.getpid()}{destination.suffix}")
+    try:
+        writer(temporary)
+        os.replace(temporary, destination)
+    finally:
+        if temporary.exists():
+            temporary.unlink()
+
+
+def write_portable_s1(source: Path, destination: Path) -> dict[str, Any]:
+    """Preserve finite S1 values and encode invalid pixels as finite -9999."""
+    source = source.resolve()
+    destination = destination.resolve()
+    with rasterio.open(source) as dataset:
+        data = dataset.read().astype("float32")
+        valid = valid_pixels(data, dataset.nodata)
+        if np.any(data[:, valid] == S1_PORTABLE_NODATA):
+            raise ValueError(f"valid source pixels collide with {S1_PORTABLE_NODATA}: {source}")
+        converted = data.copy()
+        converted[:, ~valid] = S1_PORTABLE_NODATA
+        profile = dataset.profile.copy()
+        profile.update(dtype="float32", nodata=S1_PORTABLE_NODATA, compress="deflate", predictor=3)
+
+        def writer(path: Path) -> None:
+            with rasterio.open(path, "w", **profile) as output:
+                output.write(converted)
+                _copy_tags(dataset, output)
+
+        _atomic_raster_write(destination, writer)
+        return {
+            "bands": int(dataset.count),
+            "height": int(dataset.height),
+            "width": int(dataset.width),
+            "valid_spatial_pixels": int(valid.sum()),
+            "invalid_spatial_pixels": int(valid.size - valid.sum()),
+            "source_nodata": str(dataset.nodata),
+            "portable_nodata": S1_PORTABLE_NODATA,
+        }
+
+
+def verify_portable_s1(source: Path, destination: Path) -> dict[str, Any]:
+    """Prove a portable S1 raster is a value-preserving source derivative."""
+    if not destination.is_file():
+        raise FileNotFoundError(destination)
+    with rasterio.open(source) as upstream, rasterio.open(destination) as portable:
+        original = upstream.read().astype("float32")
+        derived = portable.read().astype("float32")
+        valid = valid_pixels(original, upstream.nodata)
+        if original.shape != derived.shape:
+            raise ValueError(f"shape mismatch: {source} vs {destination}")
+        if portable.nodata != S1_PORTABLE_NODATA:
+            raise ValueError(f"unexpected portable nodata {portable.nodata}: {destination}")
+        if upstream.crs != portable.crs or upstream.transform != portable.transform:
+            raise ValueError(f"georeferencing mismatch: {source} vs {destination}")
+        if not np.array_equal(original[:, valid], derived[:, valid]):
+            raise ValueError(f"valid values changed: {source} vs {destination}")
+        if not np.all(derived[:, ~valid] == S1_PORTABLE_NODATA):
+            raise ValueError(f"invalid values were not normalized: {destination}")
+        return {
+            "valid_spatial_pixels": int(valid.sum()),
+            "invalid_spatial_pixels": int(valid.size - valid.sum()),
+            "valid_values_identical": True,
+            "georeferencing_identical": True,
+            "nodata": S1_PORTABLE_NODATA,
+        }
+
+
+def normalize_binary_mask_in_place(path: Path) -> dict[str, Any]:
+    """Convert one binary mask to uint8 0/1 with nodata 255, preserving validity."""
+    path = path.resolve()
+    with rasterio.open(path) as dataset:
+        if dataset.count != 1:
+            raise ValueError(f"binary mask must have one band: {path}")
+        source = dataset.read(1)
+        valid = valid_pixels(source, dataset.nodata)
+        positive = valid & (source > 0)
+        converted = np.full(source.shape, BINARY_PORTABLE_NODATA, dtype="uint8")
+        converted[valid] = positive[valid].astype("uint8")
+        profile = dataset.profile.copy()
+        profile.update(
+            dtype="uint8",
+            count=1,
+            nodata=BINARY_PORTABLE_NODATA,
+            compress="deflate",
+            predictor=2,
+        )
+        source_nodata = dataset.nodata
+
+        def writer(destination: Path) -> None:
+            with rasterio.open(destination, "w", **profile) as output:
+                output.write(converted, 1)
+                _copy_tags(dataset, output)
+
+        _atomic_raster_write(path, writer)
+        return {
+            "valid_pixels": int(valid.sum()),
+            "invalid_pixels": int(valid.size - valid.sum()),
+            "positive_pixels": int(positive.sum()),
+            "source_nodata": str(source_nodata),
+            "portable_nodata": BINARY_PORTABLE_NODATA,
+        }
+
+
+def verify_portable_binary_mask(path: Path) -> dict[str, Any]:
+    with rasterio.open(path) as dataset:
+        values = dataset.read(1)
+        if dataset.count != 1 or dataset.dtypes[0] != "uint8":
+            raise ValueError(f"portable binary raster must be one uint8 band: {path}")
+        if dataset.nodata != BINARY_PORTABLE_NODATA:
+            raise ValueError(f"unexpected binary nodata {dataset.nodata}: {path}")
+        unique = set(int(value) for value in np.unique(values))
+        if not unique <= {0, 1, BINARY_PORTABLE_NODATA}:
+            raise ValueError(f"non-binary values {sorted(unique)}: {path}")
+        valid = values != BINARY_PORTABLE_NODATA
+        return {
+            "valid_pixels": int(valid.sum()),
+            "invalid_pixels": int(valid.size - valid.sum()),
+            "positive_pixels": int((values == 1).sum()),
+            "values": sorted(unique),
+            "nodata": BINARY_PORTABLE_NODATA,
+        }

data/release_tools/replay_all_2921.py

@@ -0,0 +1,829 @@
+#!/usr/bin/env python3
+"""Execute every canonical GeoDisaster GT chain with the real process_* tools.
+
+The driver uses ``gt_chain`` only to select the validation call order. Workers
+receive a sanitized case containing the question and initial input artifacts;
+they never receive the expected answer or the chain itself. Every generated
+handle is persisted by the run-scoped worker runtime under the chosen output
+directory.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib
+import json
+import math
+import multiprocessing as mp
+import os
+import sys
+import time
+import traceback
+import types
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+TOOLS = {
+    "ReadData",
+    "PrepareScene",
+    "ComputeStats",
+    "MeasureArea",
+    "CompareSources",
+    "DetectChange",
+    "ClassifyChange",
+    "ScoreHazard",
+    "EstimateExposure",
+    "AssessDamage",
+    "RankRegions",
+    "CompareScenes",
+    "ExtractObjects",
+    "MapFlood",
+    "DescribeFlood",
+    "PlanRoutes",
+    "CompareRoutes",
+    "RenderMap",
+}
+
+_STATE: Any = None
+_MODULES: dict[str, Any] = {}
+_CASE_DIR: Path | None = None
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_no, line in enumerate(handle, 1):
+            if line.strip():
+                try:
+                    rows.append(json.loads(line))
+                except Exception as exc:
+                    raise ValueError(f"invalid JSON at {path}:{line_no}: {exc}") from exc
+    return rows
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(path.suffix + f".tmp.{os.getpid()}")
+    with temporary.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, ensure_ascii=False, default=str)
+        handle.write("\n")
+    temporary.replace(path)
+
+
+def install_import_stubs() -> None:
+    """Avoid importing the HTTP worker server when only process_* is needed."""
+    base_name = "tool_server.tool_workers.online_workers.base_tool_worker"
+    if base_name not in sys.modules:
+        base_module = types.ModuleType(base_name)
+
+        class BaseToolWorker:
+            def __init__(self, *args: Any, **kwargs: Any) -> None:
+                pass
+
+            def run(self) -> None:
+                pass
+
+        base_module.BaseToolWorker = BaseToolWorker
+        sys.modules[base_name] = base_module
+
+    server_name = "tool_server.utils.server_utils"
+    if server_name not in sys.modules:
+        server_module = types.ModuleType(server_name)
+
+        class DummyLogger:
+            def info(self, *args: Any, **kwargs: Any) -> None:
+                pass
+
+            def warning(self, *args: Any, **kwargs: Any) -> None:
+                pass
+
+            def error(self, *args: Any, **kwargs: Any) -> None:
+                pass
+
+        server_module.build_logger = lambda *args, **kwargs: DummyLogger()
+        sys.modules[server_name] = server_module
+
+
+def initialize_worker(code_root: str, dataset_root: str, output_dir: str) -> None:
+    global _STATE, _CASE_DIR, _MODULES
+    code_path = str(Path(code_root).resolve())
+    if code_path not in sys.path:
+        sys.path.insert(0, code_path)
+    os.environ["GEODISASTER_DATASET_ROOT"] = str(Path(dataset_root).resolve())
+    install_import_stubs()
+    _STATE = importlib.import_module(
+        "tool_server.tool_workers.online_workers.final_dataset_worker_state"
+    )
+    output = Path(output_dir).resolve()
+    _STATE.SESSION_DIR = output / "sessions"
+    _STATE.ARTIFACT_DIR = output / "artifacts"
+    _STATE.SESSION_DIR.mkdir(parents=True, exist_ok=True)
+    _STATE.ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    _CASE_DIR = output / "cases"
+    _CASE_DIR.mkdir(parents=True, exist_ok=True)
+    _MODULES = {}
+
+
+def sanitized_case(record: dict[str, Any]) -> dict[str, Any]:
+    return {
+        key: record[key]
+        for key in ("id", "sample_id", "question_type", "question", "initial_artifacts")
+        if key in record
+    }
+
+
+def compact(value: Any, max_chars: int = 24000) -> Any:
+    text = json.dumps(value, ensure_ascii=False, sort_keys=True, default=str)
+    if len(text) <= max_chars:
+        return value
+    return {"_truncated": True, "_chars": len(text), "_preview": text[:max_chars]}
+
+
+def flatten_scalars(value: Any, prefix: str = "") -> list[tuple[str, Any]]:
+    rows: list[tuple[str, Any]] = []
+    if isinstance(value, dict):
+        for key, child in value.items():
+            child_prefix = f"{prefix}.{key}" if prefix else str(key)
+            rows.extend(flatten_scalars(child, child_prefix))
+    elif isinstance(value, list):
+        for index, child in enumerate(value):
+            rows.extend(flatten_scalars(child, f"{prefix}[{index}]"))
+    else:
+        rows.append((prefix, value))
+    return rows
+
+
+def values_match(expected: Any, actual: Any) -> bool:
+    if expected is None:
+        return actual is None
+    if isinstance(expected, bool):
+        return isinstance(actual, bool) and actual is expected
+    if isinstance(expected, (int, float)) and not isinstance(expected, bool):
+        if isinstance(actual, bool):
+            return False
+        try:
+            expected_float = float(expected)
+            actual_float = float(actual)
+        except Exception:
+            return False
+        if not math.isfinite(expected_float) or not math.isfinite(actual_float):
+            return expected_float == actual_float
+        return abs(expected_float - actual_float) <= max(
+            1e-4, 1e-4 * max(1.0, abs(expected_float))
+        )
+    if isinstance(expected, str):
+        left = " ".join(expected.lower().split())
+        right = " ".join(str(actual).lower().split())
+        return left == right or (len(left) >= 8 and left in right) or (
+            len(right) >= 8 and right in left
+        )
+    return expected == actual
+
+
+def answer_support(expected: Any, artifacts: dict[str, Any]) -> dict[str, Any]:
+    """Measure whether expected scalar values occur in generated evidence.
+
+    This is deliberately an evidence-coverage audit, not an exact-answer
+    accuracy score. The runtime answer-contract layer projects the analytical
+    artifacts into the requested answer schema before strict scoring.
+    """
+    expected_leaves = [
+        (path, value)
+        for path, value in flatten_scalars(expected)
+        if value is not None and not isinstance(value, (dict, list))
+    ]
+    observed: list[tuple[str, Any]] = []
+    for handle, card in artifacts.items():
+        if not isinstance(card, dict):
+            continue
+        for field in ("result", "evidence"):
+            if field in card:
+                observed.extend(
+                    (f"{handle}.{path}", value)
+                    for path, value in flatten_scalars(card[field])
+                )
+    matched: list[dict[str, Any]] = []
+    missing: list[dict[str, Any]] = []
+    for path, value in expected_leaves:
+        hit = next(
+            ((observed_path, observed_value) for observed_path, observed_value in observed
+             if values_match(value, observed_value)),
+            None,
+        )
+        if hit:
+            matched.append(
+                {
+                    "path": path,
+                    "expected": value,
+                    "observed_path": hit[0],
+                    "observed": hit[1],
+                }
+            )
+        else:
+            missing.append({"path": path, "expected": value})
+    score = len(matched) / len(expected_leaves) if expected_leaves else 1.0
+    return {
+        "score": round(score, 6),
+        "matched_leaf_count": len(matched),
+        "expected_leaf_count": len(expected_leaves),
+        "missing_leaf_count": len(missing),
+        "missing": missing,
+        "matched": matched,
+    }
+
+
+def input_path_audit(records: list[dict[str, Any]], dataset_root: Path) -> dict[str, Any]:
+    references: list[dict[str, Any]] = []
+
+    def visit(value: Any, record_id: str) -> None:
+        if isinstance(value, dict):
+            if isinstance(value.get("path"), str) and (
+                "exists" in value or "optional" in value
+            ):
+                declared = value["path"]
+                path = Path(declared)
+                resolved = path if path.is_absolute() else dataset_root / path
+                resolved = resolved.resolve()
+                try:
+                    resolved.relative_to(dataset_root)
+                    inside_root = True
+                except ValueError:
+                    inside_root = False
+                references.append(
+                    {
+                        "record_id": record_id,
+                        "path": declared,
+                        "optional": bool(value.get("optional")),
+                        "exists_now": resolved.exists(),
+                        "absolute": path.is_absolute(),
+                        "inside_dataset_root": inside_root,
+                    }
+                )
+            for child in value.values():
+                visit(child, record_id)
+        elif isinstance(value, list):
+            for child in value:
+                visit(child, record_id)
+
+    for record in records:
+        visit(
+            {
+                "question": record.get("question"),
+                "initial_artifacts": record.get("initial_artifacts"),
+            },
+            str(record.get("id")),
+        )
+    missing_required = [r for r in references if not r["exists_now"] and not r["optional"]]
+    missing_optional = [r for r in references if not r["exists_now"] and r["optional"]]
+    outside = [r for r in references if not r["inside_dataset_root"]]
+    absolute = [r for r in references if r["absolute"]]
+    return {
+        "path_references": len(references),
+        "unique_paths": len({r["path"] for r in references}),
+        "existing_references": sum(r["exists_now"] for r in references),
+        "required_missing_references": len(missing_required),
+        "optional_missing_references": len(missing_optional),
+        "optional_missing_unique_paths": len({r["path"] for r in missing_optional}),
+        "absolute_path_references": len(absolute),
+        "outside_dataset_root_references": len(outside),
+        "required_missing": missing_required[:100],
+        "optional_missing": missing_optional[:100],
+        "outside_dataset_root": outside[:100],
+    }
+
+
+def tool_function(tool: str) -> Any:
+    if tool not in _MODULES:
+        _MODULES[tool] = importlib.import_module(
+            f"tool_server.tool_workers.online_workers.{tool}_worker"
+        )
+    return getattr(_MODULES[tool], f"process_{tool}")
+
+
+def logical_type(record: dict[str, Any]) -> str:
+    parts = str(record.get("id", "")).split("/")
+    if parts and parts[0] == "multi_hazard" and len(parts) >= 2:
+        return f"{parts[0]}/{parts[1]}/{record.get('question_type')}"
+    return f"{parts[0] if parts else 'unknown'}/{record.get('question_type')}"
+
+
+def run_record(task: tuple[int, dict[str, Any]]) -> dict[str, Any]:
+    index, record = task
+    assert _STATE is not None and _CASE_DIR is not None
+    started = time.time()
+    record_id = str(record.get("id") or f"record_{index}")
+    digest = hashlib.sha1(record_id.encode("utf-8")).hexdigest()[:12]
+    session_id = f"replay_{index:04d}_{digest}"
+    _STATE.clear_session(session_id)
+    trace: list[dict[str, Any]] = []
+    errors: list[dict[str, Any]] = []
+    reached_terminal = False
+    terminal_args: dict[str, Any] | None = None
+
+    for step_number, step in enumerate(record.get("gt_chain") or [], 1):
+        tool = str(step.get("tool") or "")
+        step_args = dict(step.get("args") or {})
+        if tool == "TaskComplete":
+            if step_args.get("status") not in {"TASK_COMPLETE", "CONTRACT_FAILURE"}:
+                errors.append(
+                    {
+                        "step": step_number,
+                        "tool": tool,
+                        "error": "invalid_terminal_status",
+                        "status": step_args.get("status"),
+                    }
+                )
+                break
+            if not isinstance(step_args.get("summary"), str) or not step_args["summary"].strip():
+                errors.append(
+                    {"step": step_number, "tool": tool, "error": "missing_terminal_summary"}
+                )
+                break
+            reached_terminal = True
+            terminal_args = step_args
+            trace.append(
+                {
+                    "step": step_number,
+                    "tool": tool,
+                    "args": step_args,
+                    "status": "TASK_COMPLETE",
+                }
+            )
+            continue
+        if tool not in TOOLS:
+            errors.append(
+                {"step": step_number, "tool": tool, "error": "unknown tool"}
+            )
+            break
+        call_args = dict(step_args)
+        call_args["session_id"] = session_id
+        if not any(item.get("tool") != "TaskComplete" for item in trace):
+            call_args["case"] = sanitized_case(record)
+        try:
+            output = _STATE.run_stateful_tool(
+                tool,
+                call_args,
+                tool_function(tool),
+                require_existing=(tool != "ReadData"),
+            )
+        except Exception as exc:
+            output = {
+                "error_code": 1,
+                "text": f"driver exception: {exc}",
+                "traceback": traceback.format_exc(),
+            }
+        trace_row = {
+            "step": step_number,
+            "tool": tool,
+            "args": step_args,
+            "error_code": output.get("error_code"),
+            "text": output.get("text"),
+            "handle": output.get("handle"),
+            "canonical_handle": output.get("canonical_handle"),
+            "global_artifact_id": output.get("global_artifact_id"),
+            "artifact_json_path": output.get("artifact_json_path"),
+            "processor": output.get("processor"),
+        }
+        if "result" in output:
+            trace_row["result"] = compact(output.get("result"))
+        trace.append(trace_row)
+        if int(output.get("error_code", 1)) != 0:
+            errors.append(
+                {
+                    "step": step_number,
+                    "tool": tool,
+                    "text": output.get("text"),
+                    "output": compact(output),
+                }
+            )
+            break
+
+    session_path = _STATE.session_path(session_id)
+    if session_path.exists():
+        state = _STATE.load_json(session_path)
+    else:
+        state = {"artifacts": {}, "answer_candidate": None}
+    artifacts = state.get("artifacts") or {}
+    generated = {
+        handle: {
+            "type": card.get("type"),
+            "canonical_handle": card.get("canonical_handle") or handle,
+            "global_artifact_id": card.get("global_artifact_id"),
+            "artifact_json_path": card.get("artifact_json_path"),
+            "processor": card.get("processor"),
+            "result": compact(card.get("result")) if "result" in card else None,
+        }
+        for handle, card in artifacts.items()
+        if isinstance(card, dict) and handle not in (record.get("initial_artifacts") or {})
+    }
+    support_artifacts = dict(artifacts)
+    if terminal_args is not None:
+        support_artifacts["task_complete"] = {"result": terminal_args}
+    support = answer_support(record.get("expected_final_answer"), support_artifacts)
+    status = "passed" if not errors and reached_terminal else "failed"
+    from evaluation.structured_answer import score_answer
+    from multi_agent.answer_contract import project_final_answer
+
+    payloads = [
+        card["result"]
+        for handle, card in artifacts.items()
+        if (
+            handle not in (record.get("initial_artifacts") or {})
+            and isinstance(card, dict)
+            and isinstance(card.get("result"), dict)
+        )
+    ]
+    projection = project_final_answer(record, payloads) if status == "passed" else None
+    strict_answer = (
+        score_answer(record.get("expected_final_answer"), projection.answer)
+        if projection is not None and projection.ok
+        else {
+            "correct": False,
+            "answer_acc": 0.0,
+            "structured_match": False,
+            "valid_json": False,
+            "scoring_policy": "terminal_answer_missing",
+        }
+    )
+    end_to_end_pass = bool(status == "passed" and strict_answer.get("correct"))
+    result = {
+        "replay_contract_version": "geodisaster_strict_replay_v2",
+        "record_index": index,
+        "dataset_id": record_id,
+        "logical_question_type": logical_type(record),
+        "question_type": record.get("question_type"),
+        "family": record_id.split("/", 1)[0],
+        "status": status,
+        "reached_task_complete": reached_terminal,
+        "tool_error_count": len(errors),
+        "errors": errors,
+        "answer_support": support,
+        "strict_answer": strict_answer,
+        "projected_final_answer": compact(projection.answer) if projection is not None else None,
+        "answer_contract_errors": list(projection.errors) if projection is not None and not projection.ok else [],
+        "end_to_end_pass": end_to_end_pass,
+        "expected_final_answer": record.get("expected_final_answer"),
+        "produced_answer_candidate": compact(state.get("answer_candidate")),
+        "generated_handle_count": len(generated),
+        "generated_handles": generated,
+        "session_id": session_id,
+        "session_path": str(session_path),
+        "elapsed_seconds": round(time.time() - started, 4),
+        "trace": trace,
+    }
+    write_json(_CASE_DIR / f"{index:04d}.json", result)
+    return result
+
+
+def summarize(
+    results: list[dict[str, Any]],
+    elapsed: float,
+    records: list[dict[str, Any]],
+    path_audit: dict[str, Any],
+) -> dict[str, Any]:
+    by_family: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    by_type: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in results:
+        by_family[str(row.get("family"))].append(row)
+        by_type[str(row.get("logical_question_type"))].append(row)
+
+    def group_summary(rows: list[dict[str, Any]]) -> dict[str, Any]:
+        return {
+            "records": len(rows),
+            "execution_passed": sum(row.get("status") == "passed" for row in rows),
+            "strict_answer_correct": sum(bool((row.get("strict_answer") or {}).get("correct")) for row in rows),
+            "end_to_end_pass": sum(bool(row.get("end_to_end_pass")) for row in rows),
+            "full_answer_support": sum(
+                float((row.get("answer_support") or {}).get("score", 0.0)) >= 0.999999
+                for row in rows
+            ),
+            "mean_answer_support": round(
+                sum(float((row.get("answer_support") or {}).get("score", 0.0)) for row in rows)
+                / len(rows),
+                6,
+            ) if rows else 0.0,
+        }
+
+    errors = Counter(
+        error.get("tool", "unknown")
+        for row in results
+        for error in (row.get("errors") or [])
+    )
+    overall = group_summary(results)
+    stored_source_replay_verified = sum(
+        (record.get("source_replay") or {}).get("matches_expected") is True
+        for record in records
+    )
+    return {
+        **overall,
+        "failed": len(results) - overall["execution_passed"],
+        "strict_answer_incorrect": len(results) - overall["strict_answer_correct"],
+        "end_to_end_failed": len(results) - overall["end_to_end_pass"],
+        "elapsed_seconds": round(elapsed, 3),
+        "logical_question_types": len(by_type),
+        "generated_artifacts": sum(int(row.get("generated_handle_count") or 0) for row in results),
+        "stored_historical_source_replay_matches_expected": stored_source_replay_verified,
+        "input_path_audit": path_audit,
+        "tool_error_counts": dict(errors),
+        "by_family": {key: group_summary(value) for key, value in sorted(by_family.items())},
+        "by_question_type": {
+            key: group_summary(value) for key, value in sorted(by_type.items())
+        },
+    }
+
+
+def write_report(output_dir: Path, summary: dict[str, Any]) -> None:
+    paths = summary["input_path_audit"]
+    lines = [
+        "# GeoDisaster 2,921-Question Functional Replay",
+        "",
+        f"- Records: `{summary['records']}`",
+        f"- Logical question types: `{summary['logical_question_types']}`",
+        f"- Execution passed: `{summary['execution_passed']}`",
+        f"- Execution failed: `{summary['failed']}`",
+        f"- Strict structured answers correct: `{summary['strict_answer_correct']}`",
+        f"- End-to-end passed: `{summary['end_to_end_pass']}`",
+        f"- End-to-end failed: `{summary['end_to_end_failed']}`",
+        f"- Generated artifacts: `{summary['generated_artifacts']}`",
+        f"- Stored historical source-replay flags marked matching: `{summary['stored_historical_source_replay_matches_expected']}`",
+        f"- Full expected-answer scalar support: `{summary['full_answer_support']}`",
+        f"- Mean expected-answer support: `{summary['mean_answer_support']}`",
+        f"- Elapsed seconds: `{summary['elapsed_seconds']}`",
+        f"- Tool errors: `{json.dumps(summary['tool_error_counts'], sort_keys=True)}`",
+        "",
+        "## Interpretation",
+        "",
+        "An end-to-end pass requires the prescribed sequence to reach `TaskComplete` without "
+        "a worker error, project a schema-valid answer from the newly generated worker evidence, "
+        "and pass the active strict structured scorer. Stored historical source-replay flags are "
+        "reported only as provenance and never determine current correctness. "
+        "Expected-answer scalar support is a separate evidence-coverage heuristic: it "
+        "checks whether gold scalar values appear anywhere in generated artifacts. It is "
+        "not exact-answer accuracy; the runtime answer-contract layer projects worker "
+        "evidence into the requested schema before strict scoring. Missing support can expose a "
+        "real numerical or semantic disagreement and should not be silently treated as a pass.",
+        "",
+        "## Input path audit",
+        "",
+        f"- Path references: `{paths['path_references']}` (`{paths['unique_paths']}` unique)",
+        f"- Existing references: `{paths['existing_references']}`",
+        f"- Required missing references: `{paths['required_missing_references']}`",
+        f"- Optional missing references: `{paths['optional_missing_references']}` "
+        f"(`{paths['optional_missing_unique_paths']}` unique)",
+        f"- Absolute path references: `{paths['absolute_path_references']}`",
+        f"- References outside dataset root: `{paths['outside_dataset_root_references']}`",
+        "",
+        "## Family results",
+        "",
+        "| Family | Records | Executed | Strict correct | End-to-end | Full support | Mean support |",
+        "|---|---:|---:|---:|---:|---:|---:|",
+    ]
+    for family, row in summary["by_family"].items():
+        lines.append(
+            f"| `{family}` | {row['records']} | {row['execution_passed']} | "
+            f"{row['strict_answer_correct']} | {row['end_to_end_pass']} | "
+            f"{row['full_answer_support']} | {row['mean_answer_support']} |"
+        )
+    lines.extend(
+        [
+            "",
+            "## Question-type results",
+            "",
+            "| Logical question type | Records | Executed | Strict correct | End-to-end | Full support | Mean support |",
+            "|---|---:|---:|---:|---:|---:|---:|",
+        ]
+    )
+    for question_type, row in summary["by_question_type"].items():
+        lines.append(
+            f"| `{question_type}` | {row['records']} | {row['execution_passed']} | "
+            f"{row['strict_answer_correct']} | {row['end_to_end_pass']} | "
+            f"{row['full_answer_support']} | {row['mean_answer_support']} |"
+        )
+    (output_dir / "report.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset-root", required=True)
+    parser.add_argument("--code-root", required=True)
+    parser.add_argument("--input-jsonl", required=True)
+    parser.add_argument("--output-dir", required=True)
+    parser.add_argument("--workers", type=int, default=4)
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--start-index", type=int, default=1)
+    parser.add_argument("--progress-every", type=int, default=25)
+    parser.add_argument("--retry-failed", action="store_true")
+    parser.add_argument(
+        "--record-id",
+        action="append",
+        default=[],
+        help="Replay only this exact record ID; repeat for multiple records.",
+    )
+    parser.add_argument(
+        "--family",
+        action="append",
+        default=[],
+        help="Replay only records whose ID begins with this family plus '/'.",
+    )
+    parser.add_argument(
+        "--question-types",
+        default="",
+        help="Comma-separated question_type values to replay.",
+    )
+    parser.add_argument(
+        "--uses-tool",
+        action="append",
+        default=[],
+        help="Replay only records whose GT chain calls this tool; repeat as needed.",
+    )
+    parser.add_argument(
+        "--one-per-type",
+        action="store_true",
+        help="Smoke-test the first record from each of the 43 logical question types.",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    input_path = Path(args.input_jsonl).resolve()
+    output_dir = Path(args.output_dir).resolve()
+    case_dir = output_dir / "cases"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    case_dir.mkdir(parents=True, exist_ok=True)
+    records = read_jsonl(input_path)
+    dataset_root = Path(args.dataset_root).resolve()
+    indexed = list(enumerate(records, 1))
+    if args.record_id:
+        selected_ids = set(args.record_id)
+        indexed = [item for item in indexed if item[1].get("id") in selected_ids]
+    if args.family:
+        prefixes = tuple(f"{family.rstrip('/')}" + "/" for family in args.family)
+        indexed = [
+            item
+            for item in indexed
+            if any(str(item[1].get("id") or "").startswith(prefix) for prefix in prefixes)
+        ]
+    if args.question_types:
+        selected_types = {
+            value.strip() for value in args.question_types.split(",") if value.strip()
+        }
+        indexed = [
+            item for item in indexed if item[1].get("question_type") in selected_types
+        ]
+    if args.uses_tool:
+        selected_tools = set(args.uses_tool)
+        indexed = [
+            item
+            for item in indexed
+            if selected_tools.intersection(
+                str(step.get("tool") or "") for step in item[1].get("gt_chain") or []
+            )
+        ]
+    if args.one_per_type:
+        seen_types: set[str] = set()
+        selected: list[tuple[int, dict[str, Any]]] = []
+        for item in indexed:
+            type_name = logical_type(item[1])
+            if type_name not in seen_types:
+                seen_types.add(type_name)
+                selected.append(item)
+        indexed = selected
+    indexed = [item for item in indexed if item[0] >= args.start_index]
+    if args.limit:
+        indexed = indexed[: args.limit]
+    path_audit = input_path_audit([record for _, record in indexed], dataset_root)
+
+    existing: dict[int, dict[str, Any]] = {}
+    pending: list[tuple[int, dict[str, Any]]] = []
+    for item in indexed:
+        index = item[0]
+        case_path = case_dir / f"{index:04d}.json"
+        if case_path.exists():
+            try:
+                cached = json.loads(case_path.read_text(encoding="utf-8"))
+            except Exception:
+                cached = None
+            cache_current = cached and cached.get("replay_contract_version") == "geodisaster_strict_replay_v2"
+            if cache_current and not (
+                args.retry_failed and not bool(cached.get("end_to_end_pass"))
+            ):
+                existing[index] = cached
+                continue
+        pending.append(item)
+
+    metadata = {
+        "input_jsonl": str(input_path),
+        "input_sha256": hashlib.sha256(input_path.read_bytes()).hexdigest(),
+        "dataset_root": str(Path(args.dataset_root).resolve()),
+        "code_root": str(Path(args.code_root).resolve()),
+        "output_dir": str(output_dir),
+        "selected_records": len(indexed),
+        "cached_records": len(existing),
+        "pending_records": len(pending),
+        "workers": max(1, args.workers),
+    }
+    write_json(output_dir / "run_config.json", metadata)
+    print(json.dumps(metadata, ensure_ascii=False), flush=True)
+
+    started = time.time()
+    new_results: dict[int, dict[str, Any]] = {}
+    if pending:
+        worker_count = min(max(1, args.workers), len(pending))
+        initializer_args = (
+            str(Path(args.code_root).resolve()),
+            str(Path(args.dataset_root).resolve()),
+            str(output_dir),
+        )
+        if worker_count == 1:
+            initialize_worker(*initializer_args)
+            iterator = map(run_record, pending)
+            pool = None
+        else:
+            context = mp.get_context("fork")
+            pool = context.Pool(
+                worker_count,
+                initializer=initialize_worker,
+                initargs=initializer_args,
+            )
+            # Canonical rows are grouped by sample and usually contain several
+            # question types over the same rasters. Keep a small row block on
+            # one process so the workers' cached raster bundles are reused.
+            iterator = pool.imap_unordered(run_record, pending, chunksize=8)
+        try:
+            for completed, result in enumerate(iterator, 1):
+                new_results[int(result["record_index"])] = result
+                if args.progress_every and (
+                    completed % args.progress_every == 0 or completed == len(pending)
+                ):
+                    passed = sum(row.get("status") == "passed" for row in new_results.values())
+                    print(
+                        json.dumps(
+                            {
+                                "completed_this_run": completed,
+                                "pending_this_run": len(pending),
+                                "passed_this_run": passed,
+                                "failed_this_run": completed - passed,
+                                "elapsed_seconds": round(time.time() - started, 2),
+                            },
+                            ensure_ascii=False,
+                        ),
+                        flush=True,
+                    )
+        finally:
+            if pool is not None:
+                pool.close()
+                pool.join()
+
+    results = [
+        (new_results.get(index) or existing[index])
+        for index, _ in indexed
+        if index in new_results or index in existing
+    ]
+    with (output_dir / "results.jsonl").open("w", encoding="utf-8") as handle:
+        for result in results:
+            handle.write(json.dumps(result, ensure_ascii=False, default=str) + "\n")
+    elapsed = time.time() - started
+    previous_summary_path = output_dir / "summary.json"
+    if not pending and previous_summary_path.exists():
+        try:
+            previous_summary = json.loads(previous_summary_path.read_text(encoding="utf-8"))
+            elapsed = float(previous_summary.get("elapsed_seconds") or elapsed)
+        except Exception:
+            pass
+    summary = summarize(
+        results,
+        elapsed,
+        [record for index, record in indexed if index in new_results or index in existing],
+        path_audit,
+    )
+    write_json(output_dir / "summary.json", summary)
+    write_report(output_dir, summary)
+    with (output_dir / "answer_support_gaps.jsonl").open("w", encoding="utf-8") as handle:
+        for result in results:
+            support = result.get("answer_support") or {}
+            if float(support.get("score", 0.0)) < 0.999999:
+                handle.write(
+                    json.dumps(
+                        {
+                            "record_index": result.get("record_index"),
+                            "dataset_id": result.get("dataset_id"),
+                            "logical_question_type": result.get("logical_question_type"),
+                            "support_score": support.get("score"),
+                            "missing": support.get("missing"),
+                        },
+                        ensure_ascii=False,
+                        default=str,
+                    )
+                    + "\n"
+                )
+    print(json.dumps(summary, indent=2, ensure_ascii=False), flush=True)
+    if summary["failed"] or summary["strict_answer_incorrect"]:
+        raise SystemExit(2)
+
+
+if __name__ == "__main__":
+    main()

data/release_tools/verify_c11_environment.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""Verify the exact C11 replay environment and its native geospatial stack."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.metadata
+import json
+import platform
+import re
+import sys
+import warnings
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+ENV_DIR = ROOT / "release_tools/environments"
+LOCK = ENV_DIR / "requirements-replay.lock.txt"
+PYTHON_VERSION = (ENV_DIR / "python-replay.version").read_text(encoding="utf-8").strip()
+EXPECTED_IMPLEMENTATION = "CPython"
+EXPECTED_SYSTEM = "Linux"
+EXPECTED_MACHINE = "x86_64"
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def locked_versions(path: Path) -> dict[str, str]:
+    versions: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        match = re.match(r"^([A-Za-z0-9_.-]+)==([^ ;\\]+)", line)
+        if match:
+            versions[re.sub(r"[-_.]+", "-", match.group(1)).lower()] = match.group(2)
+    if not versions:
+        raise ValueError(f"no locked packages found in {path}")
+    return versions
+
+
+def installed_versions() -> dict[str, str]:
+    return {
+        re.sub(r"[-_.]+", "-", distribution.metadata["Name"]).lower(): distribution.version
+        for distribution in importlib.metadata.distributions()
+        if distribution.metadata.get("Name")
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+
+    locked = locked_versions(LOCK)
+    installed = installed_versions()
+    actual_python = platform.python_version()
+    actual_implementation = platform.python_implementation()
+    actual_system = platform.system()
+    actual_machine = platform.machine()
+    missing = sorted(name for name in locked if name not in installed)
+    mismatched = {
+        name: {"expected": version, "actual": installed.get(name)}
+        for name, version in locked.items()
+        if installed.get(name) != version
+    }
+    unexpected = sorted(name for name in installed if name not in locked)
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("error")
+        import numpy as np
+        import pyproj
+        import rasterio
+        import scipy
+        from PIL import Image
+        from rasterio.io import MemoryFile
+        from scipy import ndimage
+        from shapely.geometry import Polygon
+
+        labels, components = ndimage.label(np.array([[1, 0], [0, 1]], dtype="uint8"))
+        if components != 2 or labels.shape != (2, 2):
+            raise AssertionError("SciPy connected-component smoke test failed")
+        profile = {
+            "driver": "GTiff",
+            "height": 2,
+            "width": 2,
+            "count": 1,
+            "dtype": "uint8",
+            "nodata": 255,
+            "transform": rasterio.transform.from_origin(0, 2, 1, 1),
+            "crs": "EPSG:4326",
+        }
+        with MemoryFile() as memory:
+            with memory.open(**profile) as dataset:
+                dataset.write(np.array([[1, 0], [255, 1]], dtype="uint8"), 1)
+            with memory.open() as dataset:
+                if dataset.nodata != 255 or int((dataset.read(1) == 1).sum()) != 2:
+                    raise AssertionError("Rasterio finite-nodata smoke test failed")
+        if Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]).area != 1.0:
+            raise AssertionError("Shapely geometry smoke test failed")
+        x, y = pyproj.Transformer.from_crs(4326, 3857, always_xy=True).transform(0, 0)
+        if abs(x) > 1e-9 or abs(y) > 1e-9:
+            raise AssertionError("PyProj transform smoke test failed")
+        with Image.new("RGB", (2, 2)) as image:
+            if image.size != (2, 2):
+                raise AssertionError("Pillow smoke test failed")
+
+    platform_matches = (
+        actual_implementation == EXPECTED_IMPLEMENTATION
+        and actual_system == EXPECTED_SYSTEM
+        and actual_machine == EXPECTED_MACHINE
+    )
+
+    report = {
+        "schema_version": "geodisaster_replay_environment_v1",
+        "ready": (
+            actual_python == PYTHON_VERSION
+            and platform_matches
+            and not missing
+            and not mismatched
+            and not unexpected
+        ),
+        "python": {
+            "expected": PYTHON_VERSION,
+            "actual": actual_python,
+            "expected_implementation": EXPECTED_IMPLEMENTATION,
+            "implementation": actual_implementation,
+            "executable": sys.executable,
+        },
+        "platform": {
+            "expected_system": EXPECTED_SYSTEM,
+            "system": actual_system,
+            "expected_machine": EXPECTED_MACHINE,
+            "machine": actual_machine,
+            "matches": platform_matches,
+            "release": platform.release(),
+            "libc": platform.libc_ver(),
+        },
+        "lock": {
+            "path": str(LOCK.relative_to(ROOT)),
+            "sha256": sha256(LOCK),
+            "packages": locked,
+        },
+        "installed_packages": installed,
+        "missing_packages": missing,
+        "mismatched_packages": mismatched,
+        "unexpected_packages": unexpected,
+        "native_libraries": {
+            "gdal": rasterio.__gdal_version__,
+            "proj": pyproj.proj_version_str,
+            "geos": getattr(__import__("shapely"), "geos_version_string", None),
+        },
+        "compatibility_warnings": [str(item.message) for item in caught],
+        "smoke_tests": {
+            "numpy_scipy": "passed",
+            "rasterio_finite_nodata": "passed",
+            "shapely": "passed",
+            "pyproj": "passed",
+            "pillow": "passed",
+        },
+    }
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps(report, indent=2, sort_keys=True))
+    if not report["ready"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()